* 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/

 * Date: Fri Aug 21 16:39:41 2015 +0200

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

 * Copyright (c) 2006 - 2013 Juerg Lehni

 * http://scratchdisk.com/

 * 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|enumerable|beans|preserve)$/,

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

		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, beans, preserve) {

		var beansNames = {};

		function field(name, val) {

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

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

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

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

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

				prev = preserve || isFunc && !val.base

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

						: null,

				bean;

			if (!preserve || !prev) {

				if (isFunc && prev)

					val.base = prev;

				if (isFunc && beans !== false

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

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

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

						|| !Base.isPlainObject(res))

			for (var name in src) {

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

					field(name);

			}

			for (var name in beansNames) {

				var part = beansNames[name],

					set = dest['set' + part],

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

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

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

			}

	function each(obj, iter, bind) {

		if (obj)

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

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

				? forEach

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

	function set(obj, props, exclude) {

		for (var key in props)

			if (props.hasOwnProperty(key) && !(exclude && exclude[key]))

				obj[key] = props[key];

		return obj;

	}

	return inject(function Base() {

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

			set(this, arguments[i]);

	}, {

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

					beans = src.beans,

					preserve = src.preserve;

				if (statics !== src)

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

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

		extend: function() {

			var base = this,

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

			};

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

			if (arguments.length)

				this.inject.apply(ctor, arguments);

			ctor.base = base;

			return ctor;

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

				var src = arguments[i];

				if (src)

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

			}

			var res = create(this);

		set: function(props) {

			return set(this, props);

		},

			return new this.constructor(this);

			create: create,

			set: set,

			clone: function(obj) {

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

			isPlainObject: function(obj) {

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

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

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

			pick: function(a, b) {

				return a !== undefined ? a : b;

			}

};

if (typeof module !== 'undefined')

	module.exports = Base;

Base.inject({

		return this._id != null

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

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

				: ' @' + this._id)

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

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

					var type = typeof value;

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

							? Formatter.instance.number(value)

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

				}

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

	},

	getClassName: function() {

		return this._class || '';

	},

	exportJSON: function(options) {

		return Base.exportJSON(this, options);

	},

	toJSON: function() {

		return Base.serialize(this);

	},

	_set: function(props, exclude, dontCheck) {

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

			var keys = Object.keys(props._filtering || props);

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

				var key = keys[i];

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

					var value = props[key];

					if (value !== undefined)

						this[key] = value;

				}

			}

			return true;

		}

		exports: {

			enumerable: true

		},

		extend: function extend() {

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

				name = res.prototype._class;

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

				Base.exports[name] = res;

			return res;

		},

		equals: function(obj1, obj2) {

			if (obj1 === obj2)

				return true;

			if (obj1 && obj1.equals)

				return obj1.equals(obj2);

			if (obj2 && obj2.equals)

				return obj2.equals(obj1);

			if (obj1 && obj2

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

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

					var length = obj1.length;

					if (length !== obj2.length)

						return false;

					while (length--) {

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

							return false;

					}

				} else {

					var keys = Object.keys(obj1),

						length = keys.length;

					if (length !== Object.keys(obj2).length)

						return false;

					while (length--) {

						var key = keys[length];

						if (!(obj2.hasOwnProperty(key)

								&& Base.equals(obj1[key], obj2[key])))

							return false;

					}

				}

				return true;

			}

			return false;

		},

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

			if (this === Base) {

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

				list.__index++;

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

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

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

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

			if (readIndex) {

				list.__index = index + obj.__read;

				obj.__read = undefined;

			}

			return obj;

		},

		peek: function(list, start) {

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

		},

		remain: function(list) {

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

		},

		readAll: function(list, start, options) {

			var res = [],

				entry;

						? this.read(entry, 0, options)

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

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

			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, options, length);

		},

		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, asString) {

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

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

		},

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

				var keys = Object.keys(obj);

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

					var key = keys[i];

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

							dictionary);

				}

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

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

			} else {

				res = obj;

			}

			return root && dictionary.length > 0

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

					: res;

		},

		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 (json.length == 1 && /^#/.test(type))

					return _data.dictionary[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,

							isDictionary));

				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]