/*!

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

 * http://paperjs.org/

 *

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

 * http://lehni.org/ & http://jonathanpuckey.com/

 *

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

 *

 * All rights reserved.

 *

 * Date: Sun Dec 1 23:54:52 2013 +0100

 *

 ***

 *

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

 *

 * Copyright (c) 2006 - 2013 Juerg Lehni

 * http://lehni.org/

 *

 * Distributed under the MIT license.

 *

 ***

 *

 * acorn.js

 * http://marijnhaverbeke.nl/acorn/

 *

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

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

 *

 */

var paper = new function(undefined) {

var Base = new function() {

	var hidden = /^(statics|generics|preserve|enumerable|prototype|toString|valueOf)$/,

		slice = [].slice,

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

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

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

		},

		forIn = function(iter, bind) {

			for (var i in this)

				if (this.hasOwnProperty(i))

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

		},

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

			return { __proto__: proto };

		},

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

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

			return get

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

						enumerable: true, configurable: true }

					: obj.hasOwnProperty(name)

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

							configurable: true, writable: true }

						: null;

		},

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

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

				if (desc.get)

					obj.__defineGetter__(name, desc.get);

				if (desc.set)

					obj.__defineSetter__(name, desc.set);

			} else {

				obj[name] = desc.value;

			}

			return obj;

		},

		define = function(obj, name, desc) {

			delete obj[name];

			return _define(obj, name, desc);

		};

	function inject(dest, src, enumerable, base, preserve, generics) {

		var beans;

		function field(name, val, dontCheck, generics) {

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

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

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

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

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

				res = val,

				prev = preserve || isFunc

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

				bean;

			if ((dontCheck || val !== undefined && src.hasOwnProperty(name))

					&& (!preserve || !prev)) {

				if (isFunc && prev)

					val.base = prev;

				if (isFunc && beans && val.length === 0

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

					beans.push([ bean[3].toLowerCase() + bean[4], bean[2] ]);

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

						|| res.get.length !== 0)

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

				if ((describe(dest, name)

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

					res.configurable = true;

					res.enumerable = enumerable;

				}

				define(dest, name, res);

			}

			if (generics && isFunc && (!preserve || !generics[name])) {

				generics[name] = function(bind) {

					return bind && dest[name].apply(bind,

							slice.call(arguments, 1));

				};

			}

		}

		if (src) {

			beans = [];

			for (var name in src)

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

					field(name, null, true, generics);

			field('toString');

			field('valueOf');

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

				var bean = beans[i],

					part = bean[1];

				field(bean[0], {

					get: dest['get' + part] || dest['is' + part],

					set: dest['set' + part]

				}, true);

			}

		}

		return dest;

	}

	function each(obj, iter, bind) {

		if (obj)

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

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

				? forEach

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

		return bind;

	}

	function copy(dest, source) {

		for (var i in source)

			if (source.hasOwnProperty(i))

				dest[i] = source[i];

		return dest;

	}

	function clone(obj) {

		return copy(new obj.constructor(), obj);

	}

	return inject(function Base() {

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

			copy(this, arguments[i]);

	}, {

		inject: function(src) {

			if (src) {

				var proto = this.prototype,

					base = Object.getPrototypeOf(proto).constructor,

					statics = src.statics === true ? src : src.statics;

				if (statics != src)

					inject(proto, src, src.enumerable, base && base.prototype,

							src.preserve, src.generics && this);

				inject(this, statics, true, base, src.preserve);

			}

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

				this.inject(arguments[i]);

			return this;

		},

		extend: function() {

			var base = this,

				ctor;

			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);

			define(ctor.prototype, 'constructor',

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

			inject(ctor, this, true);

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

		}

	}, true).inject({

		inject: function() {

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

				inject(this, arguments[i], arguments[i].enumerable);

			return this;

		},

		extend: function() {

			var res = create(this);

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

		},

		each: function(iter, bind) {

			return each(this, iter, bind);

		},

		clone: function() {

			return new this.constructor(this);

		},

		statics: {

			each: each,

			create: create,

			define: define,

			describe: describe,

			copy: copy,

			clone: function(obj) {

				return copy(new obj.constructor(), obj);

			},

			isPlainObject: function(obj) {

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

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

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

			},

			pick: function() {

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

					if (arguments[i] !== undefined)

						return arguments[i];

				return null;

			}

		}

	});

};

