/*!

* Paper.js v0.9.10 - 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: Tue Oct 29 22:02:29 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)$/,

toString = Object.prototype.toString,

proto = Array.prototype,

slice = proto.slice,

forEach = proto.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);

},

isArray = Array.isArray = Array.isArray || function(obj) {

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

},

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

try {

if (obj)

(asArray || typeof asArray === 'undefined' && isArray(obj)

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

} catch (e) {

if (e !== Base.stop)

throw e;

}

return bind;

}

function clone(obj) {

return each(obj, function(val, i) {

this[i] = val;

}, new obj.constructor());

}

return inject(function Base() {}, {

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 clone(this);

},

statics: {

each: each,

clone: clone,

create: create,

define: define,

describe: describe,

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;

},

stop: {}

}

});

};

if (typeof module !== 'undefined')

module.exports = Base;

Base.inject({

generics: true,

clone: function() {

return new this.constructor(this);

},

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(obj, data) {

var res = obj;

data = data || {};

if (Array.isArray(obj)) {

var type = obj[0],

isDictionary = type === 'dictionary';

if (!isDictionary) {

if (data.dictionary && obj.length == 1 && /^#/.test(type))

return data.dictionary[type];

type = Base.exports[type];

}

res = [];

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

res.push(Base.deserialize(obj[i], data));

if (isDictionary) {

data.dictionary = res[0];

} else if (type) {

var args = res;

res = Base.create(type.prototype);

type.apply(res, args);

}

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

res = {};

for (var key in obj)

res[key] = Base.deserialize(obj[key], data);

}

return res;

},

exportJSON: function(obj, options) {

return JSON.stringify(Base.serialize(obj, options));

},

importJSON: function(json) {

return Base.deserialize(

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

},

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

var amount = items && items.length,

append = index === undefined;

index = append ? list.length : index;

if (index > list.length)

index = list.length;

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

items[i]._index = index + i;

if (append) {

list.push.apply(list, items);

return [];

} else {

var args = [index, remove];

if (items)

args.push.apply(args, items);

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

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

delete removed[i]._index;

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

list[i]._index = i;

return removed;

}

},

merge: function() {

return Base.each(arguments, function(hash) {

Base.each(hash, function(value, key) {

this[key] = value;

}, this);

}, new Base(), true);

},

capitalize: function(str) {

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

return match.toUpperCase();

});

},

camelize: function(str) {

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

return chr.toUpperCase();

});

},

hyphenate: function(str) {

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

}

}

});

var Callback = {

attach: function(type, func) {

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

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

this.attach(key, value);

}, this);

return;

}

var entry = this._eventTypes[type];

if (entry) {

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

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

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

handlers.push(func);

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

entry.install.call(this, type);

}

}

},

detach: function(type, func) {

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

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

this.detach(key, value);

}, this);

return;

}

var entry = this._eventTypes[type],

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

index;

if (entry && handlers) {

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

&& handlers.length == 1) {

if (entry.uninstall)

entry.uninstall.call(this, type);

delete this._handlers[type];

} else if (index != -1) {

handlers.splice(index, 1);

}

}

},

once: function(type, func) {

this.attach(type, function() {

func.apply(this, arguments);

this.detach(type, func);

});

},

fire: function(type, event) {

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

if (!handlers)

return false;

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

Base.each(handlers, function(func) {

if (func.apply(this, args) === false && event && event.stop)

event.stop();

}, this);

return true;

},

responds: function(type) {

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

},

on: '#attach',

off: '#detach',

trigger: '#fire',

statics: {

inject: function inject() {

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

var src = arguments[i],

events = src._events;

if (events) {

var types = {};

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

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

name = isString ? entry : key,

part = Base.capitalize(name),

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

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

name = '_' + name;

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

return this[name];

};

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

if (func) {

this.attach(type, func);

} else if (this[name]) {

this.detach(type, this[name]);

}

this[name] = func;

};

});

src._eventTypes = types;

}

inject.base.call(this, src);

}

return this;

}

}

};

var PaperScope = Base.extend({

_class: 'PaperScope',

initialize: function PaperScope(script) {

paper = this;

this.project = null;

this.projects = [];

this.tools = [];

this.palettes = [];

this._id = script && (script.getAttribute('id') || script.src)

|| ('paperscope-' + (PaperScope._id++));

if (script)

script.setAttribute('id', this._id);

PaperScope._scopes[this._id] = this;

if (!this.support) {

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

PaperScope.prototype.support = {

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

nativeBlendModes: BlendMode.nativeModes

};

CanvasProvider.release(ctx);

}

},

version: '0.9.10',

getView: function() {

return this.project && this.project.view;

},

getTool: function() {

if (!this._tool)

this._tool = new Tool();

return this._tool;

},

evaluate: function(code) {

var res = paper.PaperScript.evaluate(code, this);

View.updateFocus();

return res;

},

install: function(scope) {

var that = this;

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

Base.define(scope, key, {

configurable: true,

get: function() {

return that[key];

}

});

});

for (var key in this) {

if (!/^(version|_id)/.test(key))

scope[key] = this[key];

}

},

setup: function(canvas) {

paper = this;

this.project = new Project(canvas);

return this;

},

activate: function() {

paper = this;

},

clear: function() {

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

this.projects[i].remove();

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

this.tools[i].remove();

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

this.palettes[i].remove();

},

remove: function() {

this.clear();

delete PaperScope._scopes[this._id];

},

statics: new function() {

function handleAttribute(name) {

name += 'Attribute';

return function(el, attr) {

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

};

}

return {

_scopes: {},

_id: 0,

get: function(id) {

if (typeof id === 'object')

id = id.getAttribute('id');

return this._scopes[id] || null;

},

getAttribute: handleAttribute('get'),

hasAttribute: handleAttribute('has')

};

}

});

var PaperScopeItem = Base.extend(Callback, {

initialize: function(activate) {

this._scope = paper;

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

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

this.activate();

},

activate: function() {

if (!this._scope)

return false;

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

if (prev && prev != this)

prev.fire('deactivate');

this._scope[this._reference] = this;

this.fire('activate', prev);

return true;

},

isActive: function() {

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

},

remove: function() {

if (this._index == null)

return false;

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

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

this._scope[this._reference] = null;

this._scope = null;

return true;

}

});

var Formatter = Base.extend({

initialize: function(precision) {

this.precision = precision || 5;

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

},

number: function(val) {

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

},

point: function(val, separator) {

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

},

size: function(val, separator) {

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

+ this.number(val.height);

},

rectangle: function(val, separator) {

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

+ this.size(val, separator);

}

});

Formatter.instance = new Formatter();

var Numerical = new function() {

var abscissas = [

[ 0.5773502691896257645091488],

[0,0.7745966692414833770358531],

[ 0.3399810435848562648026658,0.8611363115940525752239465],

[0,0.5384693101056830910363144,0.9061798459386639927976269],

[ 0.2386191860831969086305017,0.6612093864662645136613996,0.9324695142031520278123016],

[0,0.4058451513773971669066064,0.7415311855993944398638648,0.9491079123427585245261897],

[ 0.1834346424956498049394761,0.5255324099163289858177390,0.7966664774136267395915539,0.9602898564975362316835609],

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

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

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

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

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

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

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

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

];

var weights = [

[1],

[0.8888888888888888888888889,0.5555555555555555555555556],

[0.6521451548625461426269361,0.3478548451374538573730639],

[0.5688888888888888888888889,0.4786286704993664680412915,0.2369268850561890875142640],

[0.4679139345726910473898703,0.3607615730481386075698335,0.1713244923791703450402961],

[0.4179591836734693877551020,0.3818300505051189449503698,0.2797053914892766679014678,0.1294849661688696932706114],

[0.3626837833783619829651504,0.3137066458778872873379622,0.2223810344533744705443560,0.1012285362903762591525314],

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

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

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

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

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

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

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

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

];

var abs = Math.abs,

sqrt = Math.sqrt,

pow = Math.pow,

cos = Math.cos,

PI = Math.PI;

return {

TOLERANCE: 10e-6,

EPSILON: 10e-12,

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

isZero: function(val) {

return abs(val) <= Numerical.EPSILON;

},

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

var x = abscissas[n - 2],

w = weights[n - 2],

A = 0.5 * (b - a),

B = A + a,

i = 0,

m = (n + 1) >> 1,

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

while (i < m) {

var Ax = A * x[i];

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

}

return A * sum;

},

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

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

var fx = f(x),

dx = fx / df(x);

if (abs(dx) < tolerance)

return x;

var nx = x - dx;

if (fx > 0) {

b = x;

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

} else {

a = x;

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

}

}

},

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

var unbound = min === undefined,

count = 0;

function add(root) {

if (unbound || root >= min && root <= max)

roots[count++] = root;

return count;

}

var epsilon = this.EPSILON;

if (abs(a) < epsilon) {

if (abs(b) >= epsilon)

return add(-c / b);

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

}

var p = b / (2 * a);

var q = c / a;

var p2 = p * p;

if (p2 < q - epsilon)

return 0;

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

add (s - p);

if (s > 0)

add(-s - p);

return count;

},

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

var epsilon = this.EPSILON;

if (abs(a) < epsilon)

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

var unbound = min === undefined,

count = 0;

function add(root) {

if (unbound || root >= min && root <= max)

roots[count++] = root;

return count;

}

b /= a;

c /= a;

d /= a;

var bb = b * b,

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

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

ppp = p * p * p,

D = q * q - ppp;

b /= 3;

if (abs(D) < epsilon) {

if (abs(q) < epsilon)

return add(-b);

var sqp = sqrt(p),

snq = q > 0 ? 1 : -1;

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

return add(snq * sqp - b);

}

if (D < 0) {

var sqp = sqrt(p),

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

t = -2 * sqp,

o = 2 * PI / 3;

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

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

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

}

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

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

}

};

};

var Point = Base.extend({

_class: 'Point',

_readIndex: true,

initialize: function Point(arg0, arg1) {

var type = typeof arg0;

if (type === 'number') {

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

this.x = arg0;

this.y = hasY ? arg1 : arg0;

if (this.__read)

this.__read = hasY ? 2 : 1;

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