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

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

 * http://scratchdisk.com/ & https://puckey.studio/

 * Date: Sat Jun 22 14:16:49 2019 +0200

 * Copyright (c) 2006 - 2019 Juerg Lehni

 * https://marijnhaverbeke.nl/acorn/

var paper = function(self, undefined) {

self = self || require('./node/self.js');

var window = self.window,

	document = self.document;

		array = [],

		slice = array.slice,

		create = Object.create,

		describe = Object.getOwnPropertyDescriptor,

		define = Object.defineProperty,

		forEach = array.forEach || function(iter, bind) {

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

			}

			for (var i in this) {

			}

		},

		set = Object.assign || function(dst) {

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

				var src = arguments[i];

				for (var key in src) {

					if (src.hasOwnProperty(key))

						dst[key] = src[key];

				}

			}

			return dst;

		},

		each = function(obj, iter, bind) {

			if (obj) {

				var desc = describe(obj, 'length');

				(desc && typeof desc.value === 'number' ? forEach : forIn)

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

			}

			return bind;

						|| !Base.isPlainObject(res)) {

				}

					res.enumerable = enumerable != null ? enumerable : !bean;

	function Base() {

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

			var src = arguments[i];

			if (src)

				set(this, src);

		}

		return this;

	}

	return inject(Base, {

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

			for (var i = 0, obj, l = arguments.length;

					i < l && !(ctor && proto); i++) {

				obj = arguments[i];

				ctor = ctor || obj.initialize;

				proto = proto || obj.prototype;

			}

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

			inject(ctor, this);

	}).inject({

		enumerable: false,

		initialize: Base,

		set: Base,

				if (src) {

				}

			set: set,

			},

			slice: function(list, begin, end) {

				return slice.call(list, begin, end);

	enumerable: false,

	importJSON: function(json) {

		return Base.importJSON(json, this);

	},

	set: function(props, exclude) {

		if (props)

			Base.filter(this, props, exclude, this._prioritize);

		return this;

	}

}, {

beans: false,

statics: {

	exports: {},

	extend: function extend() {

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

			name = res.prototype._class;

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

			Base.exports[name] = res;

		return res;

	},

	equals: function(obj1, obj2) {

		if (obj1 === obj2)

			return true;

		if (obj1 && obj1.equals)

			return obj1.equals(obj2);

		if (obj2 && obj2.equals)

			return obj2.equals(obj1);

		if (obj1 && obj2

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

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

				var length = obj1.length;

				if (length !== obj2.length)

					return false;

				while (length--) {

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

						return false;

				}

			} else {

				var keys = Object.keys(obj1),

					length = keys.length;

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

					return false;

				while (length--) {

					var key = keys[length];

					if (!(obj2.hasOwnProperty(key)

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

						return false;

		return false;

	},

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

		if (this === Base) {

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

			list.__index++;

			return value;

		}

		var proto = this.prototype,

			readIndex = proto._readIndex,

			begin = start || readIndex && list.__index || 0,

			length = list.length,

			obj = list[begin];

		amount = amount || length - begin;

		if (obj instanceof this

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

				list.__index = begin + 1;

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

		}

		obj = Base.create(proto);

		if (readIndex)

			obj.__read = true;

		obj = obj.initialize.apply(obj, begin > 0 || begin + amount < length

				? Base.slice(list, begin, begin + amount)

		if (readIndex) {

			list.__index = begin + obj.__read;

			var filtered = obj.__filtered;

			if (filtered) {

				list.__filtered = filtered;

				obj.__filtered = undefined;

			}

			obj.__read = undefined;

		}

		return obj;

	},

	peek: function(list, start) {

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

	},

	remain: function(list) {

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

	},

	readList: function(list, start, options, amount) {

		var res = [],

			entry,

			begin = start || 0,

			end = amount ? begin + amount : list.length;

		for (var i = begin; i < end; i++) {

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

					? this.read(entry, 0, options)

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

		}

		return res;

	},

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

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

			hasObject = value !== undefined;

		if (hasObject) {

			var filtered = list.__filtered;

			if (!filtered) {

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

				filtered.__unfiltered = list[0];

			}

			filtered[name] = undefined;

		}

		var l = hasObject ? [value] : list,

			res = this.read(l, start, options, amount);

		return res;

	},

	getNamed: function(list, name) {

		var arg = list[0];

		if (list._hasObject === undefined)

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

		if (list._hasObject)

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

	},

	hasNamed: function(list, name) {

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

	},

	filter: function(dest, source, exclude, prioritize) {

		var processed;

		function handleKey(key) {

			if (!(exclude && key in exclude) &&

				!(processed && key in processed)) {

				var value = source[key];

				if (value !== undefined)

					dest[key] = value;

			}

		}

		if (prioritize) {

			var keys = {};

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

				if ((key = prioritize[i]) in source) {

					handleKey(key);

					keys[key] = true;

				}

			}

			processed = keys;

		}

		Object.keys(source.__unfiltered || source).forEach(handleKey);

		return dest;

	},

	isPlainValue: function(obj, asString) {

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

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

	},

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

		options = options || {};

		var isRoot = !dictionary,

			res;

		if (isRoot) {

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

			dictionary = {

				length: 0,

				definitions: {},

				references: {},

				add: function(item, create) {

					var id = '#' + item._id,

						ref = this.references[id];

					if (!ref) {

						this.length++;

						var res = create.call(item),

							name = item._class;

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

							res.unshift(name);

						this.definitions[id] = res;

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

					}

					return ref;

				}

			};

		}

		if (obj && obj._serialize) {

			res = obj._serialize(options, dictionary);

			var name = obj._class;

			if (name && !obj._compactSerialize && (isRoot || !compact)

					&& res[0] !== name) {

				res.unshift(name);

			}

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

			res = [];

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

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

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

			res = {};

			var keys = Object.keys(obj);

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

				var key = keys[i];

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

						dictionary);

			}

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

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

		} else {

			res = obj;

		}

		return isRoot && dictionary.length > 0

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

				: res;

	},

	deserialize: function(json, create, _data, _setDictionary, _isRoot) {