renkan: comparison server/php/basic/public_html/static/lib/paper/paper-full.js

Mercurial Mercurial > renkan / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

server/php/basic/public_html/static/lib/paper/paper-full.js

changeset 495	444b80998255
parent 442	adb907bba956
child 598	eb4f4eceada0

equal deleted inserted replaced

-:fd7bfe49155a
+:444b80998255
 /*!
-* Paper.js v0.9.22 - The Swiss Army Knife of Vector Graphics Scripting.
+* Paper.js v0.9.24 - The Swiss Army Knife of Vector Graphics Scripting.
 * http://paperjs.org/
 *
 * Copyright (c) 2011 - 2014, Juerg Lehni & Jonathan Puckey
 * http://scratchdisk.com/ & http://jonathanpuckey.com/
 *
 * Distributed under the MIT license. See LICENSE file for details.
 *
 * All rights reserved.
 *
-* Date: Sat Feb 28 19:20:48 2015 +0100
+* Date: Fri Aug 21 16:39:41 2015 +0200
 *
 ***
 *
 * Straps.js - Class inheritance library with support for bean-style accessors
 *
 					&& (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
+				prev = preserve || isFunc && !val.base
 						? (val && val.get ? name in dest : dest[name])
 						: null,
 				bean;
 			if (!preserve || !prev) {
 				if (isFunc && prev)
 			return this;
 		},
 		extend: function() {
 			var base = this,
-				ctor;
+				ctor,
+				proto;
 			for (var i = 0, l = arguments.length; i < l; i++)
 				if (ctor = arguments[i].initialize)
 					break;
 			ctor = ctor || function() {
 				base.apply(this, arguments);
 			};
-			ctor.prototype = create(this.prototype);
+			proto = ctor.prototype = create(this.prototype);
-			ctor.base = base;
+			define(proto, 'constructor',
-			define(ctor.prototype, 'constructor',
 					{ value: ctor, writable: true, configurable: true });
 			inject(ctor, this, true);
-			return arguments.length ? this.inject.apply(ctor, arguments) : ctor;
+			if (arguments.length)
+				this.inject.apply(ctor, arguments);
+			ctor.base = base;
+			return ctor;
 		}
 	}, true).inject({
 		inject: function() {
 			for (var i = 0, l = arguments.length; i < l; i++) {
 				var src = arguments[i];
 		return Base.serialize(this);
 	},
 	_set: function(props, exclude, dontCheck) {
 		if (props && (dontCheck || Base.isPlainObject(props))) {
-			var orig = props._filtering || props;
+			var keys = Object.keys(props._filtering || props);
-			for (var key in orig) {
+			for (var i = 0, l = keys.length; i < l; i++) {
-				if (orig.hasOwnProperty(key) && !(exclude && exclude[key])) {
+				var key = keys[i];
+				if (!(exclude && exclude[key])) {
 					var value = props[key];
 					if (value !== undefined)
 						this[key] = value;
 				}
 			}
 				Base.exports[name] = res;
 			return res;
 		},
 		equals: function(obj1, obj2) {
-			function checkKeys(o1, o2) {
-				for (var i in o1)
-					if (o1.hasOwnProperty(i) && !o2.hasOwnProperty(i))
-						return false;
-				return true;
-			}
 			if (obj1 === obj2)
 				return true;
 			if (obj1 && obj1.equals)
 				return obj1.equals(obj2);
 			if (obj2 && obj2.equals)
 				return obj2.equals(obj1);
-			if (Array.isArray(obj1) && Array.isArray(obj2)) {
+			if (obj1 && obj2
-				if (obj1.length !== obj2.length)
+					&& typeof obj1 === 'object' && typeof obj2 === 'object') {
-					return false;
+				if (Array.isArray(obj1) && Array.isArray(obj2)) {
-				for (var i = 0, l = obj1.length; i < l; i++) {
+					var length = obj1.length;
-					if (!Base.equals(obj1[i], obj2[i]))
+					if (length !== obj2.length)
 						return false;
-				}
+					while (length--) {
-				return true;
+						if (!Base.equals(obj1[length], obj2[length]))
-			}
+							return false;
-			if (obj1 && typeof obj1 === 'object'
+					}
-					&& obj2 && typeof obj2 === 'object') {
+				} else {
-				if (!checkKeys(obj1, obj2) || !checkKeys(obj2, obj1))
+					var keys = Object.keys(obj1),
-					return false;
+						length = keys.length;
-				for (var i in obj1) {
+					if (length !== Object.keys(obj2).length)
-					if (obj1.hasOwnProperty(i)
-							&& !Base.equals(obj1[i], obj2[i]))
 						return false;
+					while (length--) {
+						var key = keys[length];
+						if (!(obj2.hasOwnProperty(key)
+								&& Base.equals(obj1[key], obj2[key])))
+							return false;
+					}
 				}
 				return true;
 			}
 			return false;
 		},
 							dictionary);
 				if (compact)
 					res._compact = true;
 			} else if (Base.isPlainObject(obj)) {
 				res = {};
-				for (var i in obj)
+				var keys = Object.keys(obj);
-					if (obj.hasOwnProperty(i))
+				for (var i = 0, l = keys.length; i < l; i++) {
-						res[i] = Base.serialize(obj[i], options, compact,
+					var key = keys[i];
-								dictionary);
+					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 root && dictionary.length > 0
 					? [['dictionary', dictionary.definitions], res]
 					: res;
 		},
-		deserialize: function(json, create, _data) {
+		deserialize: function(json, create, _data, _isDictionary) {
 			var res = json,
 				isRoot = !_data;
 			_data = _data || {};
 			if (Array.isArray(json)) {
 				var type = json[0],
 					isDictionary = type === 'dictionary';
-				if (!isDictionary) {
+				if (json.length == 1 && /^#/.test(type))
-					if (_data.dictionary && json.length == 1 && /^#/.test(type))
+					return _data.dictionary[type];
-						return _data.dictionary[type];
+				type = Base.exports[type];
-					type = Base.exports[type];
-				}
 				res = [];
+				if (_isDictionary)
+					_data.dictionary = res;
 				for (var i = type ? 1 : 0, l = json.length; i < l; i++)
-					res.push(Base.deserialize(json[i], create, _data));
+					res.push(Base.deserialize(json[i], create, _data,
-				if (isDictionary) {
+							isDictionary));
-					_data.dictionary = res[0];
+				if (type) {
-				} else if (type) {
 					var args = res;
 					if (create) {
 						res = create(type, args);
 					} else {
 						res = Base.create(type.prototype);
 						type.apply(res, args);
 					}
 				}
 			} else if (Base.isPlainObject(json)) {
 				res = {};
+				if (_isDictionary)
+					_data.dictionary = res;
 				for (var key in json)
 					res[key] = Base.deserialize(json[key], create, _data);
 			}
 			return isRoot && json && json.length && json[0][0] === 'dictionary'
 					? res[1]
 		if (typeof type !== 'string') {
 			Base.each(type, function(value, key) {
 				this.on(key, value);
 			}, this);
 		} else {
-			var entry = this._eventTypes[type];
+			var types = this._eventTypes,
-			if (entry) {
+				entry = types && types[type],
-				var handlers = this._callbacks = this._callbacks || {};
+				handlers = this._callbacks = this._callbacks || {};
-				handlers = handlers[type] = handlers[type] || [];
+			handlers = handlers[type] = handlers[type] || [];
-				if (handlers.indexOf(func) === -1) {
+			if (handlers.indexOf(func) === -1) {
-					handlers.push(func);
+				handlers.push(func);
-					if (entry.install && handlers.length == 1)
+				if (entry && entry.install && handlers.length == 1)
-						entry.install.call(this, type);
+					entry.install.call(this, type);
-				}
 			}
 		}
 		return this;
 	},
 			Base.each(type, function(value, key) {
 				this.off(key, value);
 			}, this);
 			return;
 		}
-		var entry = this._eventTypes[type],
+		var types = this._eventTypes,
+			entry = types && types[type],
 			handlers = this._callbacks && this._callbacks[type],
 			index;
-		if (entry && handlers) {
+		if (handlers) {
 			if (!func || (index = handlers.indexOf(func)) !== -1
 					&& handlers.length === 1) {
-				if (entry.uninstall)
+				if (entry && entry.uninstall)
 					entry.uninstall.call(this, type);
 				delete this._callbacks[type];
 			} else if (index !== -1) {
 				handlers.splice(index, 1);
 			}
 	emit: function(type, event) {
 		var handlers = this._callbacks && this._callbacks[type];
 		if (!handlers)
 			return false;
 		var args = [].slice.call(arguments, 1);
+		handlers = handlers.slice();
 		for (var i = 0, l = handlers.length; i < l; i++) {
-			if (handlers[i].apply(this, args) === false
+			if (handlers[i].apply(this, args) === false) {
-					&& event && event.stop) {
+				if (event && event.stop)
-				event.stop();
+					event.stop();
 				break;
 			}
 		}
 		return true;
 	},
 	_installEvents: function(install) {
 		var handlers = this._callbacks,
 			key = install ? 'install' : 'uninstall';
 		for (var type in handlers) {
 			if (handlers[type].length > 0) {
-				var entry = this._eventTypes[type],
+				var types = this._eventTypes,
-					func = entry[key];
+					entry = types && types[type],
+					func = entry && entry[key];
 				if (func)
 					func.call(this, type);
 			}
 		}
 	},
 			};
 			CanvasProvider.release(ctx);
 		}
 		if (!this.browser) {
-			var browser = proto.browser = {};
+			var agent = navigator.userAgent.toLowerCase(),
-			navigator.userAgent.toLowerCase().replace(
+				platform = (/(win)/.exec(agent)
+						|| /(mac)/.exec(agent)
+						|| /(linux)/.exec(agent)
+						|| [])[0],
+				browser = proto.browser = { platform: platform };
+			if (platform)
+				browser[platform] = true;
+			agent.replace(
 				/(opera|chrome|safari|webkit|firefox|msie|trident|atom)\/?\s*([.\d]+)(?:.*version\/([.\d]+))?(?:.*rv\:([.\d]+))?/g,
 				function(all, n, v1, v2, rv) {
 					if (!browser.chrome) {
 						var v = n === 'opera' ? v2 : v1;
 						if (n === 'trident') {
 			if (browser.atom)
 				delete browser.chrome;
 		}
 	},
-	version: '0.9.22',
+	version: '0.9.24',
 	getView: function() {
 		return this.project && this.project.getView();
 	},
 				x1, x2 = Infinity,
 				B = b,
 				D;
 			b /= 2;
 			D = b * b - a * c;
-			if (abs(D) < MACHINE_EPSILON) {
+			if (D !== 0 && abs(D) < MACHINE_EPSILON) {
-				var pow = Math.pow,
+				var gmC = pow(abs(a * b * c), 1 / 3);
-					gmC = pow(abs(a*b*c), 1/3);
 				if (gmC < 1e-8) {
-					/*
-					 * we multiply with a factor to normalize the
-					 * coefficients. The factor is just the nearest exponent
-					 * of 10, big enough to raise all the coefficients to
-					 * nearly [-1, +1] range.
-					 */
 					var mult = pow(10, abs(
 						Math.floor(Math.log(gmC) * Math.LOG10E)));
 					if (!isFinite(mult))
 						mult = 0;
 					a *= mult;
 					b *= mult;
 					c *= mult;
 					D = b * b - a * c;
 				}
 			}