if (typeof module !== 'undefined')

	module.exports = Base;

Base.inject({

	generics: true,

	toString: function() {

		return this._id != null

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

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

				: ' @' + this._id)

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

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

					var type = typeof value;

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

							? Formatter.instance.number(value)

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

				}

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

	},

	exportJSON: function(options) {

		return Base.exportJSON(this, options);

	},

	toJSON: function() {

		return Base.serialize(this);

	},

	_set: function(props, exclude) {

		if (props && Base.isPlainObject(props)) {

			var orig = props._filtering || props;

			for (var key in orig) {

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

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

					var value = props[key];

					if (value !== undefined)

						this[key] = value;

				}

			}

			return true;

		}

	},

	statics: {

		exports: {},

		extend: function extend() {

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

				name = res.prototype._class;

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

				Base.exports[name] = res;

			return res;

		},

		equals: function(obj1, obj2) {

			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.length !== obj2.length)

					return false;

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

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

						return false;

				}

				return true;

			}

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

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

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

					return false;

				for (var i in obj1) {

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

						return false;

				}

				return true;

			}

			return false;

		},

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

			if (this === Base) {

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

				list._index++;

				list.__read = 1;

				return value;

			}

			var proto = this.prototype,

				readIndex = proto._readIndex,

				index = start || readIndex && list._index || 0;

			if (!length)

				length = list.length - index;

			var obj = list[index];

			if (obj instanceof this

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

				if (readIndex)

					list._index = index + 1;

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

			}

			obj = Base.create(this.prototype);

			if (readIndex)

				obj.__read = true;

			if (options)

				obj.__options = options;

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

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

				: list) || obj;

			if (readIndex) {

				list._index = index + obj.__read;

				list.__read = obj.__read;

				delete obj.__read;

				if (options)

					delete obj.__options;

			}

			return obj;

		},

		peek: function(list, start) {

			return list[list._index = start || list._index || 0];

		},

		readAll: function(list, start, options) {

			var res = [], entry;

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

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

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

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

			}

			return res;

		},

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

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

				hasObject = value !== undefined;

			if (hasObject) {

				var filtered = list._filtered;

				if (!filtered) {

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

					filtered._filtering = list[0];

				}

				filtered[name] = undefined;

			}

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

		},

		getNamed: function(list, name) {

			var arg = list[0];

			if (list._hasObject === undefined)

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

			if (list._hasObject)

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

		},

		hasNamed: function(list, name) {

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

		},

		isPlainValue: function(obj) {

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

		},

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

			options = options || {};

			var root = !dictionary,

				res;

			if (root) {

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

				dictionary = {

					length: 0,

					definitions: {},

					references: {},

					add: function(item, create) {

						var id = '#' + item._id,

							ref = this.references[id];

						if (!ref) {

							this.length++;

							var res = create.call(item),

								name = item._class;

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

								res.unshift(name);

							this.definitions[id] = res;

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

						}

						return ref;

					}

				};

			}

			if (obj && obj._serialize) {

				res = obj._serialize(options, dictionary);

				var name = obj._class;

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

					res.unshift(name);

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

				res = [];

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

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

							dictionary);

				if (compact)

					res._compact = true;

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

				res = {};

				for (var i in obj)

					if (obj.hasOwnProperty(i))

						res[i] = Base.serialize(obj[i], 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) {

			var res = json;

			_data = _data || {};

			if (Array.isArray(json)) {

				var type = json[0],

					isDictionary = type === 'dictionary';

				if (!isDictionary) {

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

						return _data.dictionary[type];

					type = Base.exports[type];

				}

				res = [];

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

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

				if (isDictionary) {

					_data.dictionary = res[0];

				} 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 = {};

				for (var key in json)

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

			}

			return res;

		},

		exportJSON: function(obj, options) {