1 /*!

     2  * Paper.js v0.9.20 - The Swiss Army Knife of Vector Graphics Scripting.

     3  * http://paperjs.org/

     4  *

     5  * Copyright (c) 2011 - 2014, Juerg Lehni & Jonathan Puckey

     6  * http://scratchdisk.com/ & http://jonathanpuckey.com/

     7  *

     8  * Distributed under the MIT license. See LICENSE file for details.

     9  *

    10  * All rights reserved.

    11  *

    12  * Date: Mon Aug 25 14:21:13 2014 +0200

    13  *

    14  ***

    15  *

    16  * Straps.js - Class inheritance library with support for bean-style accessors

    17  *

    18  * Copyright (c) 2006 - 2013 Juerg Lehni

    19  * http://scratchdisk.com/

    20  *

    21  * Distributed under the MIT license.

    22  *

    23  ***

    24  *

    25  * Acorn.js

    26  * http://marijnhaverbeke.nl/acorn/

    27  *

    28  * Acorn is a tiny, fast JavaScript parser written in JavaScript,

    29  * created by Marijn Haverbeke and released under an MIT license.

    30  *

    31  */

    32 

    33 var paper = new function(undefined) {

    34 

    35 var Base = new function() {

    36 	var hidden = /^(statics|enumerable|beans|preserve)$/,

    37 

    38 		forEach = [].forEach || function(iter, bind) {

    39 			for (var i = 0, l = this.length; i < l; i++)

    40 				iter.call(bind, this[i], i, this);

    41 		},

    42 

    43 		forIn = function(iter, bind) {

    44 			for (var i in this)

    45 				if (this.hasOwnProperty(i))

    46 					iter.call(bind, this[i], i, this);

    47 		},

    48 

    49 		create = Object.create || function(proto) {

    50 			return { __proto__: proto };

    51 		},

    52 

    53 		describe = Object.getOwnPropertyDescriptor || function(obj, name) {

    54 			var get = obj.__lookupGetter__ && obj.__lookupGetter__(name);

    55 			return get

    56 					? { get: get, set: obj.__lookupSetter__(name),

    57 						enumerable: true, configurable: true }

    58 					: obj.hasOwnProperty(name)

    59 						? { value: obj[name], enumerable: true,

    60 							configurable: true, writable: true }

    61 						: null;

    62 		},

    63 

    64 		_define = Object.defineProperty || function(obj, name, desc) {

    65 			if ((desc.get || desc.set) && obj.__defineGetter__) {

    66 				if (desc.get)

    67 					obj.__defineGetter__(name, desc.get);

    68 				if (desc.set)

    69 					obj.__defineSetter__(name, desc.set);

    70 			} else {

    71 				obj[name] = desc.value;

    72 			}

    73 			return obj;

    74 		},

    75 

    76 		define = function(obj, name, desc) {

    77 			delete obj[name];

    78 			return _define(obj, name, desc);

    79 		};

    80 

    81 	function inject(dest, src, enumerable, beans, preserve) {

    82 		var beansNames = {};

    83 

    84 		function field(name, val) {

    85 			val = val || (val = describe(src, name))

    86 					&& (val.get ? val : val.value);

    87 			if (typeof val === 'string' && val[0] === '#')

    88 				val = dest[val.substring(1)] || val;

    89 			var isFunc = typeof val === 'function',

    90 				res = val,

    91 				prev = preserve || isFunc

    92 						? (val && val.get ? name in dest : dest[name])

    93 						: null,

    94 				bean;

    95 			if (!preserve || !prev) {

    96 				if (isFunc && prev)

    97 					val.base = prev;

    98 				if (isFunc && beans !== false

    99 						&& (bean = name.match(/^([gs]et|is)(([A-Z])(.*))$/)))

   100 					beansNames[bean[3].toLowerCase() + bean[4]] = bean[2];

   101 				if (!res || isFunc || !res.get || typeof res.get !== 'function'

   102 						|| !Base.isPlainObject(res))

   103 					res = { value: res, writable: true };

   104 				if ((describe(dest, name)

   105 						|| { configurable: true }).configurable) {

   106 					res.configurable = true;

   107 					res.enumerable = enumerable;

   108 				}

   109 				define(dest, name, res);

   110 			}

   111 		}

   112 		if (src) {

   113 			for (var name in src) {

   114 				if (src.hasOwnProperty(name) && !hidden.test(name))

   115 					field(name);

   116 			}

   117 			for (var name in beansNames) {

   118 				var part = beansNames[name],

   119 					set = dest['set' + part],

   120 					get = dest['get' + part] || set && dest['is' + part];

   121 				if (get && (beans === true || get.length === 0))

   122 					field(name, { get: get, set: set });

   123 			}

   124 		}

   125 		return dest;

   126 	}

   127 

   128 	function each(obj, iter, bind) {

   129 		if (obj)

   130 			('length' in obj && !obj.getLength

   131 					&& typeof obj.length === 'number'

   132 				? forEach

   133 				: forIn).call(obj, iter, bind = bind || obj);

   134 		return bind;

   135 	}

   136 

   137 	function set(obj, props) {

   138 		for (var i in props)

   139 			if (props.hasOwnProperty(i))

   140 				obj[i] = props[i];

   141 		return obj;

   142 	}

   143 

   144 	return inject(function Base() {

   145 		for (var i = 0, l = arguments.length; i < l; i++)

   146 			set(this, arguments[i]);

   147 	}, {

   148 		inject: function(src) {

   149 			if (src) {

   150 				var statics = src.statics === true ? src : src.statics,

   151 					beans = src.beans,

   152 					preserve = src.preserve;

   153 				if (statics !== src)

   154 					inject(this.prototype, src, src.enumerable, beans, preserve);

   155 				inject(this, statics, true, beans, preserve);

   156 			}

   157 			for (var i = 1, l = arguments.length; i < l; i++)

   158 				this.inject(arguments[i]);

   159 			return this;

   160 		},

   161 

   162 		extend: function() {

   163 			var base = this,

   164 				ctor;

   165 			for (var i = 0, l = arguments.length; i < l; i++)

   166 				if (ctor = arguments[i].initialize)

   167 					break;

   168 			ctor = ctor || function() {

   169 				base.apply(this, arguments);

   170 			};

   171 			ctor.prototype = create(this.prototype);

   172 			ctor.base = base;

   173 			define(ctor.prototype, 'constructor',

   174 					{ value: ctor, writable: true, configurable: true });

   175 			inject(ctor, this, true);

   176 			return arguments.length ? this.inject.apply(ctor, arguments) : ctor;

   177 		}

   178 	}, true).inject({

   179 		inject: function() {

   180 			for (var i = 0, l = arguments.length; i < l; i++) {

   181 				var src = arguments[i];

   182 				if (src)

   183 					inject(this, src, src.enumerable, src.beans, src.preserve);

   184 			}

   185 			return this;

   186 		},

   187 

   188 		extend: function() {

   189 			var res = create(this);

   190 			return res.inject.apply(res, arguments);

   191 		},

   192 

   193 		each: function(iter, bind) {

   194 			return each(this, iter, bind);

   195 		},

   196 

   197 		set: function(props) {

   198 			return set(this, props);

   199 		},

   200 

   201 		clone: function() {

   202 			return new this.constructor(this);

   203 		},

   204 

   205 		statics: {

   206 			each: each,

   207 			create: create,

   208 			define: define,

   209 			describe: describe,

   210 			set: set,

   211 

   212 			clone: function(obj) {

   213 				return set(new obj.constructor(), obj);

   214 			},

   215 

   216 			isPlainObject: function(obj) {

   217 				var ctor = obj != null && obj.constructor;

   218 				return ctor && (ctor === Object || ctor === Base

   219 						|| ctor.name === 'Object');

   220 			},

   221 

   222 			pick: function() {

   223 				for (var i = 0, l = arguments.length; i < l; i++)

   224 					if (arguments[i] !== undefined)

   225 						return arguments[i];

   226 			}

   227 		}

   228 	});

   229 };

   230 

   231 if (typeof module !== 'undefined')

   232 	module.exports = Base;

   233 

   234 if (!Array.isArray) {

   235 	Array.isArray = function(obj) {

   236 		return Object.prototype.toString.call(obj) === '[object Array]';

   237 	};

   238 }

   239 

   240 if (!document.head) {

   241 	document.head = document.getElementsByTagName('head')[0];

   242 }

   243 

   244 Base.inject({

   245 	toString: function() {

   246 		return this._id != null

   247 			?  (this._class || 'Object') + (this._name

   248 				? " '" + this._name + "'"

   249 				: ' @' + this._id)

   250 			: '{ ' + Base.each(this, function(value, key) {

   251 				if (!/^_/.test(key)) {

   252 					var type = typeof value;

   253 					this.push(key + ': ' + (type === 'number'

   254 							? Formatter.instance.number(value)

   255 							: type === 'string' ? "'" + value + "'" : value));

   256 				}

   257 			}, []).join(', ') + ' }';

   258 	},

   259 

   260 	exportJSON: function(options) {

   261 		return Base.exportJSON(this, options);

   262 	},

   263 

   264 	toJSON: function() {

   265 		return Base.serialize(this);

   266 	},

   267 

   268 	_set: function(props, exclude, dontCheck) {

   269 		if (props && (dontCheck || Base.isPlainObject(props))) {

   270 			var orig = props._filtering || props;

   271 			for (var key in orig) {

   272 				if (key in this && orig.hasOwnProperty(key)

   273 						&& (!exclude || !exclude[key])) {

   274 					var value = props[key];

   275 					if (value !== undefined)

   276 						this[key] = value;

   277 				}

   278 			}

   279 			return true;

   280 		}

   281 	},

   282 

   283 	statics: {

   284 

   285 		exports: {

   286 			enumerable: true

   287 		},

   288 

   289 		extend: function extend() {

   290 			var res = extend.base.apply(this, arguments),

   291 				name = res.prototype._class;

   292 			if (name && !Base.exports[name])

   293 				Base.exports[name] = res;

   294 			return res;

   295 		},

   296 

   297 		equals: function(obj1, obj2) {

   298 			function checkKeys(o1, o2) {

   299 				for (var i in o1)

   300 					if (o1.hasOwnProperty(i) && !o2.hasOwnProperty(i))

   301 						return false;

   302 				return true;

   303 			}

   304 			if (obj1 === obj2)

   305 				return true;

   306 			if (obj1 && obj1.equals)

   307 				return obj1.equals(obj2);

   308 			if (obj2 && obj2.equals)

   309 				return obj2.equals(obj1);

   310 			if (Array.isArray(obj1) && Array.isArray(obj2)) {

   311 				if (obj1.length !== obj2.length)

   312 					return false;

   313 				for (var i = 0, l = obj1.length; i < l; i++) {

   314 					if (!Base.equals(obj1[i], obj2[i]))

   315 						return false;

   316 				}

   317 				return true;

   318 			}

   319 			if (obj1 && typeof obj1 === 'object'

   320 					&& obj2 && typeof obj2 === 'object') {

   321 				if (!checkKeys(obj1, obj2) || !checkKeys(obj2, obj1))

   322 					return false;

   323 				for (var i in obj1) {

   324 					if (obj1.hasOwnProperty(i)

   325 							&& !Base.equals(obj1[i], obj2[i]))

   326 						return false;

   327 				}

   328 				return true;

   329 			}

   330 			return false;

   331 		},

   332 

   333 		read: function(list, start, options, length) {

   334 			if (this === Base) {

   335 				var value = this.peek(list, start);

   336 				list.__index++;

   337 				return value;

   338 			}

   339 			var proto = this.prototype,

   340 				readIndex = proto._readIndex,

   341 				index = start || readIndex && list.__index || 0;

   342 			if (!length)

   343 				length = list.length - index;

   344 			var obj = list[index];

   345 			if (obj instanceof this

   346 				|| options && options.readNull && obj == null && length <= 1) {

   347 				if (readIndex)

   348 					list.__index = index + 1;

   349 				return obj && options && options.clone ? obj.clone() : obj;

   350 			}

   351 			obj = Base.create(this.prototype);

   352 			if (readIndex)

   353 				obj.__read = true;

   354 			obj = obj.initialize.apply(obj, index > 0 || length < list.length

   355 				? Array.prototype.slice.call(list, index, index + length)

   356 				: list) || obj;

   357 			if (readIndex) {

   358 				list.__index = index + obj.__read;

   359 				obj.__read = undefined;

   360 			}

   361 			return obj;

   362 		},

   363 

   364 		peek: function(list, start) {

   365 			return list[list.__index = start || list.__index || 0];

   366 		},

   367 

   368 		remain: function(list) {

   369 			return list.length - (list.__index || 0);

   370 		},

   371 

   372 		readAll: function(list, start, options) {

   373 			var res = [],

   374 				entry;

   375 			for (var i = start || 0, l = list.length; i < l; i++) {

   376 				res.push(Array.isArray(entry = list[i])

   377 						? this.read(entry, 0, options)

   378 						: this.read(list, i, options, 1));

   379 			}

   380 			return res;

   381 		},

   382 

   383 		readNamed: function(list, name, start, options, length) {

   384 			var value = this.getNamed(list, name),

   385 				hasObject = value !== undefined;

   386 			if (hasObject) {

   387 				var filtered = list._filtered;

   388 				if (!filtered) {

   389 					filtered = list._filtered = Base.create(list[0]);

   390 					filtered._filtering = list[0];

   391 				}

   392 				filtered[name] = undefined;

   393 			}

   394 			return this.read(hasObject ? [value] : list, start, options, length);

   395 		},

   396 

   397 		getNamed: function(list, name) {

   398 			var arg = list[0];

   399 			if (list._hasObject === undefined)

   400 				list._hasObject = list.length === 1 && Base.isPlainObject(arg);

   401 			if (list._hasObject)

   402 				return name ? arg[name] : list._filtered || arg;

   403 		},

   404 

   405 		hasNamed: function(list, name) {

   406 			return !!this.getNamed(list, name);

   407 		},

   408 

   409 		isPlainValue: function(obj, asString) {

   410 			return this.isPlainObject(obj) || Array.isArray(obj)

   411 					|| asString && typeof obj === 'string';

   412 		},

   413 

   414 		serialize: function(obj, options, compact, dictionary) {

   415 			options = options || {};

   416 

   417 			var root = !dictionary,

   418 				res;

   419 			if (root) {

   420 				options.formatter = new Formatter(options.precision);

   421 				dictionary = {

   422 					length: 0,

   423 					definitions: {},

   424 					references: {},

   425 					add: function(item, create) {

   426 						var id = '#' + item._id,

   427 							ref = this.references[id];

   428 						if (!ref) {

   429 							this.length++;

   430 							var res = create.call(item),

   431 								name = item._class;

   432 							if (name && res[0] !== name)

   433 								res.unshift(name);

   434 							this.definitions[id] = res;

   435 							ref = this.references[id] = [id];

   436 						}

   437 						return ref;

   438 					}

   439 				};

   440 			}

   441 			if (obj && obj._serialize) {

   442 				res = obj._serialize(options, dictionary);

   443 				var name = obj._class;

   444 				if (name && !compact && !res._compact && res[0] !== name)

   445 					res.unshift(name);

   446 			} else if (Array.isArray(obj)) {

   447 				res = [];

   448 				for (var i = 0, l = obj.length; i < l; i++)

   449 					res[i] = Base.serialize(obj[i], options, compact,

   450 							dictionary);

   451 				if (compact)

   452 					res._compact = true;

   453 			} else if (Base.isPlainObject(obj)) {

   454 				res = {};

   455 				for (var i in obj)

   456 					if (obj.hasOwnProperty(i))

   457 						res[i] = Base.serialize(obj[i], options, compact,

   458 								dictionary);

   459 			} else if (typeof obj === 'number') {

   460 				res = options.formatter.number(obj, options.precision);

   461 			} else {

   462 				res = obj;

   463 			}

   464 			return root && dictionary.length > 0

   465 					? [['dictionary', dictionary.definitions], res]

   466 					: res;

   467 		},

   468 

   469 		deserialize: function(json, create, _data) {

   470 			var res = json;

   471 			_data = _data || {};

   472 			if (Array.isArray(json)) {

   473 				var type = json[0],

   474 					isDictionary = type === 'dictionary';

   475 				if (!isDictionary) {

   476 					if (_data.dictionary && json.length == 1 && /^#/.test(type))

   477 						return _data.dictionary[type];

   478 					type = Base.exports[type];

   479 				}

   480 				res = [];

   481 				for (var i = type ? 1 : 0, l = json.length; i < l; i++)

   482 					res.push(Base.deserialize(json[i], create, _data));

   483 				if (isDictionary) {

   484 					_data.dictionary = res[0];

   485 				} else if (type) {

   486 					var args = res;

   487 					if (create) {

   488 						res = create(type, args);

   489 					} else {

   490 						res = Base.create(type.prototype);

   491 						type.apply(res, args);

   492 					}

   493 				}

   494 			} else if (Base.isPlainObject(json)) {

   495 				res = {};

   496 				for (var key in json)

   497 					res[key] = Base.deserialize(json[key], create, _data);

   498 			}

   499 			return res;

   500 		},

   501 

   502 		exportJSON: function(obj, options) {

   503 			var json = Base.serialize(obj, options);

   504 			return options && options.asString === false

   505 					? json

   506 					: JSON.stringify(json);

   507 		},

   508 

   509 		importJSON: function(json, target) {

   510 			return Base.deserialize(

   511 					typeof json === 'string' ? JSON.parse(json) : json,

   512 					function(type, args) {

   513 						var obj = target && target.constructor === type

   514 								? target

   515 								: Base.create(type.prototype),

   516 							isTarget = obj === target;

   517 						if (args.length === 1 && obj instanceof Item

   518 								&& (isTarget || !(obj instanceof Layer))) {

   519 							var arg = args[0];

   520 							if (Base.isPlainObject(arg))

   521 								arg.insert = false;

   522 						}

   523 						type.apply(obj, args);

   524 						if (isTarget)

   525 							target = null;

   526 						return obj;

   527 					});

   528 		},

   529 

   530 		splice: function(list, items, index, remove) {

   531 			var amount = items && items.length,

   532 				append = index === undefined;

   533 			index = append ? list.length : index;

   534 			if (index > list.length)

   535 				index = list.length;

   536 			for (var i = 0; i < amount; i++)

   537 				items[i]._index = index + i;

   538 			if (append) {

   539 				list.push.apply(list, items);

   540 				return [];

   541 			} else {

   542 				var args = [index, remove];

   543 				if (items)

   544 					args.push.apply(args, items);

   545 				var removed = list.splice.apply(list, args);

   546 				for (var i = 0, l = removed.length; i < l; i++)

   547 					removed[i]._index = undefined;

   548 				for (var i = index + amount, l = list.length; i < l; i++)

   549 					list[i]._index = i;

   550 				return removed;

   551 			}

   552 		},

   553 

   554 		capitalize: function(str) {

   555 			return str.replace(/\b[a-z]/g, function(match) {

   556 				return match.toUpperCase();

   557 			});

   558 		},

   559 

   560 		camelize: function(str) {

   561 			return str.replace(/-(.)/g, function(all, chr) {

   562 				return chr.toUpperCase();

   563 			});

   564 		},

   565 

   566 		hyphenate: function(str) {

   567 			return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();

   568 		}

   569 	}

   570 });

   571 

   572 var Callback = {

   573 	attach: function(type, func) {

   574 		if (typeof type !== 'string') {

   575 			Base.each(type, function(value, key) {

   576 				this.attach(key, value);

   577 			}, this);

   578 			return;

   579 		}

   580 		var entry = this._eventTypes[type];

   581 		if (entry) {

   582 			var handlers = this._handlers = this._handlers || {};

   583 			handlers = handlers[type] = handlers[type] || [];

   584 			if (handlers.indexOf(func) == -1) {

   585 				handlers.push(func);

   586 				if (entry.install && handlers.length == 1)

   587 					entry.install.call(this, type);

   588 			}

   589 		}

   590 	},

   591 

   592 	detach: function(type, func) {

   593 		if (typeof type !== 'string') {

   594 			Base.each(type, function(value, key) {

   595 				this.detach(key, value);

   596 			}, this);

   597 			return;

   598 		}

   599 		var entry = this._eventTypes[type],

   600 			handlers = this._handlers && this._handlers[type],

   601 			index;

   602 		if (entry && handlers) {

   603 			if (!func || (index = handlers.indexOf(func)) != -1

   604 					&& handlers.length == 1) {

   605 				if (entry.uninstall)

   606 					entry.uninstall.call(this, type);

   607 				delete this._handlers[type];

   608 			} else if (index != -1) {

   609 				handlers.splice(index, 1);

   610 			}

   611 		}

   612 	},

   613 

   614 	once: function(type, func) {

   615 		this.attach(type, function() {

   616 			func.apply(this, arguments);

   617 			this.detach(type, func);

   618 		});

   619 	},

   620 

   621 	fire: function(type, event) {

   622 		var handlers = this._handlers && this._handlers[type];

   623 		if (!handlers)

   624 			return false;

   625 		var args = [].slice.call(arguments, 1),

   626 			that = this;

   627 		for (var i = 0, l = handlers.length; i < l; i++) {

   628 			if (handlers[i].apply(that, args) === false

   629 					&& event && event.stop) {

   630 				event.stop();

   631 				break;

   632 			}

   633 		}

   634 		return true;

   635 	},

   636 

   637 	responds: function(type) {

   638 		return !!(this._handlers && this._handlers[type]);

   639 	},

   640 

   641 	on: '#attach',

   642 	off: '#detach',

   643 	trigger: '#fire',

   644 

   645 	_installEvents: function(install) {

   646 		var handlers = this._handlers,

   647 			key = install ? 'install' : 'uninstall';

   648 		for (var type in handlers) {

   649 			if (handlers[type].length > 0) {

   650 				var entry = this._eventTypes[type],

   651 					func = entry[key];

   652 				if (func)

   653 					func.call(this, type);

   654 			}

   655 		}

   656 	},

   657 

   658 	statics: {

   659 		inject: function inject() {

   660 			for (var i = 0, l = arguments.length; i < l; i++) {

   661 				var src = arguments[i],

   662 					events = src._events;

   663 				if (events) {

   664 					var types = {};

   665 					Base.each(events, function(entry, key) {

   666 						var isString = typeof entry === 'string',

   667 							name = isString ? entry : key,

   668 							part = Base.capitalize(name),

   669 							type = name.substring(2).toLowerCase();

   670 						types[type] = isString ? {} : entry;

   671 						name = '_' + name;

   672 						src['get' + part] = function() {

   673 							return this[name];

   674 						};

   675 						src['set' + part] = function(func) {

   676 							var prev = this[name];

   677 							if (prev)

   678 								this.detach(type, prev);

   679 							if (func)

   680 								this.attach(type, func);

   681 							this[name] = func;

   682 						};

   683 					});

   684 					src._eventTypes = types;

   685 				}

   686 				inject.base.call(this, src);

   687 			}

   688 			return this;

   689 		}

   690 	}

   691 };

   692 

   693 var PaperScope = Base.extend({

   694 	_class: 'PaperScope',

   695 

   696 	initialize: function PaperScope() {

   697 		paper = this;

   698 		this.settings = new Base({

   699 			applyMatrix: true,

   700 			handleSize: 4,

   701 			hitTolerance: 0

   702 		});

   703 		this.project = null;

   704 		this.projects = [];

   705 		this.tools = [];

   706 		this.palettes = [];

   707 		this._id = PaperScope._id++;

   708 		PaperScope._scopes[this._id] = this;

   709 		if (!this.support) {

   710 			var ctx = CanvasProvider.getContext(1, 1);

   711 			PaperScope.prototype.support = {

   712 				nativeDash: 'setLineDash' in ctx || 'mozDash' in ctx,

   713 				nativeBlendModes: BlendMode.nativeModes

   714 			};

   715 			CanvasProvider.release(ctx);

   716 		}

   717 	},

   718 

   719 	version: '0.9.20',

   720 

   721 	getView: function() {

   722 		return this.project && this.project.getView();

   723 	},

   724 

   725 	getPaper: function() {

   726 		return this;

   727 	},

   728 

   729 	execute: function(code, url, options) {

   730 		paper.PaperScript.execute(code, this, url, options);

   731 		View.updateFocus();

   732 	},

   733 

   734 	install: function(scope) {

   735 		var that = this;

   736 		Base.each(['project', 'view', 'tool'], function(key) {

   737 			Base.define(scope, key, {

   738 				configurable: true,

   739 				get: function() {

   740 					return that[key];

   741 				}

   742 			});

   743 		});

   744 		for (var key in this)

   745 			if (!/^_/.test(key) && this[key])

   746 				scope[key] = this[key];

   747 	},

   748 

   749 	setup: function(element) {

   750 		paper = this;

   751 		this.project = new Project(element);

   752 		return this;

   753 	},

   754 

   755 	activate: function() {

   756 		paper = this;

   757 	},

   758 

   759 	clear: function() {

   760 		for (var i = this.projects.length - 1; i >= 0; i--)

   761 			this.projects[i].remove();

   762 		for (var i = this.tools.length - 1; i >= 0; i--)

   763 			this.tools[i].remove();

   764 		for (var i = this.palettes.length - 1; i >= 0; i--)

   765 			this.palettes[i].remove();

   766 	},

   767 

   768 	remove: function() {

   769 		this.clear();

   770 		delete PaperScope._scopes[this._id];

   771 	},

   772 

   773 	statics: new function() {

   774 		function handleAttribute(name) {

   775 			name += 'Attribute';

   776 			return function(el, attr) {

   777 				return el[name](attr) || el[name]('data-paper-' + attr);

   778 			};

   779 		}

   780 

   781 		return {

   782 			_scopes: {},

   783 			_id: 0,

   784 

   785 			get: function(id) {

   786 				return this._scopes[id] || null;

   787 			},

   788 

   789 			getAttribute: handleAttribute('get'),

   790 			hasAttribute: handleAttribute('has')

   791 		};

   792 	}

   793 });

   794 

   795 var PaperScopeItem = Base.extend(Callback, {

   796 

   797 	initialize: function(activate) {

   798 		this._scope = paper;

   799 		this._index = this._scope[this._list].push(this) - 1;

   800 		if (activate || !this._scope[this._reference])

   801 			this.activate();

   802 	},

   803 

   804 	activate: function() {

   805 		if (!this._scope)

   806 			return false;

   807 		var prev = this._scope[this._reference];

   808 		if (prev && prev !== this)

   809 			prev.fire('deactivate');

   810 		this._scope[this._reference] = this;

   811 		this.fire('activate', prev);

   812 		return true;

   813 	},

   814 

   815 	isActive: function() {

   816 		return this._scope[this._reference] === this;

   817 	},

   818 

   819 	remove: function() {

   820 		if (this._index == null)

   821 			return false;

   822 		Base.splice(this._scope[this._list], null, this._index, 1);

   823 		if (this._scope[this._reference] == this)

   824 			this._scope[this._reference] = null;

   825 		this._scope = null;

   826 		return true;

   827 	}

   828 });

   829 

   830 var Formatter = Base.extend({

   831 	initialize: function(precision) {

   832 		this.precision = precision || 5;

   833 		this.multiplier = Math.pow(10, this.precision);

   834 	},

   835 

   836 	number: function(val) {

   837 		return Math.round(val * this.multiplier) / this.multiplier;

   838 	},

   839 

   840 	pair: function(val1, val2, separator) {

   841 		return this.number(val1) + (separator || ',') + this.number(val2);

   842 	},

   843 

   844 	point: function(val, separator) {

   845 		return this.number(val.x) + (separator || ',') + this.number(val.y);

   846 	},

   847 

   848 	size: function(val, separator) {

   849 		return this.number(val.width) + (separator || ',')

   850 				+ this.number(val.height);

   851 	},

   852 

   853 	rectangle: function(val, separator) {

   854 		return this.point(val, separator) + (separator || ',')

   855 				+ this.size(val, separator);

   856 	}

   857 });

   858 

   859 Formatter.instance = new Formatter();

   860 

   861 var Numerical = new function() {

   862 

   863 	var abscissas = [

   864 		[  0.5773502691896257645091488],

   865 		[0,0.7745966692414833770358531],

   866 		[  0.3399810435848562648026658,0.8611363115940525752239465],

   867 		[0,0.5384693101056830910363144,0.9061798459386639927976269],

   868 		[  0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],

   869 		[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],

   870 		[  0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],

   871 		[0,0.3242534234038089290385380,0.6133714327005903973087020,0.8360311073266357942994298,0.9681602395076260898355762],

   872 		[  0.1488743389816312108848260,0.4333953941292471907992659,0.6794095682990244062343274,0.8650633666889845107320967,0.9739065285171717200779640],

   873 		[0,0.2695431559523449723315320,0.5190961292068118159257257,0.7301520055740493240934163,0.8870625997680952990751578,0.9782286581460569928039380],

   874 		[  0.1252334085114689154724414,0.3678314989981801937526915,0.5873179542866174472967024,0.7699026741943046870368938,0.9041172563704748566784659,0.9815606342467192506905491],

   875 		[0,0.2304583159551347940655281,0.4484927510364468528779129,0.6423493394403402206439846,0.8015780907333099127942065,0.9175983992229779652065478,0.9841830547185881494728294],

   876 		[  0.1080549487073436620662447,0.3191123689278897604356718,0.5152486363581540919652907,0.6872929048116854701480198,0.8272013150697649931897947,0.9284348836635735173363911,0.9862838086968123388415973],

   877 		[0,0.2011940939974345223006283,0.3941513470775633698972074,0.5709721726085388475372267,0.7244177313601700474161861,0.8482065834104272162006483,0.9372733924007059043077589,0.9879925180204854284895657],

   878 		[  0.0950125098376374401853193,0.2816035507792589132304605,0.4580167776572273863424194,0.6178762444026437484466718,0.7554044083550030338951012,0.8656312023878317438804679,0.9445750230732325760779884,0.9894009349916499325961542]

   879 	];

   880 

   881 	var weights = [

   882 		[1],

   883 		[0.8888888888888888888888889,0.5555555555555555555555556],

   884 		[0.6521451548625461426269361,0.3478548451374538573730639],

   885 		[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],

   886 		[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],

   887 		[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],

   888 		[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],

   889 		[0.3302393550012597631645251,0.3123470770400028400686304,0.2606106964029354623187429,0.1806481606948574040584720,0.0812743883615744119718922],

   890 		[0.2955242247147528701738930,0.2692667193099963550912269,0.2190863625159820439955349,0.1494513491505805931457763,0.0666713443086881375935688],

   891 		[0.2729250867779006307144835,0.2628045445102466621806889,0.2331937645919904799185237,0.1862902109277342514260976,0.1255803694649046246346943,0.0556685671161736664827537],

   892 		[0.2491470458134027850005624,0.2334925365383548087608499,0.2031674267230659217490645,0.1600783285433462263346525,0.1069393259953184309602547,0.0471753363865118271946160],

   893 		[0.2325515532308739101945895,0.2262831802628972384120902,0.2078160475368885023125232,0.1781459807619457382800467,0.1388735102197872384636018,0.0921214998377284479144218,0.0404840047653158795200216],

   894 		[0.2152638534631577901958764,0.2051984637212956039659241,0.1855383974779378137417166,0.1572031671581935345696019,0.1215185706879031846894148,0.0801580871597602098056333,0.0351194603317518630318329],

   895 		[0.2025782419255612728806202,0.1984314853271115764561183,0.1861610000155622110268006,0.1662692058169939335532009,0.1395706779261543144478048,0.1071592204671719350118695,0.0703660474881081247092674,0.0307532419961172683546284],

   896 		[0.1894506104550684962853967,0.1826034150449235888667637,0.1691565193950025381893121,0.1495959888165767320815017,0.1246289712555338720524763,0.0951585116824927848099251,0.0622535239386478928628438,0.0271524594117540948517806]

   897 	];

   898 

   899 	var abs = Math.abs,

   900 		sqrt = Math.sqrt,

   901 		pow = Math.pow,

   902 		cos = Math.cos,

   903 		PI = Math.PI,

   904 		TOLERANCE = 10e-6,

   905 		EPSILON = 10e-12;

   906 

   907 	function setupRoots(roots, min, max) {

   908 		var unbound = min === undefined,

   909 			minE = min - EPSILON,

   910 			maxE = max + EPSILON,

   911 			count = 0;

   912 		return function(root) {

   913 			if (unbound || root > minE && root < maxE)

   914 				roots[count++] = root < min ? min : root > max ? max : root;

   915 			return count;

   916 		};

   917 	}

   918 

   919 	return {

   920 		TOLERANCE: TOLERANCE,

   921 		EPSILON: EPSILON,

   922 		KAPPA: 4 * (sqrt(2) - 1) / 3,

   923 

   924 		isZero: function(val) {

   925 			return abs(val) <= EPSILON;

   926 		},

   927 

   928 		integrate: function(f, a, b, n) {

   929 			var x = abscissas[n - 2],

   930 				w = weights[n - 2],

   931 				A = 0.5 * (b - a),

   932 				B = A + a,

   933 				i = 0,

   934 				m = (n + 1) >> 1,

   935 				sum = n & 1 ? w[i++] * f(B) : 0;

   936 			while (i < m) {

   937 				var Ax = A * x[i];

   938 				sum += w[i++] * (f(B + Ax) + f(B - Ax));

   939 			}

   940 			return A * sum;

   941 		},

   942 

   943 		findRoot: function(f, df, x, a, b, n, tolerance) {

   944 			for (var i = 0; i < n; i++) {

   945 				var fx = f(x),

   946 					dx = fx / df(x),

   947 					nx = x - dx;

   948 				if (abs(dx) < tolerance)

   949 					return nx;

   950 				if (fx > 0) {

   951 					b = x;

   952 					x = nx <= a ? 0.5 * (a + b) : nx;

   953 				} else {

   954 					a = x;

   955 					x = nx >= b ? 0.5 * (a + b) : nx;

   956 				}

   957 			}

   958 			return x;

   959 		},

   960 

   961 		solveQuadratic: function(a, b, c, roots, min, max) {

   962 			var add = setupRoots(roots, min, max);

   963 

   964 			if (abs(a) < EPSILON) {

   965 				if (abs(b) >= EPSILON)

   966 					return add(-c / b);

   967 				return abs(c) < EPSILON ? -1 : 0;

   968 			}

   969 			var p = b / (2 * a);

   970 			var q = c / a;

   971 			var p2 = p * p;

   972 			if (p2 < q - EPSILON)

   973 				return 0;

   974 			var s = p2 > q ? sqrt(p2 - q) : 0,

   975 				count = add(s - p);

   976 			if (s > 0)

   977 				count = add(-s - p);

   978 			return count;

   979 		},

   980 

   981 		solveCubic: function(a, b, c, d, roots, min, max) {

   982 			if (abs(a) < EPSILON)

   983 				return Numerical.solveQuadratic(b, c, d, roots, min, max);

   984 

   985 			b /= a;

   986 			c /= a;

   987 			d /= a;

   988 			var add = setupRoots(roots, min, max),

   989 				bb = b * b,

   990 				p = (bb - 3 * c) / 9,

   991 				q = (2 * bb * b - 9 * b * c + 27 * d) / 54,

   992 				ppp = p * p * p,

   993 				D = q * q - ppp;

   994 			b /= 3;

   995 			if (abs(D) < EPSILON) {

   996 				if (abs(q) < EPSILON)

   997 					return add(-b);

   998 				var sqp = sqrt(p),

   999 					snq = q > 0 ? 1 : -1;

  1000 				add(-snq * 2 * sqp - b);

  1001 				return add(snq * sqp - b);

  1002 			}

  1003 			if (D < 0) {

  1004 				var sqp = sqrt(p),

  1005 					phi = Math.acos(q / (sqp * sqp * sqp)) / 3,

  1006 					t = -2 * sqp,

  1007 					o = 2 * PI / 3;

  1008 				add(t * cos(phi) - b);

  1009 				add(t * cos(phi + o) - b);

  1010 				return add(t * cos(phi - o) - b);

  1011 			}

  1012 			var A = (q > 0 ? -1 : 1) * pow(abs(q) + sqrt(D), 1 / 3);

  1013 			return add(A + p / A - b);

  1014 		}

  1015 	};

  1016 };

  1017 

  1018 var Point = Base.extend({

  1019 	_class: 'Point',

  1020 	_readIndex: true,

  1021 

  1022 	initialize: function Point(arg0, arg1) {

  1023 		var type = typeof arg0;

  1024 		if (type === 'number') {

  1025 			var hasY = typeof arg1 === 'number';

  1026 			this.x = arg0;

  1027 			this.y = hasY ? arg1 : arg0;

  1028 			if (this.__read)

  1029 				this.__read = hasY ? 2 : 1;

  1030 		} else if (type === 'undefined' || arg0 === null) {

  1031 			this.x = this.y = 0;

  1032 			if (this.__read)

  1033 				this.__read = arg0 === null ? 1 : 0;

  1034 		} else {

  1035 			if (Array.isArray(arg0)) {

  1036 				this.x = arg0[0];

  1037 				this.y = arg0.length > 1 ? arg0[1] : arg0[0];

  1038 			} else if (arg0.x != null) {

  1039 				this.x = arg0.x;

  1040 				this.y = arg0.y;

  1041 			} else if (arg0.width != null) {

  1042 				this.x = arg0.width;

  1043 				this.y = arg0.height;

  1044 			} else if (arg0.angle != null) {

  1045 				this.x = arg0.length;

  1046 				this.y = 0;

  1047 				this.setAngle(arg0.angle);

  1048 			} else {

  1049 				this.x = this.y = 0;

  1050 				if (this.__read)

  1051 					this.__read = 0;

  1052 			}

  1053 			if (this.__read)

  1054 				this.__read = 1;

  1055 		}

  1056 	},

  1057 

  1058 	set: function(x, y) {

  1059 		this.x = x;

  1060 		this.y = y;

  1061 		return this;

  1062 	},

  1063 

  1064 	equals: function(point) {

  1065 		return this === point || point

  1066 				&& (this.x === point.x && this.y === point.y

  1067 					|| Array.isArray(point)

  1068 						&& this.x === point[0] && this.y === point[1])

  1069 				|| false;

  1070 	},

  1071 

  1072 	clone: function() {

  1073 		return new Point(this.x, this.y);

  1074 	},

  1075 

  1076 	toString: function() {

  1077 		var f = Formatter.instance;

  1078 		return '{ x: ' + f.number(this.x) + ', y: ' + f.number(this.y) + ' }';

  1079 	},

  1080 

  1081 	_serialize: function(options) {

  1082 		var f = options.formatter;

  1083 		return [f.number(this.x), f.number(this.y)];

  1084 	},

  1085 

  1086 	getLength: function() {

  1087 		return Math.sqrt(this.x * this.x + this.y * this.y);

  1088 	},

  1089 

  1090 	setLength: function(length) {

  1091 		if (this.isZero()) {

  1092 			var angle = this._angle || 0;

  1093 			this.set(

  1094 				Math.cos(angle) * length,

  1095 				Math.sin(angle) * length

  1096 			);

  1097 		} else {

  1098 			var scale = length / this.getLength();

  1099 			if (Numerical.isZero(scale))

  1100 				this.getAngle();

  1101 			this.set(

  1102 				this.x * scale,

  1103 				this.y * scale

  1104 			);

  1105 		}

  1106 	},

  1107 	getAngle: function() {

  1108 		return this.getAngleInRadians.apply(this, arguments) * 180 / Math.PI;

  1109 	},

  1110 

  1111 	setAngle: function(angle) {

  1112 		this.setAngleInRadians.call(this, angle * Math.PI / 180);

  1113 	},

  1114 

  1115 	getAngleInDegrees: '#getAngle',

  1116 	setAngleInDegrees: '#setAngle',

  1117 

  1118 	getAngleInRadians: function() {

  1119 		if (!arguments.length) {

  1120 			return this.isZero()

  1121 					? this._angle || 0

  1122 					: this._angle = Math.atan2(this.y, this.x);

  1123 		} else {

  1124 			var point = Point.read(arguments),

  1125 				div = this.getLength() * point.getLength();

  1126 			if (Numerical.isZero(div)) {

  1127 				return NaN;

  1128 			} else {

  1129 				var a = this.dot(point) / div;

  1130 				return Math.acos(a < -1 ? -1 : a > 1 ? 1 : a);

  1131 			}

  1132 		}

  1133 	},

  1134 

  1135 	setAngleInRadians: function(angle) {