-			if (abs(a) < MACHINE_EPSILON) {
+			if (abs(a) < EPSILON) {
-				if (abs(B) < MACHINE_EPSILON)
+				if (abs(B) < EPSILON)
-					return abs(c) < MACHINE_EPSILON ? -1 : 0;
+					return abs(c) < EPSILON ? -1 : 0;
 				x1 = -c / B;
 			} else {
 				if (D >= -MACHINE_EPSILON) {
 					D = D < 0 ? 0 : D;
 					var R = sqrt(D);
 				roots[count++] = x2;
 			return count;
 		},
 		solveCubic: function(a, b, c, d, roots, min, max) {
-			var x, b1, c2, count = 0;
+			var count = 0,
-			if (a === 0) {
+				x, b1, c2;
+			if (abs(a) < EPSILON) {
 				a = b;
 				b1 = c;
 				c2 = d;
 				x = Infinity;
-			} else if (d === 0) {
+			} else if (abs(d) < EPSILON) {
 				b1 = b;
 				c2 = c;
 				x = 0;
 			} else {
 				var ec = 1 + MACHINE_EPSILON,
 			return count;
 		}
 	};
 };
+var UID = {
+	_id: 1,
+	_pools: {},
+	get: function(ctor) {
+		if (ctor) {
+			var name = ctor._class,
+				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) {
 	isClose: function(point, tolerance) {
 		return this.getDistance(point) < tolerance;
 	},
-	isColinear: function(point) {
+	isCollinear: function(point) {
-		return Math.abs(this.cross(point)) < 1e-12;
+		return Math.abs(this.cross(point)) < 0.000001;
 	},
+	isColinear: '#isCollinear',
 	isOrthogonal: function(point) {
-		return Math.abs(this.dot(point)) < 1e-12;
+		return Math.abs(this.dot(point)) < 0.000001;
 	},
 	isZero: function() {
 		return Numerical.isZero(this.x) && Numerical.isZero(this.y);
 	},
 var Symbol = Base.extend({
 	_class: 'Symbol',
 	initialize: function Symbol(item, dontCenter) {
-		this._id = Symbol._id = (Symbol._id || 0) + 1;
+		this._id = UID.get();
 		this.project = paper.project;
 		this.project.symbols.push(this);
 		if (item)
 			this.setDefinition(item, dontCenter);
 	},
 		var hasProps = props && Base.isPlainObject(props),
 			internal = hasProps && props.internal === true,
 			matrix = this._matrix = new Matrix(),
 			project = hasProps && props.project || paper.project;
 		if (!internal)
-			this._id = Item._id = (Item._id || 0) + 1;
+			this._id = UID.get();
 		this._applyMatrix = this._canApplyMatrix && paper.settings.applyMatrix;
 		if (point)
 			matrix.translate(point);
 		matrix._owner = this;
 		this._style = new Style(project._currentStyle, this, project);
 			} else {
 				(project._activeLayer || new Layer()).addChild(this);
 			}
 		}
 		if (hasProps && props !== Item.NO_INSERT)
-			this._set(props, { insert: true, parent: true }, true);
+			this._set(props, { insert: true, project: true, parent: true },
+					true);
 		return hasProps;
 	},
 	_events: new function() {
 		}
 		return pivot;
 	},
 	setPivot: function() {
-		this._pivot = Point.read(arguments);
+		this._pivot = Point.read(arguments, 0, { clone: true, readNull: true });
 		this._position = undefined;
 	},
 	_pivot: null,
-	getRegistration: '#getPivot',
-	setRegistration: '#setPivot'
 }, Base.each(['bounds', 'strokeBounds', 'handleBounds', 'roughBounds',
 		'internalBounds', 'internalRoughBounds'],
 	function(key) {
 		var getter = 'get' + Base.capitalize(key),
 			match = key.match(/^internal(.*)$/),
 	_getBounds: function(getter, matrix, cacheItem) {
 		var children = this._children;
 		if (!children || children.length == 0)
 			return new Rectangle();
+		Item._updateBoundsCache(this, cacheItem);
 		var x1 = Infinity,
 			x2 = -x1,
 			y1 = x1,
 			y2 = x2;
 		for (var i = 0, l = children.length; i < l; i++) {
 	_getCachedBounds: function(getter, matrix, cacheItem, internalGetter) {
 		matrix = matrix && matrix.orNullIfIdentity();
 		var _matrix = internalGetter ? null : this._matrix.orNullIfIdentity(),
 			cache = (!matrix || matrix.equals(_matrix)) && getter;
-		var cacheParent = this._parent || this._parentSymbol;
+		Item._updateBoundsCache(this._parent || this._parentSymbol, cacheItem);
-		if (cacheParent) {
-			var id = cacheItem._id,
-				ref = cacheParent._boundsCache = cacheParent._boundsCache || {
-					ids: {},
-					list: []
-				};
-			if (!ref.ids[id]) {
-				ref.list.push(cacheItem);
-				ref.ids[id] = cacheItem;
-			}
-		}
 		if (cache && this._bounds && this._bounds[cache])
 			return this._bounds[cache].clone();
 		var bounds = this._getBounds(internalGetter || getter,
 				matrix || _matrix, cacheItem);
 		if (cache) {
 		}
 		return bounds;
 	},
 	statics: {
+		_updateBoundsCache: function(parent, item) {
+			if (parent) {
+				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++) {
+				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);
 	getMatrix: function() {
 		return this._matrix;
 	},
-	setMatrix: function(matrix) {
+	setMatrix: function() {
-		this._matrix.initialize(matrix);
+		var matrix = this._matrix;
+		matrix.initialize.apply(matrix, arguments);
 		if (this._applyMatrix) {
 			this.transform(null, true);
 		} else {
 			this._changed(9);
 		}
 	clone: function(insert) {
 		return this._clone(new this.constructor(Item.NO_INSERT), insert);
 	},
-	_clone: function(copy, insert) {
+	_clone: function(copy, insert, includeMatrix) {
+		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
+				'_clipMask', '_guide'],
+			children = this._children;
 		copy.setStyle(this._style);
-		if (this._children) {
+		for (var i = 0, l = children && children.length; i < l; i++) {
-			for (var i = 0, l = this._children.length; i < l; i++)
+			copy.addChild(children[i].clone(false), true);
-				copy.addChild(this._children[i].clone(false), true);
+		}
-		}
-		if (insert || insert === undefined)
-			copy.insertAbove(this);
-		var keys = ['_locked', '_visible', '_blendMode', '_opacity',
-				'_clipMask', '_guide', '_applyMatrix'];
 		for (var i = 0, l = keys.length; i < l; i++) {
 			var key = keys[i];
 			if (this.hasOwnProperty(key))
 				copy[key] = this[key];
 		}
-		copy._matrix.initialize(this._matrix);
+		if (includeMatrix !== false)
+			copy._matrix.initialize(this._matrix);
+		copy.setApplyMatrix(this._applyMatrix);
+		copy.setPivot(this._pivot);
+		copy.setSelected(this._selected);
 		copy._data = this._data ? Base.clone(this._data) : null;
-		copy.setSelected(this._selected);
+		if (insert || insert === undefined)
+			copy.insertAbove(this);
 		if (this._name)
 			copy.setName(this._name, true);
 		return copy;
 	},
 					}
 				}
 			}
 			return true;
 		}
-		if (typeof name === 'object') {
+		var type = typeof name;
+		if (type === 'object') {
 			for (var key in name) {
 				if (name.hasOwnProperty(key) && !this.matches(key, name[key]))
 					return false;
 			}
+		} else if (type === 'function') {
+			return name(this);
 		} else {
 			var value = /^(empty|editable)$/.test(name)
 					? this['is' + Base.capitalize(name)]()
 					: name === 'type'
 						? Base.hyphenate(this._class)
 	},
 	statics: {
 		_getItems: function _getItems(children, match, matrix, param,
 				firstOnly) {
-			if (!param) {
+			if (!param && typeof match === 'object') {
 				var overlapping = match.overlapping,
 					inside = match.inside,
 					bounds = overlapping || inside,
 					rect =	bounds && Rectangle.read([bounds]);
 				param = {
 					items: [],
-					inside: rect,
+					inside: !!inside,
-					overlapping: overlapping && new Path.Rectangle({
+					overlapping: !!overlapping,
+					rect: rect,
+					path: overlapping && new Path.Rectangle({
 						rectangle: rect,
 						insert: false
 					})
 				};
 				if (bounds)
 					match = Base.set({}, match,
 							{ inside: true, overlapping: true });
 			}
-			var items = param.items,
+			var items = param && param.items,
-				inside = param.inside,
+				rect = param && param.rect;
-				overlapping = param.overlapping;
+			matrix = rect && (matrix || new Matrix());
-			matrix = inside && (matrix || new Matrix());
 			for (var i = 0, l = children && children.length; i < l; i++) {
 				var child = children[i],
 					childMatrix = matrix && matrix.chain(child._matrix),
 					add = true;
-				if (inside) {
+				if (rect) {
 					var bounds = child.getBounds(childMatrix);
-					if (!inside.intersects(bounds))
+					if (!rect.intersects(bounds))
 						continue;
-					if (!(inside && inside.contains(bounds)) && !(overlapping
+					if (!(param.inside && rect.contains(bounds))
-							&& overlapping.intersects(child, childMatrix)))
+							&& !(param.overlapping && (bounds.contains(rect)
+								|| param.path.intersects(child, childMatrix))))
 						add = false;
 				}
 				if (add && child.matches(match)) {
 					items.push(child);
 					if (firstOnly)
 			direct = normalBlend && opacity === 1
 					|| param.dontStart
 					|| param.clip
 					|| (nativeBlend || normalBlend && opacity < 1)
 						&& this._canComposite(),
-			pixelRatio = param.pixelRatio,
+			pixelRatio = param.pixelRatio || 1,
 			mainCtx, itemOffset, prevOffset;
 		if (!direct) {
 			var bounds = this.getStrokeBounds(getViewMatrix(globalMatrix));
 			if (!bounds.width || !bounds.height)
 				return;
 	isEmpty: function() {
 		return false;
 	},
 	toPath: function(insert) {
-		var path = new Path[Base.capitalize(this._type)]({
+		var path = this._clone(new Path[Base.capitalize(this._type)]({
 			center: new Point(),
 			size: this._size,
 			radius: this._radius,
 			insert: false
-		});
+		}), insert);
-		path.setStyle(this._style);
+		if (paper.settings.applyMatrix)
-		path.transform(this._matrix);
+			path.setApplyMatrix(true);
-		if (insert || insert === undefined)
-			path.insertAbove(this);
 		return path;
 	},
 	_draw: function(ctx, param, strokeMatrix) {
 		var style = this._style,
 				var rx = isCircle ? radius : radius.width,
 					ry = isCircle ? radius : radius.height,
 					size = this._size,
 					width = size.width,
 					height = size.height;
-				if (untransformed && type === 'rect' && rx === 0 && ry === 0) {
+				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,
 	_applyMatrix: false,
 	_canApplyMatrix: false,
 	_boundsGetter: 'getBounds',
 	_boundsSelected: true,
 	_serializeFields: {
+		crossOrigin: null,
 		source: null
 	},
 	initialize: function Raster(object, position) {
 		if (!this._initialize(object,
 		} else if (canvas) {
 			var copyCanvas = CanvasProvider.getCanvas(this._size);
 			copyCanvas.getContext('2d').drawImage(canvas, 0, 0);
 			copy.setImage(copyCanvas);
 		}
+		copy._crossOrigin = this._crossOrigin;
 		return this._clone(copy, insert);
 	},
 	getSize: function() {
 		var size = this._size;
 		return this._image && this._image.src || this.toDataURL();
 	},
 	setSource: function(src) {
 		var that = this,
+			crossOrigin = this._crossOrigin,
 			image;
 		function loaded() {
 			var view = that.getView();
 			if (view) {
 				that.emit('load');
 				view.update();
 			}
 		}
-			image = document.getElementById(src) || new Image();
+		image = document.getElementById(src) || new Image();
+		if (crossOrigin)
+			image.crossOrigin = crossOrigin;
 		if (image.naturalWidth && image.naturalHeight) {
 			setTimeout(loaded, 0);
 		} else {
-			DomEvent.add(image, {
+			DomEvent.add(image, { load: loaded });
-				load: loaded
-			});
 			if (!image.src)
 				image.src = src;
 		}
 		this.setImage(image);
+	},
+	getCrossOrigin: function() {
+		return this._image && this._image.crossOrigin || this._crossOrigin || '';
+	},
+	setCrossOrigin: function(crossOrigin) {
+		this._crossOrigin = crossOrigin;
+		if (this._image)
+			this._image.crossOrigin = crossOrigin;
 	},
 	getElement: function() {
 		return this._canvas || this._loaded && this._image;
 	}
 		new SegmentPoint(handleIn, this, '_handleIn');
 		new SegmentPoint(handleOut, this, '_handleOut');
 	},
 	_serialize: function(options) {
-		return Base.serialize(this.isLinear() ? this._point
+		return Base.serialize(this.isStraight() ? this._point
 				: [this._point, this._handleIn, this._handleOut],
 				options, true);
 	},
 	_changed: function(point) {
 	setHandleOut: function() {
 		var point = Point.read(arguments);
 		this._handleOut.set(point.x, point.y);
 	},
+	hasHandles: function() {
+		return !this.isStraight();
+	},
+	isStraight: function() {
+		return this._handleIn.isZero() && this._handleOut.isZero();
+	},
 	isLinear: function() {
-		return this._handleIn.isZero() && this._handleOut.isZero();
+		return Segment.isLinear(this, this.getNext());
 	},
-	setLinear: function(linear) {
+	isCollinear: function(segment) {
-		if (linear) {
+		return Segment.isCollinear(this, this.getNext(),
-			this._handleIn.set(0, 0);
+				segment, segment.getNext());
-			this._handleOut.set(0, 0);
+	},
-		} else {
-		}
+	isColinear: '#isCollinear',
-	},
-	isColinear: function(segment) {
-		var next1 = this.getNext(),
-			next2 = segment.getNext();
-		return this._handleOut.isZero() && next1._handleIn.isZero()
-				&& segment._handleOut.isZero() && next2._handleIn.isZero()
-				&& next1._point.subtract(this._point).isColinear(
-					next2._point.subtract(segment._point));
-	},
 	isOrthogonal: function() {
-		var prev = this.getPrevious(),
+		return Segment.isOrthogonal(this.getPrevious(), this, this.getNext());
-			next = this.getNext();
+	},
-		return prev._handleOut.isZero() && this._handleIn.isZero()
-			&& this._handleOut.isZero() && next._handleIn.isZero()
+	isOrthogonalArc: function() {
-			&& this._point.subtract(prev._point).isOrthogonal(
+		return Segment.isOrthogonalArc(this, this.getNext());
-					next._point.subtract(this._point));
+	},
-	},
+	isArc: '#isOrthogonalArc',
-	isArc: function() {
-		var next = this.getNext(),
-			handle1 = this._handleOut,
-			handle2 = next._handleIn,
-			kappa = 0.5522847498307936;
-		if (handle1.isOrthogonal(handle2)) {
-			var from = this._point,
-				to = next._point,
-				corner = new Line(from, handle1, true).intersect(
-						new Line(to, handle2, true), true);
-			return corner && Numerical.isZero(handle1.getLength() /
-					corner.subtract(from).getLength() - kappa)
-				&& Numerical.isZero(handle2.getLength() /
-					corner.subtract(to).getLength() - kappa);
-		}
-		return false;
-	},
 	_selectionState: 0,
 	isSelected: function(_point) {
 		var state = this._selectionState;
 					coords[i++] = y;
 				}
 			}
 		}
 		return coords;
+	},
+statics: {
+		isLinear: function(seg1, seg2) {
+			var l = seg2._point.subtract(seg1._point);
+			return l.isCollinear(seg1._handleOut)
+					&& l.isCollinear(seg2._handleIn);
+		},
+		isCollinear: function(seg1, seg2, seg3, seg4) {
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+					&& seg3._handleOut.isZero() && seg4._handleIn.isZero()
+					&& seg2._point.subtract(seg1._point).isCollinear(
+						seg4._point.subtract(seg3._point));
+		},
+		isOrthogonal: function(seg1, seg2, seg3) {
+			return seg1._handleOut.isZero() && seg2._handleIn.isZero()
+				&& seg2._handleOut.isZero() && seg3._handleIn.isZero()
+				&& seg2._point.subtract(seg1._point).isOrthogonal(
+						seg3._point.subtract(seg2._point));
+		},
+		isOrthogonalArc: function(seg1, seg2) {
+			var 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;
+		},
 	}
 });
 var SegmentPoint = Point.extend({
 	initialize: function SegmentPoint(point, owner, key) {
 	getPartLength: function(from, to) {
 		return Curve.getLength(this.getValues(), from, to);
 	},
+	hasHandles: function() {
+		return !this._segment1._handleOut.isZero()
+				|| !this._segment2._handleIn.isZero();
+	},
 	isLinear: function() {
-		return this._segment1._handleOut.isZero()
+		return Segment.isLinear(this._segment1, this._segment2);
-				&& this._segment2._handleIn.isZero();
+	},
+	isCollinear: function(curve) {
+		return Ssegment.isCollinear(this._segment1, this._segment2,
+				curve._segment1, curve._segment2);
+	},
+	isOrthogonalArc: function() {
+		return Segment.isOrthogonalArc(this._segment1, this._segment2);
 	},
 	getIntersections: function(curve) {
 		return Curve.filterIntersections(Curve.getIntersections(
 				this.getValues(), curve.getValues(), this, curve, []));
 				p2._x, p2._y
 			];
 		if (matrix)
 			matrix._transformCoordinates(values, values, 4);
 		return values;
-	},
-	evaluate: function(v, t, type) {
-		var p1x = v[0], p1y = v[1],
-			c1x = v[2], c1y = v[3],
-			c2x = v[4], c2y = v[5],
-			p2x = v[6], p2y = v[7],
-			tolerance = 0.000001,
-			x, y;
-		if (type === 0 && (t < tolerance || t > 1 - tolerance)) {
-			var isZero = t < tolerance;
-			x = isZero ? p1x : p2x;
-			y = isZero ? p1y : p2y;
-		} else {
-			var cx = 3 * (c1x - p1x),
-				bx = 3 * (c2x - c1x) - cx,
-				ax = p2x - p1x - cx - bx,
-				cy = 3 * (c1y - p1y),
-				by = 3 * (c2y - c1y) - cy,
-				ay = p2y - p1y - cy - by;
-			if (type === 0) {
-				x = ((ax * t + bx) * t + cx) * t + p1x;
-				y = ((ay * t + by) * t + cy) * t + p1y;
-			} else {
-				if (t < tolerance && c1x === p1x && c1y === p1y
-						|| t > 1 - tolerance && c2x === p2x && c2y === p2y) {
-					x = c2x - c1x;
-					y = c2y - c1y;
-				} else if (t < tolerance) {
-					x = cx;
-					y = cy;
-				} else if (t > 1 - tolerance) {
-					x = 3 * (p2x - c2x);
-					y = 3 * (p2y - c2y);
-				} else {
-					x = (3 * ax * t + 2 * bx) * t + cx;
-					y = (3 * ay * t + 2 * by) * t + cy;
-				}
-				if (type === 3) {
-					var x2 = 6 * ax * t + 2 * bx,
-						y2 = 6 * ay * t + 2 * by;
-					return (x * y2 - y * x2) / Math.pow(x * x + y * y, 3 / 2);
-				}
-			}
-		}
-		return type === 2 ? new Point(y, -x) : new Point(x, y);
 	},
 	subdivide: function(v, t) {
 		var p1x = v[0], p1y = v[1],
 			c1x = v[2], c1y = v[3],
 			c1 = v[coord + 2],
 			c2 = v[coord + 4],
 			p2 = v[coord + 6],
 			c = 3 * (c1 - p1),
 			b = 3 * (c2 - c1) - c,
-			a = p2 - p1 - c - b,
+			a = p2 - p1 - c - b;
-			isZero = Numerical.isZero;
-		if (isZero(a) && isZero(b))
-			a = b = 0;
 		return Numerical.solveCubic(a, b, c, p1 - val, roots, min, max);
 	},
 	getParameterOf: function(v, x, y) {
 		var tolerance = 0.000001;
 		var txs = [],
 			tys = [],
 			sx = Curve.solveCubic(v, 0, x, txs, 0, 1),
 			sy = Curve.solveCubic(v, 1, y, tys, 0, 1),
 			tx, ty;
-		for (var cx = 0;  sx == -1 || cx < sx;) {
+		for (var cx = 0;  sx === -1 || cx < sx;) {
-			if (sx == -1 || (tx = txs[cx++]) >= 0 && tx <= 1) {
+			if (sx === -1 || (tx = txs[cx++]) > 0 && tx < 1) {
-				for (var cy = 0; sy == -1 || cy < sy;) {
+				for (var cy = 0; sy === -1 || cy < sy;) {
-					if (sy == -1 || (ty = tys[cy++]) >= 0 && ty <= 1) {
+					if (sy === -1 || (ty = tys[cy++]) > 0 && ty < 1) {
-						if (sx == -1) tx = ty;
+						if (sx === -1) {
-						else if (sy == -1) ty = tx;
+							tx = ty;
+						} else if (sy === -1) {
+							ty = tx;
+						}
 						if (Math.abs(tx - ty) < tolerance)
 							return (tx + ty) * 0.5;
 					}
 				}
-				if (sx == -1)
+				if (sx === -1)
 					break;
 			}
 		}
 		return null;
 	},
 		if (to < 1)
 			v = Curve.subdivide(v, (to - from) / (1 - from))[0];
 		return v;
 	},
+	hasHandles: function(v) {
+		var isZero = Numerical.isZero;
+		return !(isZero(v[0] - v[2]) && isZero(v[1] - v[3])
+				&& isZero(v[4] - v[6]) && isZero(v[5] - v[7]));
+	},
 	isLinear: function(v) {
-		var isZero = Numerical.isZero;
+		var p1x = v[0], p1y = v[1],
-		return isZero(v[0] - v[2]) && isZero(v[1] - v[3])
+			p2x = v[6], p2y = v[7],
-				&& isZero(v[4] - v[6]) && isZero(v[5] - v[7]);
+			l = new Point(p2x - p1x, p2y - p1y);
+		return l.isCollinear(new Point(v[2] - p1x, v[3] - p1y))
+				&& l.isCollinear(new Point(v[4] - p2x, v[5] - p2y));
 	},
 	isFlatEnough: function(v, tolerance) {
 		var p1x = v[0], p1y = v[1],
 			c1x = v[2], c1y = v[3],
 					+ 3 * u * t * t * v2
 					+ t * t * t * v3,
 					padding);
 		}
 	}
-}}, Base.each(['getBounds', 'getStrokeBounds', 'getHandleBounds', 'getRoughBounds'],
+}}, Base.each(
+	['getBounds', 'getStrokeBounds', 'getHandleBounds', 'getRoughBounds'],
 	function(name) {
 		this[name] = function() {
 			if (!this._bounds)
 				this._bounds = {};
 			var bounds = this._bounds[name];
 			return bounds.clone();
 		};
 	},
 {
-}), Base.each(['getPoint', 'getTangent', 'getNormal', 'getCurvature'],
+}), {
-	function(name, index) {
-		this[name + 'At'] = function(offset, isParameter) {
-			var values = this.getValues();
-			return Curve.evaluate(values, isParameter
-					? offset : Curve.getParameterAt(values, offset, 0), index);
-		};
-		this[name] = function(parameter) {
-			return Curve.evaluate(this.getValues(), parameter, index);
-		};
-	},
-{
 	beans: false,
 	getParameterAt: function(offset, start) {
 		return Curve.getParameterAt(this.getValues(), offset, start);
 	},
 		var point = Point.read(arguments);
 		return Curve.getParameterOf(this.getValues(), point.x, point.y);
 	},
 	getLocationAt: function(offset, isParameter) {
-		if (!isParameter)
+		var t = isParameter ? offset : this.getParameterAt(offset);
-			offset = this.getParameterAt(offset);
+		return t != null && t >= 0 && t <= 1
-		return offset >= 0 && offset <= 1 && new CurveLocation(this, offset);
+				? new CurveLocation(this, t)
+				: null;
 	},
 	getLocationOf: function() {
 		return this.getLocationAt(this.getParameterOf(Point.read(arguments)),
 				true);
 			minDist = Infinity,
 			minT = 0;
 		function refine(t) {
 			if (t >= 0 && t <= 1) {
-				var dist = point.getDistance(
+				var dist = point.getDistance(Curve.getPoint(values, t), true);
-						Curve.evaluate(values, t, 0), true);
 				if (dist < minDist) {
 					minDist = dist;
 					minT = t;
 					return true;
 				}
 		var step = 1 / (count * 2);
 		while (step > 0.000001) {
 			if (!refine(minT - step) && !refine(minT + step))
 				step /= 2;
 		}
-		var pt = Curve.evaluate(values, minT, 0);
+		var pt = Curve.getPoint(values, minT);
 		return new CurveLocation(this, minT, pt, null, null, null,
 				point.getDistance(pt));
 	},
 	getNearestPoint: function() {
 		return this.getNearestLocation.apply(this, arguments).getPoint();
 	}
-}),
+},
+new function() {
+	var methods = ['getPoint', 'getTangent', 'getNormal', 'getWeightedTangent',
+		'getWeightedNormal', 'getCurvature'];
+	return Base.each(methods,
+	function(name) {
+		this[name + 'At'] = function(offset, isParameter) {
+			var values = this.getValues();
+			return Curve[name](values, isParameter ? offset
+					: Curve.getParameterAt(values, offset, 0));
+		};
+	}, {
+		statics: {
+			evaluateMethods: methods
+		}
+	})
+},
 new function() {
 	function getLengthIntegrand(v) {
 		var p1x = v[0], p1y = v[1],
 			c1x = v[2], c1y = v[3],
 		};
 	}
 	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 p1x = v[0], p1y = v[1],
+			c1x = v[2], c1y = v[3],
+			c2x = v[4], c2y = v[5],
+			p2x = v[6], p2y = v[7],
+			tolerance = 0.000001,
+			x, y;
+		if (type === 0 && (t < tolerance || t > 1 - tolerance)) {
+			var isZero = t < tolerance;
+			x = isZero ? p1x : p2x;
+			y = isZero ? p1y : p2y;
+		} else {
+			var cx = 3 * (c1x - p1x),
+				bx = 3 * (c2x - c1x) - cx,
+				ax = p2x - p1x - cx - bx,
+				cy = 3 * (c1y - p1y),
+				by = 3 * (c2y - c1y) - cy,
+				ay = p2y - p1y - cy - by;
+			if (type === 0) {
+				x = ((ax * t + bx) * t + cx) * t + p1x;
+				y = ((ay * t + by) * t + cy) * t + p1y;
+			} else {
+				if (t < tolerance) {
+					x = cx;
+					y = cy;
+				} else if (t > 1 - tolerance) {
+					x = 3 * (p2x - c2x);
+					y = 3 * (p2y - c2y);
+				} 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 < tolerance || t > 1 - tolerance)) {
+						x = c2x - c1x;
+						y = c2y - c1y;
+					}
+					var len = Math.sqrt(x * x + y * y);
+					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: true,
 		getParameterAt: function(v, offset, start) {
 			if (start === undefined)
 				start = offset < 0 ? 1 : 0
 			if (offset === 0)
 				return start;
-			var forward = offset > 0,
+			var tolerance = 0.000001,
+				abs = Math.abs,
+				forward = offset > 0,
 				a = forward ? start : 0,
 				b = forward ? 1 : start,
 				ds = getLengthIntegrand(v),
 				rangeLength = Numerical.integrate(ds, a, b,
 						getIterations(a, b));
-			if (Math.abs(offset) >= rangeLength)
+			if (abs(offset - rangeLength) < tolerance) {
 				return forward ? b : a;
+			} else if (abs(offset) > rangeLength) {
+				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, 16,
-					0.000001);
+					tolerance);
+		},
+		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;
 		}
 	};
 }, new function() {
 	function addLocation(locations, include, curve1, t1, point1, curve2, t2,
 			point2) {
 			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]),
 			tMinNew, tMaxNew, tDiff;
-		if (q0x === q3x && uMax - uMin <= tolerance && recursion > 3) {
+		if (q0x === q3x && uMax - uMin < tolerance && recursion > 3) {
 			tMaxNew = tMinNew = (tMax + tMin) / 2;
 			tDiff = 0;
 		} else {
 			var hull = getConvexHull(dp0, dp1, dp2, dp3),
 				top = hull[0],
 		} else if (Math.max(uMax - uMin, tMaxNew - tMinNew) < tolerance) {
 			var t1 = tMinNew + (tMaxNew - tMinNew) / 2,
 				t2 = uMin + (uMax - uMin) / 2;
 			if (reverse) {
 				addLocation(locations, include,
-						curve2, t2, Curve.evaluate(v2, t2, 0),
+						curve2, t2, Curve.getPoint(v2, t2),
-						curve1, t1, Curve.evaluate(v1, t1, 0));
+						curve1, t1, Curve.getPoint(v1, t1));
 			} else {
 				addLocation(locations, include,
-						curve1, t1, Curve.evaluate(v1, t1, 0),
+						curve1, t1, Curve.getPoint(v1, t1),
-						curve2, t2, Curve.evaluate(v2, t2, 0));
+						curve2, t2, Curve.getPoint(v2, t2));
 			}
 		} else if (tDiff > 0) {
 			addCurveIntersections(v2, v1, curve2, curve1, locations, include,
 					uMin, uMax, tMinNew, tMaxNew, tDiff, !reverse, ++recursion);
 		}
 		}
 		var roots = [],
 			count = Curve.solveCubic(rvc, 1, 0, roots, 0, 1);
 		for (var i = 0; i < count; i++) {
 			var tc = roots[i],
-				x = Curve.evaluate(rvc, tc, 0).x;
+				x = Curve.getPoint(rvc, tc).x;
 			if (x >= 0 && x <= rlx2) {
 				var tl = Curve.getParameterOf(rvl, x, 0),
 					t1 = flip ? tl : tc,
 					t2 = flip ? tc : tl;
 				addLocation(locations, include,
-						curve1, t1, Curve.evaluate(v1, t1, 0),
+						curve1, t1, Curve.getPoint(v1, t1),
-						curve2, t2, Curve.evaluate(v2, t2, 0));
+						curve2, t2, Curve.getPoint(v2, t2));
 			}
 		}
 	}
 	function addLineIntersection(v1, v2, curve1, curve2, locations, include) {
 	_class: 'CurveLocation',
 	beans: true,
 	initialize: function CurveLocation(curve, parameter, point, _curve2,
 			_parameter2, _point2, _distance) {
-		this._id = CurveLocation._id = (CurveLocation._id || 0) + 1;
+		this._id = UID.get(CurveLocation);
+		var path = curve._path;
+		this._version = path ? path._version : 0;
 		this._curve = curve;
-		this._segment1 = curve._segment1;
-		this._segment2 = curve._segment2;
 		this._parameter = parameter;
-		this._point = point;
+		this._point = point || curve.getPointAt(parameter, true);
 		this._curve2 = _curve2;
 		this._parameter2 = _parameter2;
 		this._point2 = _point2;
 		this._distance = _distance;
+		this._segment1 = curve._segment1;
+		this._segment2 = curve._segment2;
 	},
 	getSegment: function(_preferFirst) {
 		if (!this._segment) {
 			var curve = this.getCurve(),
 			}
 		}
 		return this._segment;
 	},
-	getCurve: function(_uncached) {
+	getCurve: function() {
-		if (!this._curve || _uncached) {
+		var curve = this._curve,
-			this._curve = this._segment1.getCurve();
+			path = curve && curve._path;
-			if (this._curve.getParameterOf(this._point) == null)
+		if (path && path._version !== this._version) {
-				this._curve = this._segment2.getPrevious().getCurve();
+			curve = null;
-		}
+			this._parameter = null;
-		return this._curve;
+		}
-	},
+		if (!curve) {
+			curve = this._segment1.getCurve();
-	getIntersection: function() {
+			if (curve.getParameterOf(this._point) == null)
-		var intersection = this._intersection;
+				curve = this._segment2.getPrevious().getCurve();
-		if (!intersection && this._curve2) {
+			this._curve = curve;
-			var param = this._parameter2;
+			path = curve._path;
-			this._intersection = intersection = new CurveLocation(
+			this._version = path ? path._version : 0;
-					this._curve2, param, this._point2 || this._point, this);
+		}
-			intersection._intersection = this;
+		return curve;
-		}
-		return intersection;
 	},
 	getPath: function() {
 		var curve = this.getCurve();
 		return curve && curve._path;
 	},
 	getIndex: function() {
 		var curve = this.getCurve();
 		return curve && curve.getIndex();
+	},
+	getParameter: function() {
+		var curve = this.getCurve(),
+			parameter = this._parameter;
+		return curve && parameter == null
+			? this._parameter = curve.getParameterOf(this._point)
+			: parameter;
+	},
+	getPoint: function() {
+		return this._point;
 	},
 	getOffset: function() {
 		var path = this.getPath();
 		return path ? path._getOffset(this) : this.getCurveOffset();
 		var curve = this.getCurve(),
 			parameter = this.getParameter();
 		return parameter != null && curve && curve.getPartLength(0, parameter);
 	},
-	getParameter: function(_uncached) {
+	getIntersection: function() {
-		if ((this._parameter == null || _uncached) && this._point) {
+		var intersection = this._intersection;
-			var curve = this.getCurve(_uncached);
+		if (!intersection && this._curve2) {
-			this._parameter = curve && curve.getParameterOf(this._point);
+			this._intersection = intersection = new CurveLocation(this._curve2,
-		}
+					this._parameter2, this._point2 || this._point, this);
-		return this._parameter;
+			intersection._intersection = this;
-	},
+		}
+		return intersection;
-	getPoint: function(_uncached) {
-		if ((!this._point || _uncached) && this._parameter != null) {
-			var curve = this.getCurve(_uncached);
-			this._point = curve && curve.getPointAt(this._parameter, true);
-		}
-		return this._point;
 	},
 	getDistance: function() {
 		return this._distance;
 	},
 	divide: function() {
-		var curve = this.getCurve(true);
+		var curve = this.getCurve();
-		return curve && curve.divide(this.getParameter(true), true);
+		return curve && curve.divide(this.getParameter(), true);
 	},
 	split: function() {
-		var curve = this.getCurve(true);
+		var curve = this.getCurve();
-		return curve && curve.split(this.getParameter(true), true);
+		return curve && curve.split(this.getParameter(), true);
 	},
 	equals: function(loc) {
 		var abs = Math.abs,
 			tolerance = 0.000001;
 		return this === loc
-				|| loc
+				|| loc instanceof CurveLocation
-					&& this._curve === loc._curve
+					&& this.getCurve() === loc.getCurve()
+					&& abs(this.getParameter() - loc.getParameter()) < tolerance
 					&& this._curve2 === loc._curve2
-					&& abs(this._parameter - loc._parameter) <= tolerance
+					&& abs(this._parameter2 - loc._parameter2) < tolerance
-					&& abs(this._parameter2 - loc._parameter2) <= tolerance
 				|| false;
 	},
 	toString: function() {
 		var parts = [],
 			parts.push('parameter: ' + f.number(parameter));
 		if (this._distance != null)
 			parts.push('distance: ' + f.number(this._distance));
 		return '{ ' + parts.join(', ') + ' }';
 	}
-}, Base.each(['getTangent', 'getNormal', 'getCurvature'], function(name) {
+}, Base.each(Curve.evaluateMethods, function(name) {
-	var get = name + 'At';
+	if (name !== 'getPoint') {
-	this[name] = function() {
+		var get = name + 'At';
-		var parameter = this.getParameter(),
+		this[name] = function() {
-			curve = this.getCurve();
+			var parameter = this.getParameter(),
-		return parameter != null && curve && curve[get](parameter, true);
+				curve = this.getCurve();
-	};
+			return parameter != null && curve && curve[get](parameter, true);
+		};
+	}
 }, {}));
 var PathItem = Item.extend({
 	_class: 'PathItem',
 				this.moveTo(current = start);
 			switch (lower) {
 			case 'm':
 			case 'l':
 				var move = lower === 'm';
-				if (move && previous && previous !== 'z')
-					this.closePath(true);
 				for (var j = 0; j < length; j += 2)
 					this[j === 0 && move ? 'moveTo' : 'lineTo'](
 							current = getPoint(j));
 				control = current;
 				if (move)
 	},
 	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
 		if (flags & 8) {
 			var parent = this._parent;
 			if (parent)
 				parent._currentPath = undefined;
 			this._length = this._clockwise = undefined;
-			if (this._curves && !(flags & 16)) {
+			if (flags & 16) {
-				for (var i = 0, l = this._curves.length; i < l; i++)
+				this._version++;
+			} else if (this._curves) {
+			   for (var i = 0, l = this._curves.length; i < l; i++)
 					this._curves[i]._changed();
 			}
 			this._monoCurves = undefined;
 		} else if (flags & 32) {
 			this._bounds = undefined;
 	isEmpty: function() {
 		return this._segments.length === 0;
 	},
-	isPolygon: function() {
+	isLinear: function() {
-		for (var i = 0, l = this._segments.length; i < l; i++) {
+		var segments = this._segments;
-			if (!this._segments[i].isLinear())
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (!segments[i].isLinear())
 				return false;
 		}
 		return true;
+	},
+	hasHandles: function() {
+		var segments = this._segments;
+		for (var i = 0, l = segments.length; i < l; i++) {
+			if (segments[i].hasHandles())
+				return true;
+		}
+		return false;
 	},
 	_transformContent: function(matrix) {
 		var coords = new Array(6);
 		for (var i = 0, l = this._segments.length; i < l; i++)
 			pos = 0,
 			step = iterator.length / Math.ceil(iterator.length / maxDistance),
 			end = iterator.length + (this._closed ? -step : step) / 2;
 		var segments = [];
 		while (pos <= end) {
-			segments.push(new Segment(iterator.evaluate(pos, 0)));
+			segments.push(new Segment(iterator.getPointAt(pos)));
 			pos += step;
 		}
 		this.setSegments(segments);
 	},
 			type,
 			size,
 			radius,
 			topCenter;
-		function isColinear(i, j) {
+		function isCollinear(i, j) {
-			return segments[i].isColinear(segments[j]);
+			return segments[i].isCollinear(segments[j]);
 		}
 		function isOrthogonal(i) {
 			return segments[i].isOrthogonal();
 		}
 		function isArc(i) {
-			return segments[i].isArc();
+			return segments[i].isOrthogonalArc();
 		}
 		function getDistance(i, j) {
 			return segments[i]._point.getDistance(segments[j]._point);
 		}
-		if (this.isPolygon() && segments.length === 4
+		if (!this.hasHandles() && segments.length === 4
-				&& isColinear(0, 2) && isColinear(1, 3) && isOrthogonal(1)) {
+				&& 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) && isColinear(1, 5) && isColinear(3, 7)) {
+				&& 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);
 			topCenter = segments[1]._point;
 		}
 		if (type) {
 			var center = this.getPosition(true),
-				shape = new type({
+				shape = this._clone(new type({
 					center: center,
 					size: size,
 					radius: radius,
 					insert: false
-				});
+				}), insert, false);
 			shape.rotate(topCenter.subtract(center).getAngle() + 90);
-			shape.setStyle(this._style);
-			if (insert || insert === undefined)
-				shape.insertAbove(this);
 			return shape;
 		}
 		return null;
 	},
 							point: loc.getPoint()
 						})
 						: null;
 	}
-}, Base.each(['getPoint', 'getTangent', 'getNormal', 'getCurvature'],
+}, Base.each(Curve.evaluateMethods,
 	function(name) {
 		this[name + 'At'] = function(offset, isParameter) {
 			var loc = this.getLocationAt(offset, isParameter);
 			return loc && loc[name]();
 		};
 	getLocationAt: function(offset, isParameter) {
 		var curves = this.getCurves(),
 			length = 0;
 		if (isParameter) {
-			var index = ~~offset;
+			var index = ~~offset,
-			return curves[index].getLocationAt(offset - index, true);
+				curve = curves[index];
+			return curve ? curve.getLocationAt(offset - index, true) : null;
 		}
 		for (var i = 0, l = curves.length; i < l; i++) {
 			var start = length,
 				curve = curves[i];
 			length += curve.getLength();
 		function addJoin(segment, join) {
 			var handleIn = segment._handleIn,
 				handleOut = segment._handleOut;
 			if (join === 'round' || !handleIn.isZero() && !handleOut.isZero()
-					&& handleIn.isColinear(handleOut)) {
+					&& handleIn.isCollinear(handleOut)) {
 				addRound(segment);
 			} else {
 				Path._addBevelJoin(segment, join, radius, miterLimit, add);
 			}
 		}
 	},
 	_addSquareCap: function(segment, cap, radius, addPoint, area) {
 		var point = segment._point,
 			loc = segment.getLocation(),
-			normal = loc.getNormal().normalize(radius);
+			normal = loc.getNormal().multiply(radius);
 		if (area) {
 			addPoint(point.subtract(normal));
 			addPoint(point.add(normal));
 		}
 		if (cap === 'square')
 				totalLength += length;
 				segment = segment.getNext();
 			} while (segment && !segment._intersection && segment !== startSeg);
 			for (var j = 0; j < 3; j++) {
 				var length = totalLength * (j + 1) / 4;
-				for (k = 0, m = chain.length; k < m; k++) {
+				for (var k = 0, m = chain.length; k < m; k++) {
 					var node = chain[k],
 						curveLength = node.length;
 					if (length <= curveLength) {
-						if (length <= tolerance
+						if (length < tolerance
-								|| curveLength - length <= tolerance)
+								|| curveLength - length < tolerance)
 							length = curveLength / 2;
 						var curve = node.segment.getCurve(),
 							pt = curve.getPointAt(length),
 							hor = curve.isLinear() && Math.abs(curve
-									.getTangentAt(0.5, true).y) <= tolerance,
+									.getTangentAt(0.5, true).y) < tolerance,
 							path = curve._path;
 						if (path._parent instanceof CompoundPath)
 							path = path._parent;
 						windingSum += operation === 'subtract' && _path2
 							&& (path === _path1 && _path2._getWinding(pt, hor)
 				yAfter = py + tolerance;
 			for (var i = 0, l = curves.length; i < l; i++) {
 				var values = curves[i].values;
 				if (Curve.solveCubic(values, 0, px, roots, 0, 1) > 0) {
 					for (var j = roots.length - 1; j >= 0; j--) {
-						var y = Curve.evaluate(values, roots[j], 0).y;
+						var y = Curve.getPoint(values, roots[j]).y;
 						if (y < yBefore && y > yTop) {
 							yTop = y;
 						} else if (y > yAfter && y < yBottom) {
 							yBottom = y;
 						}
 			if (yBottom < Infinity)
 				windRight = getWinding(new Point(px, yBottom), curves);
 		} else {
 			var xBefore = px - tolerance,
 				xAfter = px + tolerance;
+			var startCounted = false,
+				prevCurve,
+				prevT;
 			for (var i = 0, l = curves.length; i < l; i++) {
 				var curve = curves[i],
 					values = curve.values,
-					winding = curve.winding,
+					winding = curve.winding;
-					prevT,
-					prevX;
 				if (winding && (winding === 1
 						&& py >= values[1] && py <= values[7]
 						|| py >= values[7] && py <= values[1])
 					&& Curve.solveCubic(values, 1, py, roots, 0, 1) === 1) {
-					var t = roots[0],
+					var t = roots[0];
-						x = Curve.evaluate(values, t, 0).x,
+					if (!(
-						slope = Curve.evaluate(values, t, 1).y;
+						t > tMax && startCounted && curve.next !== curves[i + 1]
-					if (!(t > tMax
+						|| t < tMin && prevT > tMax
-							&& (i === l - 1 || curve.next !== curves[i + 1])
+							&& curve.previous === prevCurve)) {
-							&& abs(Curve.evaluate(curve.next.values, 0, 0).x -x)
+						var x = Curve.getPoint(values, t).x,
-								<= tolerance
+							slope = Curve.getTangent(values, t).y,
-						|| i > 0 && curve.previous === curves[i - 1]
+							counted = false;
-							&& abs(prevX - x) < tolerance
-							&& prevT > tMax && t < tMin)) {
 						if (Numerical.isZero(slope) && !Curve.isLinear(values)
-								|| t < tMin && slope * Curve.evaluate(
+								|| t < tMin && slope * Curve.getTangent(
-									curve.previous.values, 1, 1).y < 0
+									curve.previous.values, 1).y < 0
-								|| t > tMax && slope * Curve.evaluate(
+								|| t > tMax && slope * Curve.getTangent(
-									curve.next.values, 0, 1).y < 0) {
+									curve.next.values, 0).y < 0) {
 							if (testContains && x >= xBefore && x <= xAfter) {
 								++windLeft;
 								++windRight;
+								counted = true;
 							}
 						} else if (x <= xBefore) {
 							windLeft += winding;
+							counted = true;
 						} else if (x >= xAfter) {
 							windRight += winding;
+							counted = true;
 						}
+						if (curve.previous !== curves[i - 1])
+							startCounted = t < tMin && counted;
 					}
+					prevCurve = curve;
 					prevT = t;
-					prevX = x;
 				}
 			}
 		}
 		return Math.max(abs(windLeft), abs(windRight));
 	}
 				path.setClosed(true);
 			} else {
 				path.lastSegment._handleOut.set(0, 0);
 			}
 			if (path._segments.length >
-					(path._closed ? path.isPolygon() ? 2 : 0 : 1))
+					(path._closed ? path.isLinear() ? 2 : 0 : 1))
 				paths.push(path);
 		}
 		return paths;
 	}
 				if ((curves[i].winding === 1
 						&& y >= values[1] && y <= values[7]
 						|| y >= values[7] && y <= values[1])
 						&& Curve.solveCubic(values, 1, y, roots, 0, 1) > 0) {
 					for (var j = roots.length - 1; j >= 0; j--)
-						xIntercepts.push(Curve.evaluate(values, roots[j], 0).x);
+						xIntercepts.push(Curve.getPoint(values, roots[j]).x);
 				}
 				if (xIntercepts.length > 1)
 					break;
 			}
 			point.x = (xIntercepts[0] + xIntercepts[1]) / 2;
 			value: 1,
 			index: part.index
 		};
 	},
-	evaluate: function(offset, type) {
-		var param = this.getParameterAt(offset);
-		return Curve.evaluate(this.curves[param.index], param.value, type);
-	},
 	drawPart: function(ctx, from, to) {
 		from = this.getParameterAt(from);
 		to = this.getParameterAt(to);
 		for (var i = from.index; i <= to.index; i++) {
 			var curve = Curve.getPart(this.curves[i],
 			if (i == from.index)
 				ctx.moveTo(curve[0], curve[1]);
 			ctx.bezierCurveTo.apply(ctx, curve.slice(2));
 		}
 	}
-}, Base.each(['getPoint', 'getTangent', 'getNormal', 'getCurvature'],
+}, Base.each(Curve.evaluateMethods,
-	function(name, index) {
+	function(name) {
-		this[name + 'At'] = function(offset) {
+		this[name + 'At'] = function(offset, weighted) {
-			return this.evaluate(offset, index);
+			var param = this.getParameterAt(offset);
+			return Curve[name](this.curves[param.index], param.value, weighted);
 		};
 	}, {})
 );
 var PathFitter = Base.extend({
 					pt2.add(tan2.normalize(dist)), pt2]);
 			return;
 		}
 		var uPrime = this.chordLengthParameterize(first, last),
 			maxError = Math.max(this.error, this.error * this.error),
-			split;
+			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 < this.error) {
+			if (max.error < this.error && parametersInOrder) {
 				this.addCurve(curve);
 				return;
 			}
 			split = max.index;
 			if (max.error >= maxError)
 				break;
-			this.reparameterize(first, last, uPrime, curve);
+			parametersInOrder = this.reparameterize(first, last, uPrime, curve);
 			maxError = max.error;
 		}
 		var V1 = this.points[split - 1].subtract(this.points[split]),
 			V2 = this.points[split].subtract(this.points[split + 1]),
 			tanCenter = V1.add(V2).divide(2).normalize();
 			} else {
 				alpha1 = alpha2 = 0;
 			}
 		}
-		var segLength = pt2.getDistance(pt1);
+		var segLength = pt2.getDistance(pt1),
-		epsilon *= segLength;
+			eps = epsilon * segLength,
-		if (alpha1 < epsilon || alpha2 < epsilon) {
+			handle1,
+			handle2;
+		if (alpha1 < eps || alpha2 < eps) {
 			alpha1 = alpha2 = segLength / 3;
-		}
+		} else {
+			var line = pt2.subtract(pt1);
-		return [pt1, pt1.add(tan1.normalize(alpha1)),
+			handle1 = tan1.normalize(alpha1);
-				pt2.add(tan2.normalize(alpha2)), pt2];
+			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 = [];
 	_equals: function(item) {
 		return this._content === item._content;
 	},
-	_clone: function _clone(copy, insert) {
+	_clone: function _clone(copy, insert, includeMatrix) {
 		copy.setContent(this._content);
-		return _clone.base.call(this, copy, insert);
+		return _clone.base.call(this, copy, insert, includeMatrix);
 	},
 	getContent: function() {
 		return this._content;
 	},
 						&& !(hasOverlap && /^hs[bl]$/.test(this._type))) {
 					this._components = this._convert(type);
 					this._properties = types[type];
 					this._type = type;
 				}
-				value = parser.call(this, value);
+				this._components[index] = parser.call(this, value);
-				if (value != null) {
+				this._changed();
-					this._components[index] = value;
-					this._changed();
-				}
 			};
 		}, this);
 	}, {
 		_class: 'Color',
 		_readIndex: true,
 				}
 				if (this.__read && type)
 					read = 1;
 			}
 			this._type = type || 'rgb';
-			if (type === 'gradient')
+			this._id = UID.get(Color);
-				this._id = Color._id = (Color._id || 0) + 1;
 			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]);
 var Gradient = Base.extend({
 	_class: 'Gradient',
 	initialize: function Gradient(stops, radial) {
-		this._id = Gradient._id = (Gradient._id || 0) + 1;
+		this._id = UID.get();
 		if (stops && this._set(stops))
 			stops = radial = null;
 		if (!this._stops)
 			this.setStops(stops || ['white', 'black']);
 		if (this._radial == null)
 	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);
+		return new Gradient(stops, this._radial);
 	},
 	getStops: function() {
 		return this._stops;
 	},
 			this._context.scale(pixelRatio, pixelRatio);
 		}
 	},
 	getPixelSize: function(size) {
-		var ctx = this._context,
+		var browser = paper.browser,
-			prevFont = ctx.font;
+			pixels;
-		ctx.font = size + ' serif';
+		if (browser && browser.firefox) {
-		size = parseFloat(ctx.font);
+			var parent = this._element.parentNode,
-		ctx.font = prevFont;
+				temp = document.createElement('div');
-		return size;
+			temp.style.fontSize = size;
+			parent.appendChild(temp);
+			pixels = parseFloat(DomElement.getStyles(temp).fontSize);
+			parent.removeChild(temp);
+		} 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 = Math.max(width, ctx.measureText(lines[i]).width);
 		ctx.font = prevFont;
 		return width;
 	},
-	update: function() {
+	update: function(force) {
 		var project = this._project;
-		if (!project || !project._needsUpdate)
+		if (!project || !force && !project._needsUpdate)
 			return false;
 		var ctx = this._context,
 			size = this._viewSize;
 		ctx.clearRect(0, 0, size.width + 1, size.height + 1);
 		project.draw(ctx, this._matrix, this._pixelRatio);
 		space: false
 	}),
 	charCodeMap = {},
 	keyMap = {},
+	commandFixMap,
 	downCode;
 	function handleKey(down, keyCode, charCode, event) {
 		var character = charCode ? String.fromCharCode(charCode) : '',
 			specialKey = specialKeys[keyCode],
 			view = View._focused,
 			scope = view && view.isVisible() && view._scope,
 			tool = scope && scope.tool,
 			name;
 		keyMap[key] = down;
-		if (specialKey && (name = Base.camelize(specialKey)) in modifiers)
-			modifiers[name] = down;
 		if (down) {
 			charCodeMap[keyCode] = charCode;
 		} else {
 			delete charCodeMap[keyCode];
+		}
+		if (specialKey && (name = Base.camelize(specialKey)) in modifiers) {
+			modifiers[name] = down;
+			var browser = paper.browser;
+			if (name === 'command' && browser && browser.mac) {
+				if (down) {
+					commandFixMap = {};
+				} else {
+					for (var code in commandFixMap) {
+						if (code in charCodeMap)
+							handleKey(false, code, commandFixMap[code], event);
+					}
+					commandFixMap = null;
+				}
+			}
+		} else if (down && commandFixMap) {
+			commandFixMap[keyCode] = charCode;
 		}
 		if (tool && tool.responds(type)) {
 			paper = scope;
 			tool.emit(type, new KeyEvent(down, key, character, event));
 			if (view)
 		return this._minDistance;
 	},
 	setMinDistance: function(minDistance) {
 		this._minDistance = minDistance;
-		if (this._minDistance != null && this._maxDistance != null
+		if (minDistance != null && this._maxDistance != null
-				&& this._minDistance > this._maxDistance) {
+				&& minDistance > this._maxDistance) {
-			this._maxDistance = this._minDistance;
+			this._maxDistance = minDistance;
 		}
 	},
 	getMaxDistance: function() {
 		return this._maxDistance;
 	},
 	setMaxDistance: function(maxDistance) {
 		this._maxDistance = maxDistance;
-		if (this._minDistance != null && this._maxDistance != null
+		if (this._minDistance != null && maxDistance != null
-				&& this._maxDistance < this._minDistance) {
+				&& maxDistance < this._minDistance) {
 			this._minDistance = maxDistance;
 		}
 	},
 	getFixedDistance: function() {
 				var minDist = minDistance != null ? minDistance : 0,
 					vector = point.subtract(this._point),
 					distance = vector.getLength();
 				if (distance < minDist)
 					return false;
-				var maxDist = maxDistance != null ? maxDistance : 0;
+				if (maxDistance != null && maxDistance != 0) {
-				if (maxDist != 0) {
+					if (distance > maxDistance) {
-					if (distance > maxDist) {
+						point = this._point.add(vector.normalize(maxDistance));
-						point = this._point.add(vector.normalize(maxDist));
 					} else if (matchMaxDistance) {
 						return false;
 					}
 				}
 			}
 	}
 });
 var Http = {
-	request: function(method, url, callback) {
+	request: function(method, url, callback, async) {
+		async = (async === undefined) ? true : async;
 		var xhr = new (window.ActiveXObject || XMLHttpRequest)(
 					'Microsoft.XMLHTTP');
-		xhr.open(method.toUpperCase(), url, true);
+		xhr.open(method.toUpperCase(), url, async);
 		if ('overrideMimeType' in xhr)
 			xhr.overrideMimeType('text/plain');
 		xhr.onreadystatechange = function() {
 			if (xhr.readyState === 4) {
 				var status = xhr.status;
 			}
 		}
 		return node;
 	}
-	function exportRaster(item) {
+	function exportRaster(item, options) {
 		var attrs = getTransform(item._matrix, true),
-			size = item.getSize();
+			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 = item.toDataURL();
+		attrs.href = options.embedImages === false && image && image.src
+				|| item.toDataURL();
 		return createElement('image', attrs);
 	}
 	function exportPath(item, options) {
-		if (options.matchShapes) {
+		var matchShapes = options.matchShapes;
+		if (matchShapes) {
 			var shape = item.toShape(false);
 			if (shape)
 				return exportShape(shape, options);
 		}
 		var segments = item._segments,
 			type,
 			attrs = getTransform(item._matrix);
 		if (segments.length === 0)
 			return null;
-		if (item.isPolygon()) {
+		if (matchShapes && !item.hasHandles()) {
 			if (segments.length >= 3) {
 				type = item._closed ? 'polygon' : 'polyline';
 				var parts = [];
-				for(i = 0, l = segments.length; i < l; i++)
+				for(var i = 0, l = segments.length; i < l; i++)
 					parts.push(formatter.point(segments[i]._point));
 				attrs.points = parts.join(' ');
 			} else {
 				type = 'line';
 				var first = segments[0]._point,
 			children = [];
 		if (!isClip) {
 			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++) {
+				importSVG(defs[i], options, false);
+			}
+		}
 		for (var i = 0, l = nodes.length; i < l; i++) {
 			var childNode = nodes[i],
 				child;
 			if (childNode.nodeType === 1
+					&& childNode.nodeName.toLowerCase() !== 'defs'
 					&& (child = importSVG(childNode, options, false))
 					&& !(child instanceof Symbol))
 				children.push(child);
 		}
 		item.addChildren(children);
 				: 'getStrokeColor']();
 		if (color)
 			color.setAlpha(parseFloat(value));
 	}
-	var attributes = Base.each(SVGStyles, function(entry) {
+	var attributes = Base.set(Base.each(SVGStyles, function(entry) {
 		this[entry.attribute] = function(item, value) {
 			item[entry.set](convertValue(value, entry.type, entry.fromSVG));
 			if (entry.type === 'color' && item instanceof Shape) {
 				var color = item[entry.get]();
 				if (color)
 					color.transform(new Matrix().translate(
 							item.getPosition(true).negate()));
 			}
 		};
-	}, {
+	}, {}), {
 		id: function(item, value) {
 			definitions[value] = item;
 			if (item.setName)
 				item.setName(value);
 		},
 			if (data)
 				item._data = JSON.parse(data);
 		}
 		if (isRoot) {
 			definitions = {};
-			if (applyMatrix && item)
+			if (item && Base.pick(options.applyMatrix, applyMatrix))
 				item.matrix.apply(true, true);
 		}
 		return item;
 	}
 						|| parentType === 'BinaryExpression'
 							&& /^[=!<>]/.test(parent.operator)
 						|| parentType === 'MemberExpression' && parent.computed
 				)) {
 					if (node.type === 'UpdateExpression') {
-						var arg = getCode(node.argument);
+						var arg = getCode(node.argument),
-						var str = arg + ' = __$__(' + arg
+							exp = '__$__(' + arg + ', "' + node.operator[0]
-								+ ', "' + node.operator[0] + '", 1)';
+									+ '", 1)',
+							str = arg + ' = ' + exp;
 						if (!node.prefix
 								&& (parentType === 'AssignmentExpression'
-									|| parentType === 'VariableDeclarator'))
+									|| 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),
 	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,
+				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('get', src, function(code) {
 					execute(code, scope, src);
-				});
+				}, async);
 			} else {
 				execute(script.innerHTML, scope, script.baseURI);
 			}
 			script.setAttribute('data-paper-ignore', 'true');
 			return scope;

renkan