diff --git a/client.js b/client.js
index e69de29..dcdf2f4 100644
--- a/client.js
+++ b/client.js
@@ -0,0 +1,8 @@
+requirejs.config({
+ baseUrl: 'lib'
+});
+
+
+requirejs(["Chuck/Chuck"], function(Chuck) {
+ Chuck.init();
+});
\ No newline at end of file
diff --git a/index.html b/index.html
index e69de29..d9458ca 100644
--- a/index.html
+++ b/index.html
@@ -0,0 +1,32 @@
+
+
+
+ Chuck
+
+
+
+
+
+ hello chuck
+
+
+
+
diff --git a/lib/Box2D/Box2D.js b/lib/Box2D/Box2D.js
new file mode 100644
index 0000000..b9af97f
--- /dev/null
+++ b/lib/Box2D/Box2D.js
@@ -0,0 +1,10867 @@
+define(function(){
+
+/*
+* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
+*
+* This software is provided 'as-is', without any express or implied
+* warranty. In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+* misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+var Box2D = {};
+
+(function (a2j, undefined) {
+
+ function emptyFn() {};
+ a2j.inherit = function(cls, base) {
+ var tmpCtr = cls;
+ emptyFn.prototype = base.prototype;
+ cls.prototype = new emptyFn;
+ cls.prototype.constructor = tmpCtr;
+ };
+
+ a2j.generateCallback = function generateCallback(context, cb) {
+ return function () {
+ cb.apply(context, arguments);
+ };
+ };
+
+ a2j.NVector = function NVector(length) {
+ if (length === undefined) length = 0;
+ var tmp = new Array(length || 0);
+ for (var i = 0; i < length; ++i)
+ tmp[i] = 0;
+ return tmp;
+ };
+
+ a2j.is = function is(o1, o2) {
+ if (o1 === null) return false;
+ if ((o2 instanceof Function) && (o1 instanceof o2)) return true;
+ if ((o1.constructor.__implements != undefined) && (o1.constructor.__implements[o2])) return true;
+ return false;
+ };
+
+ a2j.parseUInt = function(v) {
+ return Math.abs(parseInt(v));
+ }
+
+})(Box2D);
+
+//#TODO remove assignments from global namespace
+var Vector = Array;
+var Vector_a2j_Number = Box2D.NVector;
+//package structure
+if (typeof(Box2D) === "undefined") Box2D = {};
+if (typeof(Box2D.Collision) === "undefined") Box2D.Collision = {};
+if (typeof(Box2D.Collision.Shapes) === "undefined") Box2D.Collision.Shapes = {};
+if (typeof(Box2D.Common) === "undefined") Box2D.Common = {};
+if (typeof(Box2D.Common.Math) === "undefined") Box2D.Common.Math = {};
+if (typeof(Box2D.Dynamics) === "undefined") Box2D.Dynamics = {};
+if (typeof(Box2D.Dynamics.Contacts) === "undefined") Box2D.Dynamics.Contacts = {};
+if (typeof(Box2D.Dynamics.Controllers) === "undefined") Box2D.Dynamics.Controllers = {};
+if (typeof(Box2D.Dynamics.Joints) === "undefined") Box2D.Dynamics.Joints = {};
+//pre-definitions
+(function () {
+ Box2D.Collision.IBroadPhase = 'Box2D.Collision.IBroadPhase';
+
+ function b2AABB() {
+ b2AABB.b2AABB.apply(this, arguments);
+ };
+ Box2D.Collision.b2AABB = b2AABB;
+
+ function b2Bound() {
+ b2Bound.b2Bound.apply(this, arguments);
+ };
+ Box2D.Collision.b2Bound = b2Bound;
+
+ function b2BoundValues() {
+ b2BoundValues.b2BoundValues.apply(this, arguments);
+ if (this.constructor === b2BoundValues) this.b2BoundValues.apply(this, arguments);
+ };
+ Box2D.Collision.b2BoundValues = b2BoundValues;
+
+ function b2Collision() {
+ b2Collision.b2Collision.apply(this, arguments);
+ };
+ Box2D.Collision.b2Collision = b2Collision;
+
+ function b2ContactID() {
+ b2ContactID.b2ContactID.apply(this, arguments);
+ if (this.constructor === b2ContactID) this.b2ContactID.apply(this, arguments);
+ };
+ Box2D.Collision.b2ContactID = b2ContactID;
+
+ function b2ContactPoint() {
+ b2ContactPoint.b2ContactPoint.apply(this, arguments);
+ };
+ Box2D.Collision.b2ContactPoint = b2ContactPoint;
+
+ function b2Distance() {
+ b2Distance.b2Distance.apply(this, arguments);
+ };
+ Box2D.Collision.b2Distance = b2Distance;
+
+ function b2DistanceInput() {
+ b2DistanceInput.b2DistanceInput.apply(this, arguments);
+ };
+ Box2D.Collision.b2DistanceInput = b2DistanceInput;
+
+ function b2DistanceOutput() {
+ b2DistanceOutput.b2DistanceOutput.apply(this, arguments);
+ };
+ Box2D.Collision.b2DistanceOutput = b2DistanceOutput;
+
+ function b2DistanceProxy() {
+ b2DistanceProxy.b2DistanceProxy.apply(this, arguments);
+ };
+ Box2D.Collision.b2DistanceProxy = b2DistanceProxy;
+
+ function b2DynamicTree() {
+ b2DynamicTree.b2DynamicTree.apply(this, arguments);
+ if (this.constructor === b2DynamicTree) this.b2DynamicTree.apply(this, arguments);
+ };
+ Box2D.Collision.b2DynamicTree = b2DynamicTree;
+
+ function b2DynamicTreeBroadPhase() {
+ b2DynamicTreeBroadPhase.b2DynamicTreeBroadPhase.apply(this, arguments);
+ };
+ Box2D.Collision.b2DynamicTreeBroadPhase = b2DynamicTreeBroadPhase;
+
+ function b2DynamicTreeNode() {
+ b2DynamicTreeNode.b2DynamicTreeNode.apply(this, arguments);
+ };
+ Box2D.Collision.b2DynamicTreeNode = b2DynamicTreeNode;
+
+ function b2DynamicTreePair() {
+ b2DynamicTreePair.b2DynamicTreePair.apply(this, arguments);
+ };
+ Box2D.Collision.b2DynamicTreePair = b2DynamicTreePair;
+
+ function b2Manifold() {
+ b2Manifold.b2Manifold.apply(this, arguments);
+ if (this.constructor === b2Manifold) this.b2Manifold.apply(this, arguments);
+ };
+ Box2D.Collision.b2Manifold = b2Manifold;
+
+ function b2ManifoldPoint() {
+ b2ManifoldPoint.b2ManifoldPoint.apply(this, arguments);
+ if (this.constructor === b2ManifoldPoint) this.b2ManifoldPoint.apply(this, arguments);
+ };
+ Box2D.Collision.b2ManifoldPoint = b2ManifoldPoint;
+
+ function b2Point() {
+ b2Point.b2Point.apply(this, arguments);
+ };
+ Box2D.Collision.b2Point = b2Point;
+
+ function b2RayCastInput() {
+ b2RayCastInput.b2RayCastInput.apply(this, arguments);
+ if (this.constructor === b2RayCastInput) this.b2RayCastInput.apply(this, arguments);
+ };
+ Box2D.Collision.b2RayCastInput = b2RayCastInput;
+
+ function b2RayCastOutput() {
+ b2RayCastOutput.b2RayCastOutput.apply(this, arguments);
+ };
+ Box2D.Collision.b2RayCastOutput = b2RayCastOutput;
+
+ function b2Segment() {
+ b2Segment.b2Segment.apply(this, arguments);
+ };
+ Box2D.Collision.b2Segment = b2Segment;
+
+ function b2SeparationFunction() {
+ b2SeparationFunction.b2SeparationFunction.apply(this, arguments);
+ };
+ Box2D.Collision.b2SeparationFunction = b2SeparationFunction;
+
+ function b2Simplex() {
+ b2Simplex.b2Simplex.apply(this, arguments);
+ if (this.constructor === b2Simplex) this.b2Simplex.apply(this, arguments);
+ };
+ Box2D.Collision.b2Simplex = b2Simplex;
+
+ function b2SimplexCache() {
+ b2SimplexCache.b2SimplexCache.apply(this, arguments);
+ };
+ Box2D.Collision.b2SimplexCache = b2SimplexCache;
+
+ function b2SimplexVertex() {
+ b2SimplexVertex.b2SimplexVertex.apply(this, arguments);
+ };
+ Box2D.Collision.b2SimplexVertex = b2SimplexVertex;
+
+ function b2TimeOfImpact() {
+ b2TimeOfImpact.b2TimeOfImpact.apply(this, arguments);
+ };
+ Box2D.Collision.b2TimeOfImpact = b2TimeOfImpact;
+
+ function b2TOIInput() {
+ b2TOIInput.b2TOIInput.apply(this, arguments);
+ };
+ Box2D.Collision.b2TOIInput = b2TOIInput;
+
+ function b2WorldManifold() {
+ b2WorldManifold.b2WorldManifold.apply(this, arguments);
+ if (this.constructor === b2WorldManifold) this.b2WorldManifold.apply(this, arguments);
+ };
+ Box2D.Collision.b2WorldManifold = b2WorldManifold;
+
+ function ClipVertex() {
+ ClipVertex.ClipVertex.apply(this, arguments);
+ };
+ Box2D.Collision.ClipVertex = ClipVertex;
+
+ function Features() {
+ Features.Features.apply(this, arguments);
+ };
+ Box2D.Collision.Features = Features;
+
+ function b2CircleShape() {
+ b2CircleShape.b2CircleShape.apply(this, arguments);
+ if (this.constructor === b2CircleShape) this.b2CircleShape.apply(this, arguments);
+ };
+ Box2D.Collision.Shapes.b2CircleShape = b2CircleShape;
+
+ function b2EdgeChainDef() {
+ b2EdgeChainDef.b2EdgeChainDef.apply(this, arguments);
+ if (this.constructor === b2EdgeChainDef) this.b2EdgeChainDef.apply(this, arguments);
+ };
+ Box2D.Collision.Shapes.b2EdgeChainDef = b2EdgeChainDef;
+
+ function b2EdgeShape() {
+ b2EdgeShape.b2EdgeShape.apply(this, arguments);
+ if (this.constructor === b2EdgeShape) this.b2EdgeShape.apply(this, arguments);
+ };
+ Box2D.Collision.Shapes.b2EdgeShape = b2EdgeShape;
+
+ function b2MassData() {
+ b2MassData.b2MassData.apply(this, arguments);
+ };
+ Box2D.Collision.Shapes.b2MassData = b2MassData;
+
+ function b2PolygonShape() {
+ b2PolygonShape.b2PolygonShape.apply(this, arguments);
+ if (this.constructor === b2PolygonShape) this.b2PolygonShape.apply(this, arguments);
+ };
+ Box2D.Collision.Shapes.b2PolygonShape = b2PolygonShape;
+
+ function b2Shape() {
+ b2Shape.b2Shape.apply(this, arguments);
+ if (this.constructor === b2Shape) this.b2Shape.apply(this, arguments);
+ };
+ Box2D.Collision.Shapes.b2Shape = b2Shape;
+ Box2D.Common.b2internal = 'Box2D.Common.b2internal';
+
+ function b2Color() {
+ b2Color.b2Color.apply(this, arguments);
+ if (this.constructor === b2Color) this.b2Color.apply(this, arguments);
+ };
+ Box2D.Common.b2Color = b2Color;
+
+ function b2Settings() {
+ b2Settings.b2Settings.apply(this, arguments);
+ };
+ Box2D.Common.b2Settings = b2Settings;
+
+ function b2Mat22() {
+ b2Mat22.b2Mat22.apply(this, arguments);
+ if (this.constructor === b2Mat22) this.b2Mat22.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Mat22 = b2Mat22;
+
+ function b2Mat33() {
+ b2Mat33.b2Mat33.apply(this, arguments);
+ if (this.constructor === b2Mat33) this.b2Mat33.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Mat33 = b2Mat33;
+
+ function b2Math() {
+ b2Math.b2Math.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Math = b2Math;
+
+ function b2Sweep() {
+ b2Sweep.b2Sweep.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Sweep = b2Sweep;
+
+ function b2Transform() {
+ b2Transform.b2Transform.apply(this, arguments);
+ if (this.constructor === b2Transform) this.b2Transform.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Transform = b2Transform;
+
+ function b2Vec2() {
+ b2Vec2.b2Vec2.apply(this, arguments);
+ if (this.constructor === b2Vec2) this.b2Vec2.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Vec2 = b2Vec2;
+
+ function b2Vec3() {
+ b2Vec3.b2Vec3.apply(this, arguments);
+ if (this.constructor === b2Vec3) this.b2Vec3.apply(this, arguments);
+ };
+ Box2D.Common.Math.b2Vec3 = b2Vec3;
+
+ function b2Body() {
+ b2Body.b2Body.apply(this, arguments);
+ if (this.constructor === b2Body) this.b2Body.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2Body = b2Body;
+
+ function b2BodyDef() {
+ b2BodyDef.b2BodyDef.apply(this, arguments);
+ if (this.constructor === b2BodyDef) this.b2BodyDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2BodyDef = b2BodyDef;
+
+ function b2ContactFilter() {
+ b2ContactFilter.b2ContactFilter.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2ContactFilter = b2ContactFilter;
+
+ function b2ContactImpulse() {
+ b2ContactImpulse.b2ContactImpulse.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2ContactImpulse = b2ContactImpulse;
+
+ function b2ContactListener() {
+ b2ContactListener.b2ContactListener.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2ContactListener = b2ContactListener;
+
+ function b2ContactManager() {
+ b2ContactManager.b2ContactManager.apply(this, arguments);
+ if (this.constructor === b2ContactManager) this.b2ContactManager.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2ContactManager = b2ContactManager;
+
+ function b2DebugDraw() {
+ b2DebugDraw.b2DebugDraw.apply(this, arguments);
+ if (this.constructor === b2DebugDraw) this.b2DebugDraw.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2DebugDraw = b2DebugDraw;
+
+ function b2DestructionListener() {
+ b2DestructionListener.b2DestructionListener.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2DestructionListener = b2DestructionListener;
+
+ function b2FilterData() {
+ b2FilterData.b2FilterData.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2FilterData = b2FilterData;
+
+ function b2Fixture() {
+ b2Fixture.b2Fixture.apply(this, arguments);
+ if (this.constructor === b2Fixture) this.b2Fixture.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2Fixture = b2Fixture;
+
+ function b2FixtureDef() {
+ b2FixtureDef.b2FixtureDef.apply(this, arguments);
+ if (this.constructor === b2FixtureDef) this.b2FixtureDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2FixtureDef = b2FixtureDef;
+
+ function b2Island() {
+ b2Island.b2Island.apply(this, arguments);
+ if (this.constructor === b2Island) this.b2Island.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2Island = b2Island;
+
+ function b2TimeStep() {
+ b2TimeStep.b2TimeStep.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2TimeStep = b2TimeStep;
+
+ function b2World() {
+ b2World.b2World.apply(this, arguments);
+ if (this.constructor === b2World) this.b2World.apply(this, arguments);
+ };
+ Box2D.Dynamics.b2World = b2World;
+
+ function b2CircleContact() {
+ b2CircleContact.b2CircleContact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2CircleContact = b2CircleContact;
+
+ function b2Contact() {
+ b2Contact.b2Contact.apply(this, arguments);
+ if (this.constructor === b2Contact) this.b2Contact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2Contact = b2Contact;
+
+ function b2ContactConstraint() {
+ b2ContactConstraint.b2ContactConstraint.apply(this, arguments);
+ if (this.constructor === b2ContactConstraint) this.b2ContactConstraint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactConstraint = b2ContactConstraint;
+
+ function b2ContactConstraintPoint() {
+ b2ContactConstraintPoint.b2ContactConstraintPoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactConstraintPoint = b2ContactConstraintPoint;
+
+ function b2ContactEdge() {
+ b2ContactEdge.b2ContactEdge.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactEdge = b2ContactEdge;
+
+ function b2ContactFactory() {
+ b2ContactFactory.b2ContactFactory.apply(this, arguments);
+ if (this.constructor === b2ContactFactory) this.b2ContactFactory.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactFactory = b2ContactFactory;
+
+ function b2ContactRegister() {
+ b2ContactRegister.b2ContactRegister.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactRegister = b2ContactRegister;
+
+ function b2ContactResult() {
+ b2ContactResult.b2ContactResult.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactResult = b2ContactResult;
+
+ function b2ContactSolver() {
+ b2ContactSolver.b2ContactSolver.apply(this, arguments);
+ if (this.constructor === b2ContactSolver) this.b2ContactSolver.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2ContactSolver = b2ContactSolver;
+
+ function b2EdgeAndCircleContact() {
+ b2EdgeAndCircleContact.b2EdgeAndCircleContact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2EdgeAndCircleContact = b2EdgeAndCircleContact;
+
+ function b2NullContact() {
+ b2NullContact.b2NullContact.apply(this, arguments);
+ if (this.constructor === b2NullContact) this.b2NullContact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2NullContact = b2NullContact;
+
+ function b2PolyAndCircleContact() {
+ b2PolyAndCircleContact.b2PolyAndCircleContact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2PolyAndCircleContact = b2PolyAndCircleContact;
+
+ function b2PolyAndEdgeContact() {
+ b2PolyAndEdgeContact.b2PolyAndEdgeContact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2PolyAndEdgeContact = b2PolyAndEdgeContact;
+
+ function b2PolygonContact() {
+ b2PolygonContact.b2PolygonContact.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2PolygonContact = b2PolygonContact;
+
+ function b2PositionSolverManifold() {
+ b2PositionSolverManifold.b2PositionSolverManifold.apply(this, arguments);
+ if (this.constructor === b2PositionSolverManifold) this.b2PositionSolverManifold.apply(this, arguments);
+ };
+ Box2D.Dynamics.Contacts.b2PositionSolverManifold = b2PositionSolverManifold;
+
+ function b2BuoyancyController() {
+ b2BuoyancyController.b2BuoyancyController.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2BuoyancyController = b2BuoyancyController;
+
+ function b2ConstantAccelController() {
+ b2ConstantAccelController.b2ConstantAccelController.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2ConstantAccelController = b2ConstantAccelController;
+
+ function b2ConstantForceController() {
+ b2ConstantForceController.b2ConstantForceController.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2ConstantForceController = b2ConstantForceController;
+
+ function b2Controller() {
+ b2Controller.b2Controller.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2Controller = b2Controller;
+
+ function b2ControllerEdge() {
+ b2ControllerEdge.b2ControllerEdge.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2ControllerEdge = b2ControllerEdge;
+
+ function b2GravityController() {
+ b2GravityController.b2GravityController.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2GravityController = b2GravityController;
+
+ function b2TensorDampingController() {
+ b2TensorDampingController.b2TensorDampingController.apply(this, arguments);
+ };
+ Box2D.Dynamics.Controllers.b2TensorDampingController = b2TensorDampingController;
+
+ function b2DistanceJoint() {
+ b2DistanceJoint.b2DistanceJoint.apply(this, arguments);
+ if (this.constructor === b2DistanceJoint) this.b2DistanceJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2DistanceJoint = b2DistanceJoint;
+
+ function b2DistanceJointDef() {
+ b2DistanceJointDef.b2DistanceJointDef.apply(this, arguments);
+ if (this.constructor === b2DistanceJointDef) this.b2DistanceJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2DistanceJointDef = b2DistanceJointDef;
+
+ function b2FrictionJoint() {
+ b2FrictionJoint.b2FrictionJoint.apply(this, arguments);
+ if (this.constructor === b2FrictionJoint) this.b2FrictionJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2FrictionJoint = b2FrictionJoint;
+
+ function b2FrictionJointDef() {
+ b2FrictionJointDef.b2FrictionJointDef.apply(this, arguments);
+ if (this.constructor === b2FrictionJointDef) this.b2FrictionJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2FrictionJointDef = b2FrictionJointDef;
+
+ function b2GearJoint() {
+ b2GearJoint.b2GearJoint.apply(this, arguments);
+ if (this.constructor === b2GearJoint) this.b2GearJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2GearJoint = b2GearJoint;
+
+ function b2GearJointDef() {
+ b2GearJointDef.b2GearJointDef.apply(this, arguments);
+ if (this.constructor === b2GearJointDef) this.b2GearJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2GearJointDef = b2GearJointDef;
+
+ function b2Jacobian() {
+ b2Jacobian.b2Jacobian.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2Jacobian = b2Jacobian;
+
+ function b2Joint() {
+ b2Joint.b2Joint.apply(this, arguments);
+ if (this.constructor === b2Joint) this.b2Joint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2Joint = b2Joint;
+
+ function b2JointDef() {
+ b2JointDef.b2JointDef.apply(this, arguments);
+ if (this.constructor === b2JointDef) this.b2JointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2JointDef = b2JointDef;
+
+ function b2JointEdge() {
+ b2JointEdge.b2JointEdge.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2JointEdge = b2JointEdge;
+
+ function b2LineJoint() {
+ b2LineJoint.b2LineJoint.apply(this, arguments);
+ if (this.constructor === b2LineJoint) this.b2LineJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2LineJoint = b2LineJoint;
+
+ function b2LineJointDef() {
+ b2LineJointDef.b2LineJointDef.apply(this, arguments);
+ if (this.constructor === b2LineJointDef) this.b2LineJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2LineJointDef = b2LineJointDef;
+
+ function b2MouseJoint() {
+ b2MouseJoint.b2MouseJoint.apply(this, arguments);
+ if (this.constructor === b2MouseJoint) this.b2MouseJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2MouseJoint = b2MouseJoint;
+
+ function b2MouseJointDef() {
+ b2MouseJointDef.b2MouseJointDef.apply(this, arguments);
+ if (this.constructor === b2MouseJointDef) this.b2MouseJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2MouseJointDef = b2MouseJointDef;
+
+ function b2PrismaticJoint() {
+ b2PrismaticJoint.b2PrismaticJoint.apply(this, arguments);
+ if (this.constructor === b2PrismaticJoint) this.b2PrismaticJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2PrismaticJoint = b2PrismaticJoint;
+
+ function b2PrismaticJointDef() {
+ b2PrismaticJointDef.b2PrismaticJointDef.apply(this, arguments);
+ if (this.constructor === b2PrismaticJointDef) this.b2PrismaticJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2PrismaticJointDef = b2PrismaticJointDef;
+
+ function b2PulleyJoint() {
+ b2PulleyJoint.b2PulleyJoint.apply(this, arguments);
+ if (this.constructor === b2PulleyJoint) this.b2PulleyJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2PulleyJoint = b2PulleyJoint;
+
+ function b2PulleyJointDef() {
+ b2PulleyJointDef.b2PulleyJointDef.apply(this, arguments);
+ if (this.constructor === b2PulleyJointDef) this.b2PulleyJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2PulleyJointDef = b2PulleyJointDef;
+
+ function b2RevoluteJoint() {
+ b2RevoluteJoint.b2RevoluteJoint.apply(this, arguments);
+ if (this.constructor === b2RevoluteJoint) this.b2RevoluteJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2RevoluteJoint = b2RevoluteJoint;
+
+ function b2RevoluteJointDef() {
+ b2RevoluteJointDef.b2RevoluteJointDef.apply(this, arguments);
+ if (this.constructor === b2RevoluteJointDef) this.b2RevoluteJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2RevoluteJointDef = b2RevoluteJointDef;
+
+ function b2WeldJoint() {
+ b2WeldJoint.b2WeldJoint.apply(this, arguments);
+ if (this.constructor === b2WeldJoint) this.b2WeldJoint.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2WeldJoint = b2WeldJoint;
+
+ function b2WeldJointDef() {
+ b2WeldJointDef.b2WeldJointDef.apply(this, arguments);
+ if (this.constructor === b2WeldJointDef) this.b2WeldJointDef.apply(this, arguments);
+ };
+ Box2D.Dynamics.Joints.b2WeldJointDef = b2WeldJointDef;
+})(); //definitions
+Box2D.postDefs = [];
+(function () {
+ var b2CircleShape = Box2D.Collision.Shapes.b2CircleShape,
+ b2EdgeChainDef = Box2D.Collision.Shapes.b2EdgeChainDef,
+ b2EdgeShape = Box2D.Collision.Shapes.b2EdgeShape,
+ b2MassData = Box2D.Collision.Shapes.b2MassData,
+ b2PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
+ b2Shape = Box2D.Collision.Shapes.b2Shape,
+ b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3,
+ b2AABB = Box2D.Collision.b2AABB,
+ b2Bound = Box2D.Collision.b2Bound,
+ b2BoundValues = Box2D.Collision.b2BoundValues,
+ b2Collision = Box2D.Collision.b2Collision,
+ b2ContactID = Box2D.Collision.b2ContactID,
+ b2ContactPoint = Box2D.Collision.b2ContactPoint,
+ b2Distance = Box2D.Collision.b2Distance,
+ b2DistanceInput = Box2D.Collision.b2DistanceInput,
+ b2DistanceOutput = Box2D.Collision.b2DistanceOutput,
+ b2DistanceProxy = Box2D.Collision.b2DistanceProxy,
+ b2DynamicTree = Box2D.Collision.b2DynamicTree,
+ b2DynamicTreeBroadPhase = Box2D.Collision.b2DynamicTreeBroadPhase,
+ b2DynamicTreeNode = Box2D.Collision.b2DynamicTreeNode,
+ b2DynamicTreePair = Box2D.Collision.b2DynamicTreePair,
+ b2Manifold = Box2D.Collision.b2Manifold,
+ b2ManifoldPoint = Box2D.Collision.b2ManifoldPoint,
+ b2Point = Box2D.Collision.b2Point,
+ b2RayCastInput = Box2D.Collision.b2RayCastInput,
+ b2RayCastOutput = Box2D.Collision.b2RayCastOutput,
+ b2Segment = Box2D.Collision.b2Segment,
+ b2SeparationFunction = Box2D.Collision.b2SeparationFunction,
+ b2Simplex = Box2D.Collision.b2Simplex,
+ b2SimplexCache = Box2D.Collision.b2SimplexCache,
+ b2SimplexVertex = Box2D.Collision.b2SimplexVertex,
+ b2TimeOfImpact = Box2D.Collision.b2TimeOfImpact,
+ b2TOIInput = Box2D.Collision.b2TOIInput,
+ b2WorldManifold = Box2D.Collision.b2WorldManifold,
+ ClipVertex = Box2D.Collision.ClipVertex,
+ Features = Box2D.Collision.Features,
+ IBroadPhase = Box2D.Collision.IBroadPhase;
+
+ b2AABB.b2AABB = function () {
+ this.lowerBound = new b2Vec2();
+ this.upperBound = new b2Vec2();
+ };
+ b2AABB.prototype.IsValid = function () {
+ var dX = this.upperBound.x - this.lowerBound.x;
+ var dY = this.upperBound.y - this.lowerBound.y;
+ var valid = dX >= 0.0 && dY >= 0.0;
+ valid = valid && this.lowerBound.IsValid() && this.upperBound.IsValid();
+ return valid;
+ }
+ b2AABB.prototype.GetCenter = function () {
+ return new b2Vec2((this.lowerBound.x + this.upperBound.x) / 2, (this.lowerBound.y + this.upperBound.y) / 2);
+ }
+ b2AABB.prototype.GetExtents = function () {
+ return new b2Vec2((this.upperBound.x - this.lowerBound.x) / 2, (this.upperBound.y - this.lowerBound.y) / 2);
+ }
+ b2AABB.prototype.Contains = function (aabb) {
+ var result = true;
+ result = result && this.lowerBound.x <= aabb.lowerBound.x;
+ result = result && this.lowerBound.y <= aabb.lowerBound.y;
+ result = result && aabb.upperBound.x <= this.upperBound.x;
+ result = result && aabb.upperBound.y <= this.upperBound.y;
+ return result;
+ }
+ b2AABB.prototype.RayCast = function (output, input) {
+ var tmin = (-Number.MAX_VALUE);
+ var tmax = Number.MAX_VALUE;
+ var pX = input.p1.x;
+ var pY = input.p1.y;
+ var dX = input.p2.x - input.p1.x;
+ var dY = input.p2.y - input.p1.y;
+ var absDX = Math.abs(dX);
+ var absDY = Math.abs(dY);
+ var normal = output.normal;
+ var inv_d = 0;
+ var t1 = 0;
+ var t2 = 0;
+ var t3 = 0;
+ var s = 0; {
+ if (absDX < Number.MIN_VALUE) {
+ if (pX < this.lowerBound.x || this.upperBound.x < pX) return false;
+ }
+ else {
+ inv_d = 1.0 / dX;
+ t1 = (this.lowerBound.x - pX) * inv_d;
+ t2 = (this.upperBound.x - pX) * inv_d;
+ s = (-1.0);
+ if (t1 > t2) {
+ t3 = t1;
+ t1 = t2;
+ t2 = t3;
+ s = 1.0;
+ }
+ if (t1 > tmin) {
+ normal.x = s;
+ normal.y = 0;
+ tmin = t1;
+ }
+ tmax = Math.min(tmax, t2);
+ if (tmin > tmax) return false;
+ }
+ } {
+ if (absDY < Number.MIN_VALUE) {
+ if (pY < this.lowerBound.y || this.upperBound.y < pY) return false;
+ }
+ else {
+ inv_d = 1.0 / dY;
+ t1 = (this.lowerBound.y - pY) * inv_d;
+ t2 = (this.upperBound.y - pY) * inv_d;
+ s = (-1.0);
+ if (t1 > t2) {
+ t3 = t1;
+ t1 = t2;
+ t2 = t3;
+ s = 1.0;
+ }
+ if (t1 > tmin) {
+ normal.y = s;
+ normal.x = 0;
+ tmin = t1;
+ }
+ tmax = Math.min(tmax, t2);
+ if (tmin > tmax) return false;
+ }
+ }
+ output.fraction = tmin;
+ return true;
+ }
+ b2AABB.prototype.TestOverlap = function (other) {
+ var d1X = other.lowerBound.x - this.upperBound.x;
+ var d1Y = other.lowerBound.y - this.upperBound.y;
+ var d2X = this.lowerBound.x - other.upperBound.x;
+ var d2Y = this.lowerBound.y - other.upperBound.y;
+ if (d1X > 0.0 || d1Y > 0.0) return false;
+ if (d2X > 0.0 || d2Y > 0.0) return false;
+ return true;
+ }
+ b2AABB.Combine = function (aabb1, aabb2) {
+ var aabb = new b2AABB();
+ aabb.Combine(aabb1, aabb2);
+ return aabb;
+ }
+ b2AABB.prototype.Combine = function (aabb1, aabb2) {
+ this.lowerBound.x = Math.min(aabb1.lowerBound.x, aabb2.lowerBound.x);
+ this.lowerBound.y = Math.min(aabb1.lowerBound.y, aabb2.lowerBound.y);
+ this.upperBound.x = Math.max(aabb1.upperBound.x, aabb2.upperBound.x);
+ this.upperBound.y = Math.max(aabb1.upperBound.y, aabb2.upperBound.y);
+ }
+ b2Bound.b2Bound = function () {};
+ b2Bound.prototype.IsLower = function () {
+ return (this.value & 1) == 0;
+ }
+ b2Bound.prototype.IsUpper = function () {
+ return (this.value & 1) == 1;
+ }
+ b2Bound.prototype.Swap = function (b) {
+ var tempValue = this.value;
+ var tempProxy = this.proxy;
+ var tempStabbingCount = this.stabbingCount;
+ this.value = b.value;
+ this.proxy = b.proxy;
+ this.stabbingCount = b.stabbingCount;
+ b.value = tempValue;
+ b.proxy = tempProxy;
+ b.stabbingCount = tempStabbingCount;
+ }
+ b2BoundValues.b2BoundValues = function () {};
+ b2BoundValues.prototype.b2BoundValues = function () {
+ this.lowerValues = new Vector_a2j_Number();
+ this.lowerValues[0] = 0.0;
+ this.lowerValues[1] = 0.0;
+ this.upperValues = new Vector_a2j_Number();
+ this.upperValues[0] = 0.0;
+ this.upperValues[1] = 0.0;
+ }
+ b2Collision.b2Collision = function () {};
+ b2Collision.ClipSegmentToLine = function (vOut, vIn, normal, offset) {
+ if (offset === undefined) offset = 0;
+ var cv;
+ var numOut = 0;
+ cv = vIn[0];
+ var vIn0 = cv.v;
+ cv = vIn[1];
+ var vIn1 = cv.v;
+ var distance0 = normal.x * vIn0.x + normal.y * vIn0.y - offset;
+ var distance1 = normal.x * vIn1.x + normal.y * vIn1.y - offset;
+ if (distance0 <= 0.0) vOut[numOut++].Set(vIn[0]);
+ if (distance1 <= 0.0) vOut[numOut++].Set(vIn[1]);
+ if (distance0 * distance1 < 0.0) {
+ var interp = distance0 / (distance0 - distance1);
+ cv = vOut[numOut];
+ var tVec = cv.v;
+ tVec.x = vIn0.x + interp * (vIn1.x - vIn0.x);
+ tVec.y = vIn0.y + interp * (vIn1.y - vIn0.y);
+ cv = vOut[numOut];
+ var cv2;
+ if (distance0 > 0.0) {
+ cv2 = vIn[0];
+ cv.id = cv2.id;
+ }
+ else {
+ cv2 = vIn[1];
+ cv.id = cv2.id;
+ }++numOut;
+ }
+ return numOut;
+ }
+ b2Collision.EdgeSeparation = function (poly1, xf1, edge1, poly2, xf2) {
+ if (edge1 === undefined) edge1 = 0;
+ var count1 = parseInt(poly1.m_vertexCount);
+ var vertices1 = poly1.m_vertices;
+ var normals1 = poly1.m_normals;
+ var count2 = parseInt(poly2.m_vertexCount);
+ var vertices2 = poly2.m_vertices;
+ var tMat;
+ var tVec;
+ tMat = xf1.R;
+ tVec = normals1[edge1];
+ var normal1WorldX = (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var normal1WorldY = (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = xf2.R;
+ var normal1X = (tMat.col1.x * normal1WorldX + tMat.col1.y * normal1WorldY);
+ var normal1Y = (tMat.col2.x * normal1WorldX + tMat.col2.y * normal1WorldY);
+ var index = 0;
+ var minDot = Number.MAX_VALUE;
+ for (var i = 0; i < count2; ++i) {
+ tVec = vertices2[i];
+ var dot = tVec.x * normal1X + tVec.y * normal1Y;
+ if (dot < minDot) {
+ minDot = dot;
+ index = i;
+ }
+ }
+ tVec = vertices1[edge1];
+ tMat = xf1.R;
+ var v1X = xf1.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var v1Y = xf1.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tVec = vertices2[index];
+ tMat = xf2.R;
+ var v2X = xf2.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var v2Y = xf2.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ v2X -= v1X;
+ v2Y -= v1Y;
+ var separation = v2X * normal1WorldX + v2Y * normal1WorldY;
+ return separation;
+ }
+ b2Collision.FindMaxSeparation = function (edgeIndex, poly1, xf1, poly2, xf2) {
+ var count1 = parseInt(poly1.m_vertexCount);
+ var normals1 = poly1.m_normals;
+ var tVec;
+ var tMat;
+ tMat = xf2.R;
+ tVec = poly2.m_centroid;
+ var dX = xf2.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var dY = xf2.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = xf1.R;
+ tVec = poly1.m_centroid;
+ dX -= xf1.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ dY -= xf1.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ var dLocal1X = (dX * xf1.R.col1.x + dY * xf1.R.col1.y);
+ var dLocal1Y = (dX * xf1.R.col2.x + dY * xf1.R.col2.y);
+ var edge = 0;
+ var maxDot = (-Number.MAX_VALUE);
+ for (var i = 0; i < count1; ++i) {
+ tVec = normals1[i];
+ var dot = (tVec.x * dLocal1X + tVec.y * dLocal1Y);
+ if (dot > maxDot) {
+ maxDot = dot;
+ edge = i;
+ }
+ }
+ var s = b2Collision.EdgeSeparation(poly1, xf1, edge, poly2, xf2);
+ var prevEdge = parseInt(edge - 1 >= 0 ? edge - 1 : count1 - 1);
+ var sPrev = b2Collision.EdgeSeparation(poly1, xf1, prevEdge, poly2, xf2);
+ var nextEdge = parseInt(edge + 1 < count1 ? edge + 1 : 0);
+ var sNext = b2Collision.EdgeSeparation(poly1, xf1, nextEdge, poly2, xf2);
+ var bestEdge = 0;
+ var bestSeparation = 0;
+ var increment = 0;
+ if (sPrev > s && sPrev > sNext) {
+ increment = (-1);
+ bestEdge = prevEdge;
+ bestSeparation = sPrev;
+ }
+ else if (sNext > s) {
+ increment = 1;
+ bestEdge = nextEdge;
+ bestSeparation = sNext;
+ }
+ else {
+ edgeIndex[0] = edge;
+ return s;
+ }
+ while (true) {
+ if (increment == (-1)) edge = bestEdge - 1 >= 0 ? bestEdge - 1 : count1 - 1;
+ else edge = bestEdge + 1 < count1 ? bestEdge + 1 : 0;s = b2Collision.EdgeSeparation(poly1, xf1, edge, poly2, xf2);
+ if (s > bestSeparation) {
+ bestEdge = edge;
+ bestSeparation = s;
+ }
+ else {
+ break;
+ }
+ }
+ edgeIndex[0] = bestEdge;
+ return bestSeparation;
+ }
+ b2Collision.FindIncidentEdge = function (c, poly1, xf1, edge1, poly2, xf2) {
+ if (edge1 === undefined) edge1 = 0;
+ var count1 = parseInt(poly1.m_vertexCount);
+ var normals1 = poly1.m_normals;
+ var count2 = parseInt(poly2.m_vertexCount);
+ var vertices2 = poly2.m_vertices;
+ var normals2 = poly2.m_normals;
+ var tMat;
+ var tVec;
+ tMat = xf1.R;
+ tVec = normals1[edge1];
+ var normal1X = (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var normal1Y = (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = xf2.R;
+ var tX = (tMat.col1.x * normal1X + tMat.col1.y * normal1Y);
+ normal1Y = (tMat.col2.x * normal1X + tMat.col2.y * normal1Y);
+ normal1X = tX;
+ var index = 0;
+ var minDot = Number.MAX_VALUE;
+ for (var i = 0; i < count2; ++i) {
+ tVec = normals2[i];
+ var dot = (normal1X * tVec.x + normal1Y * tVec.y);
+ if (dot < minDot) {
+ minDot = dot;
+ index = i;
+ }
+ }
+ var tClip;
+ var i1 = parseInt(index);
+ var i2 = parseInt(i1 + 1 < count2 ? i1 + 1 : 0);
+ tClip = c[0];
+ tVec = vertices2[i1];
+ tMat = xf2.R;
+ tClip.v.x = xf2.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ tClip.v.y = xf2.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tClip.id.features.referenceEdge = edge1;
+ tClip.id.features.incidentEdge = i1;
+ tClip.id.features.incidentVertex = 0;
+ tClip = c[1];
+ tVec = vertices2[i2];
+ tMat = xf2.R;
+ tClip.v.x = xf2.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ tClip.v.y = xf2.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tClip.id.features.referenceEdge = edge1;
+ tClip.id.features.incidentEdge = i2;
+ tClip.id.features.incidentVertex = 1;
+ }
+ b2Collision.MakeClipPointVector = function () {
+ var r = new Vector(2);
+ r[0] = new ClipVertex();
+ r[1] = new ClipVertex();
+ return r;
+ }
+ b2Collision.CollidePolygons = function (manifold, polyA, xfA, polyB, xfB) {
+ var cv;
+ manifold.m_pointCount = 0;
+ var totalRadius = polyA.m_radius + polyB.m_radius;
+ var edgeA = 0;
+ b2Collision.s_edgeAO[0] = edgeA;
+ var separationA = b2Collision.FindMaxSeparation(b2Collision.s_edgeAO, polyA, xfA, polyB, xfB);
+ edgeA = b2Collision.s_edgeAO[0];
+ if (separationA > totalRadius) return;
+ var edgeB = 0;
+ b2Collision.s_edgeBO[0] = edgeB;
+ var separationB = b2Collision.FindMaxSeparation(b2Collision.s_edgeBO, polyB, xfB, polyA, xfA);
+ edgeB = b2Collision.s_edgeBO[0];
+ if (separationB > totalRadius) return;
+ var poly1;
+ var poly2;
+ var xf1;
+ var xf2;
+ var edge1 = 0;
+ var flip = 0;
+ var k_relativeTol = 0.98;
+ var k_absoluteTol = 0.001;
+ var tMat;
+ if (separationB > k_relativeTol * separationA + k_absoluteTol) {
+ poly1 = polyB;
+ poly2 = polyA;
+ xf1 = xfB;
+ xf2 = xfA;
+ edge1 = edgeB;
+ manifold.m_type = b2Manifold.e_faceB;
+ flip = 1;
+ }
+ else {
+ poly1 = polyA;
+ poly2 = polyB;
+ xf1 = xfA;
+ xf2 = xfB;
+ edge1 = edgeA;
+ manifold.m_type = b2Manifold.e_faceA;
+ flip = 0;
+ }
+ var incidentEdge = b2Collision.s_incidentEdge;
+ b2Collision.FindIncidentEdge(incidentEdge, poly1, xf1, edge1, poly2, xf2);
+ var count1 = parseInt(poly1.m_vertexCount);
+ var vertices1 = poly1.m_vertices;
+ var local_v11 = vertices1[edge1];
+ var local_v12;
+ if (edge1 + 1 < count1) {
+ local_v12 = vertices1[parseInt(edge1 + 1)];
+ }
+ else {
+ local_v12 = vertices1[0];
+ }
+ var localTangent = b2Collision.s_localTangent;
+ localTangent.Set(local_v12.x - local_v11.x, local_v12.y - local_v11.y);
+ localTangent.Normalize();
+ var localNormal = b2Collision.s_localNormal;
+ localNormal.x = localTangent.y;
+ localNormal.y = (-localTangent.x);
+ var planePoint = b2Collision.s_planePoint;
+ planePoint.Set(0.5 * (local_v11.x + local_v12.x), 0.5 * (local_v11.y + local_v12.y));
+ var tangent = b2Collision.s_tangent;
+ tMat = xf1.R;
+ tangent.x = (tMat.col1.x * localTangent.x + tMat.col2.x * localTangent.y);
+ tangent.y = (tMat.col1.y * localTangent.x + tMat.col2.y * localTangent.y);
+ var tangent2 = b2Collision.s_tangent2;
+ tangent2.x = (-tangent.x);
+ tangent2.y = (-tangent.y);
+ var normal = b2Collision.s_normal;
+ normal.x = tangent.y;
+ normal.y = (-tangent.x);
+ var v11 = b2Collision.s_v11;
+ var v12 = b2Collision.s_v12;
+ v11.x = xf1.position.x + (tMat.col1.x * local_v11.x + tMat.col2.x * local_v11.y);
+ v11.y = xf1.position.y + (tMat.col1.y * local_v11.x + tMat.col2.y * local_v11.y);
+ v12.x = xf1.position.x + (tMat.col1.x * local_v12.x + tMat.col2.x * local_v12.y);
+ v12.y = xf1.position.y + (tMat.col1.y * local_v12.x + tMat.col2.y * local_v12.y);
+ var frontOffset = normal.x * v11.x + normal.y * v11.y;
+ var sideOffset1 = (-tangent.x * v11.x) - tangent.y * v11.y + totalRadius;
+ var sideOffset2 = tangent.x * v12.x + tangent.y * v12.y + totalRadius;
+ var clipPoints1 = b2Collision.s_clipPoints1;
+ var clipPoints2 = b2Collision.s_clipPoints2;
+ var np = 0;
+ np = b2Collision.ClipSegmentToLine(clipPoints1, incidentEdge, tangent2, sideOffset1);
+ if (np < 2) return;
+ np = b2Collision.ClipSegmentToLine(clipPoints2, clipPoints1, tangent, sideOffset2);
+ if (np < 2) return;
+ manifold.m_localPlaneNormal.SetV(localNormal);
+ manifold.m_localPoint.SetV(planePoint);
+ var pointCount = 0;
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; ++i) {
+ cv = clipPoints2[i];
+ var separation = normal.x * cv.v.x + normal.y * cv.v.y - frontOffset;
+ if (separation <= totalRadius) {
+ var cp = manifold.m_points[pointCount];
+ tMat = xf2.R;
+ var tX = cv.v.x - xf2.position.x;
+ var tY = cv.v.y - xf2.position.y;
+ cp.m_localPoint.x = (tX * tMat.col1.x + tY * tMat.col1.y);
+ cp.m_localPoint.y = (tX * tMat.col2.x + tY * tMat.col2.y);
+ cp.m_id.Set(cv.id);
+ cp.m_id.features.flip = flip;
+ ++pointCount;
+ }
+ }
+ manifold.m_pointCount = pointCount;
+ }
+ b2Collision.CollideCircles = function (manifold, circle1, xf1, circle2, xf2) {
+ manifold.m_pointCount = 0;
+ var tMat;
+ var tVec;
+ tMat = xf1.R;
+ tVec = circle1.m_p;
+ var p1X = xf1.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var p1Y = xf1.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = xf2.R;
+ tVec = circle2.m_p;
+ var p2X = xf2.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var p2Y = xf2.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ var dX = p2X - p1X;
+ var dY = p2Y - p1Y;
+ var distSqr = dX * dX + dY * dY;
+ var radius = circle1.m_radius + circle2.m_radius;
+ if (distSqr > radius * radius) {
+ return;
+ }
+ manifold.m_type = b2Manifold.e_circles;
+ manifold.m_localPoint.SetV(circle1.m_p);
+ manifold.m_localPlaneNormal.SetZero();
+ manifold.m_pointCount = 1;
+ manifold.m_points[0].m_localPoint.SetV(circle2.m_p);
+ manifold.m_points[0].m_id.key = 0;
+ }
+ b2Collision.CollidePolygonAndCircle = function (manifold, polygon, xf1, circle, xf2) {
+ manifold.m_pointCount = 0;
+ var tPoint;
+ var dX = 0;
+ var dY = 0;
+ var positionX = 0;
+ var positionY = 0;
+ var tVec;
+ var tMat;
+ tMat = xf2.R;
+ tVec = circle.m_p;
+ var cX = xf2.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var cY = xf2.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ dX = cX - xf1.position.x;
+ dY = cY - xf1.position.y;
+ tMat = xf1.R;
+ var cLocalX = (dX * tMat.col1.x + dY * tMat.col1.y);
+ var cLocalY = (dX * tMat.col2.x + dY * tMat.col2.y);
+ var dist = 0;
+ var normalIndex = 0;
+ var separation = (-Number.MAX_VALUE);
+ var radius = polygon.m_radius + circle.m_radius;
+ var vertexCount = parseInt(polygon.m_vertexCount);
+ var vertices = polygon.m_vertices;
+ var normals = polygon.m_normals;
+ for (var i = 0; i < vertexCount; ++i) {
+ tVec = vertices[i];
+ dX = cLocalX - tVec.x;
+ dY = cLocalY - tVec.y;
+ tVec = normals[i];
+ var s = tVec.x * dX + tVec.y * dY;
+ if (s > radius) {
+ return;
+ }
+ if (s > separation) {
+ separation = s;
+ normalIndex = i;
+ }
+ }
+ var vertIndex1 = parseInt(normalIndex);
+ var vertIndex2 = parseInt(vertIndex1 + 1 < vertexCount ? vertIndex1 + 1 : 0);
+ var v1 = vertices[vertIndex1];
+ var v2 = vertices[vertIndex2];
+ if (separation < Number.MIN_VALUE) {
+ manifold.m_pointCount = 1;
+ manifold.m_type = b2Manifold.e_faceA;
+ manifold.m_localPlaneNormal.SetV(normals[normalIndex]);
+ manifold.m_localPoint.x = 0.5 * (v1.x + v2.x);
+ manifold.m_localPoint.y = 0.5 * (v1.y + v2.y);
+ manifold.m_points[0].m_localPoint.SetV(circle.m_p);
+ manifold.m_points[0].m_id.key = 0;
+ return;
+ }
+ var u1 = (cLocalX - v1.x) * (v2.x - v1.x) + (cLocalY - v1.y) * (v2.y - v1.y);
+ var u2 = (cLocalX - v2.x) * (v1.x - v2.x) + (cLocalY - v2.y) * (v1.y - v2.y);
+ if (u1 <= 0.0) {
+ if ((cLocalX - v1.x) * (cLocalX - v1.x) + (cLocalY - v1.y) * (cLocalY - v1.y) > radius * radius) return;
+ manifold.m_pointCount = 1;
+ manifold.m_type = b2Manifold.e_faceA;
+ manifold.m_localPlaneNormal.x = cLocalX - v1.x;
+ manifold.m_localPlaneNormal.y = cLocalY - v1.y;
+ manifold.m_localPlaneNormal.Normalize();
+ manifold.m_localPoint.SetV(v1);
+ manifold.m_points[0].m_localPoint.SetV(circle.m_p);
+ manifold.m_points[0].m_id.key = 0;
+ }
+ else if (u2 <= 0) {
+ if ((cLocalX - v2.x) * (cLocalX - v2.x) + (cLocalY - v2.y) * (cLocalY - v2.y) > radius * radius) return;
+ manifold.m_pointCount = 1;
+ manifold.m_type = b2Manifold.e_faceA;
+ manifold.m_localPlaneNormal.x = cLocalX - v2.x;
+ manifold.m_localPlaneNormal.y = cLocalY - v2.y;
+ manifold.m_localPlaneNormal.Normalize();
+ manifold.m_localPoint.SetV(v2);
+ manifold.m_points[0].m_localPoint.SetV(circle.m_p);
+ manifold.m_points[0].m_id.key = 0;
+ }
+ else {
+ var faceCenterX = 0.5 * (v1.x + v2.x);
+ var faceCenterY = 0.5 * (v1.y + v2.y);
+ separation = (cLocalX - faceCenterX) * normals[vertIndex1].x + (cLocalY - faceCenterY) * normals[vertIndex1].y;
+ if (separation > radius) return;
+ manifold.m_pointCount = 1;
+ manifold.m_type = b2Manifold.e_faceA;
+ manifold.m_localPlaneNormal.x = normals[vertIndex1].x;
+ manifold.m_localPlaneNormal.y = normals[vertIndex1].y;
+ manifold.m_localPlaneNormal.Normalize();
+ manifold.m_localPoint.Set(faceCenterX, faceCenterY);
+ manifold.m_points[0].m_localPoint.SetV(circle.m_p);
+ manifold.m_points[0].m_id.key = 0;
+ }
+ }
+ b2Collision.TestOverlap = function (a, b) {
+ var t1 = b.lowerBound;
+ var t2 = a.upperBound;
+ var d1X = t1.x - t2.x;
+ var d1Y = t1.y - t2.y;
+ t1 = a.lowerBound;
+ t2 = b.upperBound;
+ var d2X = t1.x - t2.x;
+ var d2Y = t1.y - t2.y;
+ if (d1X > 0.0 || d1Y > 0.0) return false;
+ if (d2X > 0.0 || d2Y > 0.0) return false;
+ return true;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.b2Collision.s_incidentEdge = b2Collision.MakeClipPointVector();
+ Box2D.Collision.b2Collision.s_clipPoints1 = b2Collision.MakeClipPointVector();
+ Box2D.Collision.b2Collision.s_clipPoints2 = b2Collision.MakeClipPointVector();
+ Box2D.Collision.b2Collision.s_edgeAO = new Vector_a2j_Number(1);
+ Box2D.Collision.b2Collision.s_edgeBO = new Vector_a2j_Number(1);
+ Box2D.Collision.b2Collision.s_localTangent = new b2Vec2();
+ Box2D.Collision.b2Collision.s_localNormal = new b2Vec2();
+ Box2D.Collision.b2Collision.s_planePoint = new b2Vec2();
+ Box2D.Collision.b2Collision.s_normal = new b2Vec2();
+ Box2D.Collision.b2Collision.s_tangent = new b2Vec2();
+ Box2D.Collision.b2Collision.s_tangent2 = new b2Vec2();
+ Box2D.Collision.b2Collision.s_v11 = new b2Vec2();
+ Box2D.Collision.b2Collision.s_v12 = new b2Vec2();
+ Box2D.Collision.b2Collision.b2CollidePolyTempVec = new b2Vec2();
+ Box2D.Collision.b2Collision.b2_nullFeature = 0x000000ff;
+ });
+ b2ContactID.b2ContactID = function () {
+ this.features = new Features();
+ };
+ b2ContactID.prototype.b2ContactID = function () {
+ this.features._m_id = this;
+ }
+ b2ContactID.prototype.Set = function (id) {
+ this.key = id._key;
+ }
+ b2ContactID.prototype.Copy = function () {
+ var id = new b2ContactID();
+ id.key = this.key;
+ return id;
+ }
+ Object.defineProperty(b2ContactID.prototype, 'key', {
+ enumerable: false,
+ configurable: true,
+ get: function () {
+ return this._key;
+ }
+ });
+ Object.defineProperty(b2ContactID.prototype, 'key', {
+ enumerable: false,
+ configurable: true,
+ set: function (value) {
+ if (value === undefined) value = 0;
+ this._key = value;
+ this.features._referenceEdge = this._key & 0x000000ff;
+ this.features._incidentEdge = ((this._key & 0x0000ff00) >> 8) & 0x000000ff;
+ this.features._incidentVertex = ((this._key & 0x00ff0000) >> 16) & 0x000000ff;
+ this.features._flip = ((this._key & 0xff000000) >> 24) & 0x000000ff;
+ }
+ });
+ b2ContactPoint.b2ContactPoint = function () {
+ this.position = new b2Vec2();
+ this.velocity = new b2Vec2();
+ this.normal = new b2Vec2();
+ this.id = new b2ContactID();
+ };
+ b2Distance.b2Distance = function () {};
+ b2Distance.Distance = function (output, cache, input) {
+ ++b2Distance.b2_gjkCalls;
+ var proxyA = input.proxyA;
+ var proxyB = input.proxyB;
+ var transformA = input.transformA;
+ var transformB = input.transformB;
+ var simplex = b2Distance.s_simplex;
+ simplex.ReadCache(cache, proxyA, transformA, proxyB, transformB);
+ var vertices = simplex.m_vertices;
+ var k_maxIters = 20;
+ var saveA = b2Distance.s_saveA;
+ var saveB = b2Distance.s_saveB;
+ var saveCount = 0;
+ var closestPoint = simplex.GetClosestPoint();
+ var distanceSqr1 = closestPoint.LengthSquared();
+ var distanceSqr2 = distanceSqr1;
+ var i = 0;
+ var p;
+ var iter = 0;
+ while (iter < k_maxIters) {
+ saveCount = simplex.m_count;
+ for (i = 0;
+ i < saveCount; i++) {
+ saveA[i] = vertices[i].indexA;
+ saveB[i] = vertices[i].indexB;
+ }
+ switch (simplex.m_count) {
+ case 1:
+ break;
+ case 2:
+ simplex.Solve2();
+ break;
+ case 3:
+ simplex.Solve3();
+ break;
+ default:
+ b2Settings.b2Assert(false);
+ }
+ if (simplex.m_count == 3) {
+ break;
+ }
+ p = simplex.GetClosestPoint();
+ distanceSqr2 = p.LengthSquared();
+ if (distanceSqr2 > distanceSqr1) {}
+ distanceSqr1 = distanceSqr2;
+ var d = simplex.GetSearchDirection();
+ if (d.LengthSquared() < Number.MIN_VALUE * Number.MIN_VALUE) {
+ break;
+ }
+ var vertex = vertices[simplex.m_count];
+ vertex.indexA = proxyA.GetSupport(b2Math.MulTMV(transformA.R, d.GetNegative()));
+ vertex.wA = b2Math.MulX(transformA, proxyA.GetVertex(vertex.indexA));
+ vertex.indexB = proxyB.GetSupport(b2Math.MulTMV(transformB.R, d));
+ vertex.wB = b2Math.MulX(transformB, proxyB.GetVertex(vertex.indexB));
+ vertex.w = b2Math.SubtractVV(vertex.wB, vertex.wA);
+ ++iter;
+ ++b2Distance.b2_gjkIters;
+ var duplicate = false;
+ for (i = 0;
+ i < saveCount; i++) {
+ if (vertex.indexA == saveA[i] && vertex.indexB == saveB[i]) {
+ duplicate = true;
+ break;
+ }
+ }
+ if (duplicate) {
+ break;
+ }++simplex.m_count;
+ }
+ b2Distance.b2_gjkMaxIters = b2Math.Max(b2Distance.b2_gjkMaxIters, iter);
+ simplex.GetWitnessPoints(output.pointA, output.pointB);
+ output.distance = b2Math.SubtractVV(output.pointA, output.pointB).Length();
+ output.iterations = iter;
+ simplex.WriteCache(cache);
+ if (input.useRadii) {
+ var rA = proxyA.m_radius;
+ var rB = proxyB.m_radius;
+ if (output.distance > rA + rB && output.distance > Number.MIN_VALUE) {
+ output.distance -= rA + rB;
+ var normal = b2Math.SubtractVV(output.pointB, output.pointA);
+ normal.Normalize();
+ output.pointA.x += rA * normal.x;
+ output.pointA.y += rA * normal.y;
+ output.pointB.x -= rB * normal.x;
+ output.pointB.y -= rB * normal.y;
+ }
+ else {
+ p = new b2Vec2();
+ p.x = .5 * (output.pointA.x + output.pointB.x);
+ p.y = .5 * (output.pointA.y + output.pointB.y);
+ output.pointA.x = output.pointB.x = p.x;
+ output.pointA.y = output.pointB.y = p.y;
+ output.distance = 0.0;
+ }
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.b2Distance.s_simplex = new b2Simplex();
+ Box2D.Collision.b2Distance.s_saveA = new Vector_a2j_Number(3);
+ Box2D.Collision.b2Distance.s_saveB = new Vector_a2j_Number(3);
+ });
+ b2DistanceInput.b2DistanceInput = function () {};
+ b2DistanceOutput.b2DistanceOutput = function () {
+ this.pointA = new b2Vec2();
+ this.pointB = new b2Vec2();
+ };
+ b2DistanceProxy.b2DistanceProxy = function () {};
+ b2DistanceProxy.prototype.Set = function (shape) {
+ switch (shape.GetType()) {
+ case b2Shape.e_circleShape:
+ {
+ var circle = (shape instanceof b2CircleShape ? shape : null);
+ this.m_vertices = new Vector(1, true);
+ this.m_vertices[0] = circle.m_p;
+ this.m_count = 1;
+ this.m_radius = circle.m_radius;
+ }
+ break;
+ case b2Shape.e_polygonShape:
+ {
+ var polygon = (shape instanceof b2PolygonShape ? shape : null);
+ this.m_vertices = polygon.m_vertices;
+ this.m_count = polygon.m_vertexCount;
+ this.m_radius = polygon.m_radius;
+ }
+ break;
+ default:
+ b2Settings.b2Assert(false);
+ }
+ }
+ b2DistanceProxy.prototype.GetSupport = function (d) {
+ var bestIndex = 0;
+ var bestValue = this.m_vertices[0].x * d.x + this.m_vertices[0].y * d.y;
+ for (var i = 1; i < this.m_count; ++i) {
+ var value = this.m_vertices[i].x * d.x + this.m_vertices[i].y * d.y;
+ if (value > bestValue) {
+ bestIndex = i;
+ bestValue = value;
+ }
+ }
+ return bestIndex;
+ }
+ b2DistanceProxy.prototype.GetSupportVertex = function (d) {
+ var bestIndex = 0;
+ var bestValue = this.m_vertices[0].x * d.x + this.m_vertices[0].y * d.y;
+ for (var i = 1; i < this.m_count; ++i) {
+ var value = this.m_vertices[i].x * d.x + this.m_vertices[i].y * d.y;
+ if (value > bestValue) {
+ bestIndex = i;
+ bestValue = value;
+ }
+ }
+ return this.m_vertices[bestIndex];
+ }
+ b2DistanceProxy.prototype.GetVertexCount = function () {
+ return this.m_count;
+ }
+ b2DistanceProxy.prototype.GetVertex = function (index) {
+ if (index === undefined) index = 0;
+ b2Settings.b2Assert(0 <= index && index < this.m_count);
+ return this.m_vertices[index];
+ }
+ b2DynamicTree.b2DynamicTree = function () {};
+ b2DynamicTree.prototype.b2DynamicTree = function () {
+ this.m_root = null;
+ this.m_freeList = null;
+ this.m_path = 0;
+ this.m_insertionCount = 0;
+ }
+ b2DynamicTree.prototype.CreateProxy = function (aabb, userData) {
+ var node = this.AllocateNode();
+ var extendX = b2Settings.b2_aabbExtension;
+ var extendY = b2Settings.b2_aabbExtension;
+ node.aabb.lowerBound.x = aabb.lowerBound.x - extendX;
+ node.aabb.lowerBound.y = aabb.lowerBound.y - extendY;
+ node.aabb.upperBound.x = aabb.upperBound.x + extendX;
+ node.aabb.upperBound.y = aabb.upperBound.y + extendY;
+ node.userData = userData;
+ this.InsertLeaf(node);
+ return node;
+ }
+ b2DynamicTree.prototype.DestroyProxy = function (proxy) {
+ this.RemoveLeaf(proxy);
+ this.FreeNode(proxy);
+ }
+ b2DynamicTree.prototype.MoveProxy = function (proxy, aabb, displacement) {
+ b2Settings.b2Assert(proxy.IsLeaf());
+ if (proxy.aabb.Contains(aabb)) {
+ return false;
+ }
+ this.RemoveLeaf(proxy);
+ var extendX = b2Settings.b2_aabbExtension + b2Settings.b2_aabbMultiplier * (displacement.x > 0 ? displacement.x : (-displacement.x));
+ var extendY = b2Settings.b2_aabbExtension + b2Settings.b2_aabbMultiplier * (displacement.y > 0 ? displacement.y : (-displacement.y));
+ proxy.aabb.lowerBound.x = aabb.lowerBound.x - extendX;
+ proxy.aabb.lowerBound.y = aabb.lowerBound.y - extendY;
+ proxy.aabb.upperBound.x = aabb.upperBound.x + extendX;
+ proxy.aabb.upperBound.y = aabb.upperBound.y + extendY;
+ this.InsertLeaf(proxy);
+ return true;
+ }
+ b2DynamicTree.prototype.Rebalance = function (iterations) {
+ if (iterations === undefined) iterations = 0;
+ if (this.m_root == null) return;
+ for (var i = 0; i < iterations; i++) {
+ var node = this.m_root;
+ var bit = 0;
+ while (node.IsLeaf() == false) {
+ node = (this.m_path >> bit) & 1 ? node.child2 : node.child1;
+ bit = (bit + 1) & 31;
+ }++this.m_path;
+ this.RemoveLeaf(node);
+ this.InsertLeaf(node);
+ }
+ }
+ b2DynamicTree.prototype.GetFatAABB = function (proxy) {
+ return proxy.aabb;
+ }
+ b2DynamicTree.prototype.GetUserData = function (proxy) {
+ return proxy.userData;
+ }
+ b2DynamicTree.prototype.Query = function (callback, aabb) {
+ if (this.m_root == null) return;
+ var stack = new Vector();
+ var count = 0;
+ stack[count++] = this.m_root;
+ while (count > 0) {
+ var node = stack[--count];
+ if (node.aabb.TestOverlap(aabb)) {
+ if (node.IsLeaf()) {
+ var proceed = callback(node);
+ if (!proceed) return;
+ }
+ else {
+ stack[count++] = node.child1;
+ stack[count++] = node.child2;
+ }
+ }
+ }
+ }
+ b2DynamicTree.prototype.RayCast = function (callback, input) {
+ if (this.m_root == null) return;
+ var p1 = input.p1;
+ var p2 = input.p2;
+ var r = b2Math.SubtractVV(p1, p2);
+ r.Normalize();
+ var v = b2Math.CrossFV(1.0, r);
+ var abs_v = b2Math.AbsV(v);
+ var maxFraction = input.maxFraction;
+ var segmentAABB = new b2AABB();
+ var tX = 0;
+ var tY = 0; {
+ tX = p1.x + maxFraction * (p2.x - p1.x);
+ tY = p1.y + maxFraction * (p2.y - p1.y);
+ segmentAABB.lowerBound.x = Math.min(p1.x, tX);
+ segmentAABB.lowerBound.y = Math.min(p1.y, tY);
+ segmentAABB.upperBound.x = Math.max(p1.x, tX);
+ segmentAABB.upperBound.y = Math.max(p1.y, tY);
+ }
+ var stack = new Vector();
+ var count = 0;
+ stack[count++] = this.m_root;
+ while (count > 0) {
+ var node = stack[--count];
+ if (node.aabb.TestOverlap(segmentAABB) == false) {
+ continue;
+ }
+ var c = node.aabb.GetCenter();
+ var h = node.aabb.GetExtents();
+ var separation = Math.abs(v.x * (p1.x - c.x) + v.y * (p1.y - c.y)) - abs_v.x * h.x - abs_v.y * h.y;
+ if (separation > 0.0) continue;
+ if (node.IsLeaf()) {
+ var subInput = new b2RayCastInput();
+ subInput.p1 = input.p1;
+ subInput.p2 = input.p2;
+ subInput.maxFraction = input.maxFraction;
+ maxFraction = callback(subInput, node);
+ if (maxFraction == 0.0) return;
+ if (maxFraction > 0.0) {
+ tX = p1.x + maxFraction * (p2.x - p1.x);
+ tY = p1.y + maxFraction * (p2.y - p1.y);
+ segmentAABB.lowerBound.x = Math.min(p1.x, tX);
+ segmentAABB.lowerBound.y = Math.min(p1.y, tY);
+ segmentAABB.upperBound.x = Math.max(p1.x, tX);
+ segmentAABB.upperBound.y = Math.max(p1.y, tY);
+ }
+ }
+ else {
+ stack[count++] = node.child1;
+ stack[count++] = node.child2;
+ }
+ }
+ }
+ b2DynamicTree.prototype.AllocateNode = function () {
+ if (this.m_freeList) {
+ var node = this.m_freeList;
+ this.m_freeList = node.parent;
+ node.parent = null;
+ node.child1 = null;
+ node.child2 = null;
+ return node;
+ }
+ return new b2DynamicTreeNode();
+ }
+ b2DynamicTree.prototype.FreeNode = function (node) {
+ node.parent = this.m_freeList;
+ this.m_freeList = node;
+ }
+ b2DynamicTree.prototype.InsertLeaf = function (leaf) {
+ ++this.m_insertionCount;
+ if (this.m_root == null) {
+ this.m_root = leaf;
+ this.m_root.parent = null;
+ return;
+ }
+ var center = leaf.aabb.GetCenter();
+ var sibling = this.m_root;
+ if (sibling.IsLeaf() == false) {
+ do {
+ var child1 = sibling.child1;
+ var child2 = sibling.child2;
+ var norm1 = Math.abs((child1.aabb.lowerBound.x + child1.aabb.upperBound.x) / 2 - center.x) + Math.abs((child1.aabb.lowerBound.y + child1.aabb.upperBound.y) / 2 - center.y);
+ var norm2 = Math.abs((child2.aabb.lowerBound.x + child2.aabb.upperBound.x) / 2 - center.x) + Math.abs((child2.aabb.lowerBound.y + child2.aabb.upperBound.y) / 2 - center.y);
+ if (norm1 < norm2) {
+ sibling = child1;
+ }
+ else {
+ sibling = child2;
+ }
+ }
+ while (sibling.IsLeaf() == false)
+ }
+ var node1 = sibling.parent;
+ var node2 = this.AllocateNode();
+ node2.parent = node1;
+ node2.userData = null;
+ node2.aabb.Combine(leaf.aabb, sibling.aabb);
+ if (node1) {
+ if (sibling.parent.child1 == sibling) {
+ node1.child1 = node2;
+ }
+ else {
+ node1.child2 = node2;
+ }
+ node2.child1 = sibling;
+ node2.child2 = leaf;
+ sibling.parent = node2;
+ leaf.parent = node2;
+ do {
+ if (node1.aabb.Contains(node2.aabb)) break;
+ node1.aabb.Combine(node1.child1.aabb, node1.child2.aabb);
+ node2 = node1;
+ node1 = node1.parent;
+ }
+ while (node1)
+ }
+ else {
+ node2.child1 = sibling;
+ node2.child2 = leaf;
+ sibling.parent = node2;
+ leaf.parent = node2;
+ this.m_root = node2;
+ }
+ }
+ b2DynamicTree.prototype.RemoveLeaf = function (leaf) {
+ if (leaf == this.m_root) {
+ this.m_root = null;
+ return;
+ }
+ var node2 = leaf.parent;
+ var node1 = node2.parent;
+ var sibling;
+ if (node2.child1 == leaf) {
+ sibling = node2.child2;
+ }
+ else {
+ sibling = node2.child1;
+ }
+ if (node1) {
+ if (node1.child1 == node2) {
+ node1.child1 = sibling;
+ }
+ else {
+ node1.child2 = sibling;
+ }
+ sibling.parent = node1;
+ this.FreeNode(node2);
+ while (node1) {
+ var oldAABB = node1.aabb;
+ node1.aabb = b2AABB.Combine(node1.child1.aabb, node1.child2.aabb);
+ if (oldAABB.Contains(node1.aabb)) break;
+ node1 = node1.parent;
+ }
+ }
+ else {
+ this.m_root = sibling;
+ sibling.parent = null;
+ this.FreeNode(node2);
+ }
+ }
+ b2DynamicTreeBroadPhase.b2DynamicTreeBroadPhase = function () {
+ this.m_tree = new b2DynamicTree();
+ this.m_moveBuffer = new Vector();
+ this.m_pairBuffer = new Vector();
+ this.m_pairCount = 0;
+ };
+ b2DynamicTreeBroadPhase.prototype.CreateProxy = function (aabb, userData) {
+ var proxy = this.m_tree.CreateProxy(aabb, userData);
+ ++this.m_proxyCount;
+ this.BufferMove(proxy);
+ return proxy;
+ }
+ b2DynamicTreeBroadPhase.prototype.DestroyProxy = function (proxy) {
+ this.UnBufferMove(proxy);
+ --this.m_proxyCount;
+ this.m_tree.DestroyProxy(proxy);
+ }
+ b2DynamicTreeBroadPhase.prototype.MoveProxy = function (proxy, aabb, displacement) {
+ var buffer = this.m_tree.MoveProxy(proxy, aabb, displacement);
+ if (buffer) {
+ this.BufferMove(proxy);
+ }
+ }
+ b2DynamicTreeBroadPhase.prototype.TestOverlap = function (proxyA, proxyB) {
+ var aabbA = this.m_tree.GetFatAABB(proxyA);
+ var aabbB = this.m_tree.GetFatAABB(proxyB);
+ return aabbA.TestOverlap(aabbB);
+ }
+ b2DynamicTreeBroadPhase.prototype.GetUserData = function (proxy) {
+ return this.m_tree.GetUserData(proxy);
+ }
+ b2DynamicTreeBroadPhase.prototype.GetFatAABB = function (proxy) {
+ return this.m_tree.GetFatAABB(proxy);
+ }
+ b2DynamicTreeBroadPhase.prototype.GetProxyCount = function () {
+ return this.m_proxyCount;
+ }
+ b2DynamicTreeBroadPhase.prototype.UpdatePairs = function (callback) {
+ var __this = this;
+ __this.m_pairCount = 0;
+ var i = 0,
+ queryProxy;
+ for (i = 0;
+ i < __this.m_moveBuffer.length; ++i) {
+ queryProxy = __this.m_moveBuffer[i];
+
+ function QueryCallback(proxy) {
+ if (proxy == queryProxy) return true;
+ if (__this.m_pairCount == __this.m_pairBuffer.length) {
+ __this.m_pairBuffer[__this.m_pairCount] = new b2DynamicTreePair();
+ }
+ var pair = __this.m_pairBuffer[__this.m_pairCount];
+ pair.proxyA = proxy < queryProxy ? proxy : queryProxy;
+ pair.proxyB = proxy >= queryProxy ? proxy : queryProxy;++__this.m_pairCount;
+ return true;
+ };
+ var fatAABB = __this.m_tree.GetFatAABB(queryProxy);
+ __this.m_tree.Query(QueryCallback, fatAABB);
+ }
+ __this.m_moveBuffer.length = 0;
+ for (var i = 0; i < __this.m_pairCount;) {
+ var primaryPair = __this.m_pairBuffer[i];
+ var userDataA = __this.m_tree.GetUserData(primaryPair.proxyA);
+ var userDataB = __this.m_tree.GetUserData(primaryPair.proxyB);
+ callback(userDataA, userDataB);
+ ++i;
+ while (i < __this.m_pairCount) {
+ var pair = __this.m_pairBuffer[i];
+ if (pair.proxyA != primaryPair.proxyA || pair.proxyB != primaryPair.proxyB) {
+ break;
+ }++i;
+ }
+ }
+ }
+ b2DynamicTreeBroadPhase.prototype.Query = function (callback, aabb) {
+ this.m_tree.Query(callback, aabb);
+ }
+ b2DynamicTreeBroadPhase.prototype.RayCast = function (callback, input) {
+ this.m_tree.RayCast(callback, input);
+ }
+ b2DynamicTreeBroadPhase.prototype.Validate = function () {}
+ b2DynamicTreeBroadPhase.prototype.Rebalance = function (iterations) {
+ if (iterations === undefined) iterations = 0;
+ this.m_tree.Rebalance(iterations);
+ }
+ b2DynamicTreeBroadPhase.prototype.BufferMove = function (proxy) {
+ this.m_moveBuffer[this.m_moveBuffer.length] = proxy;
+ }
+ b2DynamicTreeBroadPhase.prototype.UnBufferMove = function (proxy) {
+ var i = parseInt(this.m_moveBuffer.indexOf(proxy));
+ this.m_moveBuffer.splice(i, 1);
+ }
+ b2DynamicTreeBroadPhase.prototype.ComparePairs = function (pair1, pair2) {
+ return 0;
+ }
+ b2DynamicTreeBroadPhase.__implements = {};
+ b2DynamicTreeBroadPhase.__implements[IBroadPhase] = true;
+ b2DynamicTreeNode.b2DynamicTreeNode = function () {
+ this.aabb = new b2AABB();
+ };
+ b2DynamicTreeNode.prototype.IsLeaf = function () {
+ return this.child1 == null;
+ }
+ b2DynamicTreePair.b2DynamicTreePair = function () {};
+ b2Manifold.b2Manifold = function () {
+ this.m_pointCount = 0;
+ };
+ b2Manifold.prototype.b2Manifold = function () {
+ this.m_points = new Vector(b2Settings.b2_maxManifoldPoints);
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; i++) {
+ this.m_points[i] = new b2ManifoldPoint();
+ }
+ this.m_localPlaneNormal = new b2Vec2();
+ this.m_localPoint = new b2Vec2();
+ }
+ b2Manifold.prototype.Reset = function () {
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; i++) {
+ ((this.m_points[i] instanceof b2ManifoldPoint ? this.m_points[i] : null)).Reset();
+ }
+ this.m_localPlaneNormal.SetZero();
+ this.m_localPoint.SetZero();
+ this.m_type = 0;
+ this.m_pointCount = 0;
+ }
+ b2Manifold.prototype.Set = function (m) {
+ this.m_pointCount = m.m_pointCount;
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; i++) {
+ ((this.m_points[i] instanceof b2ManifoldPoint ? this.m_points[i] : null)).Set(m.m_points[i]);
+ }
+ this.m_localPlaneNormal.SetV(m.m_localPlaneNormal);
+ this.m_localPoint.SetV(m.m_localPoint);
+ this.m_type = m.m_type;
+ }
+ b2Manifold.prototype.Copy = function () {
+ var copy = new b2Manifold();
+ copy.Set(this);
+ return copy;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.b2Manifold.e_circles = 0x0001;
+ Box2D.Collision.b2Manifold.e_faceA = 0x0002;
+ Box2D.Collision.b2Manifold.e_faceB = 0x0004;
+ });
+ b2ManifoldPoint.b2ManifoldPoint = function () {
+ this.m_localPoint = new b2Vec2();
+ this.m_id = new b2ContactID();
+ };
+ b2ManifoldPoint.prototype.b2ManifoldPoint = function () {
+ this.Reset();
+ }
+ b2ManifoldPoint.prototype.Reset = function () {
+ this.m_localPoint.SetZero();
+ this.m_normalImpulse = 0.0;
+ this.m_tangentImpulse = 0.0;
+ this.m_id.key = 0;
+ }
+ b2ManifoldPoint.prototype.Set = function (m) {
+ this.m_localPoint.SetV(m.m_localPoint);
+ this.m_normalImpulse = m.m_normalImpulse;
+ this.m_tangentImpulse = m.m_tangentImpulse;
+ this.m_id.Set(m.m_id);
+ }
+ b2Point.b2Point = function () {
+ this.p = new b2Vec2();
+ };
+ b2Point.prototype.Support = function (xf, vX, vY) {
+ if (vX === undefined) vX = 0;
+ if (vY === undefined) vY = 0;
+ return this.p;
+ }
+ b2Point.prototype.GetFirstVertex = function (xf) {
+ return this.p;
+ }
+ b2RayCastInput.b2RayCastInput = function () {
+ this.p1 = new b2Vec2();
+ this.p2 = new b2Vec2();
+ };
+ b2RayCastInput.prototype.b2RayCastInput = function (p1, p2, maxFraction) {
+ if (p1 === undefined) p1 = null;
+ if (p2 === undefined) p2 = null;
+ if (maxFraction === undefined) maxFraction = 1;
+ if (p1) this.p1.SetV(p1);
+ if (p2) this.p2.SetV(p2);
+ this.maxFraction = maxFraction;
+ }
+ b2RayCastOutput.b2RayCastOutput = function () {
+ this.normal = new b2Vec2();
+ };
+ b2Segment.b2Segment = function () {
+ this.p1 = new b2Vec2();
+ this.p2 = new b2Vec2();
+ };
+ b2Segment.prototype.TestSegment = function (lambda, normal, segment, maxLambda) {
+ if (maxLambda === undefined) maxLambda = 0;
+ var s = segment.p1;
+ var rX = segment.p2.x - s.x;
+ var rY = segment.p2.y - s.y;
+ var dX = this.p2.x - this.p1.x;
+ var dY = this.p2.y - this.p1.y;
+ var nX = dY;
+ var nY = (-dX);
+ var k_slop = 100.0 * Number.MIN_VALUE;
+ var denom = (-(rX * nX + rY * nY));
+ if (denom > k_slop) {
+ var bX = s.x - this.p1.x;
+ var bY = s.y - this.p1.y;
+ var a = (bX * nX + bY * nY);
+ if (0.0 <= a && a <= maxLambda * denom) {
+ var mu2 = (-rX * bY) + rY * bX;
+ if ((-k_slop * denom) <= mu2 && mu2 <= denom * (1.0 + k_slop)) {
+ a /= denom;
+ var nLen = Math.sqrt(nX * nX + nY * nY);
+ nX /= nLen;
+ nY /= nLen;
+ lambda[0] = a;
+ normal.Set(nX, nY);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ b2Segment.prototype.Extend = function (aabb) {
+ this.ExtendForward(aabb);
+ this.ExtendBackward(aabb);
+ }
+
+
+
+
+ b2Segment.prototype.ExtendForward = function (aabb) {
+ var dX = this.p2.x - this.p1.x;
+ var dY = this.p2.y - this.p1.y;
+ var lambda = Math.min(dX > 0 ? (aabb.upperBound.x - this.p1.x) / dX : dX < 0 ? (aabb.lowerBound.x - this.p1.x) / dX : Number.POSITIVE_INFINITY,
+ dY > 0 ? (aabb.upperBound.y - this.p1.y) / dY : dY < 0 ? (aabb.lowerBound.y - this.p1.y) / dY : Number.POSITIVE_INFINITY);
+ this.p2.x = this.p1.x + dX * lambda;
+ this.p2.y = this.p1.y + dY * lambda;
+ }
+ b2Segment.prototype.ExtendBackward = function (aabb) {
+ var dX = (-this.p2.x) + this.p1.x;
+ var dY = (-this.p2.y) + this.p1.y;
+ var lambda = Math.min(dX > 0 ? (aabb.upperBound.x - this.p2.x) / dX : dX < 0 ? (aabb.lowerBound.x - this.p2.x) / dX : Number.POSITIVE_INFINITY,
+ dY > 0 ? (aabb.upperBound.y - this.p2.y) / dY : dY < 0 ? (aabb.lowerBound.y - this.p2.y) / dY : Number.POSITIVE_INFINITY);
+ this.p1.x = this.p2.x + dX * lambda;
+ this.p1.y = this.p2.y + dY * lambda;
+ }
+ b2SeparationFunction.b2SeparationFunction = function () {
+ this.m_localPoint = new b2Vec2();
+ this.m_axis = new b2Vec2();
+ };
+ b2SeparationFunction.prototype.Initialize = function (cache, proxyA, transformA, proxyB, transformB) {
+ this.m_proxyA = proxyA;
+ this.m_proxyB = proxyB;
+ var count = parseInt(cache.count);
+ b2Settings.b2Assert(0 < count && count < 3);
+ var localPointA;
+ var localPointA1;
+ var localPointA2;
+ var localPointB;
+ var localPointB1;
+ var localPointB2;
+ var pointAX = 0;
+ var pointAY = 0;
+ var pointBX = 0;
+ var pointBY = 0;
+ var normalX = 0;
+ var normalY = 0;
+ var tMat;
+ var tVec;
+ var s = 0;
+ var sgn = 0;
+ if (count == 1) {
+ this.m_type = b2SeparationFunction.e_points;
+ localPointA = this.m_proxyA.GetVertex(cache.indexA[0]);
+ localPointB = this.m_proxyB.GetVertex(cache.indexB[0]);
+ tVec = localPointA;
+ tMat = transformA.R;
+ pointAX = transformA.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointAY = transformA.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tVec = localPointB;
+ tMat = transformB.R;
+ pointBX = transformB.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointBY = transformB.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ this.m_axis.x = pointBX - pointAX;
+ this.m_axis.y = pointBY - pointAY;
+ this.m_axis.Normalize();
+ }
+ else if (cache.indexB[0] == cache.indexB[1]) {
+ this.m_type = b2SeparationFunction.e_faceA;
+ localPointA1 = this.m_proxyA.GetVertex(cache.indexA[0]);
+ localPointA2 = this.m_proxyA.GetVertex(cache.indexA[1]);
+ localPointB = this.m_proxyB.GetVertex(cache.indexB[0]);
+ this.m_localPoint.x = 0.5 * (localPointA1.x + localPointA2.x);
+ this.m_localPoint.y = 0.5 * (localPointA1.y + localPointA2.y);
+ this.m_axis = b2Math.CrossVF(b2Math.SubtractVV(localPointA2, localPointA1), 1.0);
+ this.m_axis.Normalize();
+ tVec = this.m_axis;
+ tMat = transformA.R;
+ normalX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ normalY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tVec = this.m_localPoint;
+ tMat = transformA.R;
+ pointAX = transformA.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointAY = transformA.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tVec = localPointB;
+ tMat = transformB.R;
+ pointBX = transformB.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointBY = transformB.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ s = (pointBX - pointAX) * normalX + (pointBY - pointAY) * normalY;
+ if (s < 0.0) {
+ this.m_axis.NegativeSelf();
+ }
+ }
+ else if (cache.indexA[0] == cache.indexA[0]) {
+ this.m_type = b2SeparationFunction.e_faceB;
+ localPointB1 = this.m_proxyB.GetVertex(cache.indexB[0]);
+ localPointB2 = this.m_proxyB.GetVertex(cache.indexB[1]);
+ localPointA = this.m_proxyA.GetVertex(cache.indexA[0]);
+ this.m_localPoint.x = 0.5 * (localPointB1.x + localPointB2.x);
+ this.m_localPoint.y = 0.5 * (localPointB1.y + localPointB2.y);
+ this.m_axis = b2Math.CrossVF(b2Math.SubtractVV(localPointB2, localPointB1), 1.0);
+ this.m_axis.Normalize();
+ tVec = this.m_axis;
+ tMat = transformB.R;
+ normalX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ normalY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tVec = this.m_localPoint;
+ tMat = transformB.R;
+ pointBX = transformB.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointBY = transformB.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tVec = localPointA;
+ tMat = transformA.R;
+ pointAX = transformA.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointAY = transformA.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ s = (pointAX - pointBX) * normalX + (pointAY - pointBY) * normalY;
+ if (s < 0.0) {
+ this.m_axis.NegativeSelf();
+ }
+ }
+ else {
+ localPointA1 = this.m_proxyA.GetVertex(cache.indexA[0]);
+ localPointA2 = this.m_proxyA.GetVertex(cache.indexA[1]);
+ localPointB1 = this.m_proxyB.GetVertex(cache.indexB[0]);
+ localPointB2 = this.m_proxyB.GetVertex(cache.indexB[1]);
+ var pA = b2Math.MulX(transformA, localPointA);
+ var dA = b2Math.MulMV(transformA.R, b2Math.SubtractVV(localPointA2, localPointA1));
+ var pB = b2Math.MulX(transformB, localPointB);
+ var dB = b2Math.MulMV(transformB.R, b2Math.SubtractVV(localPointB2, localPointB1));
+ var a = dA.x * dA.x + dA.y * dA.y;
+ var e = dB.x * dB.x + dB.y * dB.y;
+ var r = b2Math.SubtractVV(dB, dA);
+ var c = dA.x * r.x + dA.y * r.y;
+ var f = dB.x * r.x + dB.y * r.y;
+ var b = dA.x * dB.x + dA.y * dB.y;
+ var denom = a * e - b * b;
+ s = 0.0;
+ if (denom != 0.0) {
+ s = b2Math.Clamp((b * f - c * e) / denom, 0.0, 1.0);
+ }
+ var t = (b * s + f) / e;
+ if (t < 0.0) {
+ t = 0.0;
+ s = b2Math.Clamp((b - c) / a, 0.0, 1.0);
+ }
+ localPointA = new b2Vec2();
+ localPointA.x = localPointA1.x + s * (localPointA2.x - localPointA1.x);
+ localPointA.y = localPointA1.y + s * (localPointA2.y - localPointA1.y);
+ localPointB = new b2Vec2();
+ localPointB.x = localPointB1.x + s * (localPointB2.x - localPointB1.x);
+ localPointB.y = localPointB1.y + s * (localPointB2.y - localPointB1.y);
+ if (s == 0.0 || s == 1.0) {
+ this.m_type = b2SeparationFunction.e_faceB;
+ this.m_axis = b2Math.CrossVF(b2Math.SubtractVV(localPointB2, localPointB1), 1.0);
+ this.m_axis.Normalize();
+ this.m_localPoint = localPointB;
+ tVec = this.m_axis;
+ tMat = transformB.R;
+ normalX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ normalY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tVec = this.m_localPoint;
+ tMat = transformB.R;
+ pointBX = transformB.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointBY = transformB.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tVec = localPointA;
+ tMat = transformA.R;
+ pointAX = transformA.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointAY = transformA.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ sgn = (pointAX - pointBX) * normalX + (pointAY - pointBY) * normalY;
+ if (s < 0.0) {
+ this.m_axis.NegativeSelf();
+ }
+ }
+ else {
+ this.m_type = b2SeparationFunction.e_faceA;
+ this.m_axis = b2Math.CrossVF(b2Math.SubtractVV(localPointA2, localPointA1), 1.0);
+ this.m_localPoint = localPointA;
+ tVec = this.m_axis;
+ tMat = transformA.R;
+ normalX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ normalY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tVec = this.m_localPoint;
+ tMat = transformA.R;
+ pointAX = transformA.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointAY = transformA.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tVec = localPointB;
+ tMat = transformB.R;
+ pointBX = transformB.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ pointBY = transformB.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ sgn = (pointBX - pointAX) * normalX + (pointBY - pointAY) * normalY;
+ if (s < 0.0) {
+ this.m_axis.NegativeSelf();
+ }
+ }
+ }
+ }
+ b2SeparationFunction.prototype.Evaluate = function (transformA, transformB) {
+ var axisA;
+ var axisB;
+ var localPointA;
+ var localPointB;
+ var pointA;
+ var pointB;
+ var seperation = 0;
+ var normal;
+ switch (this.m_type) {
+ case b2SeparationFunction.e_points:
+ {
+ axisA = b2Math.MulTMV(transformA.R, this.m_axis);
+ axisB = b2Math.MulTMV(transformB.R, this.m_axis.GetNegative());
+ localPointA = this.m_proxyA.GetSupportVertex(axisA);
+ localPointB = this.m_proxyB.GetSupportVertex(axisB);
+ pointA = b2Math.MulX(transformA, localPointA);
+ pointB = b2Math.MulX(transformB, localPointB);
+ seperation = (pointB.x - pointA.x) * this.m_axis.x + (pointB.y - pointA.y) * this.m_axis.y;
+ return seperation;
+ }
+ case b2SeparationFunction.e_faceA:
+ {
+ normal = b2Math.MulMV(transformA.R, this.m_axis);
+ pointA = b2Math.MulX(transformA, this.m_localPoint);
+ axisB = b2Math.MulTMV(transformB.R, normal.GetNegative());
+ localPointB = this.m_proxyB.GetSupportVertex(axisB);
+ pointB = b2Math.MulX(transformB, localPointB);
+ seperation = (pointB.x - pointA.x) * normal.x + (pointB.y - pointA.y) * normal.y;
+ return seperation;
+ }
+ case b2SeparationFunction.e_faceB:
+ {
+ normal = b2Math.MulMV(transformB.R, this.m_axis);
+ pointB = b2Math.MulX(transformB, this.m_localPoint);
+ axisA = b2Math.MulTMV(transformA.R, normal.GetNegative());
+ localPointA = this.m_proxyA.GetSupportVertex(axisA);
+ pointA = b2Math.MulX(transformA, localPointA);
+ seperation = (pointA.x - pointB.x) * normal.x + (pointA.y - pointB.y) * normal.y;
+ return seperation;
+ }
+ default:
+ b2Settings.b2Assert(false);
+ return 0.0;
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.b2SeparationFunction.e_points = 0x01;
+ Box2D.Collision.b2SeparationFunction.e_faceA = 0x02;
+ Box2D.Collision.b2SeparationFunction.e_faceB = 0x04;
+ });
+ b2Simplex.b2Simplex = function () {
+ this.m_v1 = new b2SimplexVertex();
+ this.m_v2 = new b2SimplexVertex();
+ this.m_v3 = new b2SimplexVertex();
+ this.m_vertices = new Vector(3);
+ };
+ b2Simplex.prototype.b2Simplex = function () {
+ this.m_vertices[0] = this.m_v1;
+ this.m_vertices[1] = this.m_v2;
+ this.m_vertices[2] = this.m_v3;
+ }
+ b2Simplex.prototype.ReadCache = function (cache, proxyA, transformA, proxyB, transformB) {
+ b2Settings.b2Assert(0 <= cache.count && cache.count <= 3);
+ var wALocal;
+ var wBLocal;
+ this.m_count = cache.count;
+ var vertices = this.m_vertices;
+ for (var i = 0; i < this.m_count; i++) {
+ var v = vertices[i];
+ v.indexA = cache.indexA[i];
+ v.indexB = cache.indexB[i];
+ wALocal = proxyA.GetVertex(v.indexA);
+ wBLocal = proxyB.GetVertex(v.indexB);
+ v.wA = b2Math.MulX(transformA, wALocal);
+ v.wB = b2Math.MulX(transformB, wBLocal);
+ v.w = b2Math.SubtractVV(v.wB, v.wA);
+ v.a = 0;
+ }
+ if (this.m_count > 1) {
+ var metric1 = cache.metric;
+ var metric2 = this.GetMetric();
+ if (metric2 < .5 * metric1 || 2.0 * metric1 < metric2 || metric2 < Number.MIN_VALUE) {
+ this.m_count = 0;
+ }
+ }
+ if (this.m_count == 0) {
+ v = vertices[0];
+ v.indexA = 0;
+ v.indexB = 0;
+ wALocal = proxyA.GetVertex(0);
+ wBLocal = proxyB.GetVertex(0);
+ v.wA = b2Math.MulX(transformA, wALocal);
+ v.wB = b2Math.MulX(transformB, wBLocal);
+ v.w = b2Math.SubtractVV(v.wB, v.wA);
+ this.m_count = 1;
+ }
+ }
+ b2Simplex.prototype.WriteCache = function (cache) {
+ cache.metric = this.GetMetric();
+ cache.count = Box2D.parseUInt(this.m_count);
+ var vertices = this.m_vertices;
+ for (var i = 0; i < this.m_count; i++) {
+ cache.indexA[i] = Box2D.parseUInt(vertices[i].indexA);
+ cache.indexB[i] = Box2D.parseUInt(vertices[i].indexB);
+ }
+ }
+ b2Simplex.prototype.GetSearchDirection = function () {
+ switch (this.m_count) {
+ case 1:
+ return this.m_v1.w.GetNegative();
+ case 2:
+ {
+ var e12 = b2Math.SubtractVV(this.m_v2.w, this.m_v1.w);
+ var sgn = b2Math.CrossVV(e12, this.m_v1.w.GetNegative());
+ if (sgn > 0.0) {
+ return b2Math.CrossFV(1.0, e12);
+ }
+ else {
+ return b2Math.CrossVF(e12, 1.0);
+ }
+ }
+ default:
+ b2Settings.b2Assert(false);
+ return new b2Vec2();
+ }
+ }
+ b2Simplex.prototype.GetClosestPoint = function () {
+ switch (this.m_count) {
+ case 0:
+ b2Settings.b2Assert(false);
+ return new b2Vec2();
+ case 1:
+ return this.m_v1.w;
+ case 2:
+ return new b2Vec2(this.m_v1.a * this.m_v1.w.x + this.m_v2.a * this.m_v2.w.x, this.m_v1.a * this.m_v1.w.y + this.m_v2.a * this.m_v2.w.y);
+ default:
+ b2Settings.b2Assert(false);
+ return new b2Vec2();
+ }
+ }
+ b2Simplex.prototype.GetWitnessPoints = function (pA, pB) {
+ switch (this.m_count) {
+ case 0:
+ b2Settings.b2Assert(false);
+ break;
+ case 1:
+ pA.SetV(this.m_v1.wA);
+ pB.SetV(this.m_v1.wB);
+ break;
+ case 2:
+ pA.x = this.m_v1.a * this.m_v1.wA.x + this.m_v2.a * this.m_v2.wA.x;
+ pA.y = this.m_v1.a * this.m_v1.wA.y + this.m_v2.a * this.m_v2.wA.y;
+ pB.x = this.m_v1.a * this.m_v1.wB.x + this.m_v2.a * this.m_v2.wB.x;
+ pB.y = this.m_v1.a * this.m_v1.wB.y + this.m_v2.a * this.m_v2.wB.y;
+ break;
+ case 3:
+ pB.x = pA.x = this.m_v1.a * this.m_v1.wA.x + this.m_v2.a * this.m_v2.wA.x + this.m_v3.a * this.m_v3.wA.x;
+ pB.y = pA.y = this.m_v1.a * this.m_v1.wA.y + this.m_v2.a * this.m_v2.wA.y + this.m_v3.a * this.m_v3.wA.y;
+ break;
+ default:
+ b2Settings.b2Assert(false);
+ break;
+ }
+ }
+ b2Simplex.prototype.GetMetric = function () {
+ switch (this.m_count) {
+ case 0:
+ b2Settings.b2Assert(false);
+ return 0.0;
+ case 1:
+ return 0.0;
+ case 2:
+ return b2Math.SubtractVV(this.m_v1.w, this.m_v2.w).Length();
+ case 3:
+ return b2Math.CrossVV(b2Math.SubtractVV(this.m_v2.w, this.m_v1.w), b2Math.SubtractVV(this.m_v3.w, this.m_v1.w));
+ default:
+ b2Settings.b2Assert(false);
+ return 0.0;
+ }
+ }
+ b2Simplex.prototype.Solve2 = function () {
+ var w1 = this.m_v1.w;
+ var w2 = this.m_v2.w;
+ var e12 = b2Math.SubtractVV(w2, w1);
+ var d12_2 = (-(w1.x * e12.x + w1.y * e12.y));
+ if (d12_2 <= 0.0) {
+ this.m_v1.a = 1.0;
+ this.m_count = 1;
+ return;
+ }
+ var d12_1 = (w2.x * e12.x + w2.y * e12.y);
+ if (d12_1 <= 0.0) {
+ this.m_v2.a = 1.0;
+ this.m_count = 1;
+ this.m_v1.Set(this.m_v2);
+ return;
+ }
+ var inv_d12 = 1.0 / (d12_1 + d12_2);
+ this.m_v1.a = d12_1 * inv_d12;
+ this.m_v2.a = d12_2 * inv_d12;
+ this.m_count = 2;
+ }
+ b2Simplex.prototype.Solve3 = function () {
+ var w1 = this.m_v1.w;
+ var w2 = this.m_v2.w;
+ var w3 = this.m_v3.w;
+ var e12 = b2Math.SubtractVV(w2, w1);
+ var w1e12 = b2Math.Dot(w1, e12);
+ var w2e12 = b2Math.Dot(w2, e12);
+ var d12_1 = w2e12;
+ var d12_2 = (-w1e12);
+ var e13 = b2Math.SubtractVV(w3, w1);
+ var w1e13 = b2Math.Dot(w1, e13);
+ var w3e13 = b2Math.Dot(w3, e13);
+ var d13_1 = w3e13;
+ var d13_2 = (-w1e13);
+ var e23 = b2Math.SubtractVV(w3, w2);
+ var w2e23 = b2Math.Dot(w2, e23);
+ var w3e23 = b2Math.Dot(w3, e23);
+ var d23_1 = w3e23;
+ var d23_2 = (-w2e23);
+ var n123 = b2Math.CrossVV(e12, e13);
+ var d123_1 = n123 * b2Math.CrossVV(w2, w3);
+ var d123_2 = n123 * b2Math.CrossVV(w3, w1);
+ var d123_3 = n123 * b2Math.CrossVV(w1, w2);
+ if (d12_2 <= 0.0 && d13_2 <= 0.0) {
+ this.m_v1.a = 1.0;
+ this.m_count = 1;
+ return;
+ }
+ if (d12_1 > 0.0 && d12_2 > 0.0 && d123_3 <= 0.0) {
+ var inv_d12 = 1.0 / (d12_1 + d12_2);
+ this.m_v1.a = d12_1 * inv_d12;
+ this.m_v2.a = d12_2 * inv_d12;
+ this.m_count = 2;
+ return;
+ }
+ if (d13_1 > 0.0 && d13_2 > 0.0 && d123_2 <= 0.0) {
+ var inv_d13 = 1.0 / (d13_1 + d13_2);
+ this.m_v1.a = d13_1 * inv_d13;
+ this.m_v3.a = d13_2 * inv_d13;
+ this.m_count = 2;
+ this.m_v2.Set(this.m_v3);
+ return;
+ }
+ if (d12_1 <= 0.0 && d23_2 <= 0.0) {
+ this.m_v2.a = 1.0;
+ this.m_count = 1;
+ this.m_v1.Set(this.m_v2);
+ return;
+ }
+ if (d13_1 <= 0.0 && d23_1 <= 0.0) {
+ this.m_v3.a = 1.0;
+ this.m_count = 1;
+ this.m_v1.Set(this.m_v3);
+ return;
+ }
+ if (d23_1 > 0.0 && d23_2 > 0.0 && d123_1 <= 0.0) {
+ var inv_d23 = 1.0 / (d23_1 + d23_2);
+ this.m_v2.a = d23_1 * inv_d23;
+ this.m_v3.a = d23_2 * inv_d23;
+ this.m_count = 2;
+ this.m_v1.Set(this.m_v3);
+ return;
+ }
+ var inv_d123 = 1.0 / (d123_1 + d123_2 + d123_3);
+ this.m_v1.a = d123_1 * inv_d123;
+ this.m_v2.a = d123_2 * inv_d123;
+ this.m_v3.a = d123_3 * inv_d123;
+ this.m_count = 3;
+ }
+ b2SimplexCache.b2SimplexCache = function () {
+ this.indexA = new Vector_a2j_Number(3);
+ this.indexB = new Vector_a2j_Number(3);
+ };
+ b2SimplexVertex.b2SimplexVertex = function () {};
+ b2SimplexVertex.prototype.Set = function (other) {
+ this.wA.SetV(other.wA);
+ this.wB.SetV(other.wB);
+ this.w.SetV(other.w);
+ this.a = other.a;
+ this.indexA = other.indexA;
+ this.indexB = other.indexB;
+ }
+ b2TimeOfImpact.b2TimeOfImpact = function () {};
+ b2TimeOfImpact.TimeOfImpact = function (input) {
+ ++b2TimeOfImpact.b2_toiCalls;
+ var proxyA = input.proxyA;
+ var proxyB = input.proxyB;
+ var sweepA = input.sweepA;
+ var sweepB = input.sweepB;
+ b2Settings.b2Assert(sweepA.t0 == sweepB.t0);
+ b2Settings.b2Assert(1.0 - sweepA.t0 > Number.MIN_VALUE);
+ var radius = proxyA.m_radius + proxyB.m_radius;
+ var tolerance = input.tolerance;
+ var alpha = 0.0;
+ var k_maxIterations = 1000;
+ var iter = 0;
+ var target = 0.0;
+ b2TimeOfImpact.s_cache.count = 0;
+ b2TimeOfImpact.s_distanceInput.useRadii = false;
+ for (;;) {
+ sweepA.GetTransform(b2TimeOfImpact.s_xfA, alpha);
+ sweepB.GetTransform(b2TimeOfImpact.s_xfB, alpha);
+ b2TimeOfImpact.s_distanceInput.proxyA = proxyA;
+ b2TimeOfImpact.s_distanceInput.proxyB = proxyB;
+ b2TimeOfImpact.s_distanceInput.transformA = b2TimeOfImpact.s_xfA;
+ b2TimeOfImpact.s_distanceInput.transformB = b2TimeOfImpact.s_xfB;
+ b2Distance.Distance(b2TimeOfImpact.s_distanceOutput, b2TimeOfImpact.s_cache, b2TimeOfImpact.s_distanceInput);
+ if (b2TimeOfImpact.s_distanceOutput.distance <= 0.0) {
+ alpha = 1.0;
+ break;
+ }
+ b2TimeOfImpact.s_fcn.Initialize(b2TimeOfImpact.s_cache, proxyA, b2TimeOfImpact.s_xfA, proxyB, b2TimeOfImpact.s_xfB);
+ var separation = b2TimeOfImpact.s_fcn.Evaluate(b2TimeOfImpact.s_xfA, b2TimeOfImpact.s_xfB);
+ if (separation <= 0.0) {
+ alpha = 1.0;
+ break;
+ }
+ if (iter == 0) {
+ if (separation > radius) {
+ target = b2Math.Max(radius - tolerance, 0.75 * radius);
+ }
+ else {
+ target = b2Math.Max(separation - tolerance, 0.02 * radius);
+ }
+ }
+ if (separation - target < 0.5 * tolerance) {
+ if (iter == 0) {
+ alpha = 1.0;
+ break;
+ }
+ break;
+ }
+ var newAlpha = alpha; {
+ var x1 = alpha;
+ var x2 = 1.0;
+ var f1 = separation;
+ sweepA.GetTransform(b2TimeOfImpact.s_xfA, x2);
+ sweepB.GetTransform(b2TimeOfImpact.s_xfB, x2);
+ var f2 = b2TimeOfImpact.s_fcn.Evaluate(b2TimeOfImpact.s_xfA, b2TimeOfImpact.s_xfB);
+ if (f2 >= target) {
+ alpha = 1.0;
+ break;
+ }
+ var rootIterCount = 0;
+ for (;;) {
+ var x = 0;
+ if (rootIterCount & 1) {
+ x = x1 + (target - f1) * (x2 - x1) / (f2 - f1);
+ }
+ else {
+ x = 0.5 * (x1 + x2);
+ }
+ sweepA.GetTransform(b2TimeOfImpact.s_xfA, x);
+ sweepB.GetTransform(b2TimeOfImpact.s_xfB, x);
+ var f = b2TimeOfImpact.s_fcn.Evaluate(b2TimeOfImpact.s_xfA, b2TimeOfImpact.s_xfB);
+ if (b2Math.Abs(f - target) < 0.025 * tolerance) {
+ newAlpha = x;
+ break;
+ }
+ if (f > target) {
+ x1 = x;
+ f1 = f;
+ }
+ else {
+ x2 = x;
+ f2 = f;
+ }++rootIterCount;
+ ++b2TimeOfImpact.b2_toiRootIters;
+ if (rootIterCount == 50) {
+ break;
+ }
+ }
+ b2TimeOfImpact.b2_toiMaxRootIters = b2Math.Max(b2TimeOfImpact.b2_toiMaxRootIters, rootIterCount);
+ }
+ if (newAlpha < (1.0 + 100.0 * Number.MIN_VALUE) * alpha) {
+ break;
+ }
+ alpha = newAlpha;
+ iter++;
+ ++b2TimeOfImpact.b2_toiIters;
+ if (iter == k_maxIterations) {
+ break;
+ }
+ }
+ b2TimeOfImpact.b2_toiMaxIters = b2Math.Max(b2TimeOfImpact.b2_toiMaxIters, iter);
+ return alpha;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.b2TimeOfImpact.b2_toiCalls = 0;
+ Box2D.Collision.b2TimeOfImpact.b2_toiIters = 0;
+ Box2D.Collision.b2TimeOfImpact.b2_toiMaxIters = 0;
+ Box2D.Collision.b2TimeOfImpact.b2_toiRootIters = 0;
+ Box2D.Collision.b2TimeOfImpact.b2_toiMaxRootIters = 0;
+ Box2D.Collision.b2TimeOfImpact.s_cache = new b2SimplexCache();
+ Box2D.Collision.b2TimeOfImpact.s_distanceInput = new b2DistanceInput();
+ Box2D.Collision.b2TimeOfImpact.s_xfA = new b2Transform();
+ Box2D.Collision.b2TimeOfImpact.s_xfB = new b2Transform();
+ Box2D.Collision.b2TimeOfImpact.s_fcn = new b2SeparationFunction();
+ Box2D.Collision.b2TimeOfImpact.s_distanceOutput = new b2DistanceOutput();
+ });
+ b2TOIInput.b2TOIInput = function () {
+ this.proxyA = new b2DistanceProxy();
+ this.proxyB = new b2DistanceProxy();
+ this.sweepA = new b2Sweep();
+ this.sweepB = new b2Sweep();
+ };
+ b2WorldManifold.b2WorldManifold = function () {
+ this.m_normal = new b2Vec2();
+ };
+ b2WorldManifold.prototype.b2WorldManifold = function () {
+ this.m_points = new Vector(b2Settings.b2_maxManifoldPoints);
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; i++) {
+ this.m_points[i] = new b2Vec2();
+ }
+ }
+ b2WorldManifold.prototype.Initialize = function (manifold, xfA, radiusA, xfB, radiusB) {
+ if (radiusA === undefined) radiusA = 0;
+ if (radiusB === undefined) radiusB = 0;
+ if (manifold.m_pointCount == 0) {
+ return;
+ }
+ var i = 0;
+ var tVec;
+ var tMat;
+ var normalX = 0;
+ var normalY = 0;
+ var planePointX = 0;
+ var planePointY = 0;
+ var clipPointX = 0;
+ var clipPointY = 0;
+ switch (manifold.m_type) {
+ case b2Manifold.e_circles:
+ {
+ tMat = xfA.R;
+ tVec = manifold.m_localPoint;
+ var pointAX = xfA.position.x + tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ var pointAY = xfA.position.y + tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = xfB.R;
+ tVec = manifold.m_points[0].m_localPoint;
+ var pointBX = xfB.position.x + tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ var pointBY = xfB.position.y + tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ var dX = pointBX - pointAX;
+ var dY = pointBY - pointAY;
+ var d2 = dX * dX + dY * dY;
+ if (d2 > Number.MIN_VALUE * Number.MIN_VALUE) {
+ var d = Math.sqrt(d2);
+ this.m_normal.x = dX / d;
+ this.m_normal.y = dY / d;
+ }
+ else {
+ this.m_normal.x = 1;
+ this.m_normal.y = 0;
+ }
+ var cAX = pointAX + radiusA * this.m_normal.x;
+ var cAY = pointAY + radiusA * this.m_normal.y;
+ var cBX = pointBX - radiusB * this.m_normal.x;
+ var cBY = pointBY - radiusB * this.m_normal.y;
+ this.m_points[0].x = 0.5 * (cAX + cBX);
+ this.m_points[0].y = 0.5 * (cAY + cBY);
+ }
+ break;
+ case b2Manifold.e_faceA:
+ {
+ tMat = xfA.R;
+ tVec = manifold.m_localPlaneNormal;
+ normalX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ normalY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = xfA.R;
+ tVec = manifold.m_localPoint;
+ planePointX = xfA.position.x + tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ planePointY = xfA.position.y + tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ this.m_normal.x = normalX;
+ this.m_normal.y = normalY;
+ for (i = 0;
+ i < manifold.m_pointCount; i++) {
+ tMat = xfB.R;
+ tVec = manifold.m_points[i].m_localPoint;
+ clipPointX = xfB.position.x + tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ clipPointY = xfB.position.y + tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ this.m_points[i].x = clipPointX + 0.5 * (radiusA - (clipPointX - planePointX) * normalX - (clipPointY - planePointY) * normalY - radiusB) * normalX;
+ this.m_points[i].y = clipPointY + 0.5 * (radiusA - (clipPointX - planePointX) * normalX - (clipPointY - planePointY) * normalY - radiusB) * normalY;
+ }
+ }
+ break;
+ case b2Manifold.e_faceB:
+ {
+ tMat = xfB.R;
+ tVec = manifold.m_localPlaneNormal;
+ normalX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ normalY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = xfB.R;
+ tVec = manifold.m_localPoint;
+ planePointX = xfB.position.x + tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ planePointY = xfB.position.y + tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ this.m_normal.x = (-normalX);
+ this.m_normal.y = (-normalY);
+ for (i = 0;
+ i < manifold.m_pointCount; i++) {
+ tMat = xfA.R;
+ tVec = manifold.m_points[i].m_localPoint;
+ clipPointX = xfA.position.x + tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ clipPointY = xfA.position.y + tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ this.m_points[i].x = clipPointX + 0.5 * (radiusB - (clipPointX - planePointX) * normalX - (clipPointY - planePointY) * normalY - radiusA) * normalX;
+ this.m_points[i].y = clipPointY + 0.5 * (radiusB - (clipPointX - planePointX) * normalX - (clipPointY - planePointY) * normalY - radiusA) * normalY;
+ }
+ }
+ break;
+ }
+ }
+ ClipVertex.ClipVertex = function () {
+ this.v = new b2Vec2();
+ this.id = new b2ContactID();
+ };
+ ClipVertex.prototype.Set = function (other) {
+ this.v.SetV(other.v);
+ this.id.Set(other.id);
+ }
+ Features.Features = function () {};
+ Object.defineProperty(Features.prototype, 'referenceEdge', {
+ enumerable: false,
+ configurable: true,
+ get: function () {
+ return this._referenceEdge;
+ }
+ });
+ Object.defineProperty(Features.prototype, 'referenceEdge', {
+ enumerable: false,
+ configurable: true,
+ set: function (value) {
+ if (value === undefined) value = 0;
+ this._referenceEdge = value;
+ this._m_id._key = (this._m_id._key & 0xffffff00) | (this._referenceEdge & 0x000000ff);
+ }
+ });
+ Object.defineProperty(Features.prototype, 'incidentEdge', {
+ enumerable: false,
+ configurable: true,
+ get: function () {
+ return this._incidentEdge;
+ }
+ });
+ Object.defineProperty(Features.prototype, 'incidentEdge', {
+ enumerable: false,
+ configurable: true,
+ set: function (value) {
+ if (value === undefined) value = 0;
+ this._incidentEdge = value;
+ this._m_id._key = (this._m_id._key & 0xffff00ff) | ((this._incidentEdge << 8) & 0x0000ff00);
+ }
+ });
+ Object.defineProperty(Features.prototype, 'incidentVertex', {
+ enumerable: false,
+ configurable: true,
+ get: function () {
+ return this._incidentVertex;
+ }
+ });
+ Object.defineProperty(Features.prototype, 'incidentVertex', {
+ enumerable: false,
+ configurable: true,
+ set: function (value) {
+ if (value === undefined) value = 0;
+ this._incidentVertex = value;
+ this._m_id._key = (this._m_id._key & 0xff00ffff) | ((this._incidentVertex << 16) & 0x00ff0000);
+ }
+ });
+ Object.defineProperty(Features.prototype, 'flip', {
+ enumerable: false,
+ configurable: true,
+ get: function () {
+ return this._flip;
+ }
+ });
+ Object.defineProperty(Features.prototype, 'flip', {
+ enumerable: false,
+ configurable: true,
+ set: function (value) {
+ if (value === undefined) value = 0;
+ this._flip = value;
+ this._m_id._key = (this._m_id._key & 0x00ffffff) | ((this._flip << 24) & 0xff000000);
+ }
+ });
+})();
+(function () {
+ var b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2CircleShape = Box2D.Collision.Shapes.b2CircleShape,
+ b2EdgeChainDef = Box2D.Collision.Shapes.b2EdgeChainDef,
+ b2EdgeShape = Box2D.Collision.Shapes.b2EdgeShape,
+ b2MassData = Box2D.Collision.Shapes.b2MassData,
+ b2PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
+ b2Shape = Box2D.Collision.Shapes.b2Shape,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3,
+ b2Body = Box2D.Dynamics.b2Body,
+ b2BodyDef = Box2D.Dynamics.b2BodyDef,
+ b2ContactFilter = Box2D.Dynamics.b2ContactFilter,
+ b2ContactImpulse = Box2D.Dynamics.b2ContactImpulse,
+ b2ContactListener = Box2D.Dynamics.b2ContactListener,
+ b2ContactManager = Box2D.Dynamics.b2ContactManager,
+ b2DebugDraw = Box2D.Dynamics.b2DebugDraw,
+ b2DestructionListener = Box2D.Dynamics.b2DestructionListener,
+ b2FilterData = Box2D.Dynamics.b2FilterData,
+ b2Fixture = Box2D.Dynamics.b2Fixture,
+ b2FixtureDef = Box2D.Dynamics.b2FixtureDef,
+ b2Island = Box2D.Dynamics.b2Island,
+ b2TimeStep = Box2D.Dynamics.b2TimeStep,
+ b2World = Box2D.Dynamics.b2World,
+ b2AABB = Box2D.Collision.b2AABB,
+ b2Bound = Box2D.Collision.b2Bound,
+ b2BoundValues = Box2D.Collision.b2BoundValues,
+ b2Collision = Box2D.Collision.b2Collision,
+ b2ContactID = Box2D.Collision.b2ContactID,
+ b2ContactPoint = Box2D.Collision.b2ContactPoint,
+ b2Distance = Box2D.Collision.b2Distance,
+ b2DistanceInput = Box2D.Collision.b2DistanceInput,
+ b2DistanceOutput = Box2D.Collision.b2DistanceOutput,
+ b2DistanceProxy = Box2D.Collision.b2DistanceProxy,
+ b2DynamicTree = Box2D.Collision.b2DynamicTree,
+ b2DynamicTreeBroadPhase = Box2D.Collision.b2DynamicTreeBroadPhase,
+ b2DynamicTreeNode = Box2D.Collision.b2DynamicTreeNode,
+ b2DynamicTreePair = Box2D.Collision.b2DynamicTreePair,
+ b2Manifold = Box2D.Collision.b2Manifold,
+ b2ManifoldPoint = Box2D.Collision.b2ManifoldPoint,
+ b2Point = Box2D.Collision.b2Point,
+ b2RayCastInput = Box2D.Collision.b2RayCastInput,
+ b2RayCastOutput = Box2D.Collision.b2RayCastOutput,
+ b2Segment = Box2D.Collision.b2Segment,
+ b2SeparationFunction = Box2D.Collision.b2SeparationFunction,
+ b2Simplex = Box2D.Collision.b2Simplex,
+ b2SimplexCache = Box2D.Collision.b2SimplexCache,
+ b2SimplexVertex = Box2D.Collision.b2SimplexVertex,
+ b2TimeOfImpact = Box2D.Collision.b2TimeOfImpact,
+ b2TOIInput = Box2D.Collision.b2TOIInput,
+ b2WorldManifold = Box2D.Collision.b2WorldManifold,
+ ClipVertex = Box2D.Collision.ClipVertex,
+ Features = Box2D.Collision.Features,
+ IBroadPhase = Box2D.Collision.IBroadPhase;
+
+ Box2D.inherit(b2CircleShape, Box2D.Collision.Shapes.b2Shape);
+ b2CircleShape.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
+ b2CircleShape.b2CircleShape = function () {
+ Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
+ this.m_p = new b2Vec2();
+ };
+ b2CircleShape.prototype.Copy = function () {
+ var s = new b2CircleShape();
+ s.Set(this);
+ return s;
+ }
+ b2CircleShape.prototype.Set = function (other) {
+ this.__super.Set.call(this, other);
+ if (Box2D.is(other, b2CircleShape)) {
+ var other2 = (other instanceof b2CircleShape ? other : null);
+ this.m_p.SetV(other2.m_p);
+ }
+ }
+ b2CircleShape.prototype.TestPoint = function (transform, p) {
+ var tMat = transform.R;
+ var dX = transform.position.x + (tMat.col1.x * this.m_p.x + tMat.col2.x * this.m_p.y);
+ var dY = transform.position.y + (tMat.col1.y * this.m_p.x + tMat.col2.y * this.m_p.y);
+ dX = p.x - dX;
+ dY = p.y - dY;
+ return (dX * dX + dY * dY) <= this.m_radius * this.m_radius;
+ }
+ b2CircleShape.prototype.RayCast = function (output, input, transform) {
+ var tMat = transform.R;
+ var positionX = transform.position.x + (tMat.col1.x * this.m_p.x + tMat.col2.x * this.m_p.y);
+ var positionY = transform.position.y + (tMat.col1.y * this.m_p.x + tMat.col2.y * this.m_p.y);
+ var sX = input.p1.x - positionX;
+ var sY = input.p1.y - positionY;
+ var b = (sX * sX + sY * sY) - this.m_radius * this.m_radius;
+ var rX = input.p2.x - input.p1.x;
+ var rY = input.p2.y - input.p1.y;
+ var c = (sX * rX + sY * rY);
+ var rr = (rX * rX + rY * rY);
+ var sigma = c * c - rr * b;
+ if (sigma < 0.0 || rr < Number.MIN_VALUE) {
+ return false;
+ }
+ var a = (-(c + Math.sqrt(sigma)));
+ if (0.0 <= a && a <= input.maxFraction * rr) {
+ a /= rr;
+ output.fraction = a;
+ output.normal.x = sX + a * rX;
+ output.normal.y = sY + a * rY;
+ output.normal.Normalize();
+ return true;
+ }
+ return false;
+ }
+ b2CircleShape.prototype.ComputeAABB = function (aabb, transform) {
+ var tMat = transform.R;
+ var pX = transform.position.x + (tMat.col1.x * this.m_p.x + tMat.col2.x * this.m_p.y);
+ var pY = transform.position.y + (tMat.col1.y * this.m_p.x + tMat.col2.y * this.m_p.y);
+ aabb.lowerBound.Set(pX - this.m_radius, pY - this.m_radius);
+ aabb.upperBound.Set(pX + this.m_radius, pY + this.m_radius);
+ }
+ b2CircleShape.prototype.ComputeMass = function (massData, density) {
+ if (density === undefined) density = 0;
+ massData.mass = density * b2Settings.b2_pi * this.m_radius * this.m_radius;
+ massData.center.SetV(this.m_p);
+ massData.I = massData.mass * (0.5 * this.m_radius * this.m_radius + (this.m_p.x * this.m_p.x + this.m_p.y * this.m_p.y));
+ }
+ b2CircleShape.prototype.ComputeSubmergedArea = function (normal, offset, xf, c) {
+ if (offset === undefined) offset = 0;
+ var p = b2Math.MulX(xf, this.m_p);
+ var l = (-(b2Math.Dot(normal, p) - offset));
+ if (l < (-this.m_radius) + Number.MIN_VALUE) {
+ return 0;
+ }
+ if (l > this.m_radius) {
+ c.SetV(p);
+ return Math.PI * this.m_radius * this.m_radius;
+ }
+ var r2 = this.m_radius * this.m_radius;
+ var l2 = l * l;
+ var area = r2 * (Math.asin(l / this.m_radius) + Math.PI / 2) + l * Math.sqrt(r2 - l2);
+ var com = (-2 / 3 * Math.pow(r2 - l2, 1.5) / area);
+ c.x = p.x + normal.x * com;
+ c.y = p.y + normal.y * com;
+ return area;
+ }
+ b2CircleShape.prototype.GetLocalPosition = function () {
+ return this.m_p;
+ }
+ b2CircleShape.prototype.SetLocalPosition = function (position) {
+ this.m_p.SetV(position);
+ }
+ b2CircleShape.prototype.GetRadius = function () {
+ return this.m_radius;
+ }
+ b2CircleShape.prototype.SetRadius = function (radius) {
+ if (radius === undefined) radius = 0;
+ this.m_radius = radius;
+ }
+ b2CircleShape.prototype.b2CircleShape = function (radius) {
+ if (radius === undefined) radius = 0;
+ this.__super.b2Shape.call(this);
+ this.m_type = b2Shape.e_circleShape;
+ this.m_radius = radius;
+ }
+ b2EdgeChainDef.b2EdgeChainDef = function () {};
+ b2EdgeChainDef.prototype.b2EdgeChainDef = function () {
+ this.vertexCount = 0;
+ this.isALoop = true;
+ this.vertices = [];
+ }
+ Box2D.inherit(b2EdgeShape, Box2D.Collision.Shapes.b2Shape);
+ b2EdgeShape.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
+ b2EdgeShape.b2EdgeShape = function () {
+ Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
+ this.s_supportVec = new b2Vec2();
+ this.m_v1 = new b2Vec2();
+ this.m_v2 = new b2Vec2();
+ this.m_coreV1 = new b2Vec2();
+ this.m_coreV2 = new b2Vec2();
+ this.m_normal = new b2Vec2();
+ this.m_direction = new b2Vec2();
+ this.m_cornerDir1 = new b2Vec2();
+ this.m_cornerDir2 = new b2Vec2();
+ };
+ b2EdgeShape.prototype.TestPoint = function (transform, p) {
+ return false;
+ }
+ b2EdgeShape.prototype.RayCast = function (output, input, transform) {
+ var tMat;
+ var rX = input.p2.x - input.p1.x;
+ var rY = input.p2.y - input.p1.y;
+ tMat = transform.R;
+ var v1X = transform.position.x + (tMat.col1.x * this.m_v1.x + tMat.col2.x * this.m_v1.y);
+ var v1Y = transform.position.y + (tMat.col1.y * this.m_v1.x + tMat.col2.y * this.m_v1.y);
+ var nX = transform.position.y + (tMat.col1.y * this.m_v2.x + tMat.col2.y * this.m_v2.y) - v1Y;
+ var nY = (-(transform.position.x + (tMat.col1.x * this.m_v2.x + tMat.col2.x * this.m_v2.y) - v1X));
+ var k_slop = 100.0 * Number.MIN_VALUE;
+ var denom = (-(rX * nX + rY * nY));
+ if (denom > k_slop) {
+ var bX = input.p1.x - v1X;
+ var bY = input.p1.y - v1Y;
+ var a = (bX * nX + bY * nY);
+ if (0.0 <= a && a <= input.maxFraction * denom) {
+ var mu2 = (-rX * bY) + rY * bX;
+ if ((-k_slop * denom) <= mu2 && mu2 <= denom * (1.0 + k_slop)) {
+ a /= denom;
+ output.fraction = a;
+ var nLen = Math.sqrt(nX * nX + nY * nY);
+ output.normal.x = nX / nLen;
+ output.normal.y = nY / nLen;
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+ b2EdgeShape.prototype.ComputeAABB = function (aabb, transform) {
+ var tMat = transform.R;
+ var v1X = transform.position.x + (tMat.col1.x * this.m_v1.x + tMat.col2.x * this.m_v1.y);
+ var v1Y = transform.position.y + (tMat.col1.y * this.m_v1.x + tMat.col2.y * this.m_v1.y);
+ var v2X = transform.position.x + (tMat.col1.x * this.m_v2.x + tMat.col2.x * this.m_v2.y);
+ var v2Y = transform.position.y + (tMat.col1.y * this.m_v2.x + tMat.col2.y * this.m_v2.y);
+ if (v1X < v2X) {
+ aabb.lowerBound.x = v1X;
+ aabb.upperBound.x = v2X;
+ }
+ else {
+ aabb.lowerBound.x = v2X;
+ aabb.upperBound.x = v1X;
+ }
+ if (v1Y < v2Y) {
+ aabb.lowerBound.y = v1Y;
+ aabb.upperBound.y = v2Y;
+ }
+ else {
+ aabb.lowerBound.y = v2Y;
+ aabb.upperBound.y = v1Y;
+ }
+ }
+ b2EdgeShape.prototype.ComputeMass = function (massData, density) {
+ if (density === undefined) density = 0;
+ massData.mass = 0;
+ massData.center.SetV(this.m_v1);
+ massData.I = 0;
+ }
+ b2EdgeShape.prototype.ComputeSubmergedArea = function (normal, offset, xf, c) {
+ if (offset === undefined) offset = 0;
+ var v0 = new b2Vec2(normal.x * offset, normal.y * offset);
+ var v1 = b2Math.MulX(xf, this.m_v1);
+ var v2 = b2Math.MulX(xf, this.m_v2);
+ var d1 = b2Math.Dot(normal, v1) - offset;
+ var d2 = b2Math.Dot(normal, v2) - offset;
+ if (d1 > 0) {
+ if (d2 > 0) {
+ return 0;
+ }
+ else {
+ v1.x = (-d2 / (d1 - d2) * v1.x) + d1 / (d1 - d2) * v2.x;
+ v1.y = (-d2 / (d1 - d2) * v1.y) + d1 / (d1 - d2) * v2.y;
+ }
+ }
+ else {
+ if (d2 > 0) {
+ v2.x = (-d2 / (d1 - d2) * v1.x) + d1 / (d1 - d2) * v2.x;
+ v2.y = (-d2 / (d1 - d2) * v1.y) + d1 / (d1 - d2) * v2.y;
+ }
+ else {}
+ }
+ c.x = (v0.x + v1.x + v2.x) / 3;
+ c.y = (v0.y + v1.y + v2.y) / 3;
+ return 0.5 * ((v1.x - v0.x) * (v2.y - v0.y) - (v1.y - v0.y) * (v2.x - v0.x));
+ }
+ b2EdgeShape.prototype.GetLength = function () {
+ return this.m_length;
+ }
+ b2EdgeShape.prototype.GetVertex1 = function () {
+ return this.m_v1;
+ }
+ b2EdgeShape.prototype.GetVertex2 = function () {
+ return this.m_v2;
+ }
+ b2EdgeShape.prototype.GetCoreVertex1 = function () {
+ return this.m_coreV1;
+ }
+ b2EdgeShape.prototype.GetCoreVertex2 = function () {
+ return this.m_coreV2;
+ }
+ b2EdgeShape.prototype.GetNormalVector = function () {
+ return this.m_normal;
+ }
+ b2EdgeShape.prototype.GetDirectionVector = function () {
+ return this.m_direction;
+ }
+ b2EdgeShape.prototype.GetCorner1Vector = function () {
+ return this.m_cornerDir1;
+ }
+ b2EdgeShape.prototype.GetCorner2Vector = function () {
+ return this.m_cornerDir2;
+ }
+ b2EdgeShape.prototype.Corner1IsConvex = function () {
+ return this.m_cornerConvex1;
+ }
+ b2EdgeShape.prototype.Corner2IsConvex = function () {
+ return this.m_cornerConvex2;
+ }
+ b2EdgeShape.prototype.GetFirstVertex = function (xf) {
+ var tMat = xf.R;
+ return new b2Vec2(xf.position.x + (tMat.col1.x * this.m_coreV1.x + tMat.col2.x * this.m_coreV1.y), xf.position.y + (tMat.col1.y * this.m_coreV1.x + tMat.col2.y * this.m_coreV1.y));
+ }
+ b2EdgeShape.prototype.GetNextEdge = function () {
+ return this.m_nextEdge;
+ }
+ b2EdgeShape.prototype.GetPrevEdge = function () {
+ return this.m_prevEdge;
+ }
+ b2EdgeShape.prototype.Support = function (xf, dX, dY) {
+ if (dX === undefined) dX = 0;
+ if (dY === undefined) dY = 0;
+ var tMat = xf.R;
+ var v1X = xf.position.x + (tMat.col1.x * this.m_coreV1.x + tMat.col2.x * this.m_coreV1.y);
+ var v1Y = xf.position.y + (tMat.col1.y * this.m_coreV1.x + tMat.col2.y * this.m_coreV1.y);
+ var v2X = xf.position.x + (tMat.col1.x * this.m_coreV2.x + tMat.col2.x * this.m_coreV2.y);
+ var v2Y = xf.position.y + (tMat.col1.y * this.m_coreV2.x + tMat.col2.y * this.m_coreV2.y);
+ if ((v1X * dX + v1Y * dY) > (v2X * dX + v2Y * dY)) {
+ this.s_supportVec.x = v1X;
+ this.s_supportVec.y = v1Y;
+ }
+ else {
+ this.s_supportVec.x = v2X;
+ this.s_supportVec.y = v2Y;
+ }
+ return this.s_supportVec;
+ }
+ b2EdgeShape.prototype.b2EdgeShape = function (v1, v2) {
+ this.__super.b2Shape.call(this);
+ this.m_type = b2Shape.e_edgeShape;
+ this.m_prevEdge = null;
+ this.m_nextEdge = null;
+ this.m_v1 = v1;
+ this.m_v2 = v2;
+ this.m_direction.Set(this.m_v2.x - this.m_v1.x, this.m_v2.y - this.m_v1.y);
+ this.m_length = this.m_direction.Normalize();
+ this.m_normal.Set(this.m_direction.y, (-this.m_direction.x));
+ this.m_coreV1.Set((-b2Settings.b2_toiSlop * (this.m_normal.x - this.m_direction.x)) + this.m_v1.x, (-b2Settings.b2_toiSlop * (this.m_normal.y - this.m_direction.y)) + this.m_v1.y);
+ this.m_coreV2.Set((-b2Settings.b2_toiSlop * (this.m_normal.x + this.m_direction.x)) + this.m_v2.x, (-b2Settings.b2_toiSlop * (this.m_normal.y + this.m_direction.y)) + this.m_v2.y);
+ this.m_cornerDir1 = this.m_normal;
+ this.m_cornerDir2.Set((-this.m_normal.x), (-this.m_normal.y));
+ }
+ b2EdgeShape.prototype.SetPrevEdge = function (edge, core, cornerDir, convex) {
+ this.m_prevEdge = edge;
+ this.m_coreV1 = core;
+ this.m_cornerDir1 = cornerDir;
+ this.m_cornerConvex1 = convex;
+ }
+ b2EdgeShape.prototype.SetNextEdge = function (edge, core, cornerDir, convex) {
+ this.m_nextEdge = edge;
+ this.m_coreV2 = core;
+ this.m_cornerDir2 = cornerDir;
+ this.m_cornerConvex2 = convex;
+ }
+ b2MassData.b2MassData = function () {
+ this.mass = 0.0;
+ this.center = new b2Vec2(0, 0);
+ this.I = 0.0;
+ };
+ Box2D.inherit(b2PolygonShape, Box2D.Collision.Shapes.b2Shape);
+ b2PolygonShape.prototype.__super = Box2D.Collision.Shapes.b2Shape.prototype;
+ b2PolygonShape.b2PolygonShape = function () {
+ Box2D.Collision.Shapes.b2Shape.b2Shape.apply(this, arguments);
+ };
+ b2PolygonShape.prototype.Copy = function () {
+ var s = new b2PolygonShape();
+ s.Set(this);
+ return s;
+ }
+ b2PolygonShape.prototype.Set = function (other) {
+ this.__super.Set.call(this, other);
+ if (Box2D.is(other, b2PolygonShape)) {
+ var other2 = (other instanceof b2PolygonShape ? other : null);
+ this.m_centroid.SetV(other2.m_centroid);
+ this.m_vertexCount = other2.m_vertexCount;
+ this.Reserve(this.m_vertexCount);
+ for (var i = 0; i < this.m_vertexCount; i++) {
+ this.m_vertices[i].SetV(other2.m_vertices[i]);
+ this.m_normals[i].SetV(other2.m_normals[i]);
+ }
+ }
+ }
+ b2PolygonShape.prototype.SetAsArray = function (vertices, vertexCount) {
+ if (vertexCount === undefined) vertexCount = 0;
+ var v = new Vector();
+ var i = 0,
+ tVec;
+ for (i = 0;
+ i < vertices.length; ++i) {
+ tVec = vertices[i];
+ v.push(tVec);
+ }
+ this.SetAsVector(v, vertexCount);
+ }
+ b2PolygonShape.AsArray = function (vertices, vertexCount) {
+ if (vertexCount === undefined) vertexCount = 0;
+ var polygonShape = new b2PolygonShape();
+ polygonShape.SetAsArray(vertices, vertexCount);
+ return polygonShape;
+ }
+ b2PolygonShape.prototype.SetAsVector = function (vertices, vertexCount) {
+ if (vertexCount === undefined) vertexCount = 0;
+ if (vertexCount == 0) vertexCount = vertices.length;
+ b2Settings.b2Assert(2 <= vertexCount);
+ this.m_vertexCount = vertexCount;
+ this.Reserve(vertexCount);
+ var i = 0;
+ for (i = 0;
+ i < this.m_vertexCount; i++) {
+ this.m_vertices[i].SetV(vertices[i]);
+ }
+ for (i = 0;
+ i < this.m_vertexCount; ++i) {
+ var i1 = parseInt(i);
+ var i2 = parseInt(i + 1 < this.m_vertexCount ? i + 1 : 0);
+ var edge = b2Math.SubtractVV(this.m_vertices[i2], this.m_vertices[i1]);
+ b2Settings.b2Assert(edge.LengthSquared() > Number.MIN_VALUE);
+ this.m_normals[i].SetV(b2Math.CrossVF(edge, 1.0));
+ this.m_normals[i].Normalize();
+ }
+ this.m_centroid = b2PolygonShape.ComputeCentroid(this.m_vertices, this.m_vertexCount);
+ }
+ b2PolygonShape.AsVector = function (vertices, vertexCount) {
+ if (vertexCount === undefined) vertexCount = 0;
+ var polygonShape = new b2PolygonShape();
+ polygonShape.SetAsVector(vertices, vertexCount);
+ return polygonShape;
+ }
+ b2PolygonShape.prototype.SetAsBox = function (hx, hy) {
+ if (hx === undefined) hx = 0;
+ if (hy === undefined) hy = 0;
+ this.m_vertexCount = 4;
+ this.Reserve(4);
+ this.m_vertices[0].Set((-hx), (-hy));
+ this.m_vertices[1].Set(hx, (-hy));
+ this.m_vertices[2].Set(hx, hy);
+ this.m_vertices[3].Set((-hx), hy);
+ this.m_normals[0].Set(0.0, (-1.0));
+ this.m_normals[1].Set(1.0, 0.0);
+ this.m_normals[2].Set(0.0, 1.0);
+ this.m_normals[3].Set((-1.0), 0.0);
+ this.m_centroid.SetZero();
+ }
+ b2PolygonShape.AsBox = function (hx, hy) {
+ if (hx === undefined) hx = 0;
+ if (hy === undefined) hy = 0;
+ var polygonShape = new b2PolygonShape();
+ polygonShape.SetAsBox(hx, hy);
+ return polygonShape;
+ }
+ b2PolygonShape.prototype.SetAsOrientedBox = function (hx, hy, center, angle) {
+ if (hx === undefined) hx = 0;
+ if (hy === undefined) hy = 0;
+ if (center === undefined) center = null;
+ if (angle === undefined) angle = 0.0;
+ this.m_vertexCount = 4;
+ this.Reserve(4);
+ this.m_vertices[0].Set((-hx), (-hy));
+ this.m_vertices[1].Set(hx, (-hy));
+ this.m_vertices[2].Set(hx, hy);
+ this.m_vertices[3].Set((-hx), hy);
+ this.m_normals[0].Set(0.0, (-1.0));
+ this.m_normals[1].Set(1.0, 0.0);
+ this.m_normals[2].Set(0.0, 1.0);
+ this.m_normals[3].Set((-1.0), 0.0);
+ this.m_centroid = center;
+ var xf = new b2Transform();
+ xf.position = center;
+ xf.R.Set(angle);
+ for (var i = 0; i < this.m_vertexCount; ++i) {
+ this.m_vertices[i] = b2Math.MulX(xf, this.m_vertices[i]);
+ this.m_normals[i] = b2Math.MulMV(xf.R, this.m_normals[i]);
+ }
+ }
+ b2PolygonShape.AsOrientedBox = function (hx, hy, center, angle) {
+ if (hx === undefined) hx = 0;
+ if (hy === undefined) hy = 0;
+ if (center === undefined) center = null;
+ if (angle === undefined) angle = 0.0;
+ var polygonShape = new b2PolygonShape();
+ polygonShape.SetAsOrientedBox(hx, hy, center, angle);
+ return polygonShape;
+ }
+ b2PolygonShape.prototype.SetAsEdge = function (v1, v2) {
+ this.m_vertexCount = 2;
+ this.Reserve(2);
+ this.m_vertices[0].SetV(v1);
+ this.m_vertices[1].SetV(v2);
+ this.m_centroid.x = 0.5 * (v1.x + v2.x);
+ this.m_centroid.y = 0.5 * (v1.y + v2.y);
+ this.m_normals[0] = b2Math.CrossVF(b2Math.SubtractVV(v2, v1), 1.0);
+ this.m_normals[0].Normalize();
+ this.m_normals[1].x = (-this.m_normals[0].x);
+ this.m_normals[1].y = (-this.m_normals[0].y);
+ }
+ b2PolygonShape.AsEdge = function (v1, v2) {
+ var polygonShape = new b2PolygonShape();
+ polygonShape.SetAsEdge(v1, v2);
+ return polygonShape;
+ }
+ b2PolygonShape.prototype.TestPoint = function (xf, p) {
+ var tVec;
+ var tMat = xf.R;
+ var tX = p.x - xf.position.x;
+ var tY = p.y - xf.position.y;
+ var pLocalX = (tX * tMat.col1.x + tY * tMat.col1.y);
+ var pLocalY = (tX * tMat.col2.x + tY * tMat.col2.y);
+ for (var i = 0; i < this.m_vertexCount; ++i) {
+ tVec = this.m_vertices[i];
+ tX = pLocalX - tVec.x;
+ tY = pLocalY - tVec.y;
+ tVec = this.m_normals[i];
+ var dot = (tVec.x * tX + tVec.y * tY);
+ if (dot > 0.0) {
+ return false;
+ }
+ }
+ return true;
+ }
+ b2PolygonShape.prototype.RayCast = function (output, input, transform) {
+ var lower = 0.0;
+ var upper = input.maxFraction;
+ var tX = 0;
+ var tY = 0;
+ var tMat;
+ var tVec;
+ tX = input.p1.x - transform.position.x;
+ tY = input.p1.y - transform.position.y;
+ tMat = transform.R;
+ var p1X = (tX * tMat.col1.x + tY * tMat.col1.y);
+ var p1Y = (tX * tMat.col2.x + tY * tMat.col2.y);
+ tX = input.p2.x - transform.position.x;
+ tY = input.p2.y - transform.position.y;
+ tMat = transform.R;
+ var p2X = (tX * tMat.col1.x + tY * tMat.col1.y);
+ var p2Y = (tX * tMat.col2.x + tY * tMat.col2.y);
+ var dX = p2X - p1X;
+ var dY = p2Y - p1Y;
+ var index = parseInt((-1));
+ for (var i = 0; i < this.m_vertexCount; ++i) {
+ tVec = this.m_vertices[i];
+ tX = tVec.x - p1X;
+ tY = tVec.y - p1Y;
+ tVec = this.m_normals[i];
+ var numerator = (tVec.x * tX + tVec.y * tY);
+ var denominator = (tVec.x * dX + tVec.y * dY);
+ if (denominator == 0.0) {
+ if (numerator < 0.0) {
+ return false;
+ }
+ }
+ else {
+ if (denominator < 0.0 && numerator < lower * denominator) {
+ lower = numerator / denominator;
+ index = i;
+ }
+ else if (denominator > 0.0 && numerator < upper * denominator) {
+ upper = numerator / denominator;
+ }
+ }
+ if (upper < lower - Number.MIN_VALUE) {
+ return false;
+ }
+ }
+ if (index >= 0) {
+ output.fraction = lower;
+ tMat = transform.R;
+ tVec = this.m_normals[index];
+ output.normal.x = (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ output.normal.y = (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ return true;
+ }
+ return false;
+ }
+ b2PolygonShape.prototype.ComputeAABB = function (aabb, xf) {
+ var tMat = xf.R;
+ var tVec = this.m_vertices[0];
+ var lowerX = xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var lowerY = xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ var upperX = lowerX;
+ var upperY = lowerY;
+ for (var i = 1; i < this.m_vertexCount; ++i) {
+ tVec = this.m_vertices[i];
+ var vX = xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var vY = xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ lowerX = lowerX < vX ? lowerX : vX;
+ lowerY = lowerY < vY ? lowerY : vY;
+ upperX = upperX > vX ? upperX : vX;
+ upperY = upperY > vY ? upperY : vY;
+ }
+ aabb.lowerBound.x = lowerX - this.m_radius;
+ aabb.lowerBound.y = lowerY - this.m_radius;
+ aabb.upperBound.x = upperX + this.m_radius;
+ aabb.upperBound.y = upperY + this.m_radius;
+ }
+ b2PolygonShape.prototype.ComputeMass = function (massData, density) {
+ if (density === undefined) density = 0;
+ if (this.m_vertexCount == 2) {
+ massData.center.x = 0.5 * (this.m_vertices[0].x + this.m_vertices[1].x);
+ massData.center.y = 0.5 * (this.m_vertices[0].y + this.m_vertices[1].y);
+ massData.mass = 0.0;
+ massData.I = 0.0;
+ return;
+ }
+ var centerX = 0.0;
+ var centerY = 0.0;
+ var area = 0.0;
+ var I = 0.0;
+ var p1X = 0.0;
+ var p1Y = 0.0;
+ var k_inv3 = 1.0 / 3.0;
+ for (var i = 0; i < this.m_vertexCount; ++i) {
+ var p2 = this.m_vertices[i];
+ var p3 = i + 1 < this.m_vertexCount ? this.m_vertices[parseInt(i + 1)] : this.m_vertices[0];
+ var e1X = p2.x - p1X;
+ var e1Y = p2.y - p1Y;
+ var e2X = p3.x - p1X;
+ var e2Y = p3.y - p1Y;
+ var D = e1X * e2Y - e1Y * e2X;
+ var triangleArea = 0.5 * D;area += triangleArea;
+ centerX += triangleArea * k_inv3 * (p1X + p2.x + p3.x);
+ centerY += triangleArea * k_inv3 * (p1Y + p2.y + p3.y);
+ var px = p1X;
+ var py = p1Y;
+ var ex1 = e1X;
+ var ey1 = e1Y;
+ var ex2 = e2X;
+ var ey2 = e2Y;
+ var intx2 = k_inv3 * (0.25 * (ex1 * ex1 + ex2 * ex1 + ex2 * ex2) + (px * ex1 + px * ex2)) + 0.5 * px * px;
+ var inty2 = k_inv3 * (0.25 * (ey1 * ey1 + ey2 * ey1 + ey2 * ey2) + (py * ey1 + py * ey2)) + 0.5 * py * py;I += D * (intx2 + inty2);
+ }
+ massData.mass = density * area;
+ centerX *= 1.0 / area;
+ centerY *= 1.0 / area;
+ massData.center.Set(centerX, centerY);
+ massData.I = density * I;
+ }
+ b2PolygonShape.prototype.ComputeSubmergedArea = function (normal, offset, xf, c) {
+ if (offset === undefined) offset = 0;
+ var normalL = b2Math.MulTMV(xf.R, normal);
+ var offsetL = offset - b2Math.Dot(normal, xf.position);
+ var depths = new Vector_a2j_Number();
+ var diveCount = 0;
+ var intoIndex = parseInt((-1));
+ var outoIndex = parseInt((-1));
+ var lastSubmerged = false;
+ var i = 0;
+ for (i = 0;
+ i < this.m_vertexCount; ++i) {
+ depths[i] = b2Math.Dot(normalL, this.m_vertices[i]) - offsetL;
+ var isSubmerged = depths[i] < (-Number.MIN_VALUE);
+ if (i > 0) {
+ if (isSubmerged) {
+ if (!lastSubmerged) {
+ intoIndex = i - 1;
+ diveCount++;
+ }
+ }
+ else {
+ if (lastSubmerged) {
+ outoIndex = i - 1;
+ diveCount++;
+ }
+ }
+ }
+ lastSubmerged = isSubmerged;
+ }
+ switch (diveCount) {
+ case 0:
+ if (lastSubmerged) {
+ var md = new b2MassData();
+ this.ComputeMass(md, 1);
+ c.SetV(b2Math.MulX(xf, md.center));
+ return md.mass;
+ }
+ else {
+ return 0;
+ }
+ break;
+ case 1:
+ if (intoIndex == (-1)) {
+ intoIndex = this.m_vertexCount - 1;
+ }
+ else {
+ outoIndex = this.m_vertexCount - 1;
+ }
+ break;
+ }
+ var intoIndex2 = parseInt((intoIndex + 1) % this.m_vertexCount);
+ var outoIndex2 = parseInt((outoIndex + 1) % this.m_vertexCount);
+ var intoLamdda = (0 - depths[intoIndex]) / (depths[intoIndex2] - depths[intoIndex]);
+ var outoLamdda = (0 - depths[outoIndex]) / (depths[outoIndex2] - depths[outoIndex]);
+ var intoVec = new b2Vec2(this.m_vertices[intoIndex].x * (1 - intoLamdda) + this.m_vertices[intoIndex2].x * intoLamdda, this.m_vertices[intoIndex].y * (1 - intoLamdda) + this.m_vertices[intoIndex2].y * intoLamdda);
+ var outoVec = new b2Vec2(this.m_vertices[outoIndex].x * (1 - outoLamdda) + this.m_vertices[outoIndex2].x * outoLamdda, this.m_vertices[outoIndex].y * (1 - outoLamdda) + this.m_vertices[outoIndex2].y * outoLamdda);
+ var area = 0;
+ var center = new b2Vec2();
+ var p2 = this.m_vertices[intoIndex2];
+ var p3;
+ i = intoIndex2;
+ while (i != outoIndex2) {
+ i = (i + 1) % this.m_vertexCount;
+ if (i == outoIndex2) p3 = outoVec;
+ else p3 = this.m_vertices[i];
+ var triangleArea = 0.5 * ((p2.x - intoVec.x) * (p3.y - intoVec.y) - (p2.y - intoVec.y) * (p3.x - intoVec.x));
+ area += triangleArea;
+ center.x += triangleArea * (intoVec.x + p2.x + p3.x) / 3;
+ center.y += triangleArea * (intoVec.y + p2.y + p3.y) / 3;
+ p2 = p3;
+ }
+ center.Multiply(1 / area);
+ c.SetV(b2Math.MulX(xf, center));
+ return area;
+ }
+ b2PolygonShape.prototype.GetVertexCount = function () {
+ return this.m_vertexCount;
+ }
+ b2PolygonShape.prototype.GetVertices = function () {
+ return this.m_vertices;
+ }
+ b2PolygonShape.prototype.GetNormals = function () {
+ return this.m_normals;
+ }
+ b2PolygonShape.prototype.GetSupport = function (d) {
+ var bestIndex = 0;
+ var bestValue = this.m_vertices[0].x * d.x + this.m_vertices[0].y * d.y;
+ for (var i = 1; i < this.m_vertexCount; ++i) {
+ var value = this.m_vertices[i].x * d.x + this.m_vertices[i].y * d.y;
+ if (value > bestValue) {
+ bestIndex = i;
+ bestValue = value;
+ }
+ }
+ return bestIndex;
+ }
+ b2PolygonShape.prototype.GetSupportVertex = function (d) {
+ var bestIndex = 0;
+ var bestValue = this.m_vertices[0].x * d.x + this.m_vertices[0].y * d.y;
+ for (var i = 1; i < this.m_vertexCount; ++i) {
+ var value = this.m_vertices[i].x * d.x + this.m_vertices[i].y * d.y;
+ if (value > bestValue) {
+ bestIndex = i;
+ bestValue = value;
+ }
+ }
+ return this.m_vertices[bestIndex];
+ }
+ b2PolygonShape.prototype.Validate = function () {
+ return false;
+ }
+ b2PolygonShape.prototype.b2PolygonShape = function () {
+ this.__super.b2Shape.call(this);
+ this.m_type = b2Shape.e_polygonShape;
+ this.m_centroid = new b2Vec2();
+ this.m_vertices = new Vector();
+ this.m_normals = new Vector();
+ }
+ b2PolygonShape.prototype.Reserve = function (count) {
+ if (count === undefined) count = 0;
+ for (var i = parseInt(this.m_vertices.length); i < count; i++) {
+ this.m_vertices[i] = new b2Vec2();
+ this.m_normals[i] = new b2Vec2();
+ }
+ }
+ b2PolygonShape.ComputeCentroid = function (vs, count) {
+ if (count === undefined) count = 0;
+ var c = new b2Vec2();
+ var area = 0.0;
+ var p1X = 0.0;
+ var p1Y = 0.0;
+ var inv3 = 1.0 / 3.0;
+ for (var i = 0; i < count; ++i) {
+ var p2 = vs[i];
+ var p3 = i + 1 < count ? vs[parseInt(i + 1)] : vs[0];
+ var e1X = p2.x - p1X;
+ var e1Y = p2.y - p1Y;
+ var e2X = p3.x - p1X;
+ var e2Y = p3.y - p1Y;
+ var D = (e1X * e2Y - e1Y * e2X);
+ var triangleArea = 0.5 * D;area += triangleArea;
+ c.x += triangleArea * inv3 * (p1X + p2.x + p3.x);
+ c.y += triangleArea * inv3 * (p1Y + p2.y + p3.y);
+ }
+ c.x *= 1.0 / area;
+ c.y *= 1.0 / area;
+ return c;
+ }
+ b2PolygonShape.ComputeOBB = function (obb, vs, count) {
+ if (count === undefined) count = 0;
+ var i = 0;
+ var p = new Vector(count + 1);
+ for (i = 0;
+ i < count; ++i) {
+ p[i] = vs[i];
+ }
+ p[count] = p[0];
+ var minArea = Number.MAX_VALUE;
+ for (i = 1;
+ i <= count; ++i) {
+ var root = p[parseInt(i - 1)];
+ var uxX = p[i].x - root.x;
+ var uxY = p[i].y - root.y;
+ var length = Math.sqrt(uxX * uxX + uxY * uxY);
+ uxX /= length;
+ uxY /= length;
+ var uyX = (-uxY);
+ var uyY = uxX;
+ var lowerX = Number.MAX_VALUE;
+ var lowerY = Number.MAX_VALUE;
+ var upperX = (-Number.MAX_VALUE);
+ var upperY = (-Number.MAX_VALUE);
+ for (var j = 0; j < count; ++j) {
+ var dX = p[j].x - root.x;
+ var dY = p[j].y - root.y;
+ var rX = (uxX * dX + uxY * dY);
+ var rY = (uyX * dX + uyY * dY);
+ if (rX < lowerX) lowerX = rX;
+ if (rY < lowerY) lowerY = rY;
+ if (rX > upperX) upperX = rX;
+ if (rY > upperY) upperY = rY;
+ }
+ var area = (upperX - lowerX) * (upperY - lowerY);
+ if (area < 0.95 * minArea) {
+ minArea = area;
+ obb.R.col1.x = uxX;
+ obb.R.col1.y = uxY;
+ obb.R.col2.x = uyX;
+ obb.R.col2.y = uyY;
+ var centerX = 0.5 * (lowerX + upperX);
+ var centerY = 0.5 * (lowerY + upperY);
+ var tMat = obb.R;
+ obb.center.x = root.x + (tMat.col1.x * centerX + tMat.col2.x * centerY);
+ obb.center.y = root.y + (tMat.col1.y * centerX + tMat.col2.y * centerY);
+ obb.extents.x = 0.5 * (upperX - lowerX);
+ obb.extents.y = 0.5 * (upperY - lowerY);
+ }
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.Shapes.b2PolygonShape.s_mat = new b2Mat22();
+ });
+ b2Shape.b2Shape = function () {};
+ b2Shape.prototype.Copy = function () {
+ return null;
+ }
+ b2Shape.prototype.Set = function (other) {
+ this.m_radius = other.m_radius;
+ }
+ b2Shape.prototype.GetType = function () {
+ return this.m_type;
+ }
+ b2Shape.prototype.TestPoint = function (xf, p) {
+ return false;
+ }
+ b2Shape.prototype.RayCast = function (output, input, transform) {
+ return false;
+ }
+ b2Shape.prototype.ComputeAABB = function (aabb, xf) {}
+ b2Shape.prototype.ComputeMass = function (massData, density) {
+ if (density === undefined) density = 0;
+ }
+ b2Shape.prototype.ComputeSubmergedArea = function (normal, offset, xf, c) {
+ if (offset === undefined) offset = 0;
+ return 0;
+ }
+ b2Shape.TestOverlap = function (shape1, transform1, shape2, transform2) {
+ var input = new b2DistanceInput();
+ input.proxyA = new b2DistanceProxy();
+ input.proxyA.Set(shape1);
+ input.proxyB = new b2DistanceProxy();
+ input.proxyB.Set(shape2);
+ input.transformA = transform1;
+ input.transformB = transform2;
+ input.useRadii = true;
+ var simplexCache = new b2SimplexCache();
+ simplexCache.count = 0;
+ var output = new b2DistanceOutput();
+ b2Distance.Distance(output, simplexCache, input);
+ return output.distance < 10.0 * Number.MIN_VALUE;
+ }
+ b2Shape.prototype.b2Shape = function () {
+ this.m_type = b2Shape.e_unknownShape;
+ this.m_radius = b2Settings.b2_linearSlop;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Collision.Shapes.b2Shape.e_unknownShape = parseInt((-1));
+ Box2D.Collision.Shapes.b2Shape.e_circleShape = 0;
+ Box2D.Collision.Shapes.b2Shape.e_polygonShape = 1;
+ Box2D.Collision.Shapes.b2Shape.e_edgeShape = 2;
+ Box2D.Collision.Shapes.b2Shape.e_shapeTypeCount = 3;
+ Box2D.Collision.Shapes.b2Shape.e_hitCollide = 1;
+ Box2D.Collision.Shapes.b2Shape.e_missCollide = 0;
+ Box2D.Collision.Shapes.b2Shape.e_startsInsideCollide = parseInt((-1));
+ });
+})();
+(function () {
+ var b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3;
+
+ b2Color.b2Color = function () {
+ this._r = 0;
+ this._g = 0;
+ this._b = 0;
+ };
+ b2Color.prototype.b2Color = function (rr, gg, bb) {
+ if (rr === undefined) rr = 0;
+ if (gg === undefined) gg = 0;
+ if (bb === undefined) bb = 0;
+ this._r = Box2D.parseUInt(255 * b2Math.Clamp(rr, 0.0, 1.0));
+ this._g = Box2D.parseUInt(255 * b2Math.Clamp(gg, 0.0, 1.0));
+ this._b = Box2D.parseUInt(255 * b2Math.Clamp(bb, 0.0, 1.0));
+ }
+ b2Color.prototype.Set = function (rr, gg, bb) {
+ if (rr === undefined) rr = 0;
+ if (gg === undefined) gg = 0;
+ if (bb === undefined) bb = 0;
+ this._r = Box2D.parseUInt(255 * b2Math.Clamp(rr, 0.0, 1.0));
+ this._g = Box2D.parseUInt(255 * b2Math.Clamp(gg, 0.0, 1.0));
+ this._b = Box2D.parseUInt(255 * b2Math.Clamp(bb, 0.0, 1.0));
+ }
+ Object.defineProperty(b2Color.prototype, 'r', {
+ enumerable: false,
+ configurable: true,
+ set: function (rr) {
+ if (rr === undefined) rr = 0;
+ this._r = Box2D.parseUInt(255 * b2Math.Clamp(rr, 0.0, 1.0));
+ }
+ });
+ Object.defineProperty(b2Color.prototype, 'g', {
+ enumerable: false,
+ configurable: true,
+ set: function (gg) {
+ if (gg === undefined) gg = 0;
+ this._g = Box2D.parseUInt(255 * b2Math.Clamp(gg, 0.0, 1.0));
+ }
+ });
+ Object.defineProperty(b2Color.prototype, 'b', {
+ enumerable: false,
+ configurable: true,
+ set: function (bb) {
+ if (bb === undefined) bb = 0;
+ this._b = Box2D.parseUInt(255 * b2Math.Clamp(bb, 0.0, 1.0));
+ }
+ });
+ Object.defineProperty(b2Color.prototype, 'color', {
+ enumerable: false,
+ configurable: true,
+ get: function () {
+ return (this._r << 16) | (this._g << 8) | (this._b);
+ }
+ });
+ b2Settings.b2Settings = function () {};
+ b2Settings.b2MixFriction = function (friction1, friction2) {
+ if (friction1 === undefined) friction1 = 0;
+ if (friction2 === undefined) friction2 = 0;
+ return Math.sqrt(friction1 * friction2);
+ }
+ b2Settings.b2MixRestitution = function (restitution1, restitution2) {
+ if (restitution1 === undefined) restitution1 = 0;
+ if (restitution2 === undefined) restitution2 = 0;
+ return restitution1 > restitution2 ? restitution1 : restitution2;
+ }
+ b2Settings.b2Assert = function (a) {
+ if (!a) {
+ throw "Assertion Failed";
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Common.b2Settings.VERSION = "2.1alpha";
+ Box2D.Common.b2Settings.USHRT_MAX = 0x0000ffff;
+ Box2D.Common.b2Settings.b2_pi = Math.PI;
+ Box2D.Common.b2Settings.b2_maxManifoldPoints = 2;
+ Box2D.Common.b2Settings.b2_aabbExtension = 0.1;
+ Box2D.Common.b2Settings.b2_aabbMultiplier = 2.0;
+ Box2D.Common.b2Settings.b2_polygonRadius = 2.0 * b2Settings.b2_linearSlop;
+ Box2D.Common.b2Settings.b2_linearSlop = 0.005;
+ Box2D.Common.b2Settings.b2_angularSlop = 2.0 / 180.0 * b2Settings.b2_pi;
+ Box2D.Common.b2Settings.b2_toiSlop = 8.0 * b2Settings.b2_linearSlop;
+ Box2D.Common.b2Settings.b2_maxTOIContactsPerIsland = 32;
+ Box2D.Common.b2Settings.b2_maxTOIJointsPerIsland = 32;
+ Box2D.Common.b2Settings.b2_velocityThreshold = 1.0;
+ Box2D.Common.b2Settings.b2_maxLinearCorrection = 0.2;
+ Box2D.Common.b2Settings.b2_maxAngularCorrection = 8.0 / 180.0 * b2Settings.b2_pi;
+ Box2D.Common.b2Settings.b2_maxTranslation = 2.0;
+ Box2D.Common.b2Settings.b2_maxTranslationSquared = b2Settings.b2_maxTranslation * b2Settings.b2_maxTranslation;
+ Box2D.Common.b2Settings.b2_maxRotation = 0.5 * b2Settings.b2_pi;
+ Box2D.Common.b2Settings.b2_maxRotationSquared = b2Settings.b2_maxRotation * b2Settings.b2_maxRotation;
+ Box2D.Common.b2Settings.b2_contactBaumgarte = 0.2;
+ Box2D.Common.b2Settings.b2_timeToSleep = 0.5;
+ Box2D.Common.b2Settings.b2_linearSleepTolerance = 0.01;
+ Box2D.Common.b2Settings.b2_angularSleepTolerance = 2.0 / 180.0 * b2Settings.b2_pi;
+ });
+})();
+(function () {
+ var b2AABB = Box2D.Collision.b2AABB,
+ b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3;
+
+ b2Mat22.b2Mat22 = function () {
+ this.col1 = new b2Vec2();
+ this.col2 = new b2Vec2();
+ };
+ b2Mat22.prototype.b2Mat22 = function () {
+ this.SetIdentity();
+ }
+ b2Mat22.FromAngle = function (angle) {
+ if (angle === undefined) angle = 0;
+ var mat = new b2Mat22();
+ mat.Set(angle);
+ return mat;
+ }
+ b2Mat22.FromVV = function (c1, c2) {
+ var mat = new b2Mat22();
+ mat.SetVV(c1, c2);
+ return mat;
+ }
+ b2Mat22.prototype.Set = function (angle) {
+ if (angle === undefined) angle = 0;
+ var c = Math.cos(angle);
+ var s = Math.sin(angle);
+ this.col1.x = c;
+ this.col2.x = (-s);
+ this.col1.y = s;
+ this.col2.y = c;
+ }
+ b2Mat22.prototype.SetVV = function (c1, c2) {
+ this.col1.SetV(c1);
+ this.col2.SetV(c2);
+ }
+ b2Mat22.prototype.Copy = function () {
+ var mat = new b2Mat22();
+ mat.SetM(this);
+ return mat;
+ }
+ b2Mat22.prototype.SetM = function (m) {
+ this.col1.SetV(m.col1);
+ this.col2.SetV(m.col2);
+ }
+ b2Mat22.prototype.AddM = function (m) {
+ this.col1.x += m.col1.x;
+ this.col1.y += m.col1.y;
+ this.col2.x += m.col2.x;
+ this.col2.y += m.col2.y;
+ }
+ b2Mat22.prototype.SetIdentity = function () {
+ this.col1.x = 1.0;
+ this.col2.x = 0.0;
+ this.col1.y = 0.0;
+ this.col2.y = 1.0;
+ }
+ b2Mat22.prototype.SetZero = function () {
+ this.col1.x = 0.0;
+ this.col2.x = 0.0;
+ this.col1.y = 0.0;
+ this.col2.y = 0.0;
+ }
+ b2Mat22.prototype.GetAngle = function () {
+ return Math.atan2(this.col1.y, this.col1.x);
+ }
+ b2Mat22.prototype.GetInverse = function (out) {
+ var a = this.col1.x;
+ var b = this.col2.x;
+ var c = this.col1.y;
+ var d = this.col2.y;
+ var det = a * d - b * c;
+ if (det != 0.0) {
+ det = 1.0 / det;
+ }
+ out.col1.x = det * d;
+ out.col2.x = (-det * b);
+ out.col1.y = (-det * c);
+ out.col2.y = det * a;
+ return out;
+ }
+ b2Mat22.prototype.Solve = function (out, bX, bY) {
+ if (bX === undefined) bX = 0;
+ if (bY === undefined) bY = 0;
+ var a11 = this.col1.x;
+ var a12 = this.col2.x;
+ var a21 = this.col1.y;
+ var a22 = this.col2.y;
+ var det = a11 * a22 - a12 * a21;
+ if (det != 0.0) {
+ det = 1.0 / det;
+ }
+ out.x = det * (a22 * bX - a12 * bY);
+ out.y = det * (a11 * bY - a21 * bX);
+ return out;
+ }
+ b2Mat22.prototype.Abs = function () {
+ this.col1.Abs();
+ this.col2.Abs();
+ }
+ b2Mat33.b2Mat33 = function () {
+ this.col1 = new b2Vec3();
+ this.col2 = new b2Vec3();
+ this.col3 = new b2Vec3();
+ };
+ b2Mat33.prototype.b2Mat33 = function (c1, c2, c3) {
+ if (c1 === undefined) c1 = null;
+ if (c2 === undefined) c2 = null;
+ if (c3 === undefined) c3 = null;
+ if (!c1 && !c2 && !c3) {
+ this.col1.SetZero();
+ this.col2.SetZero();
+ this.col3.SetZero();
+ }
+ else {
+ this.col1.SetV(c1);
+ this.col2.SetV(c2);
+ this.col3.SetV(c3);
+ }
+ }
+ b2Mat33.prototype.SetVVV = function (c1, c2, c3) {
+ this.col1.SetV(c1);
+ this.col2.SetV(c2);
+ this.col3.SetV(c3);
+ }
+ b2Mat33.prototype.Copy = function () {
+ return new b2Mat33(this.col1, this.col2, this.col3);
+ }
+ b2Mat33.prototype.SetM = function (m) {
+ this.col1.SetV(m.col1);
+ this.col2.SetV(m.col2);
+ this.col3.SetV(m.col3);
+ }
+ b2Mat33.prototype.AddM = function (m) {
+ this.col1.x += m.col1.x;
+ this.col1.y += m.col1.y;
+ this.col1.z += m.col1.z;
+ this.col2.x += m.col2.x;
+ this.col2.y += m.col2.y;
+ this.col2.z += m.col2.z;
+ this.col3.x += m.col3.x;
+ this.col3.y += m.col3.y;
+ this.col3.z += m.col3.z;
+ }
+ b2Mat33.prototype.SetIdentity = function () {
+ this.col1.x = 1.0;
+ this.col2.x = 0.0;
+ this.col3.x = 0.0;
+ this.col1.y = 0.0;
+ this.col2.y = 1.0;
+ this.col3.y = 0.0;
+ this.col1.z = 0.0;
+ this.col2.z = 0.0;
+ this.col3.z = 1.0;
+ }
+ b2Mat33.prototype.SetZero = function () {
+ this.col1.x = 0.0;
+ this.col2.x = 0.0;
+ this.col3.x = 0.0;
+ this.col1.y = 0.0;
+ this.col2.y = 0.0;
+ this.col3.y = 0.0;
+ this.col1.z = 0.0;
+ this.col2.z = 0.0;
+ this.col3.z = 0.0;
+ }
+ b2Mat33.prototype.Solve22 = function (out, bX, bY) {
+ if (bX === undefined) bX = 0;
+ if (bY === undefined) bY = 0;
+ var a11 = this.col1.x;
+ var a12 = this.col2.x;
+ var a21 = this.col1.y;
+ var a22 = this.col2.y;
+ var det = a11 * a22 - a12 * a21;
+ if (det != 0.0) {
+ det = 1.0 / det;
+ }
+ out.x = det * (a22 * bX - a12 * bY);
+ out.y = det * (a11 * bY - a21 * bX);
+ return out;
+ }
+ b2Mat33.prototype.Solve33 = function (out, bX, bY, bZ) {
+ if (bX === undefined) bX = 0;
+ if (bY === undefined) bY = 0;
+ if (bZ === undefined) bZ = 0;
+ var a11 = this.col1.x;
+ var a21 = this.col1.y;
+ var a31 = this.col1.z;
+ var a12 = this.col2.x;
+ var a22 = this.col2.y;
+ var a32 = this.col2.z;
+ var a13 = this.col3.x;
+ var a23 = this.col3.y;
+ var a33 = this.col3.z;
+ var det = a11 * (a22 * a33 - a32 * a23) + a21 * (a32 * a13 - a12 * a33) + a31 * (a12 * a23 - a22 * a13);
+ if (det != 0.0) {
+ det = 1.0 / det;
+ }
+ out.x = det * (bX * (a22 * a33 - a32 * a23) + bY * (a32 * a13 - a12 * a33) + bZ * (a12 * a23 - a22 * a13));
+ out.y = det * (a11 * (bY * a33 - bZ * a23) + a21 * (bZ * a13 - bX * a33) + a31 * (bX * a23 - bY * a13));
+ out.z = det * (a11 * (a22 * bZ - a32 * bY) + a21 * (a32 * bX - a12 * bZ) + a31 * (a12 * bY - a22 * bX));
+ return out;
+ }
+ b2Math.b2Math = function () {};
+ b2Math.IsValid = function (x) {
+ if (x === undefined) x = 0;
+ return isFinite(x);
+ }
+ b2Math.Dot = function (a, b) {
+ return a.x * b.x + a.y * b.y;
+ }
+ b2Math.CrossVV = function (a, b) {
+ return a.x * b.y - a.y * b.x;
+ }
+ b2Math.CrossVF = function (a, s) {
+ if (s === undefined) s = 0;
+ var v = new b2Vec2(s * a.y, (-s * a.x));
+ return v;
+ }
+ b2Math.CrossFV = function (s, a) {
+ if (s === undefined) s = 0;
+ var v = new b2Vec2((-s * a.y), s * a.x);
+ return v;
+ }
+ b2Math.MulMV = function (A, v) {
+ var u = new b2Vec2(A.col1.x * v.x + A.col2.x * v.y, A.col1.y * v.x + A.col2.y * v.y);
+ return u;
+ }
+ b2Math.MulTMV = function (A, v) {
+ var u = new b2Vec2(b2Math.Dot(v, A.col1), b2Math.Dot(v, A.col2));
+ return u;
+ }
+ b2Math.MulX = function (T, v) {
+ var a = b2Math.MulMV(T.R, v);
+ a.x += T.position.x;
+ a.y += T.position.y;
+ return a;
+ }
+ b2Math.MulXT = function (T, v) {
+ var a = b2Math.SubtractVV(v, T.position);
+ var tX = (a.x * T.R.col1.x + a.y * T.R.col1.y);
+ a.y = (a.x * T.R.col2.x + a.y * T.R.col2.y);
+ a.x = tX;
+ return a;
+ }
+ b2Math.AddVV = function (a, b) {
+ var v = new b2Vec2(a.x + b.x, a.y + b.y);
+ return v;
+ }
+ b2Math.SubtractVV = function (a, b) {
+ var v = new b2Vec2(a.x - b.x, a.y - b.y);
+ return v;
+ }
+ b2Math.Distance = function (a, b) {
+ var cX = a.x - b.x;
+ var cY = a.y - b.y;
+ return Math.sqrt(cX * cX + cY * cY);
+ }
+ b2Math.DistanceSquared = function (a, b) {
+ var cX = a.x - b.x;
+ var cY = a.y - b.y;
+ return (cX * cX + cY * cY);
+ }
+ b2Math.MulFV = function (s, a) {
+ if (s === undefined) s = 0;
+ var v = new b2Vec2(s * a.x, s * a.y);
+ return v;
+ }
+ b2Math.AddMM = function (A, B) {
+ var C = b2Mat22.FromVV(b2Math.AddVV(A.col1, B.col1), b2Math.AddVV(A.col2, B.col2));
+ return C;
+ }
+ b2Math.MulMM = function (A, B) {
+ var C = b2Mat22.FromVV(b2Math.MulMV(A, B.col1), b2Math.MulMV(A, B.col2));
+ return C;
+ }
+ b2Math.MulTMM = function (A, B) {
+ var c1 = new b2Vec2(b2Math.Dot(A.col1, B.col1), b2Math.Dot(A.col2, B.col1));
+ var c2 = new b2Vec2(b2Math.Dot(A.col1, B.col2), b2Math.Dot(A.col2, B.col2));
+ var C = b2Mat22.FromVV(c1, c2);
+ return C;
+ }
+ b2Math.Abs = function (a) {
+ if (a === undefined) a = 0;
+ return a > 0.0 ? a : (-a);
+ }
+ b2Math.AbsV = function (a) {
+ var b = new b2Vec2(b2Math.Abs(a.x), b2Math.Abs(a.y));
+ return b;
+ }
+ b2Math.AbsM = function (A) {
+ var B = b2Mat22.FromVV(b2Math.AbsV(A.col1), b2Math.AbsV(A.col2));
+ return B;
+ }
+ b2Math.Min = function (a, b) {
+ if (a === undefined) a = 0;
+ if (b === undefined) b = 0;
+ return a < b ? a : b;
+ }
+ b2Math.MinV = function (a, b) {
+ var c = new b2Vec2(b2Math.Min(a.x, b.x), b2Math.Min(a.y, b.y));
+ return c;
+ }
+ b2Math.Max = function (a, b) {
+ if (a === undefined) a = 0;
+ if (b === undefined) b = 0;
+ return a > b ? a : b;
+ }
+ b2Math.MaxV = function (a, b) {
+ var c = new b2Vec2(b2Math.Max(a.x, b.x), b2Math.Max(a.y, b.y));
+ return c;
+ }
+ b2Math.Clamp = function (a, low, high) {
+ if (a === undefined) a = 0;
+ if (low === undefined) low = 0;
+ if (high === undefined) high = 0;
+ return a < low ? low : a > high ? high : a;
+ }
+ b2Math.ClampV = function (a, low, high) {
+ return b2Math.MaxV(low, b2Math.MinV(a, high));
+ }
+ b2Math.Swap = function (a, b) {
+ var tmp = a[0];
+ a[0] = b[0];
+ b[0] = tmp;
+ }
+ b2Math.Random = function () {
+ return Math.random() * 2 - 1;
+ }
+ b2Math.RandomRange = function (lo, hi) {
+ if (lo === undefined) lo = 0;
+ if (hi === undefined) hi = 0;
+ var r = Math.random();
+ r = (hi - lo) * r + lo;
+ return r;
+ }
+ b2Math.NextPowerOfTwo = function (x) {
+ if (x === undefined) x = 0;
+ x |= (x >> 1) & 0x7FFFFFFF;
+ x |= (x >> 2) & 0x3FFFFFFF;
+ x |= (x >> 4) & 0x0FFFFFFF;
+ x |= (x >> 8) & 0x00FFFFFF;
+ x |= (x >> 16) & 0x0000FFFF;
+ return x + 1;
+ }
+ b2Math.IsPowerOfTwo = function (x) {
+ if (x === undefined) x = 0;
+ var result = x > 0 && (x & (x - 1)) == 0;
+ return result;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Common.Math.b2Math.b2Vec2_zero = new b2Vec2(0.0, 0.0);
+ Box2D.Common.Math.b2Math.b2Mat22_identity = b2Mat22.FromVV(new b2Vec2(1.0, 0.0), new b2Vec2(0.0, 1.0));
+ Box2D.Common.Math.b2Math.b2Transform_identity = new b2Transform(b2Math.b2Vec2_zero, b2Math.b2Mat22_identity);
+ });
+ b2Sweep.b2Sweep = function () {
+ this.localCenter = new b2Vec2();
+ this.c0 = new b2Vec2;
+ this.c = new b2Vec2();
+ };
+ b2Sweep.prototype.Set = function (other) {
+ this.localCenter.SetV(other.localCenter);
+ this.c0.SetV(other.c0);
+ this.c.SetV(other.c);
+ this.a0 = other.a0;
+ this.a = other.a;
+ this.t0 = other.t0;
+ }
+ b2Sweep.prototype.Copy = function () {
+ var copy = new b2Sweep();
+ copy.localCenter.SetV(this.localCenter);
+ copy.c0.SetV(this.c0);
+ copy.c.SetV(this.c);
+ copy.a0 = this.a0;
+ copy.a = this.a;
+ copy.t0 = this.t0;
+ return copy;
+ }
+ b2Sweep.prototype.GetTransform = function (xf, alpha) {
+ if (alpha === undefined) alpha = 0;
+ xf.position.x = (1.0 - alpha) * this.c0.x + alpha * this.c.x;
+ xf.position.y = (1.0 - alpha) * this.c0.y + alpha * this.c.y;
+ var angle = (1.0 - alpha) * this.a0 + alpha * this.a;
+ xf.R.Set(angle);
+ var tMat = xf.R;
+ xf.position.x -= (tMat.col1.x * this.localCenter.x + tMat.col2.x * this.localCenter.y);
+ xf.position.y -= (tMat.col1.y * this.localCenter.x + tMat.col2.y * this.localCenter.y);
+ }
+ b2Sweep.prototype.Advance = function (t) {
+ if (t === undefined) t = 0;
+ if (this.t0 < t && 1.0 - this.t0 > Number.MIN_VALUE) {
+ var alpha = (t - this.t0) / (1.0 - this.t0);
+ this.c0.x = (1.0 - alpha) * this.c0.x + alpha * this.c.x;
+ this.c0.y = (1.0 - alpha) * this.c0.y + alpha * this.c.y;
+ this.a0 = (1.0 - alpha) * this.a0 + alpha * this.a;
+ this.t0 = t;
+ }
+ }
+ b2Transform.b2Transform = function () {
+ this.position = new b2Vec2;
+ this.R = new b2Mat22();
+ };
+ b2Transform.prototype.b2Transform = function (pos, r) {
+ if (pos === undefined) pos = null;
+ if (r === undefined) r = null;
+ if (pos) {
+ this.position.SetV(pos);
+ this.R.SetM(r);
+ }
+ }
+ b2Transform.prototype.Initialize = function (pos, r) {
+ this.position.SetV(pos);
+ this.R.SetM(r);
+ }
+ b2Transform.prototype.SetIdentity = function () {
+ this.position.SetZero();
+ this.R.SetIdentity();
+ }
+ b2Transform.prototype.Set = function (x) {
+ this.position.SetV(x.position);
+ this.R.SetM(x.R);
+ }
+ b2Transform.prototype.GetAngle = function () {
+ return Math.atan2(this.R.col1.y, this.R.col1.x);
+ }
+ b2Vec2.b2Vec2 = function () {};
+ b2Vec2.prototype.b2Vec2 = function (x_, y_) {
+ if (x_ === undefined) x_ = 0;
+ if (y_ === undefined) y_ = 0;
+ this.x = x_;
+ this.y = y_;
+ }
+ b2Vec2.prototype.SetZero = function () {
+ this.x = 0.0;
+ this.y = 0.0;
+ }
+ b2Vec2.prototype.Set = function (x_, y_) {
+ if (x_ === undefined) x_ = 0;
+ if (y_ === undefined) y_ = 0;
+ this.x = x_;
+ this.y = y_;
+ }
+ b2Vec2.prototype.SetV = function (v) {
+ this.x = v.x;
+ this.y = v.y;
+ }
+ b2Vec2.prototype.GetNegative = function () {
+ return new b2Vec2((-this.x), (-this.y));
+ }
+ b2Vec2.prototype.NegativeSelf = function () {
+ this.x = (-this.x);
+ this.y = (-this.y);
+ }
+ b2Vec2.Make = function (x_, y_) {
+ if (x_ === undefined) x_ = 0;
+ if (y_ === undefined) y_ = 0;
+ return new b2Vec2(x_, y_);
+ }
+ b2Vec2.prototype.Copy = function () {
+ return new b2Vec2(this.x, this.y);
+ }
+ b2Vec2.prototype.Add = function (v) {
+ this.x += v.x;
+ this.y += v.y;
+ }
+ b2Vec2.prototype.Subtract = function (v) {
+ this.x -= v.x;
+ this.y -= v.y;
+ }
+ b2Vec2.prototype.Multiply = function (a) {
+ if (a === undefined) a = 0;
+ this.x *= a;
+ this.y *= a;
+ }
+ b2Vec2.prototype.MulM = function (A) {
+ var tX = this.x;
+ this.x = A.col1.x * tX + A.col2.x * this.y;
+ this.y = A.col1.y * tX + A.col2.y * this.y;
+ }
+ b2Vec2.prototype.MulTM = function (A) {
+ var tX = b2Math.Dot(this, A.col1);
+ this.y = b2Math.Dot(this, A.col2);
+ this.x = tX;
+ }
+ b2Vec2.prototype.CrossVF = function (s) {
+ if (s === undefined) s = 0;
+ var tX = this.x;
+ this.x = s * this.y;
+ this.y = (-s * tX);
+ }
+ b2Vec2.prototype.CrossFV = function (s) {
+ if (s === undefined) s = 0;
+ var tX = this.x;
+ this.x = (-s * this.y);
+ this.y = s * tX;
+ }
+ b2Vec2.prototype.MinV = function (b) {
+ this.x = this.x < b.x ? this.x : b.x;
+ this.y = this.y < b.y ? this.y : b.y;
+ }
+ b2Vec2.prototype.MaxV = function (b) {
+ this.x = this.x > b.x ? this.x : b.x;
+ this.y = this.y > b.y ? this.y : b.y;
+ }
+ b2Vec2.prototype.Abs = function () {
+ if (this.x < 0) this.x = (-this.x);
+ if (this.y < 0) this.y = (-this.y);
+ }
+ b2Vec2.prototype.Length = function () {
+ return Math.sqrt(this.x * this.x + this.y * this.y);
+ }
+ b2Vec2.prototype.LengthSquared = function () {
+ return (this.x * this.x + this.y * this.y);
+ }
+ b2Vec2.prototype.Normalize = function () {
+ var length = Math.sqrt(this.x * this.x + this.y * this.y);
+ if (length < Number.MIN_VALUE) {
+ return 0.0;
+ }
+ var invLength = 1.0 / length;
+ this.x *= invLength;
+ this.y *= invLength;
+ return length;
+ }
+ b2Vec2.prototype.IsValid = function () {
+ return b2Math.IsValid(this.x) && b2Math.IsValid(this.y);
+ }
+ b2Vec3.b2Vec3 = function () {};
+ b2Vec3.prototype.b2Vec3 = function (x, y, z) {
+ if (x === undefined) x = 0;
+ if (y === undefined) y = 0;
+ if (z === undefined) z = 0;
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+ b2Vec3.prototype.SetZero = function () {
+ this.x = this.y = this.z = 0.0;
+ }
+ b2Vec3.prototype.Set = function (x, y, z) {
+ if (x === undefined) x = 0;
+ if (y === undefined) y = 0;
+ if (z === undefined) z = 0;
+ this.x = x;
+ this.y = y;
+ this.z = z;
+ }
+ b2Vec3.prototype.SetV = function (v) {
+ this.x = v.x;
+ this.y = v.y;
+ this.z = v.z;
+ }
+ b2Vec3.prototype.GetNegative = function () {
+ return new b2Vec3((-this.x), (-this.y), (-this.z));
+ }
+ b2Vec3.prototype.NegativeSelf = function () {
+ this.x = (-this.x);
+ this.y = (-this.y);
+ this.z = (-this.z);
+ }
+ b2Vec3.prototype.Copy = function () {
+ return new b2Vec3(this.x, this.y, this.z);
+ }
+ b2Vec3.prototype.Add = function (v) {
+ this.x += v.x;
+ this.y += v.y;
+ this.z += v.z;
+ }
+ b2Vec3.prototype.Subtract = function (v) {
+ this.x -= v.x;
+ this.y -= v.y;
+ this.z -= v.z;
+ }
+ b2Vec3.prototype.Multiply = function (a) {
+ if (a === undefined) a = 0;
+ this.x *= a;
+ this.y *= a;
+ this.z *= a;
+ }
+})();
+(function () {
+ var b2ControllerEdge = Box2D.Dynamics.Controllers.b2ControllerEdge,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3,
+ b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2AABB = Box2D.Collision.b2AABB,
+ b2Bound = Box2D.Collision.b2Bound,
+ b2BoundValues = Box2D.Collision.b2BoundValues,
+ b2Collision = Box2D.Collision.b2Collision,
+ b2ContactID = Box2D.Collision.b2ContactID,
+ b2ContactPoint = Box2D.Collision.b2ContactPoint,
+ b2Distance = Box2D.Collision.b2Distance,
+ b2DistanceInput = Box2D.Collision.b2DistanceInput,
+ b2DistanceOutput = Box2D.Collision.b2DistanceOutput,
+ b2DistanceProxy = Box2D.Collision.b2DistanceProxy,
+ b2DynamicTree = Box2D.Collision.b2DynamicTree,
+ b2DynamicTreeBroadPhase = Box2D.Collision.b2DynamicTreeBroadPhase,
+ b2DynamicTreeNode = Box2D.Collision.b2DynamicTreeNode,
+ b2DynamicTreePair = Box2D.Collision.b2DynamicTreePair,
+ b2Manifold = Box2D.Collision.b2Manifold,
+ b2ManifoldPoint = Box2D.Collision.b2ManifoldPoint,
+ b2Point = Box2D.Collision.b2Point,
+ b2RayCastInput = Box2D.Collision.b2RayCastInput,
+ b2RayCastOutput = Box2D.Collision.b2RayCastOutput,
+ b2Segment = Box2D.Collision.b2Segment,
+ b2SeparationFunction = Box2D.Collision.b2SeparationFunction,
+ b2Simplex = Box2D.Collision.b2Simplex,
+ b2SimplexCache = Box2D.Collision.b2SimplexCache,
+ b2SimplexVertex = Box2D.Collision.b2SimplexVertex,
+ b2TimeOfImpact = Box2D.Collision.b2TimeOfImpact,
+ b2TOIInput = Box2D.Collision.b2TOIInput,
+ b2WorldManifold = Box2D.Collision.b2WorldManifold,
+ ClipVertex = Box2D.Collision.ClipVertex,
+ Features = Box2D.Collision.Features,
+ IBroadPhase = Box2D.Collision.IBroadPhase,
+ b2CircleShape = Box2D.Collision.Shapes.b2CircleShape,
+ b2EdgeChainDef = Box2D.Collision.Shapes.b2EdgeChainDef,
+ b2EdgeShape = Box2D.Collision.Shapes.b2EdgeShape,
+ b2MassData = Box2D.Collision.Shapes.b2MassData,
+ b2PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
+ b2Shape = Box2D.Collision.Shapes.b2Shape,
+ b2Body = Box2D.Dynamics.b2Body,
+ b2BodyDef = Box2D.Dynamics.b2BodyDef,
+ b2ContactFilter = Box2D.Dynamics.b2ContactFilter,
+ b2ContactImpulse = Box2D.Dynamics.b2ContactImpulse,
+ b2ContactListener = Box2D.Dynamics.b2ContactListener,
+ b2ContactManager = Box2D.Dynamics.b2ContactManager,
+ b2DebugDraw = Box2D.Dynamics.b2DebugDraw,
+ b2DestructionListener = Box2D.Dynamics.b2DestructionListener,
+ b2FilterData = Box2D.Dynamics.b2FilterData,
+ b2Fixture = Box2D.Dynamics.b2Fixture,
+ b2FixtureDef = Box2D.Dynamics.b2FixtureDef,
+ b2Island = Box2D.Dynamics.b2Island,
+ b2TimeStep = Box2D.Dynamics.b2TimeStep,
+ b2World = Box2D.Dynamics.b2World,
+ b2CircleContact = Box2D.Dynamics.Contacts.b2CircleContact,
+ b2Contact = Box2D.Dynamics.Contacts.b2Contact,
+ b2ContactConstraint = Box2D.Dynamics.Contacts.b2ContactConstraint,
+ b2ContactConstraintPoint = Box2D.Dynamics.Contacts.b2ContactConstraintPoint,
+ b2ContactEdge = Box2D.Dynamics.Contacts.b2ContactEdge,
+ b2ContactFactory = Box2D.Dynamics.Contacts.b2ContactFactory,
+ b2ContactRegister = Box2D.Dynamics.Contacts.b2ContactRegister,
+ b2ContactResult = Box2D.Dynamics.Contacts.b2ContactResult,
+ b2ContactSolver = Box2D.Dynamics.Contacts.b2ContactSolver,
+ b2EdgeAndCircleContact = Box2D.Dynamics.Contacts.b2EdgeAndCircleContact,
+ b2NullContact = Box2D.Dynamics.Contacts.b2NullContact,
+ b2PolyAndCircleContact = Box2D.Dynamics.Contacts.b2PolyAndCircleContact,
+ b2PolyAndEdgeContact = Box2D.Dynamics.Contacts.b2PolyAndEdgeContact,
+ b2PolygonContact = Box2D.Dynamics.Contacts.b2PolygonContact,
+ b2PositionSolverManifold = Box2D.Dynamics.Contacts.b2PositionSolverManifold,
+ b2Controller = Box2D.Dynamics.Controllers.b2Controller,
+ b2DistanceJoint = Box2D.Dynamics.Joints.b2DistanceJoint,
+ b2DistanceJointDef = Box2D.Dynamics.Joints.b2DistanceJointDef,
+ b2FrictionJoint = Box2D.Dynamics.Joints.b2FrictionJoint,
+ b2FrictionJointDef = Box2D.Dynamics.Joints.b2FrictionJointDef,
+ b2GearJoint = Box2D.Dynamics.Joints.b2GearJoint,
+ b2GearJointDef = Box2D.Dynamics.Joints.b2GearJointDef,
+ b2Jacobian = Box2D.Dynamics.Joints.b2Jacobian,
+ b2Joint = Box2D.Dynamics.Joints.b2Joint,
+ b2JointDef = Box2D.Dynamics.Joints.b2JointDef,
+ b2JointEdge = Box2D.Dynamics.Joints.b2JointEdge,
+ b2LineJoint = Box2D.Dynamics.Joints.b2LineJoint,
+ b2LineJointDef = Box2D.Dynamics.Joints.b2LineJointDef,
+ b2MouseJoint = Box2D.Dynamics.Joints.b2MouseJoint,
+ b2MouseJointDef = Box2D.Dynamics.Joints.b2MouseJointDef,
+ b2PrismaticJoint = Box2D.Dynamics.Joints.b2PrismaticJoint,
+ b2PrismaticJointDef = Box2D.Dynamics.Joints.b2PrismaticJointDef,
+ b2PulleyJoint = Box2D.Dynamics.Joints.b2PulleyJoint,
+ b2PulleyJointDef = Box2D.Dynamics.Joints.b2PulleyJointDef,
+ b2RevoluteJoint = Box2D.Dynamics.Joints.b2RevoluteJoint,
+ b2RevoluteJointDef = Box2D.Dynamics.Joints.b2RevoluteJointDef,
+ b2WeldJoint = Box2D.Dynamics.Joints.b2WeldJoint,
+ b2WeldJointDef = Box2D.Dynamics.Joints.b2WeldJointDef;
+
+ b2Body.b2Body = function () {
+ this.m_xf = new b2Transform();
+ this.m_sweep = new b2Sweep();
+ this.m_linearVelocity = new b2Vec2();
+ this.m_force = new b2Vec2();
+ };
+ b2Body.prototype.connectEdges = function (s1, s2, angle1) {
+ if (angle1 === undefined) angle1 = 0;
+ var angle2 = Math.atan2(s2.GetDirectionVector().y, s2.GetDirectionVector().x);
+ var coreOffset = Math.tan((angle2 - angle1) * 0.5);
+ var core = b2Math.MulFV(coreOffset, s2.GetDirectionVector());
+ core = b2Math.SubtractVV(core, s2.GetNormalVector());
+ core = b2Math.MulFV(b2Settings.b2_toiSlop, core);
+ core = b2Math.AddVV(core, s2.GetVertex1());
+ var cornerDir = b2Math.AddVV(s1.GetDirectionVector(), s2.GetDirectionVector());
+ cornerDir.Normalize();
+ var convex = b2Math.Dot(s1.GetDirectionVector(), s2.GetNormalVector()) > 0.0;
+ s1.SetNextEdge(s2, core, cornerDir, convex);
+ s2.SetPrevEdge(s1, core, cornerDir, convex);
+ return angle2;
+ }
+ b2Body.prototype.CreateFixture = function (def) {
+ if (this.m_world.IsLocked() == true) {
+ return null;
+ }
+ var fixture = new b2Fixture();
+ fixture.Create(this, this.m_xf, def);
+ if (this.m_flags & b2Body.e_activeFlag) {
+ var broadPhase = this.m_world.m_contactManager.m_broadPhase;
+ fixture.CreateProxy(broadPhase, this.m_xf);
+ }
+ fixture.m_next = this.m_fixtureList;
+ this.m_fixtureList = fixture;
+ ++this.m_fixtureCount;
+ fixture.m_body = this;
+ if (fixture.m_density > 0.0) {
+ this.ResetMassData();
+ }
+ this.m_world.m_flags |= b2World.e_newFixture;
+ return fixture;
+ }
+ b2Body.prototype.CreateFixture2 = function (shape, density) {
+ if (density === undefined) density = 0.0;
+ var def = new b2FixtureDef();
+ def.shape = shape;
+ def.density = density;
+ return this.CreateFixture(def);
+ }
+ b2Body.prototype.DestroyFixture = function (fixture) {
+ if (this.m_world.IsLocked() == true) {
+ return;
+ }
+ var node = this.m_fixtureList;
+ var ppF = null;
+ var found = false;
+ while (node != null) {
+ if (node == fixture) {
+ if (ppF) ppF.m_next = fixture.m_next;
+ else this.m_fixtureList = fixture.m_next;
+ found = true;
+ break;
+ }
+ ppF = node;
+ node = node.m_next;
+ }
+ var edge = this.m_contactList;
+ while (edge) {
+ var c = edge.contact;
+ edge = edge.next;
+ var fixtureA = c.GetFixtureA();
+ var fixtureB = c.GetFixtureB();
+ if (fixture == fixtureA || fixture == fixtureB) {
+ this.m_world.m_contactManager.Destroy(c);
+ }
+ }
+ if (this.m_flags & b2Body.e_activeFlag) {
+ var broadPhase = this.m_world.m_contactManager.m_broadPhase;
+ fixture.DestroyProxy(broadPhase);
+ }
+ else {}
+ fixture.Destroy();
+ fixture.m_body = null;
+ fixture.m_next = null;
+ --this.m_fixtureCount;
+ this.ResetMassData();
+ }
+ b2Body.prototype.SetPositionAndAngle = function (position, angle) {
+ if (angle === undefined) angle = 0;
+ var f;
+ if (this.m_world.IsLocked() == true) {
+ return;
+ }
+ this.m_xf.R.Set(angle);
+ this.m_xf.position.SetV(position);
+ var tMat = this.m_xf.R;
+ var tVec = this.m_sweep.localCenter;
+ this.m_sweep.c.x = (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ this.m_sweep.c.y = (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ this.m_sweep.c.x += this.m_xf.position.x;
+ this.m_sweep.c.y += this.m_xf.position.y;
+ this.m_sweep.c0.SetV(this.m_sweep.c);
+ this.m_sweep.a0 = this.m_sweep.a = angle;
+ var broadPhase = this.m_world.m_contactManager.m_broadPhase;
+ for (f = this.m_fixtureList;
+ f; f = f.m_next) {
+ f.Synchronize(broadPhase, this.m_xf, this.m_xf);
+ }
+ this.m_world.m_contactManager.FindNewContacts();
+ }
+ b2Body.prototype.SetTransform = function (xf) {
+ this.SetPositionAndAngle(xf.position, xf.GetAngle());
+ }
+ b2Body.prototype.GetTransform = function () {
+ return this.m_xf;
+ }
+ b2Body.prototype.GetPosition = function () {
+ return this.m_xf.position;
+ }
+ b2Body.prototype.SetPosition = function (position) {
+ this.SetPositionAndAngle(position, this.GetAngle());
+ }
+ b2Body.prototype.GetAngle = function () {
+ return this.m_sweep.a;
+ }
+ b2Body.prototype.SetAngle = function (angle) {
+ if (angle === undefined) angle = 0;
+ this.SetPositionAndAngle(this.GetPosition(), angle);
+ }
+ b2Body.prototype.GetWorldCenter = function () {
+ return this.m_sweep.c;
+ }
+ b2Body.prototype.GetLocalCenter = function () {
+ return this.m_sweep.localCenter;
+ }
+ b2Body.prototype.SetLinearVelocity = function (v) {
+ if (this.m_type == b2Body.b2_staticBody) {
+ return;
+ }
+ this.m_linearVelocity.SetV(v);
+ }
+ b2Body.prototype.GetLinearVelocity = function () {
+ return this.m_linearVelocity;
+ }
+ b2Body.prototype.SetAngularVelocity = function (omega) {
+ if (omega === undefined) omega = 0;
+ if (this.m_type == b2Body.b2_staticBody) {
+ return;
+ }
+ this.m_angularVelocity = omega;
+ }
+ b2Body.prototype.GetAngularVelocity = function () {
+ return this.m_angularVelocity;
+ }
+ b2Body.prototype.GetDefinition = function () {
+ var bd = new b2BodyDef();
+ bd.type = this.GetType();
+ bd.allowSleep = (this.m_flags & b2Body.e_allowSleepFlag) == b2Body.e_allowSleepFlag;
+ bd.angle = this.GetAngle();
+ bd.angularDamping = this.m_angularDamping;
+ bd.angularVelocity = this.m_angularVelocity;
+ bd.fixedRotation = (this.m_flags & b2Body.e_fixedRotationFlag) == b2Body.e_fixedRotationFlag;
+ bd.bullet = (this.m_flags & b2Body.e_bulletFlag) == b2Body.e_bulletFlag;
+ bd.awake = (this.m_flags & b2Body.e_awakeFlag) == b2Body.e_awakeFlag;
+ bd.linearDamping = this.m_linearDamping;
+ bd.linearVelocity.SetV(this.GetLinearVelocity());
+ bd.position = this.GetPosition();
+ bd.userData = this.GetUserData();
+ return bd;
+ }
+ b2Body.prototype.ApplyForce = function (force, point) {
+ if (this.m_type != b2Body.b2_dynamicBody) {
+ return;
+ }
+ if (this.IsAwake() == false) {
+ this.SetAwake(true);
+ }
+ this.m_force.x += force.x;
+ this.m_force.y += force.y;
+ this.m_torque += ((point.x - this.m_sweep.c.x) * force.y - (point.y - this.m_sweep.c.y) * force.x);
+ }
+ b2Body.prototype.ApplyTorque = function (torque) {
+ if (torque === undefined) torque = 0;
+ if (this.m_type != b2Body.b2_dynamicBody) {
+ return;
+ }
+ if (this.IsAwake() == false) {
+ this.SetAwake(true);
+ }
+ this.m_torque += torque;
+ }
+ b2Body.prototype.ApplyImpulse = function (impulse, point) {
+ if (this.m_type != b2Body.b2_dynamicBody) {
+ return;
+ }
+ if (this.IsAwake() == false) {
+ this.SetAwake(true);
+ }
+ this.m_linearVelocity.x += this.m_invMass * impulse.x;
+ this.m_linearVelocity.y += this.m_invMass * impulse.y;
+ this.m_angularVelocity += this.m_invI * ((point.x - this.m_sweep.c.x) * impulse.y - (point.y - this.m_sweep.c.y) * impulse.x);
+ }
+ b2Body.prototype.Split = function (callback) {
+ var linearVelocity = this.GetLinearVelocity().Copy();
+ var angularVelocity = this.GetAngularVelocity();
+ var center = this.GetWorldCenter();
+ var body1 = this;
+ var body2 = this.m_world.CreateBody(this.GetDefinition());
+ var prev;
+ for (var f = body1.m_fixtureList; f;) {
+ if (callback(f)) {
+ var next = f.m_next;
+ if (prev) {
+ prev.m_next = next;
+ }
+ else {
+ body1.m_fixtureList = next;
+ }
+ body1.m_fixtureCount--;
+ f.m_next = body2.m_fixtureList;
+ body2.m_fixtureList = f;
+ body2.m_fixtureCount++;
+ f.m_body = body2;
+ f = next;
+ }
+ else {
+ prev = f;
+ f = f.m_next;
+ }
+ }
+ body1.ResetMassData();
+ body2.ResetMassData();
+ var center1 = body1.GetWorldCenter();
+ var center2 = body2.GetWorldCenter();
+ var velocity1 = b2Math.AddVV(linearVelocity, b2Math.CrossFV(angularVelocity, b2Math.SubtractVV(center1, center)));
+ var velocity2 = b2Math.AddVV(linearVelocity, b2Math.CrossFV(angularVelocity, b2Math.SubtractVV(center2, center)));
+ body1.SetLinearVelocity(velocity1);
+ body2.SetLinearVelocity(velocity2);
+ body1.SetAngularVelocity(angularVelocity);
+ body2.SetAngularVelocity(angularVelocity);
+ body1.SynchronizeFixtures();
+ body2.SynchronizeFixtures();
+ return body2;
+ }
+ b2Body.prototype.Merge = function (other) {
+ var f;
+ for (f = other.m_fixtureList;
+ f;) {
+ var next = f.m_next;
+ other.m_fixtureCount--;
+ f.m_next = this.m_fixtureList;
+ this.m_fixtureList = f;
+ this.m_fixtureCount++;
+ f.m_body = body2;
+ f = next;
+ }
+ body1.m_fixtureCount = 0;
+ var body1 = this;
+
+ var body2 = other;
+ var center1 = body1.GetWorldCenter();
+ var center2 = body2.GetWorldCenter();
+ var velocity1 = body1.GetLinearVelocity().Copy();
+ var velocity2 = body2.GetLinearVelocity().Copy();
+ var angular1 = body1.GetAngularVelocity();
+ var angular = body2.GetAngularVelocity();
+ body1.ResetMassData();
+ this.SynchronizeFixtures();
+ }
+ b2Body.prototype.GetMass = function () {
+ return this.m_mass;
+ }
+ b2Body.prototype.GetInertia = function () {
+ return this.m_I;
+ }
+ b2Body.prototype.GetMassData = function (data) {
+ data.mass = this.m_mass;
+ data.I = this.m_I;
+ data.center.SetV(this.m_sweep.localCenter);
+ }
+ b2Body.prototype.SetMassData = function (massData) {
+ b2Settings.b2Assert(this.m_world.IsLocked() == false);
+ if (this.m_world.IsLocked() == true) {
+ return;
+ }
+ if (this.m_type != b2Body.b2_dynamicBody) {
+ return;
+ }
+ this.m_invMass = 0.0;
+ this.m_I = 0.0;
+ this.m_invI = 0.0;
+ this.m_mass = massData.mass;
+ if (this.m_mass <= 0.0) {
+ this.m_mass = 1.0;
+ }
+ this.m_invMass = 1.0 / this.m_mass;
+ if (massData.I > 0.0 && (this.m_flags & b2Body.e_fixedRotationFlag) == 0) {
+ this.m_I = massData.I - this.m_mass * (massData.center.x * massData.center.x + massData.center.y * massData.center.y);
+ this.m_invI = 1.0 / this.m_I;
+ }
+ var oldCenter = this.m_sweep.c.Copy();
+ this.m_sweep.localCenter.SetV(massData.center);
+ this.m_sweep.c0.SetV(b2Math.MulX(this.m_xf, this.m_sweep.localCenter));
+ this.m_sweep.c.SetV(this.m_sweep.c0);
+ this.m_linearVelocity.x += this.m_angularVelocity * (-(this.m_sweep.c.y - oldCenter.y));
+ this.m_linearVelocity.y += this.m_angularVelocity * (+(this.m_sweep.c.x - oldCenter.x));
+ }
+ b2Body.prototype.ResetMassData = function () {
+ this.m_mass = 0.0;
+ this.m_invMass = 0.0;
+ this.m_I = 0.0;
+ this.m_invI = 0.0;
+ this.m_sweep.localCenter.SetZero();
+ if (this.m_type == b2Body.b2_staticBody || this.m_type == b2Body.b2_kinematicBody) {
+ return;
+ }
+ var center = b2Vec2.Make(0, 0);
+ for (var f = this.m_fixtureList; f; f = f.m_next) {
+ if (f.m_density == 0.0) {
+ continue;
+ }
+ var massData = f.GetMassData();
+ this.m_mass += massData.mass;
+ center.x += massData.center.x * massData.mass;
+ center.y += massData.center.y * massData.mass;
+ this.m_I += massData.I;
+ }
+ if (this.m_mass > 0.0) {
+ this.m_invMass = 1.0 / this.m_mass;
+ center.x *= this.m_invMass;
+ center.y *= this.m_invMass;
+ }
+ else {
+ this.m_mass = 1.0;
+ this.m_invMass = 1.0;
+ }
+ if (this.m_I > 0.0 && (this.m_flags & b2Body.e_fixedRotationFlag) == 0) {
+ this.m_I -= this.m_mass * (center.x * center.x + center.y * center.y);
+ this.m_I *= this.m_inertiaScale;
+ b2Settings.b2Assert(this.m_I > 0);
+ this.m_invI = 1.0 / this.m_I;
+ }
+ else {
+ this.m_I = 0.0;
+ this.m_invI = 0.0;
+ }
+ var oldCenter = this.m_sweep.c.Copy();
+ this.m_sweep.localCenter.SetV(center);
+ this.m_sweep.c0.SetV(b2Math.MulX(this.m_xf, this.m_sweep.localCenter));
+ this.m_sweep.c.SetV(this.m_sweep.c0);
+ this.m_linearVelocity.x += this.m_angularVelocity * (-(this.m_sweep.c.y - oldCenter.y));
+ this.m_linearVelocity.y += this.m_angularVelocity * (+(this.m_sweep.c.x - oldCenter.x));
+ }
+ b2Body.prototype.GetWorldPoint = function (localPoint) {
+ var A = this.m_xf.R;
+ var u = new b2Vec2(A.col1.x * localPoint.x + A.col2.x * localPoint.y, A.col1.y * localPoint.x + A.col2.y * localPoint.y);
+ u.x += this.m_xf.position.x;
+ u.y += this.m_xf.position.y;
+ return u;
+ }
+ b2Body.prototype.GetWorldVector = function (localVector) {
+ return b2Math.MulMV(this.m_xf.R, localVector);
+ }
+ b2Body.prototype.GetLocalPoint = function (worldPoint) {
+ return b2Math.MulXT(this.m_xf, worldPoint);
+ }
+ b2Body.prototype.GetLocalVector = function (worldVector) {
+ return b2Math.MulTMV(this.m_xf.R, worldVector);
+ }
+ b2Body.prototype.GetLinearVelocityFromWorldPoint = function (worldPoint) {
+ return new b2Vec2(this.m_linearVelocity.x - this.m_angularVelocity * (worldPoint.y - this.m_sweep.c.y), this.m_linearVelocity.y + this.m_angularVelocity * (worldPoint.x - this.m_sweep.c.x));
+ }
+ b2Body.prototype.GetLinearVelocityFromLocalPoint = function (localPoint) {
+ var A = this.m_xf.R;
+ var worldPoint = new b2Vec2(A.col1.x * localPoint.x + A.col2.x * localPoint.y, A.col1.y * localPoint.x + A.col2.y * localPoint.y);
+ worldPoint.x += this.m_xf.position.x;
+ worldPoint.y += this.m_xf.position.y;
+ return new b2Vec2(this.m_linearVelocity.x - this.m_angularVelocity * (worldPoint.y - this.m_sweep.c.y), this.m_linearVelocity.y + this.m_angularVelocity * (worldPoint.x - this.m_sweep.c.x));
+ }
+ b2Body.prototype.GetLinearDamping = function () {
+ return this.m_linearDamping;
+ }
+ b2Body.prototype.SetLinearDamping = function (linearDamping) {
+ if (linearDamping === undefined) linearDamping = 0;
+ this.m_linearDamping = linearDamping;
+ }
+ b2Body.prototype.GetAngularDamping = function () {
+ return this.m_angularDamping;
+ }
+ b2Body.prototype.SetAngularDamping = function (angularDamping) {
+ if (angularDamping === undefined) angularDamping = 0;
+ this.m_angularDamping = angularDamping;
+ }
+ b2Body.prototype.SetType = function (type) {
+ if (type === undefined) type = 0;
+ if (this.m_type == type) {
+ return;
+ }
+ this.m_type = type;
+ this.ResetMassData();
+ if (this.m_type == b2Body.b2_staticBody) {
+ this.m_linearVelocity.SetZero();
+ this.m_angularVelocity = 0.0;
+ }
+ this.SetAwake(true);
+ this.m_force.SetZero();
+ this.m_torque = 0.0;
+ for (var ce = this.m_contactList; ce; ce = ce.next) {
+ ce.contact.FlagForFiltering();
+ }
+ }
+ b2Body.prototype.GetType = function () {
+ return this.m_type;
+ }
+ b2Body.prototype.SetBullet = function (flag) {
+ if (flag) {
+ this.m_flags |= b2Body.e_bulletFlag;
+ }
+ else {
+ this.m_flags &= ~b2Body.e_bulletFlag;
+ }
+ }
+ b2Body.prototype.IsBullet = function () {
+ return (this.m_flags & b2Body.e_bulletFlag) == b2Body.e_bulletFlag;
+ }
+ b2Body.prototype.SetSleepingAllowed = function (flag) {
+ if (flag) {
+ this.m_flags |= b2Body.e_allowSleepFlag;
+ }
+ else {
+ this.m_flags &= ~b2Body.e_allowSleepFlag;
+ this.SetAwake(true);
+ }
+ }
+ b2Body.prototype.SetAwake = function (flag) {
+ if (flag) {
+ this.m_flags |= b2Body.e_awakeFlag;
+ this.m_sleepTime = 0.0;
+ }
+ else {
+ this.m_flags &= ~b2Body.e_awakeFlag;
+ this.m_sleepTime = 0.0;
+ this.m_linearVelocity.SetZero();
+ this.m_angularVelocity = 0.0;
+ this.m_force.SetZero();
+ this.m_torque = 0.0;
+ }
+ }
+ b2Body.prototype.IsAwake = function () {
+ return (this.m_flags & b2Body.e_awakeFlag) == b2Body.e_awakeFlag;
+ }
+ b2Body.prototype.SetFixedRotation = function (fixed) {
+ if (fixed) {
+ this.m_flags |= b2Body.e_fixedRotationFlag;
+ }
+ else {
+ this.m_flags &= ~b2Body.e_fixedRotationFlag;
+ }
+ this.ResetMassData();
+ }
+ b2Body.prototype.IsFixedRotation = function () {
+ return (this.m_flags & b2Body.e_fixedRotationFlag) == b2Body.e_fixedRotationFlag;
+ }
+ b2Body.prototype.SetActive = function (flag) {
+ if (flag == this.IsActive()) {
+ return;
+ }
+ var broadPhase;
+ var f;
+ if (flag) {
+ this.m_flags |= b2Body.e_activeFlag;
+ broadPhase = this.m_world.m_contactManager.m_broadPhase;
+ for (f = this.m_fixtureList;
+ f; f = f.m_next) {
+ f.CreateProxy(broadPhase, this.m_xf);
+ }
+ }
+ else {
+ this.m_flags &= ~b2Body.e_activeFlag;
+ broadPhase = this.m_world.m_contactManager.m_broadPhase;
+ for (f = this.m_fixtureList;
+ f; f = f.m_next) {
+ f.DestroyProxy(broadPhase);
+ }
+ var ce = this.m_contactList;
+ while (ce) {
+ var ce0 = ce;
+ ce = ce.next;
+ this.m_world.m_contactManager.Destroy(ce0.contact);
+ }
+ this.m_contactList = null;
+ }
+ }
+ b2Body.prototype.IsActive = function () {
+ return (this.m_flags & b2Body.e_activeFlag) == b2Body.e_activeFlag;
+ }
+ b2Body.prototype.IsSleepingAllowed = function () {
+ return (this.m_flags & b2Body.e_allowSleepFlag) == b2Body.e_allowSleepFlag;
+ }
+ b2Body.prototype.GetFixtureList = function () {
+ return this.m_fixtureList;
+ }
+ b2Body.prototype.GetJointList = function () {
+ return this.m_jointList;
+ }
+ b2Body.prototype.GetControllerList = function () {
+ return this.m_controllerList;
+ }
+ b2Body.prototype.GetContactList = function () {
+ return this.m_contactList;
+ }
+ b2Body.prototype.GetNext = function () {
+ return this.m_next;
+ }
+ b2Body.prototype.GetUserData = function () {
+ return this.m_userData;
+ }
+ b2Body.prototype.SetUserData = function (data) {
+ this.m_userData = data;
+ }
+ b2Body.prototype.GetWorld = function () {
+ return this.m_world;
+ }
+ b2Body.prototype.b2Body = function (bd, world) {
+ this.m_flags = 0;
+ if (bd.bullet) {
+ this.m_flags |= b2Body.e_bulletFlag;
+ }
+ if (bd.fixedRotation) {
+ this.m_flags |= b2Body.e_fixedRotationFlag;
+ }
+ if (bd.allowSleep) {
+ this.m_flags |= b2Body.e_allowSleepFlag;
+ }
+ if (bd.awake) {
+ this.m_flags |= b2Body.e_awakeFlag;
+ }
+ if (bd.active) {
+ this.m_flags |= b2Body.e_activeFlag;
+ }
+ this.m_world = world;
+ this.m_xf.position.SetV(bd.position);
+ this.m_xf.R.Set(bd.angle);
+ this.m_sweep.localCenter.SetZero();
+ this.m_sweep.t0 = 1.0;
+ this.m_sweep.a0 = this.m_sweep.a = bd.angle;
+ var tMat = this.m_xf.R;
+ var tVec = this.m_sweep.localCenter;
+ this.m_sweep.c.x = (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ this.m_sweep.c.y = (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ this.m_sweep.c.x += this.m_xf.position.x;
+ this.m_sweep.c.y += this.m_xf.position.y;
+ this.m_sweep.c0.SetV(this.m_sweep.c);
+ this.m_jointList = null;
+ this.m_controllerList = null;
+ this.m_contactList = null;
+ this.m_controllerCount = 0;
+ this.m_prev = null;
+ this.m_next = null;
+ this.m_linearVelocity.SetV(bd.linearVelocity);
+ this.m_angularVelocity = bd.angularVelocity;
+ this.m_linearDamping = bd.linearDamping;
+ this.m_angularDamping = bd.angularDamping;
+ this.m_force.Set(0.0, 0.0);
+ this.m_torque = 0.0;
+ this.m_sleepTime = 0.0;
+ this.m_type = bd.type;
+ if (this.m_type == b2Body.b2_dynamicBody) {
+ this.m_mass = 1.0;
+ this.m_invMass = 1.0;
+ }
+ else {
+ this.m_mass = 0.0;
+ this.m_invMass = 0.0;
+ }
+ this.m_I = 0.0;
+ this.m_invI = 0.0;
+ this.m_inertiaScale = bd.inertiaScale;
+ this.m_userData = bd.userData;
+ this.m_fixtureList = null;
+ this.m_fixtureCount = 0;
+ }
+ b2Body.prototype.SynchronizeFixtures = function () {
+ var xf1 = b2Body.s_xf1;
+ xf1.R.Set(this.m_sweep.a0);
+ var tMat = xf1.R;
+ var tVec = this.m_sweep.localCenter;
+ xf1.position.x = this.m_sweep.c0.x - (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ xf1.position.y = this.m_sweep.c0.y - (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ var f;
+ var broadPhase = this.m_world.m_contactManager.m_broadPhase;
+ for (f = this.m_fixtureList;
+ f; f = f.m_next) {
+ f.Synchronize(broadPhase, xf1, this.m_xf);
+ }
+ }
+ b2Body.prototype.SynchronizeTransform = function () {
+ this.m_xf.R.Set(this.m_sweep.a);
+ var tMat = this.m_xf.R;
+ var tVec = this.m_sweep.localCenter;
+ this.m_xf.position.x = this.m_sweep.c.x - (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ this.m_xf.position.y = this.m_sweep.c.y - (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ }
+ b2Body.prototype.ShouldCollide = function (other) {
+ if (this.m_type != b2Body.b2_dynamicBody && other.m_type != b2Body.b2_dynamicBody) {
+ return false;
+ }
+ for (var jn = this.m_jointList; jn; jn = jn.next) {
+ if (jn.other == other) if (jn.joint.m_collideConnected == false) {
+ return false;
+ }
+ }
+ return true;
+ }
+ b2Body.prototype.Advance = function (t) {
+ if (t === undefined) t = 0;
+ this.m_sweep.Advance(t);
+ this.m_sweep.c.SetV(this.m_sweep.c0);
+ this.m_sweep.a = this.m_sweep.a0;
+ this.SynchronizeTransform();
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2Body.s_xf1 = new b2Transform();
+ Box2D.Dynamics.b2Body.e_islandFlag = 0x0001;
+ Box2D.Dynamics.b2Body.e_awakeFlag = 0x0002;
+ Box2D.Dynamics.b2Body.e_allowSleepFlag = 0x0004;
+ Box2D.Dynamics.b2Body.e_bulletFlag = 0x0008;
+ Box2D.Dynamics.b2Body.e_fixedRotationFlag = 0x0010;
+ Box2D.Dynamics.b2Body.e_activeFlag = 0x0020;
+ Box2D.Dynamics.b2Body.b2_staticBody = 0;
+ Box2D.Dynamics.b2Body.b2_kinematicBody = 1;
+ Box2D.Dynamics.b2Body.b2_dynamicBody = 2;
+ });
+ b2BodyDef.b2BodyDef = function () {
+ this.position = new b2Vec2();
+ this.linearVelocity = new b2Vec2();
+ };
+ b2BodyDef.prototype.b2BodyDef = function () {
+ this.userData = null;
+ this.position.Set(0.0, 0.0);
+ this.angle = 0.0;
+ this.linearVelocity.Set(0, 0);
+ this.angularVelocity = 0.0;
+ this.linearDamping = 0.0;
+ this.angularDamping = 0.0;
+ this.allowSleep = true;
+ this.awake = true;
+ this.fixedRotation = false;
+ this.bullet = false;
+ this.type = b2Body.b2_staticBody;
+ this.active = true;
+ this.inertiaScale = 1.0;
+ }
+ b2ContactFilter.b2ContactFilter = function () {};
+ b2ContactFilter.prototype.ShouldCollide = function (fixtureA, fixtureB) {
+ var filter1 = fixtureA.GetFilterData();
+ var filter2 = fixtureB.GetFilterData();
+ if (filter1.groupIndex == filter2.groupIndex && filter1.groupIndex != 0) {
+ return filter1.groupIndex > 0;
+ }
+ var collide = (filter1.maskBits & filter2.categoryBits) != 0 && (filter1.categoryBits & filter2.maskBits) != 0;
+ return collide;
+ }
+ b2ContactFilter.prototype.RayCollide = function (userData, fixture) {
+ if (!userData) return true;
+ return this.ShouldCollide((userData instanceof b2Fixture ? userData : null), fixture);
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2ContactFilter.b2_defaultFilter = new b2ContactFilter();
+ });
+ b2ContactImpulse.b2ContactImpulse = function () {
+ this.normalImpulses = new Vector_a2j_Number(b2Settings.b2_maxManifoldPoints);
+ this.tangentImpulses = new Vector_a2j_Number(b2Settings.b2_maxManifoldPoints);
+ };
+ b2ContactListener.b2ContactListener = function () {};
+ b2ContactListener.prototype.BeginContact = function (contact) {}
+ b2ContactListener.prototype.EndContact = function (contact) {}
+ b2ContactListener.prototype.PreSolve = function (contact, oldManifold) {}
+ b2ContactListener.prototype.PostSolve = function (contact, impulse) {}
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2ContactListener.b2_defaultListener = new b2ContactListener();
+ });
+ b2ContactManager.b2ContactManager = function () {};
+ b2ContactManager.prototype.b2ContactManager = function () {
+ this.m_world = null;
+ this.m_contactCount = 0;
+ this.m_contactFilter = b2ContactFilter.b2_defaultFilter;
+ this.m_contactListener = b2ContactListener.b2_defaultListener;
+ this.m_contactFactory = new b2ContactFactory(this.m_allocator);
+ this.m_broadPhase = new b2DynamicTreeBroadPhase();
+ }
+ b2ContactManager.prototype.AddPair = function (proxyUserDataA, proxyUserDataB) {
+ var fixtureA = (proxyUserDataA instanceof b2Fixture ? proxyUserDataA : null);
+ var fixtureB = (proxyUserDataB instanceof b2Fixture ? proxyUserDataB : null);
+ var bodyA = fixtureA.GetBody();
+ var bodyB = fixtureB.GetBody();
+ if (bodyA == bodyB) return;
+ var edge = bodyB.GetContactList();
+ while (edge) {
+ if (edge.other == bodyA) {
+ var fA = edge.contact.GetFixtureA();
+ var fB = edge.contact.GetFixtureB();
+ if (fA == fixtureA && fB == fixtureB) return;
+ if (fA == fixtureB && fB == fixtureA) return;
+ }
+ edge = edge.next;
+ }
+ if (bodyB.ShouldCollide(bodyA) == false) {
+ return;
+ }
+ if (this.m_contactFilter.ShouldCollide(fixtureA, fixtureB) == false) {
+ return;
+ }
+ var c = this.m_contactFactory.Create(fixtureA, fixtureB);
+ fixtureA = c.GetFixtureA();
+ fixtureB = c.GetFixtureB();
+ bodyA = fixtureA.m_body;
+ bodyB = fixtureB.m_body;
+ c.m_prev = null;
+ c.m_next = this.m_world.m_contactList;
+ if (this.m_world.m_contactList != null) {
+ this.m_world.m_contactList.m_prev = c;
+ }
+ this.m_world.m_contactList = c;
+ c.m_nodeA.contact = c;
+ c.m_nodeA.other = bodyB;
+ c.m_nodeA.prev = null;
+ c.m_nodeA.next = bodyA.m_contactList;
+ if (bodyA.m_contactList != null) {
+ bodyA.m_contactList.prev = c.m_nodeA;
+ }
+ bodyA.m_contactList = c.m_nodeA;
+ c.m_nodeB.contact = c;
+ c.m_nodeB.other = bodyA;
+ c.m_nodeB.prev = null;
+ c.m_nodeB.next = bodyB.m_contactList;
+ if (bodyB.m_contactList != null) {
+ bodyB.m_contactList.prev = c.m_nodeB;
+ }
+ bodyB.m_contactList = c.m_nodeB;
+ ++this.m_world.m_contactCount;
+ return;
+ }
+ b2ContactManager.prototype.FindNewContacts = function () {
+ this.m_broadPhase.UpdatePairs(Box2D.generateCallback(this, this.AddPair));
+ }
+ b2ContactManager.prototype.Destroy = function (c) {
+ var fixtureA = c.GetFixtureA();
+ var fixtureB = c.GetFixtureB();
+ var bodyA = fixtureA.GetBody();
+ var bodyB = fixtureB.GetBody();
+ if (c.IsTouching()) {
+ this.m_contactListener.EndContact(c);
+ }
+ if (c.m_prev) {
+ c.m_prev.m_next = c.m_next;
+ }
+ if (c.m_next) {
+ c.m_next.m_prev = c.m_prev;
+ }
+ if (c == this.m_world.m_contactList) {
+ this.m_world.m_contactList = c.m_next;
+ }
+ if (c.m_nodeA.prev) {
+ c.m_nodeA.prev.next = c.m_nodeA.next;
+ }
+ if (c.m_nodeA.next) {
+ c.m_nodeA.next.prev = c.m_nodeA.prev;
+ }
+ if (c.m_nodeA == bodyA.m_contactList) {
+ bodyA.m_contactList = c.m_nodeA.next;
+ }
+ if (c.m_nodeB.prev) {
+ c.m_nodeB.prev.next = c.m_nodeB.next;
+ }
+ if (c.m_nodeB.next) {
+ c.m_nodeB.next.prev = c.m_nodeB.prev;
+ }
+ if (c.m_nodeB == bodyB.m_contactList) {
+ bodyB.m_contactList = c.m_nodeB.next;
+ }
+ this.m_contactFactory.Destroy(c);
+ --this.m_contactCount;
+ }
+ b2ContactManager.prototype.Collide = function () {
+ var c = this.m_world.m_contactList;
+ while (c) {
+ var fixtureA = c.GetFixtureA();
+ var fixtureB = c.GetFixtureB();
+ var bodyA = fixtureA.GetBody();
+ var bodyB = fixtureB.GetBody();
+ if (bodyA.IsAwake() == false && bodyB.IsAwake() == false) {
+ c = c.GetNext();
+ continue;
+ }
+ if (c.m_flags & b2Contact.e_filterFlag) {
+ if (bodyB.ShouldCollide(bodyA) == false) {
+ var cNuke = c;
+ c = cNuke.GetNext();
+ this.Destroy(cNuke);
+ continue;
+ }
+ if (this.m_contactFilter.ShouldCollide(fixtureA, fixtureB) == false) {
+ cNuke = c;
+ c = cNuke.GetNext();
+ this.Destroy(cNuke);
+ continue;
+ }
+ c.m_flags &= ~b2Contact.e_filterFlag;
+ }
+ var proxyA = fixtureA.m_proxy;
+ var proxyB = fixtureB.m_proxy;
+ var overlap = this.m_broadPhase.TestOverlap(proxyA, proxyB);
+ if (overlap == false) {
+ cNuke = c;
+ c = cNuke.GetNext();
+ this.Destroy(cNuke);
+ continue;
+ }
+ c.Update(this.m_contactListener);
+ c = c.GetNext();
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2ContactManager.s_evalCP = new b2ContactPoint();
+ });
+ b2DebugDraw.b2DebugDraw = function () {};
+ b2DebugDraw.prototype.b2DebugDraw = function () {}
+ b2DebugDraw.prototype.SetFlags = function (flags) {
+ if (flags === undefined) flags = 0;
+ }
+ b2DebugDraw.prototype.GetFlags = function () {}
+ b2DebugDraw.prototype.AppendFlags = function (flags) {
+ if (flags === undefined) flags = 0;
+ }
+ b2DebugDraw.prototype.ClearFlags = function (flags) {
+ if (flags === undefined) flags = 0;
+ }
+ b2DebugDraw.prototype.SetSprite = function (sprite) {}
+ b2DebugDraw.prototype.GetSprite = function () {}
+ b2DebugDraw.prototype.SetDrawScale = function (drawScale) {
+ if (drawScale === undefined) drawScale = 0;
+ }
+ b2DebugDraw.prototype.GetDrawScale = function () {}
+ b2DebugDraw.prototype.SetLineThickness = function (lineThickness) {
+ if (lineThickness === undefined) lineThickness = 0;
+ }
+ b2DebugDraw.prototype.GetLineThickness = function () {}
+ b2DebugDraw.prototype.SetAlpha = function (alpha) {
+ if (alpha === undefined) alpha = 0;
+ }
+ b2DebugDraw.prototype.GetAlpha = function () {}
+ b2DebugDraw.prototype.SetFillAlpha = function (alpha) {
+ if (alpha === undefined) alpha = 0;
+ }
+ b2DebugDraw.prototype.GetFillAlpha = function () {}
+ b2DebugDraw.prototype.SetXFormScale = function (xformScale) {
+ if (xformScale === undefined) xformScale = 0;
+ }
+ b2DebugDraw.prototype.GetXFormScale = function () {}
+ b2DebugDraw.prototype.DrawPolygon = function (vertices, vertexCount, color) {
+ if (vertexCount === undefined) vertexCount = 0;
+ }
+ b2DebugDraw.prototype.DrawSolidPolygon = function (vertices, vertexCount, color) {
+ if (vertexCount === undefined) vertexCount = 0;
+ }
+ b2DebugDraw.prototype.DrawCircle = function (center, radius, color) {
+ if (radius === undefined) radius = 0;
+ }
+ b2DebugDraw.prototype.DrawSolidCircle = function (center, radius, axis, color) {
+ if (radius === undefined) radius = 0;
+ }
+ b2DebugDraw.prototype.DrawSegment = function (p1, p2, color) {}
+ b2DebugDraw.prototype.DrawTransform = function (xf) {}
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2DebugDraw.e_shapeBit = 0x0001;
+ Box2D.Dynamics.b2DebugDraw.e_jointBit = 0x0002;
+ Box2D.Dynamics.b2DebugDraw.e_aabbBit = 0x0004;
+ Box2D.Dynamics.b2DebugDraw.e_pairBit = 0x0008;
+ Box2D.Dynamics.b2DebugDraw.e_centerOfMassBit = 0x0010;
+ Box2D.Dynamics.b2DebugDraw.e_controllerBit = 0x0020;
+ });
+ b2DestructionListener.b2DestructionListener = function () {};
+ b2DestructionListener.prototype.SayGoodbyeJoint = function (joint) {}
+ b2DestructionListener.prototype.SayGoodbyeFixture = function (fixture) {}
+ b2FilterData.b2FilterData = function () {
+ this.categoryBits = 0x0001;
+ this.maskBits = 0xFFFF;
+ this.groupIndex = 0;
+ };
+ b2FilterData.prototype.Copy = function () {
+ var copy = new b2FilterData();
+ copy.categoryBits = this.categoryBits;
+ copy.maskBits = this.maskBits;
+ copy.groupIndex = this.groupIndex;
+ return copy;
+ }
+ b2Fixture.b2Fixture = function () {
+ this.m_filter = new b2FilterData();
+ };
+ b2Fixture.prototype.GetType = function () {
+ return this.m_shape.GetType();
+ }
+ b2Fixture.prototype.GetShape = function () {
+ return this.m_shape;
+ }
+ b2Fixture.prototype.SetSensor = function (sensor) {
+ if (this.m_isSensor == sensor) return;
+ this.m_isSensor = sensor;
+ if (this.m_body == null) return;
+ var edge = this.m_body.GetContactList();
+ while (edge) {
+ var contact = edge.contact;
+ var fixtureA = contact.GetFixtureA();
+ var fixtureB = contact.GetFixtureB();
+ if (fixtureA == this || fixtureB == this) contact.SetSensor(fixtureA.IsSensor() || fixtureB.IsSensor());
+ edge = edge.next;
+ }
+ }
+ b2Fixture.prototype.IsSensor = function () {
+ return this.m_isSensor;
+ }
+ b2Fixture.prototype.SetFilterData = function (filter) {
+ this.m_filter = filter.Copy();
+ if (this.m_body) return;
+ var edge = this.m_body.GetContactList();
+ while (edge) {
+ var contact = edge.contact;
+ var fixtureA = contact.GetFixtureA();
+ var fixtureB = contact.GetFixtureB();
+ if (fixtureA == this || fixtureB == this) contact.FlagForFiltering();
+ edge = edge.next;
+ }
+ }
+ b2Fixture.prototype.GetFilterData = function () {
+ return this.m_filter.Copy();
+ }
+ b2Fixture.prototype.GetBody = function () {
+ return this.m_body;
+ }
+ b2Fixture.prototype.GetNext = function () {
+ return this.m_next;
+ }
+ b2Fixture.prototype.GetUserData = function () {
+ return this.m_userData;
+ }
+ b2Fixture.prototype.SetUserData = function (data) {
+ this.m_userData = data;
+ }
+ b2Fixture.prototype.TestPoint = function (p) {
+ return this.m_shape.TestPoint(this.m_body.GetTransform(), p);
+ }
+ b2Fixture.prototype.RayCast = function (output, input) {
+ return this.m_shape.RayCast(output, input, this.m_body.GetTransform());
+ }
+ b2Fixture.prototype.GetMassData = function (massData) {
+ if (massData === undefined) massData = null;
+ if (massData == null) {
+ massData = new b2MassData();
+ }
+ this.m_shape.ComputeMass(massData, this.m_density);
+ return massData;
+ }
+ b2Fixture.prototype.SetDensity = function (density) {
+ if (density === undefined) density = 0;
+ this.m_density = density;
+ }
+ b2Fixture.prototype.GetDensity = function () {
+ return this.m_density;
+ }
+ b2Fixture.prototype.GetFriction = function () {
+ return this.m_friction;
+ }
+ b2Fixture.prototype.SetFriction = function (friction) {
+ if (friction === undefined) friction = 0;
+ this.m_friction = friction;
+ }
+ b2Fixture.prototype.GetRestitution = function () {
+ return this.m_restitution;
+ }
+ b2Fixture.prototype.SetRestitution = function (restitution) {
+ if (restitution === undefined) restitution = 0;
+ this.m_restitution = restitution;
+ }
+ b2Fixture.prototype.GetAABB = function () {
+ return this.m_aabb;
+ }
+ b2Fixture.prototype.b2Fixture = function () {
+ this.m_aabb = new b2AABB();
+ this.m_userData = null;
+ this.m_body = null;
+ this.m_next = null;
+ this.m_shape = null;
+ this.m_density = 0.0;
+ this.m_friction = 0.0;
+ this.m_restitution = 0.0;
+ }
+ b2Fixture.prototype.Create = function (body, xf, def) {
+ this.m_userData = def.userData;
+ this.m_friction = def.friction;
+ this.m_restitution = def.restitution;
+ this.m_body = body;
+ this.m_next = null;
+ this.m_filter = def.filter.Copy();
+ this.m_isSensor = def.isSensor;
+ this.m_shape = def.shape.Copy();
+ this.m_density = def.density;
+ }
+ b2Fixture.prototype.Destroy = function () {
+ this.m_shape = null;
+ }
+ b2Fixture.prototype.CreateProxy = function (broadPhase, xf) {
+ this.m_shape.ComputeAABB(this.m_aabb, xf);
+ this.m_proxy = broadPhase.CreateProxy(this.m_aabb, this);
+ }
+ b2Fixture.prototype.DestroyProxy = function (broadPhase) {
+ if (this.m_proxy == null) {
+ return;
+ }
+ broadPhase.DestroyProxy(this.m_proxy);
+ this.m_proxy = null;
+ }
+ b2Fixture.prototype.Synchronize = function (broadPhase, transform1, transform2) {
+ if (!this.m_proxy) return;
+ var aabb1 = new b2AABB();
+ var aabb2 = new b2AABB();
+ this.m_shape.ComputeAABB(aabb1, transform1);
+ this.m_shape.ComputeAABB(aabb2, transform2);
+ this.m_aabb.Combine(aabb1, aabb2);
+ var displacement = b2Math.SubtractVV(transform2.position, transform1.position);
+ broadPhase.MoveProxy(this.m_proxy, this.m_aabb, displacement);
+ }
+ b2FixtureDef.b2FixtureDef = function () {
+ this.filter = new b2FilterData();
+ };
+ b2FixtureDef.prototype.b2FixtureDef = function () {
+ this.shape = null;
+ this.userData = null;
+ this.friction = 0.2;
+ this.restitution = 0.0;
+ this.density = 0.0;
+ this.filter.categoryBits = 0x0001;
+ this.filter.maskBits = 0xFFFF;
+ this.filter.groupIndex = 0;
+ this.isSensor = false;
+ }
+ b2Island.b2Island = function () {};
+ b2Island.prototype.b2Island = function () {
+ this.m_bodies = new Vector();
+ this.m_contacts = new Vector();
+ this.m_joints = new Vector();
+ }
+ b2Island.prototype.Initialize = function (bodyCapacity, contactCapacity, jointCapacity, allocator, listener, contactSolver) {
+ if (bodyCapacity === undefined) bodyCapacity = 0;
+ if (contactCapacity === undefined) contactCapacity = 0;
+ if (jointCapacity === undefined) jointCapacity = 0;
+ var i = 0;
+ this.m_bodyCapacity = bodyCapacity;
+ this.m_contactCapacity = contactCapacity;
+ this.m_jointCapacity = jointCapacity;
+ this.m_bodyCount = 0;
+ this.m_contactCount = 0;
+ this.m_jointCount = 0;
+ this.m_allocator = allocator;
+ this.m_listener = listener;
+ this.m_contactSolver = contactSolver;
+ for (i = this.m_bodies.length;
+ i < bodyCapacity; i++)
+ this.m_bodies[i] = null;
+ for (i = this.m_contacts.length;
+ i < contactCapacity; i++)
+ this.m_contacts[i] = null;
+ for (i = this.m_joints.length;
+ i < jointCapacity; i++)
+ this.m_joints[i] = null;
+ }
+ b2Island.prototype.Clear = function () {
+ this.m_bodyCount = 0;
+ this.m_contactCount = 0;
+ this.m_jointCount = 0;
+ }
+ b2Island.prototype.Solve = function (step, gravity, allowSleep) {
+ var i = 0;
+ var j = 0;
+ var b;
+ var joint;
+ for (i = 0;
+ i < this.m_bodyCount; ++i) {
+ b = this.m_bodies[i];
+ if (b.GetType() != b2Body.b2_dynamicBody) continue;
+ b.m_linearVelocity.x += step.dt * (gravity.x + b.m_invMass * b.m_force.x);
+ b.m_linearVelocity.y += step.dt * (gravity.y + b.m_invMass * b.m_force.y);
+ b.m_angularVelocity += step.dt * b.m_invI * b.m_torque;
+ b.m_linearVelocity.Multiply(b2Math.Clamp(1.0 - step.dt * b.m_linearDamping, 0.0, 1.0));
+ b.m_angularVelocity *= b2Math.Clamp(1.0 - step.dt * b.m_angularDamping, 0.0, 1.0);
+ }
+ this.m_contactSolver.Initialize(step, this.m_contacts, this.m_contactCount, this.m_allocator);
+ var contactSolver = this.m_contactSolver;
+ contactSolver.InitVelocityConstraints(step);
+ for (i = 0;
+ i < this.m_jointCount; ++i) {
+ joint = this.m_joints[i];
+ joint.InitVelocityConstraints(step);
+ }
+ for (i = 0;
+ i < step.velocityIterations; ++i) {
+ for (j = 0;
+ j < this.m_jointCount; ++j) {
+ joint = this.m_joints[j];
+ joint.SolveVelocityConstraints(step);
+ }
+ contactSolver.SolveVelocityConstraints();
+ }
+ for (i = 0;
+ i < this.m_jointCount; ++i) {
+ joint = this.m_joints[i];
+ joint.FinalizeVelocityConstraints();
+ }
+ contactSolver.FinalizeVelocityConstraints();
+ for (i = 0;
+ i < this.m_bodyCount; ++i) {
+ b = this.m_bodies[i];
+ if (b.GetType() == b2Body.b2_staticBody) continue;
+ var translationX = step.dt * b.m_linearVelocity.x;
+ var translationY = step.dt * b.m_linearVelocity.y;
+ if ((translationX * translationX + translationY * translationY) > b2Settings.b2_maxTranslationSquared) {
+ b.m_linearVelocity.Normalize();
+ b.m_linearVelocity.x *= b2Settings.b2_maxTranslation * step.inv_dt;
+ b.m_linearVelocity.y *= b2Settings.b2_maxTranslation * step.inv_dt;
+ }
+ var rotation = step.dt * b.m_angularVelocity;
+ if (rotation * rotation > b2Settings.b2_maxRotationSquared) {
+ if (b.m_angularVelocity < 0.0) {
+ b.m_angularVelocity = (-b2Settings.b2_maxRotation * step.inv_dt);
+ }
+ else {
+ b.m_angularVelocity = b2Settings.b2_maxRotation * step.inv_dt;
+ }
+ }
+ b.m_sweep.c0.SetV(b.m_sweep.c);
+ b.m_sweep.a0 = b.m_sweep.a;
+ b.m_sweep.c.x += step.dt * b.m_linearVelocity.x;
+ b.m_sweep.c.y += step.dt * b.m_linearVelocity.y;
+ b.m_sweep.a += step.dt * b.m_angularVelocity;
+ b.SynchronizeTransform();
+ }
+ for (i = 0;
+ i < step.positionIterations; ++i) {
+ var contactsOkay = contactSolver.SolvePositionConstraints(b2Settings.b2_contactBaumgarte);
+ var jointsOkay = true;
+ for (j = 0;
+ j < this.m_jointCount; ++j) {
+ joint = this.m_joints[j];
+ var jointOkay = joint.SolvePositionConstraints(b2Settings.b2_contactBaumgarte);
+ jointsOkay = jointsOkay && jointOkay;
+ }
+ if (contactsOkay && jointsOkay) {
+ break;
+ }
+ }
+ this.Report(contactSolver.m_constraints);
+ if (allowSleep) {
+ var minSleepTime = Number.MAX_VALUE;
+ var linTolSqr = b2Settings.b2_linearSleepTolerance * b2Settings.b2_linearSleepTolerance;
+ var angTolSqr = b2Settings.b2_angularSleepTolerance * b2Settings.b2_angularSleepTolerance;
+ for (i = 0;
+ i < this.m_bodyCount; ++i) {
+ b = this.m_bodies[i];
+ if (b.GetType() == b2Body.b2_staticBody) {
+ continue;
+ }
+ if ((b.m_flags & b2Body.e_allowSleepFlag) == 0) {
+ b.m_sleepTime = 0.0;
+ minSleepTime = 0.0;
+ }
+ if ((b.m_flags & b2Body.e_allowSleepFlag) == 0 || b.m_angularVelocity * b.m_angularVelocity > angTolSqr || b2Math.Dot(b.m_linearVelocity, b.m_linearVelocity) > linTolSqr) {
+ b.m_sleepTime = 0.0;
+ minSleepTime = 0.0;
+ }
+ else {
+ b.m_sleepTime += step.dt;
+ minSleepTime = b2Math.Min(minSleepTime, b.m_sleepTime);
+ }
+ }
+ if (minSleepTime >= b2Settings.b2_timeToSleep) {
+ for (i = 0;
+ i < this.m_bodyCount; ++i) {
+ b = this.m_bodies[i];
+ b.SetAwake(false);
+ }
+ }
+ }
+ }
+ b2Island.prototype.SolveTOI = function (subStep) {
+ var i = 0;
+ var j = 0;
+ this.m_contactSolver.Initialize(subStep, this.m_contacts, this.m_contactCount, this.m_allocator);
+ var contactSolver = this.m_contactSolver;
+ for (i = 0;
+ i < this.m_jointCount; ++i) {
+ this.m_joints[i].InitVelocityConstraints(subStep);
+ }
+ for (i = 0;
+ i < subStep.velocityIterations; ++i) {
+ contactSolver.SolveVelocityConstraints();
+ for (j = 0;
+ j < this.m_jointCount; ++j) {
+ this.m_joints[j].SolveVelocityConstraints(subStep);
+ }
+ }
+ for (i = 0;
+ i < this.m_bodyCount; ++i) {
+ var b = this.m_bodies[i];
+ if (b.GetType() == b2Body.b2_staticBody) continue;
+ var translationX = subStep.dt * b.m_linearVelocity.x;
+ var translationY = subStep.dt * b.m_linearVelocity.y;
+ if ((translationX * translationX + translationY * translationY) > b2Settings.b2_maxTranslationSquared) {
+ b.m_linearVelocity.Normalize();
+ b.m_linearVelocity.x *= b2Settings.b2_maxTranslation * subStep.inv_dt;
+ b.m_linearVelocity.y *= b2Settings.b2_maxTranslation * subStep.inv_dt;
+ }
+ var rotation = subStep.dt * b.m_angularVelocity;
+ if (rotation * rotation > b2Settings.b2_maxRotationSquared) {
+ if (b.m_angularVelocity < 0.0) {
+ b.m_angularVelocity = (-b2Settings.b2_maxRotation * subStep.inv_dt);
+ }
+ else {
+ b.m_angularVelocity = b2Settings.b2_maxRotation * subStep.inv_dt;
+ }
+ }
+ b.m_sweep.c0.SetV(b.m_sweep.c);
+ b.m_sweep.a0 = b.m_sweep.a;
+ b.m_sweep.c.x += subStep.dt * b.m_linearVelocity.x;
+ b.m_sweep.c.y += subStep.dt * b.m_linearVelocity.y;
+ b.m_sweep.a += subStep.dt * b.m_angularVelocity;
+ b.SynchronizeTransform();
+ }
+ var k_toiBaumgarte = 0.75;
+ for (i = 0;
+ i < subStep.positionIterations; ++i) {
+ var contactsOkay = contactSolver.SolvePositionConstraints(k_toiBaumgarte);
+ var jointsOkay = true;
+ for (j = 0;
+ j < this.m_jointCount; ++j) {
+ var jointOkay = this.m_joints[j].SolvePositionConstraints(b2Settings.b2_contactBaumgarte);
+ jointsOkay = jointsOkay && jointOkay;
+ }
+ if (contactsOkay && jointsOkay) {
+ break;
+ }
+ }
+ this.Report(contactSolver.m_constraints);
+ }
+ b2Island.prototype.Report = function (constraints) {
+ if (this.m_listener == null) {
+ return;
+ }
+ for (var i = 0; i < this.m_contactCount; ++i) {
+ var c = this.m_contacts[i];
+ var cc = constraints[i];
+ for (var j = 0; j < cc.pointCount; ++j) {
+ b2Island.s_impulse.normalImpulses[j] = cc.points[j].normalImpulse;
+ b2Island.s_impulse.tangentImpulses[j] = cc.points[j].tangentImpulse;
+ }
+ this.m_listener.PostSolve(c, b2Island.s_impulse);
+ }
+ }
+ b2Island.prototype.AddBody = function (body) {
+ body.m_islandIndex = this.m_bodyCount;
+ this.m_bodies[this.m_bodyCount++] = body;
+ }
+ b2Island.prototype.AddContact = function (contact) {
+ this.m_contacts[this.m_contactCount++] = contact;
+ }
+ b2Island.prototype.AddJoint = function (joint) {
+ this.m_joints[this.m_jointCount++] = joint;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2Island.s_impulse = new b2ContactImpulse();
+ });
+ b2TimeStep.b2TimeStep = function () {};
+ b2TimeStep.prototype.Set = function (step) {
+ this.dt = step.dt;
+ this.inv_dt = step.inv_dt;
+ this.positionIterations = step.positionIterations;
+ this.velocityIterations = step.velocityIterations;
+ this.warmStarting = step.warmStarting;
+ }
+ b2World.b2World = function () {
+ this.s_stack = new Vector();
+ this.m_contactManager = new b2ContactManager();
+ this.m_contactSolver = new b2ContactSolver();
+ this.m_island = new b2Island();
+ };
+ b2World.prototype.b2World = function (gravity, doSleep) {
+ this.m_destructionListener = null;
+ this.m_debugDraw = null;
+ this.m_bodyList = null;
+ this.m_contactList = null;
+ this.m_jointList = null;
+ this.m_controllerList = null;
+ this.m_bodyCount = 0;
+ this.m_contactCount = 0;
+ this.m_jointCount = 0;
+ this.m_controllerCount = 0;
+ b2World.m_warmStarting = true;
+ b2World.m_continuousPhysics = true;
+ this.m_allowSleep = doSleep;
+ this.m_gravity = gravity;
+ this.m_inv_dt0 = 0.0;
+ this.m_contactManager.m_world = this;
+ var bd = new b2BodyDef();
+ this.m_groundBody = this.CreateBody(bd);
+ }
+ b2World.prototype.SetDestructionListener = function (listener) {
+ this.m_destructionListener = listener;
+ }
+ b2World.prototype.SetContactFilter = function (filter) {
+ this.m_contactManager.m_contactFilter = filter;
+ }
+ b2World.prototype.SetContactListener = function (listener) {
+ this.m_contactManager.m_contactListener = listener;
+ }
+ b2World.prototype.SetDebugDraw = function (debugDraw) {
+ this.m_debugDraw = debugDraw;
+ }
+ b2World.prototype.SetBroadPhase = function (broadPhase) {
+ var oldBroadPhase = this.m_contactManager.m_broadPhase;
+ this.m_contactManager.m_broadPhase = broadPhase;
+ for (var b = this.m_bodyList; b; b = b.m_next) {
+ for (var f = b.m_fixtureList; f; f = f.m_next) {
+ f.m_proxy = broadPhase.CreateProxy(oldBroadPhase.GetFatAABB(f.m_proxy), f);
+ }
+ }
+ }
+ b2World.prototype.Validate = function () {
+ this.m_contactManager.m_broadPhase.Validate();
+ }
+ b2World.prototype.GetProxyCount = function () {
+ return this.m_contactManager.m_broadPhase.GetProxyCount();
+ }
+ b2World.prototype.CreateBody = function (def) {
+ if (this.IsLocked() == true) {
+ return null;
+ }
+ var b = new b2Body(def, this);
+ b.m_prev = null;
+ b.m_next = this.m_bodyList;
+ if (this.m_bodyList) {
+ this.m_bodyList.m_prev = b;
+ }
+ this.m_bodyList = b;
+ ++this.m_bodyCount;
+ return b;
+ }
+ b2World.prototype.DestroyBody = function (b) {
+ if (this.IsLocked() == true) {
+ return;
+ }
+ var jn = b.m_jointList;
+ while (jn) {
+ var jn0 = jn;
+ jn = jn.next;
+ if (this.m_destructionListener) {
+ this.m_destructionListener.SayGoodbyeJoint(jn0.joint);
+ }
+ this.DestroyJoint(jn0.joint);
+ }
+ var coe = b.m_controllerList;
+ while (coe) {
+ var coe0 = coe;
+ coe = coe.nextController;
+ coe0.controller.RemoveBody(b);
+ }
+ var ce = b.m_contactList;
+ while (ce) {
+ var ce0 = ce;
+ ce = ce.next;
+ this.m_contactManager.Destroy(ce0.contact);
+ }
+ b.m_contactList = null;
+ var f = b.m_fixtureList;
+ while (f) {
+ var f0 = f;
+ f = f.m_next;
+ if (this.m_destructionListener) {
+ this.m_destructionListener.SayGoodbyeFixture(f0);
+ }
+ f0.DestroyProxy(this.m_contactManager.m_broadPhase);
+ f0.Destroy();
+ }
+ b.m_fixtureList = null;
+ b.m_fixtureCount = 0;
+ if (b.m_prev) {
+ b.m_prev.m_next = b.m_next;
+ }
+ if (b.m_next) {
+ b.m_next.m_prev = b.m_prev;
+ }
+ if (b == this.m_bodyList) {
+ this.m_bodyList = b.m_next;
+ }--this.m_bodyCount;
+ }
+ b2World.prototype.CreateJoint = function (def) {
+ var j = b2Joint.Create(def, null);
+ j.m_prev = null;
+ j.m_next = this.m_jointList;
+ if (this.m_jointList) {
+ this.m_jointList.m_prev = j;
+ }
+ this.m_jointList = j;
+ ++this.m_jointCount;
+ j.m_edgeA.joint = j;
+ j.m_edgeA.other = j.m_bodyB;
+ j.m_edgeA.prev = null;
+ j.m_edgeA.next = j.m_bodyA.m_jointList;
+ if (j.m_bodyA.m_jointList) j.m_bodyA.m_jointList.prev = j.m_edgeA;
+ j.m_bodyA.m_jointList = j.m_edgeA;
+ j.m_edgeB.joint = j;
+ j.m_edgeB.other = j.m_bodyA;
+ j.m_edgeB.prev = null;
+ j.m_edgeB.next = j.m_bodyB.m_jointList;
+ if (j.m_bodyB.m_jointList) j.m_bodyB.m_jointList.prev = j.m_edgeB;
+ j.m_bodyB.m_jointList = j.m_edgeB;
+ var bodyA = def.bodyA;
+ var bodyB = def.bodyB;
+ if (def.collideConnected == false) {
+ var edge = bodyB.GetContactList();
+ while (edge) {
+ if (edge.other == bodyA) {
+ edge.contact.FlagForFiltering();
+ }
+ edge = edge.next;
+ }
+ }
+ return j;
+ }
+ b2World.prototype.DestroyJoint = function (j) {
+ var collideConnected = j.m_collideConnected;
+ if (j.m_prev) {
+ j.m_prev.m_next = j.m_next;
+ }
+ if (j.m_next) {
+ j.m_next.m_prev = j.m_prev;
+ }
+ if (j == this.m_jointList) {
+ this.m_jointList = j.m_next;
+ }
+ var bodyA = j.m_bodyA;
+ var bodyB = j.m_bodyB;
+ bodyA.SetAwake(true);
+ bodyB.SetAwake(true);
+ if (j.m_edgeA.prev) {
+ j.m_edgeA.prev.next = j.m_edgeA.next;
+ }
+ if (j.m_edgeA.next) {
+ j.m_edgeA.next.prev = j.m_edgeA.prev;
+ }
+ if (j.m_edgeA == bodyA.m_jointList) {
+ bodyA.m_jointList = j.m_edgeA.next;
+ }
+ j.m_edgeA.prev = null;
+ j.m_edgeA.next = null;
+ if (j.m_edgeB.prev) {
+ j.m_edgeB.prev.next = j.m_edgeB.next;
+ }
+ if (j.m_edgeB.next) {
+ j.m_edgeB.next.prev = j.m_edgeB.prev;
+ }
+ if (j.m_edgeB == bodyB.m_jointList) {
+ bodyB.m_jointList = j.m_edgeB.next;
+ }
+ j.m_edgeB.prev = null;
+ j.m_edgeB.next = null;
+ b2Joint.Destroy(j, null);
+ --this.m_jointCount;
+ if (collideConnected == false) {
+ var edge = bodyB.GetContactList();
+ while (edge) {
+ if (edge.other == bodyA) {
+ edge.contact.FlagForFiltering();
+ }
+ edge = edge.next;
+ }
+ }
+ }
+ b2World.prototype.AddController = function (c) {
+ c.m_next = this.m_controllerList;
+ c.m_prev = null;
+ this.m_controllerList = c;
+ c.m_world = this;
+ this.m_controllerCount++;
+ return c;
+ }
+ b2World.prototype.RemoveController = function (c) {
+ if (c.m_prev) c.m_prev.m_next = c.m_next;
+ if (c.m_next) c.m_next.m_prev = c.m_prev;
+ if (this.m_controllerList == c) this.m_controllerList = c.m_next;
+ this.m_controllerCount--;
+ }
+ b2World.prototype.CreateController = function (controller) {
+ if (controller.m_world != this) throw new Error("Controller can only be a member of one world");
+ controller.m_next = this.m_controllerList;
+ controller.m_prev = null;
+ if (this.m_controllerList) this.m_controllerList.m_prev = controller;
+ this.m_controllerList = controller;
+ ++this.m_controllerCount;
+ controller.m_world = this;
+ return controller;
+ }
+ b2World.prototype.DestroyController = function (controller) {
+ controller.Clear();
+ if (controller.m_next) controller.m_next.m_prev = controller.m_prev;
+ if (controller.m_prev) controller.m_prev.m_next = controller.m_next;
+ if (controller == this.m_controllerList) this.m_controllerList = controller.m_next;
+ --this.m_controllerCount;
+ }
+ b2World.prototype.SetWarmStarting = function (flag) {
+ b2World.m_warmStarting = flag;
+ }
+ b2World.prototype.SetContinuousPhysics = function (flag) {
+ b2World.m_continuousPhysics = flag;
+ }
+ b2World.prototype.GetBodyCount = function () {
+ return this.m_bodyCount;
+ }
+ b2World.prototype.GetJointCount = function () {
+ return this.m_jointCount;
+ }
+ b2World.prototype.GetContactCount = function () {
+ return this.m_contactCount;
+ }
+ b2World.prototype.SetGravity = function (gravity) {
+ this.m_gravity = gravity;
+ }
+ b2World.prototype.GetGravity = function () {
+ return this.m_gravity;
+ }
+ b2World.prototype.GetGroundBody = function () {
+ return this.m_groundBody;
+ }
+ b2World.prototype.Step = function (dt, velocityIterations, positionIterations) {
+ if (dt === undefined) dt = 0;
+ if (velocityIterations === undefined) velocityIterations = 0;
+ if (positionIterations === undefined) positionIterations = 0;
+ if (this.m_flags & b2World.e_newFixture) {
+ this.m_contactManager.FindNewContacts();
+ this.m_flags &= ~b2World.e_newFixture;
+ }
+ this.m_flags |= b2World.e_locked;
+ var step = b2World.s_timestep2;
+ step.dt = dt;
+ step.velocityIterations = velocityIterations;
+ step.positionIterations = positionIterations;
+ if (dt > 0.0) {
+ step.inv_dt = 1.0 / dt;
+ }
+ else {
+ step.inv_dt = 0.0;
+ }
+ step.dtRatio = this.m_inv_dt0 * dt;
+ step.warmStarting = b2World.m_warmStarting;
+ this.m_contactManager.Collide();
+ if (step.dt > 0.0) {
+ this.Solve(step);
+ }
+ if (b2World.m_continuousPhysics && step.dt > 0.0) {
+ this.SolveTOI(step);
+ }
+ if (step.dt > 0.0) {
+ this.m_inv_dt0 = step.inv_dt;
+ }
+ this.m_flags &= ~b2World.e_locked;
+ }
+ b2World.prototype.ClearForces = function () {
+ for (var body = this.m_bodyList; body; body = body.m_next) {
+ body.m_force.SetZero();
+ body.m_torque = 0.0;
+ }
+ }
+ b2World.prototype.DrawDebugData = function () {
+ if (this.m_debugDraw == null) {
+ return;
+ }
+ this.m_debugDraw.m_sprite.graphics.clear();
+ var flags = this.m_debugDraw.GetFlags();
+ var i = 0;
+ var b;
+ var f;
+ var s;
+ var j;
+ var bp;
+ var invQ = new b2Vec2;
+ var x1 = new b2Vec2;
+ var x2 = new b2Vec2;
+ var xf;
+ var b1 = new b2AABB();
+ var b2 = new b2AABB();
+ var vs = [new b2Vec2(), new b2Vec2(), new b2Vec2(), new b2Vec2()];
+ var color = new b2Color(0, 0, 0);
+ if (flags & b2DebugDraw.e_shapeBit) {
+ for (b = this.m_bodyList;
+ b; b = b.m_next) {
+ xf = b.m_xf;
+ for (f = b.GetFixtureList();
+ f; f = f.m_next) {
+ s = f.GetShape();
+ if (b.IsActive() == false) {
+ color.Set(0.5, 0.5, 0.3);
+ this.DrawShape(s, xf, color);
+ }
+ else if (b.GetType() == b2Body.b2_staticBody) {
+ color.Set(0.5, 0.9, 0.5);
+ this.DrawShape(s, xf, color);
+ }
+ else if (b.GetType() == b2Body.b2_kinematicBody) {
+ color.Set(0.5, 0.5, 0.9);
+ this.DrawShape(s, xf, color);
+ }
+ else if (b.IsAwake() == false) {
+ color.Set(0.6, 0.6, 0.6);
+ this.DrawShape(s, xf, color);
+ }
+ else {
+ color.Set(0.9, 0.7, 0.7);
+ this.DrawShape(s, xf, color);
+ }
+ }
+ }
+ }
+ if (flags & b2DebugDraw.e_jointBit) {
+ for (j = this.m_jointList;
+ j; j = j.m_next) {
+ this.DrawJoint(j);
+ }
+ }
+ if (flags & b2DebugDraw.e_controllerBit) {
+ for (var c = this.m_controllerList; c; c = c.m_next) {
+ c.Draw(this.m_debugDraw);
+ }
+ }
+ if (flags & b2DebugDraw.e_pairBit) {
+ color.Set(0.3, 0.9, 0.9);
+ for (var contact = this.m_contactManager.m_contactList; contact; contact = contact.GetNext()) {
+ var fixtureA = contact.GetFixtureA();
+ var fixtureB = contact.GetFixtureB();
+ var cA = fixtureA.GetAABB().GetCenter();
+ var cB = fixtureB.GetAABB().GetCenter();
+ this.m_debugDraw.DrawSegment(cA, cB, color);
+ }
+ }
+ if (flags & b2DebugDraw.e_aabbBit) {
+ bp = this.m_contactManager.m_broadPhase;
+ vs = [new b2Vec2(), new b2Vec2(), new b2Vec2(), new b2Vec2()];
+ for (b = this.m_bodyList;
+ b; b = b.GetNext()) {
+ if (b.IsActive() == false) {
+ continue;
+ }
+ for (f = b.GetFixtureList();
+ f; f = f.GetNext()) {
+ var aabb = bp.GetFatAABB(f.m_proxy);
+ vs[0].Set(aabb.lowerBound.x, aabb.lowerBound.y);
+ vs[1].Set(aabb.upperBound.x, aabb.lowerBound.y);
+ vs[2].Set(aabb.upperBound.x, aabb.upperBound.y);
+ vs[3].Set(aabb.lowerBound.x, aabb.upperBound.y);
+ this.m_debugDraw.DrawPolygon(vs, 4, color);
+ }
+ }
+ }
+ if (flags & b2DebugDraw.e_centerOfMassBit) {
+ for (b = this.m_bodyList;
+ b; b = b.m_next) {
+ xf = b2World.s_xf;
+ xf.R = b.m_xf.R;
+ xf.position = b.GetWorldCenter();
+ this.m_debugDraw.DrawTransform(xf);
+ }
+ }
+ }
+ b2World.prototype.QueryAABB = function (callback, aabb) {
+ var __this = this;
+ var broadPhase = __this.m_contactManager.m_broadPhase;
+
+ function WorldQueryWrapper(proxy) {
+ return callback(broadPhase.GetUserData(proxy));
+ };
+ broadPhase.Query(WorldQueryWrapper, aabb);
+ }
+ b2World.prototype.QueryShape = function (callback, shape, transform) {
+ var __this = this;
+ if (transform === undefined) transform = null;
+ if (transform == null) {
+ transform = new b2Transform();
+ transform.SetIdentity();
+ }
+ var broadPhase = __this.m_contactManager.m_broadPhase;
+
+ function WorldQueryWrapper(proxy) {
+ var fixture = (broadPhase.GetUserData(proxy) instanceof b2Fixture ? broadPhase.GetUserData(proxy) : null);
+ if (b2Shape.TestOverlap(shape, transform, fixture.GetShape(), fixture.GetBody().GetTransform())) return callback(fixture);
+ return true;
+ };
+ var aabb = new b2AABB();
+ shape.ComputeAABB(aabb, transform);
+ broadPhase.Query(WorldQueryWrapper, aabb);
+ }
+ b2World.prototype.QueryPoint = function (callback, p) {
+ var __this = this;
+ var broadPhase = __this.m_contactManager.m_broadPhase;
+
+ function WorldQueryWrapper(proxy) {
+ var fixture = (broadPhase.GetUserData(proxy) instanceof b2Fixture ? broadPhase.GetUserData(proxy) : null);
+ if (fixture.TestPoint(p)) return callback(fixture);
+ return true;
+ };
+ var aabb = new b2AABB();
+ aabb.lowerBound.Set(p.x - b2Settings.b2_linearSlop, p.y - b2Settings.b2_linearSlop);
+ aabb.upperBound.Set(p.x + b2Settings.b2_linearSlop, p.y + b2Settings.b2_linearSlop);
+ broadPhase.Query(WorldQueryWrapper, aabb);
+ }
+ b2World.prototype.RayCast = function (callback, point1, point2) {
+ var __this = this;
+ var broadPhase = __this.m_contactManager.m_broadPhase;
+ var output = new b2RayCastOutput;
+
+ function RayCastWrapper(input, proxy) {
+ var userData = broadPhase.GetUserData(proxy);
+ var fixture = (userData instanceof b2Fixture ? userData : null);
+ var hit = fixture.RayCast(output, input);
+ if (hit) {
+ var fraction = output.fraction;
+ var point = new b2Vec2((1.0 - fraction) * point1.x + fraction * point2.x, (1.0 - fraction) * point1.y + fraction * point2.y);
+ return callback(fixture, point, output.normal, fraction);
+ }
+ return input.maxFraction;
+ };
+ var input = new b2RayCastInput(point1, point2);
+ broadPhase.RayCast(RayCastWrapper, input);
+ }
+ b2World.prototype.RayCastOne = function (point1, point2) {
+ var __this = this;
+ var result;
+
+ function RayCastOneWrapper(fixture, point, normal, fraction) {
+ if (fraction === undefined) fraction = 0;
+ result = fixture;
+ return fraction;
+ };
+ __this.RayCast(RayCastOneWrapper, point1, point2);
+ return result;
+ }
+ b2World.prototype.RayCastAll = function (point1, point2) {
+ var __this = this;
+ var result = new Vector();
+
+ function RayCastAllWrapper(fixture, point, normal, fraction) {
+ if (fraction === undefined) fraction = 0;
+ result[result.length] = fixture;
+ return 1;
+ };
+ __this.RayCast(RayCastAllWrapper, point1, point2);
+ return result;
+ }
+ b2World.prototype.GetBodyList = function () {
+ return this.m_bodyList;
+ }
+ b2World.prototype.GetJointList = function () {
+ return this.m_jointList;
+ }
+ b2World.prototype.GetContactList = function () {
+ return this.m_contactList;
+ }
+ b2World.prototype.IsLocked = function () {
+ return (this.m_flags & b2World.e_locked) > 0;
+ }
+ b2World.prototype.Solve = function (step) {
+ var b;
+ for (var controller = this.m_controllerList; controller; controller = controller.m_next) {
+ controller.Step(step);
+ }
+ var island = this.m_island;
+ island.Initialize(this.m_bodyCount, this.m_contactCount, this.m_jointCount, null, this.m_contactManager.m_contactListener, this.m_contactSolver);
+ for (b = this.m_bodyList;
+ b; b = b.m_next) {
+ b.m_flags &= ~b2Body.e_islandFlag;
+ }
+ for (var c = this.m_contactList; c; c = c.m_next) {
+ c.m_flags &= ~b2Contact.e_islandFlag;
+ }
+ for (var j = this.m_jointList; j; j = j.m_next) {
+ j.m_islandFlag = false;
+ }
+ var stackSize = parseInt(this.m_bodyCount);
+ var stack = this.s_stack;
+ for (var seed = this.m_bodyList; seed; seed = seed.m_next) {
+ if (seed.m_flags & b2Body.e_islandFlag) {
+ continue;
+ }
+ if (seed.IsAwake() == false || seed.IsActive() == false) {
+ continue;
+ }
+ if (seed.GetType() == b2Body.b2_staticBody) {
+ continue;
+ }
+ island.Clear();
+ var stackCount = 0;
+ stack[stackCount++] = seed;
+ seed.m_flags |= b2Body.e_islandFlag;
+ while (stackCount > 0) {
+ b = stack[--stackCount];
+ island.AddBody(b);
+ if (b.IsAwake() == false) {
+ b.SetAwake(true);
+ }
+ if (b.GetType() == b2Body.b2_staticBody) {
+ continue;
+ }
+ var other;
+ for (var ce = b.m_contactList; ce; ce = ce.next) {
+ if (ce.contact.m_flags & b2Contact.e_islandFlag) {
+ continue;
+ }
+ if (ce.contact.IsSensor() == true || ce.contact.IsEnabled() == false || ce.contact.IsTouching() == false) {
+ continue;
+ }
+ island.AddContact(ce.contact);
+ ce.contact.m_flags |= b2Contact.e_islandFlag;
+ other = ce.other;
+ if (other.m_flags & b2Body.e_islandFlag) {
+ continue;
+ }
+ stack[stackCount++] = other;
+ other.m_flags |= b2Body.e_islandFlag;
+ }
+ for (var jn = b.m_jointList; jn; jn = jn.next) {
+ if (jn.joint.m_islandFlag == true) {
+ continue;
+ }
+ other = jn.other;
+ if (other.IsActive() == false) {
+ continue;
+ }
+ island.AddJoint(jn.joint);
+ jn.joint.m_islandFlag = true;
+ if (other.m_flags & b2Body.e_islandFlag) {
+ continue;
+ }
+ stack[stackCount++] = other;
+ other.m_flags |= b2Body.e_islandFlag;
+ }
+ }
+ island.Solve(step, this.m_gravity, this.m_allowSleep);
+ for (var i = 0; i < island.m_bodyCount; ++i) {
+ b = island.m_bodies[i];
+ if (b.GetType() == b2Body.b2_staticBody) {
+ b.m_flags &= ~b2Body.e_islandFlag;
+ }
+ }
+ }
+ for (i = 0;
+ i < stack.length; ++i) {
+ if (!stack[i]) break;
+ stack[i] = null;
+ }
+ for (b = this.m_bodyList;
+ b; b = b.m_next) {
+ if (b.IsAwake() == false || b.IsActive() == false) {
+ continue;
+ }
+ if (b.GetType() == b2Body.b2_staticBody) {
+ continue;
+ }
+ b.SynchronizeFixtures();
+ }
+ this.m_contactManager.FindNewContacts();
+ }
+ b2World.prototype.SolveTOI = function (step) {
+ var b;
+ var fA;
+ var fB;
+ var bA;
+ var bB;
+ var cEdge;
+ var j;
+ var island = this.m_island;
+ island.Initialize(this.m_bodyCount, b2Settings.b2_maxTOIContactsPerIsland, b2Settings.b2_maxTOIJointsPerIsland, null, this.m_contactManager.m_contactListener, this.m_contactSolver);
+ var queue = b2World.s_queue;
+ for (b = this.m_bodyList;
+ b; b = b.m_next) {
+ b.m_flags &= ~b2Body.e_islandFlag;
+ b.m_sweep.t0 = 0.0;
+ }
+ var c;
+ for (c = this.m_contactList;
+ c; c = c.m_next) {
+ c.m_flags &= ~ (b2Contact.e_toiFlag | b2Contact.e_islandFlag);
+ }
+ for (j = this.m_jointList;
+ j; j = j.m_next) {
+ j.m_islandFlag = false;
+ }
+ for (;;) {
+ var minContact = null;
+ var minTOI = 1.0;
+ for (c = this.m_contactList;
+ c; c = c.m_next) {
+ if (c.IsSensor() == true || c.IsEnabled() == false || c.IsContinuous() == false) {
+ continue;
+ }
+ var toi = 1.0;
+ if (c.m_flags & b2Contact.e_toiFlag) {
+ toi = c.m_toi;
+ }
+ else {
+ fA = c.m_fixtureA;
+ fB = c.m_fixtureB;
+ bA = fA.m_body;
+ bB = fB.m_body;
+ if ((bA.GetType() != b2Body.b2_dynamicBody || bA.IsAwake() == false) && (bB.GetType() != b2Body.b2_dynamicBody || bB.IsAwake() == false)) {
+ continue;
+ }
+ var t0 = bA.m_sweep.t0;
+ if (bA.m_sweep.t0 < bB.m_sweep.t0) {
+ t0 = bB.m_sweep.t0;
+ bA.m_sweep.Advance(t0);
+ }
+ else if (bB.m_sweep.t0 < bA.m_sweep.t0) {
+ t0 = bA.m_sweep.t0;
+ bB.m_sweep.Advance(t0);
+ }
+ toi = c.ComputeTOI(bA.m_sweep, bB.m_sweep);
+ b2Settings.b2Assert(0.0 <= toi && toi <= 1.0);
+ if (toi > 0.0 && toi < 1.0) {
+ toi = (1.0 - toi) * t0 + toi;
+ if (toi > 1) toi = 1;
+ }
+ c.m_toi = toi;
+ c.m_flags |= b2Contact.e_toiFlag;
+ }
+ if (Number.MIN_VALUE < toi && toi < minTOI) {
+ minContact = c;
+ minTOI = toi;
+ }
+ }
+ if (minContact == null || 1.0 - 100.0 * Number.MIN_VALUE < minTOI) {
+ break;
+ }
+ fA = minContact.m_fixtureA;
+ fB = minContact.m_fixtureB;
+ bA = fA.m_body;
+ bB = fB.m_body;
+ b2World.s_backupA.Set(bA.m_sweep);
+ b2World.s_backupB.Set(bB.m_sweep);
+ bA.Advance(minTOI);
+ bB.Advance(minTOI);
+ minContact.Update(this.m_contactManager.m_contactListener);
+ minContact.m_flags &= ~b2Contact.e_toiFlag;
+ if (minContact.IsSensor() == true || minContact.IsEnabled() == false) {
+ bA.m_sweep.Set(b2World.s_backupA);
+ bB.m_sweep.Set(b2World.s_backupB);
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ continue;
+ }
+ if (minContact.IsTouching() == false) {
+ continue;
+ }
+ var seed = bA;
+ if (seed.GetType() != b2Body.b2_dynamicBody) {
+ seed = bB;
+ }
+ island.Clear();
+ var queueStart = 0;
+ var queueSize = 0;
+ queue[queueStart + queueSize++] = seed;
+ seed.m_flags |= b2Body.e_islandFlag;
+ while (queueSize > 0) {
+ b = queue[queueStart++];
+ --queueSize;
+ island.AddBody(b);
+ if (b.IsAwake() == false) {
+ b.SetAwake(true);
+ }
+ if (b.GetType() != b2Body.b2_dynamicBody) {
+ continue;
+ }
+ for (cEdge = b.m_contactList;
+ cEdge; cEdge = cEdge.next) {
+ if (island.m_contactCount == island.m_contactCapacity) {
+ break;
+ }
+ if (cEdge.contact.m_flags & b2Contact.e_islandFlag) {
+ continue;
+ }
+ if (cEdge.contact.IsSensor() == true || cEdge.contact.IsEnabled() == false || cEdge.contact.IsTouching() == false) {
+ continue;
+ }
+ island.AddContact(cEdge.contact);
+ cEdge.contact.m_flags |= b2Contact.e_islandFlag;
+ var other = cEdge.other;
+ if (other.m_flags & b2Body.e_islandFlag) {
+ continue;
+ }
+ if (other.GetType() != b2Body.b2_staticBody) {
+ other.Advance(minTOI);
+ other.SetAwake(true);
+ }
+ queue[queueStart + queueSize] = other;
+ ++queueSize;
+ other.m_flags |= b2Body.e_islandFlag;
+ }
+ for (var jEdge = b.m_jointList; jEdge; jEdge = jEdge.next) {
+ if (island.m_jointCount == island.m_jointCapacity) continue;
+ if (jEdge.joint.m_islandFlag == true) continue;
+ other = jEdge.other;
+ if (other.IsActive() == false) {
+ continue;
+ }
+ island.AddJoint(jEdge.joint);
+ jEdge.joint.m_islandFlag = true;
+ if (other.m_flags & b2Body.e_islandFlag) continue;
+ if (other.GetType() != b2Body.b2_staticBody) {
+ other.Advance(minTOI);
+ other.SetAwake(true);
+ }
+ queue[queueStart + queueSize] = other;
+ ++queueSize;
+ other.m_flags |= b2Body.e_islandFlag;
+ }
+ }
+ var subStep = b2World.s_timestep;
+ subStep.warmStarting = false;
+ subStep.dt = (1.0 - minTOI) * step.dt;
+ subStep.inv_dt = 1.0 / subStep.dt;
+ subStep.dtRatio = 0.0;
+ subStep.velocityIterations = step.velocityIterations;
+ subStep.positionIterations = step.positionIterations;
+ island.SolveTOI(subStep);
+ var i = 0;
+ for (i = 0;
+ i < island.m_bodyCount; ++i) {
+ b = island.m_bodies[i];
+ b.m_flags &= ~b2Body.e_islandFlag;
+ if (b.IsAwake() == false) {
+ continue;
+ }
+ if (b.GetType() != b2Body.b2_dynamicBody) {
+ continue;
+ }
+ b.SynchronizeFixtures();
+ for (cEdge = b.m_contactList;
+ cEdge; cEdge = cEdge.next) {
+ cEdge.contact.m_flags &= ~b2Contact.e_toiFlag;
+ }
+ }
+ for (i = 0;
+ i < island.m_contactCount; ++i) {
+ c = island.m_contacts[i];
+ c.m_flags &= ~ (b2Contact.e_toiFlag | b2Contact.e_islandFlag);
+ }
+ for (i = 0;
+ i < island.m_jointCount; ++i) {
+ j = island.m_joints[i];
+ j.m_islandFlag = false;
+ }
+ this.m_contactManager.FindNewContacts();
+ }
+ }
+ b2World.prototype.DrawJoint = function (joint) {
+ var b1 = joint.GetBodyA();
+ var b2 = joint.GetBodyB();
+ var xf1 = b1.m_xf;
+ var xf2 = b2.m_xf;
+ var x1 = xf1.position;
+ var x2 = xf2.position;
+ var p1 = joint.GetAnchorA();
+ var p2 = joint.GetAnchorB();
+ var color = b2World.s_jointColor;
+ switch (joint.m_type) {
+ case b2Joint.e_distanceJoint:
+ this.m_debugDraw.DrawSegment(p1, p2, color);
+ break;
+ case b2Joint.e_pulleyJoint:
+ {
+ var pulley = ((joint instanceof b2PulleyJoint ? joint : null));
+ var s1 = pulley.GetGroundAnchorA();
+ var s2 = pulley.GetGroundAnchorB();
+ this.m_debugDraw.DrawSegment(s1, p1, color);
+ this.m_debugDraw.DrawSegment(s2, p2, color);
+ this.m_debugDraw.DrawSegment(s1, s2, color);
+ }
+ break;
+ case b2Joint.e_mouseJoint:
+ this.m_debugDraw.DrawSegment(p1, p2, color);
+ break;
+ default:
+ if (b1 != this.m_groundBody) this.m_debugDraw.DrawSegment(x1, p1, color);
+ this.m_debugDraw.DrawSegment(p1, p2, color);
+ if (b2 != this.m_groundBody) this.m_debugDraw.DrawSegment(x2, p2, color);
+ }
+ }
+ b2World.prototype.DrawShape = function (shape, xf, color) {
+ switch (shape.m_type) {
+ case b2Shape.e_circleShape:
+ {
+ var circle = ((shape instanceof b2CircleShape ? shape : null));
+ var center = b2Math.MulX(xf, circle.m_p);
+ var radius = circle.m_radius;
+ var axis = xf.R.col1;
+ this.m_debugDraw.DrawSolidCircle(center, radius, axis, color);
+ }
+ break;
+ case b2Shape.e_polygonShape:
+ {
+ var i = 0;
+ var poly = ((shape instanceof b2PolygonShape ? shape : null));
+ var vertexCount = parseInt(poly.GetVertexCount());
+ var localVertices = poly.GetVertices();
+ var vertices = new Vector(vertexCount);
+ for (i = 0;
+ i < vertexCount; ++i) {
+ vertices[i] = b2Math.MulX(xf, localVertices[i]);
+ }
+ this.m_debugDraw.DrawSolidPolygon(vertices, vertexCount, color);
+ }
+ break;
+ case b2Shape.e_edgeShape:
+ {
+ var edge = (shape instanceof b2EdgeShape ? shape : null);
+ this.m_debugDraw.DrawSegment(b2Math.MulX(xf, edge.GetVertex1()), b2Math.MulX(xf, edge.GetVertex2()), color);
+ }
+ break;
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.b2World.s_timestep2 = new b2TimeStep();
+ Box2D.Dynamics.b2World.s_xf = new b2Transform();
+ Box2D.Dynamics.b2World.s_backupA = new b2Sweep();
+ Box2D.Dynamics.b2World.s_backupB = new b2Sweep();
+ Box2D.Dynamics.b2World.s_timestep = new b2TimeStep();
+ Box2D.Dynamics.b2World.s_queue = new Vector();
+ Box2D.Dynamics.b2World.s_jointColor = new b2Color(0.5, 0.8, 0.8);
+ Box2D.Dynamics.b2World.e_newFixture = 0x0001;
+ Box2D.Dynamics.b2World.e_locked = 0x0002;
+ });
+})();
+(function () {
+ var b2CircleShape = Box2D.Collision.Shapes.b2CircleShape,
+ b2EdgeChainDef = Box2D.Collision.Shapes.b2EdgeChainDef,
+ b2EdgeShape = Box2D.Collision.Shapes.b2EdgeShape,
+ b2MassData = Box2D.Collision.Shapes.b2MassData,
+ b2PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
+ b2Shape = Box2D.Collision.Shapes.b2Shape,
+ b2CircleContact = Box2D.Dynamics.Contacts.b2CircleContact,
+ b2Contact = Box2D.Dynamics.Contacts.b2Contact,
+ b2ContactConstraint = Box2D.Dynamics.Contacts.b2ContactConstraint,
+ b2ContactConstraintPoint = Box2D.Dynamics.Contacts.b2ContactConstraintPoint,
+ b2ContactEdge = Box2D.Dynamics.Contacts.b2ContactEdge,
+ b2ContactFactory = Box2D.Dynamics.Contacts.b2ContactFactory,
+ b2ContactRegister = Box2D.Dynamics.Contacts.b2ContactRegister,
+ b2ContactResult = Box2D.Dynamics.Contacts.b2ContactResult,
+ b2ContactSolver = Box2D.Dynamics.Contacts.b2ContactSolver,
+ b2EdgeAndCircleContact = Box2D.Dynamics.Contacts.b2EdgeAndCircleContact,
+ b2NullContact = Box2D.Dynamics.Contacts.b2NullContact,
+ b2PolyAndCircleContact = Box2D.Dynamics.Contacts.b2PolyAndCircleContact,
+ b2PolyAndEdgeContact = Box2D.Dynamics.Contacts.b2PolyAndEdgeContact,
+ b2PolygonContact = Box2D.Dynamics.Contacts.b2PolygonContact,
+ b2PositionSolverManifold = Box2D.Dynamics.Contacts.b2PositionSolverManifold,
+ b2Body = Box2D.Dynamics.b2Body,
+ b2BodyDef = Box2D.Dynamics.b2BodyDef,
+ b2ContactFilter = Box2D.Dynamics.b2ContactFilter,
+ b2ContactImpulse = Box2D.Dynamics.b2ContactImpulse,
+ b2ContactListener = Box2D.Dynamics.b2ContactListener,
+ b2ContactManager = Box2D.Dynamics.b2ContactManager,
+ b2DebugDraw = Box2D.Dynamics.b2DebugDraw,
+ b2DestructionListener = Box2D.Dynamics.b2DestructionListener,
+ b2FilterData = Box2D.Dynamics.b2FilterData,
+ b2Fixture = Box2D.Dynamics.b2Fixture,
+ b2FixtureDef = Box2D.Dynamics.b2FixtureDef,
+ b2Island = Box2D.Dynamics.b2Island,
+ b2TimeStep = Box2D.Dynamics.b2TimeStep,
+ b2World = Box2D.Dynamics.b2World,
+ b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3,
+ b2AABB = Box2D.Collision.b2AABB,
+ b2Bound = Box2D.Collision.b2Bound,
+ b2BoundValues = Box2D.Collision.b2BoundValues,
+ b2Collision = Box2D.Collision.b2Collision,
+ b2ContactID = Box2D.Collision.b2ContactID,
+ b2ContactPoint = Box2D.Collision.b2ContactPoint,
+ b2Distance = Box2D.Collision.b2Distance,
+ b2DistanceInput = Box2D.Collision.b2DistanceInput,
+ b2DistanceOutput = Box2D.Collision.b2DistanceOutput,
+ b2DistanceProxy = Box2D.Collision.b2DistanceProxy,
+ b2DynamicTree = Box2D.Collision.b2DynamicTree,
+ b2DynamicTreeBroadPhase = Box2D.Collision.b2DynamicTreeBroadPhase,
+ b2DynamicTreeNode = Box2D.Collision.b2DynamicTreeNode,
+ b2DynamicTreePair = Box2D.Collision.b2DynamicTreePair,
+ b2Manifold = Box2D.Collision.b2Manifold,
+ b2ManifoldPoint = Box2D.Collision.b2ManifoldPoint,
+ b2Point = Box2D.Collision.b2Point,
+ b2RayCastInput = Box2D.Collision.b2RayCastInput,
+ b2RayCastOutput = Box2D.Collision.b2RayCastOutput,
+ b2Segment = Box2D.Collision.b2Segment,
+ b2SeparationFunction = Box2D.Collision.b2SeparationFunction,
+ b2Simplex = Box2D.Collision.b2Simplex,
+ b2SimplexCache = Box2D.Collision.b2SimplexCache,
+ b2SimplexVertex = Box2D.Collision.b2SimplexVertex,
+ b2TimeOfImpact = Box2D.Collision.b2TimeOfImpact,
+ b2TOIInput = Box2D.Collision.b2TOIInput,
+ b2WorldManifold = Box2D.Collision.b2WorldManifold,
+ ClipVertex = Box2D.Collision.ClipVertex,
+ Features = Box2D.Collision.Features,
+ IBroadPhase = Box2D.Collision.IBroadPhase;
+
+ Box2D.inherit(b2CircleContact, Box2D.Dynamics.Contacts.b2Contact);
+ b2CircleContact.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
+ b2CircleContact.b2CircleContact = function () {
+ Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments);
+ };
+ b2CircleContact.Create = function (allocator) {
+ return new b2CircleContact();
+ }
+ b2CircleContact.Destroy = function (contact, allocator) {}
+ b2CircleContact.prototype.Reset = function (fixtureA, fixtureB) {
+ this.__super.Reset.call(this, fixtureA, fixtureB);
+ }
+ b2CircleContact.prototype.Evaluate = function () {
+ var bA = this.m_fixtureA.GetBody();
+ var bB = this.m_fixtureB.GetBody();
+ b2Collision.CollideCircles(this.m_manifold, (this.m_fixtureA.GetShape() instanceof b2CircleShape ? this.m_fixtureA.GetShape() : null), bA.m_xf, (this.m_fixtureB.GetShape() instanceof b2CircleShape ? this.m_fixtureB.GetShape() : null), bB.m_xf);
+ }
+ b2Contact.b2Contact = function () {
+ this.m_nodeA = new b2ContactEdge();
+ this.m_nodeB = new b2ContactEdge();
+ this.m_manifold = new b2Manifold();
+ this.m_oldManifold = new b2Manifold();
+ };
+ b2Contact.prototype.GetManifold = function () {
+ return this.m_manifold;
+ }
+ b2Contact.prototype.GetWorldManifold = function (worldManifold) {
+ var bodyA = this.m_fixtureA.GetBody();
+ var bodyB = this.m_fixtureB.GetBody();
+ var shapeA = this.m_fixtureA.GetShape();
+ var shapeB = this.m_fixtureB.GetShape();
+ worldManifold.Initialize(this.m_manifold, bodyA.GetTransform(), shapeA.m_radius, bodyB.GetTransform(), shapeB.m_radius);
+ }
+ b2Contact.prototype.IsTouching = function () {
+ return (this.m_flags & b2Contact.e_touchingFlag) == b2Contact.e_touchingFlag;
+ }
+ b2Contact.prototype.IsContinuous = function () {
+ return (this.m_flags & b2Contact.e_continuousFlag) == b2Contact.e_continuousFlag;
+ }
+ b2Contact.prototype.SetSensor = function (sensor) {
+ if (sensor) {
+ this.m_flags |= b2Contact.e_sensorFlag;
+ }
+ else {
+ this.m_flags &= ~b2Contact.e_sensorFlag;
+ }
+ }
+ b2Contact.prototype.IsSensor = function () {
+ return (this.m_flags & b2Contact.e_sensorFlag) == b2Contact.e_sensorFlag;
+ }
+ b2Contact.prototype.SetEnabled = function (flag) {
+ if (flag) {
+ this.m_flags |= b2Contact.e_enabledFlag;
+ }
+ else {
+ this.m_flags &= ~b2Contact.e_enabledFlag;
+ }
+ }
+ b2Contact.prototype.IsEnabled = function () {
+ return (this.m_flags & b2Contact.e_enabledFlag) == b2Contact.e_enabledFlag;
+ }
+ b2Contact.prototype.GetNext = function () {
+ return this.m_next;
+ }
+ b2Contact.prototype.GetFixtureA = function () {
+ return this.m_fixtureA;
+ }
+ b2Contact.prototype.GetFixtureB = function () {
+ return this.m_fixtureB;
+ }
+ b2Contact.prototype.FlagForFiltering = function () {
+ this.m_flags |= b2Contact.e_filterFlag;
+ }
+ b2Contact.prototype.b2Contact = function () {}
+ b2Contact.prototype.Reset = function (fixtureA, fixtureB) {
+ if (fixtureA === undefined) fixtureA = null;
+ if (fixtureB === undefined) fixtureB = null;
+ this.m_flags = b2Contact.e_enabledFlag;
+ if (!fixtureA || !fixtureB) {
+ this.m_fixtureA = null;
+ this.m_fixtureB = null;
+ return;
+ }
+ if (fixtureA.IsSensor() || fixtureB.IsSensor()) {
+ this.m_flags |= b2Contact.e_sensorFlag;
+ }
+ var bodyA = fixtureA.GetBody();
+ var bodyB = fixtureB.GetBody();
+ if (bodyA.GetType() != b2Body.b2_dynamicBody || bodyA.IsBullet() || bodyB.GetType() != b2Body.b2_dynamicBody || bodyB.IsBullet()) {
+ this.m_flags |= b2Contact.e_continuousFlag;
+ }
+ this.m_fixtureA = fixtureA;
+ this.m_fixtureB = fixtureB;
+ this.m_manifold.m_pointCount = 0;
+ this.m_prev = null;
+ this.m_next = null;
+ this.m_nodeA.contact = null;
+ this.m_nodeA.prev = null;
+ this.m_nodeA.next = null;
+ this.m_nodeA.other = null;
+ this.m_nodeB.contact = null;
+ this.m_nodeB.prev = null;
+ this.m_nodeB.next = null;
+ this.m_nodeB.other = null;
+ }
+ b2Contact.prototype.Update = function (listener) {
+ var tManifold = this.m_oldManifold;
+ this.m_oldManifold = this.m_manifold;
+ this.m_manifold = tManifold;
+ this.m_flags |= b2Contact.e_enabledFlag;
+ var touching = false;
+ var wasTouching = (this.m_flags & b2Contact.e_touchingFlag) == b2Contact.e_touchingFlag;
+ var bodyA = this.m_fixtureA.m_body;
+ var bodyB = this.m_fixtureB.m_body;
+ var aabbOverlap = this.m_fixtureA.m_aabb.TestOverlap(this.m_fixtureB.m_aabb);
+ if (this.m_flags & b2Contact.e_sensorFlag) {
+ if (aabbOverlap) {
+ var shapeA = this.m_fixtureA.GetShape();
+ var shapeB = this.m_fixtureB.GetShape();
+ var xfA = bodyA.GetTransform();
+ var xfB = bodyB.GetTransform();
+ touching = b2Shape.TestOverlap(shapeA, xfA, shapeB, xfB);
+ }
+ this.m_manifold.m_pointCount = 0;
+ }
+ else {
+ if (bodyA.GetType() != b2Body.b2_dynamicBody || bodyA.IsBullet() || bodyB.GetType() != b2Body.b2_dynamicBody || bodyB.IsBullet()) {
+ this.m_flags |= b2Contact.e_continuousFlag;
+ }
+ else {
+ this.m_flags &= ~b2Contact.e_continuousFlag;
+ }
+ if (aabbOverlap) {
+ this.Evaluate();
+ touching = this.m_manifold.m_pointCount > 0;
+ for (var i = 0; i < this.m_manifold.m_pointCount; ++i) {
+ var mp2 = this.m_manifold.m_points[i];
+ mp2.m_normalImpulse = 0.0;
+ mp2.m_tangentImpulse = 0.0;
+ var id2 = mp2.m_id;
+ for (var j = 0; j < this.m_oldManifold.m_pointCount; ++j) {
+ var mp1 = this.m_oldManifold.m_points[j];
+ if (mp1.m_id.key == id2.key) {
+ mp2.m_normalImpulse = mp1.m_normalImpulse;
+ mp2.m_tangentImpulse = mp1.m_tangentImpulse;
+ break;
+ }
+ }
+ }
+ }
+ else {
+ this.m_manifold.m_pointCount = 0;
+ }
+ if (touching != wasTouching) {
+ bodyA.SetAwake(true);
+ bodyB.SetAwake(true);
+ }
+ }
+ if (touching) {
+ this.m_flags |= b2Contact.e_touchingFlag;
+ }
+ else {
+ this.m_flags &= ~b2Contact.e_touchingFlag;
+ }
+ if (wasTouching == false && touching == true) {
+ listener.BeginContact(this);
+ }
+ if (wasTouching == true && touching == false) {
+ listener.EndContact(this);
+ }
+ if ((this.m_flags & b2Contact.e_sensorFlag) == 0) {
+ listener.PreSolve(this, this.m_oldManifold);
+ }
+ }
+ b2Contact.prototype.Evaluate = function () {}
+ b2Contact.prototype.ComputeTOI = function (sweepA, sweepB) {
+ b2Contact.s_input.proxyA.Set(this.m_fixtureA.GetShape());
+ b2Contact.s_input.proxyB.Set(this.m_fixtureB.GetShape());
+ b2Contact.s_input.sweepA = sweepA;
+ b2Contact.s_input.sweepB = sweepB;
+ b2Contact.s_input.tolerance = b2Settings.b2_linearSlop;
+ return b2TimeOfImpact.TimeOfImpact(b2Contact.s_input);
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.Contacts.b2Contact.e_sensorFlag = 0x0001;
+ Box2D.Dynamics.Contacts.b2Contact.e_continuousFlag = 0x0002;
+ Box2D.Dynamics.Contacts.b2Contact.e_islandFlag = 0x0004;
+ Box2D.Dynamics.Contacts.b2Contact.e_toiFlag = 0x0008;
+ Box2D.Dynamics.Contacts.b2Contact.e_touchingFlag = 0x0010;
+ Box2D.Dynamics.Contacts.b2Contact.e_enabledFlag = 0x0020;
+ Box2D.Dynamics.Contacts.b2Contact.e_filterFlag = 0x0040;
+ Box2D.Dynamics.Contacts.b2Contact.s_input = new b2TOIInput();
+ });
+ b2ContactConstraint.b2ContactConstraint = function () {
+ this.localPlaneNormal = new b2Vec2();
+ this.localPoint = new b2Vec2();
+ this.normal = new b2Vec2();
+ this.normalMass = new b2Mat22();
+ this.K = new b2Mat22();
+ };
+ b2ContactConstraint.prototype.b2ContactConstraint = function () {
+ this.points = new Vector(b2Settings.b2_maxManifoldPoints);
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; i++) {
+ this.points[i] = new b2ContactConstraintPoint();
+ }
+ }
+ b2ContactConstraintPoint.b2ContactConstraintPoint = function () {
+ this.localPoint = new b2Vec2();
+ this.rA = new b2Vec2();
+ this.rB = new b2Vec2();
+ };
+ b2ContactEdge.b2ContactEdge = function () {};
+ b2ContactFactory.b2ContactFactory = function () {};
+ b2ContactFactory.prototype.b2ContactFactory = function (allocator) {
+ this.m_allocator = allocator;
+ this.InitializeRegisters();
+ }
+ b2ContactFactory.prototype.AddType = function (createFcn, destroyFcn, type1, type2) {
+ if (type1 === undefined) type1 = 0;
+ if (type2 === undefined) type2 = 0;
+ this.m_registers[type1][type2].createFcn = createFcn;
+ this.m_registers[type1][type2].destroyFcn = destroyFcn;
+ this.m_registers[type1][type2].primary = true;
+ if (type1 != type2) {
+ this.m_registers[type2][type1].createFcn = createFcn;
+ this.m_registers[type2][type1].destroyFcn = destroyFcn;
+ this.m_registers[type2][type1].primary = false;
+ }
+ }
+ b2ContactFactory.prototype.InitializeRegisters = function () {
+ this.m_registers = new Vector(b2Shape.e_shapeTypeCount);
+ for (var i = 0; i < b2Shape.e_shapeTypeCount; i++) {
+ this.m_registers[i] = new Vector(b2Shape.e_shapeTypeCount);
+ for (var j = 0; j < b2Shape.e_shapeTypeCount; j++) {
+ this.m_registers[i][j] = new b2ContactRegister();
+ }
+ }
+ this.AddType(b2CircleContact.Create, b2CircleContact.Destroy, b2Shape.e_circleShape, b2Shape.e_circleShape);
+ this.AddType(b2PolyAndCircleContact.Create, b2PolyAndCircleContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_circleShape);
+ this.AddType(b2PolygonContact.Create, b2PolygonContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_polygonShape);
+ this.AddType(b2EdgeAndCircleContact.Create, b2EdgeAndCircleContact.Destroy, b2Shape.e_edgeShape, b2Shape.e_circleShape);
+ this.AddType(b2PolyAndEdgeContact.Create, b2PolyAndEdgeContact.Destroy, b2Shape.e_polygonShape, b2Shape.e_edgeShape);
+ }
+ b2ContactFactory.prototype.Create = function (fixtureA, fixtureB) {
+ var type1 = parseInt(fixtureA.GetType());
+ var type2 = parseInt(fixtureB.GetType());
+ var reg = this.m_registers[type1][type2];
+ var c;
+ if (reg.pool) {
+ c = reg.pool;
+ reg.pool = c.m_next;
+ reg.poolCount--;
+ c.Reset(fixtureA, fixtureB);
+ return c;
+ }
+ var createFcn = reg.createFcn;
+ if (createFcn != null) {
+ if (reg.primary) {
+ c = createFcn(this.m_allocator);
+ c.Reset(fixtureA, fixtureB);
+ return c;
+ }
+ else {
+ c = createFcn(this.m_allocator);
+ c.Reset(fixtureB, fixtureA);
+ return c;
+ }
+ }
+ else {
+ return null;
+ }
+ }
+ b2ContactFactory.prototype.Destroy = function (contact) {
+ if (contact.m_manifold.m_pointCount > 0) {
+ contact.m_fixtureA.m_body.SetAwake(true);
+ contact.m_fixtureB.m_body.SetAwake(true);
+ }
+ var type1 = parseInt(contact.m_fixtureA.GetType());
+ var type2 = parseInt(contact.m_fixtureB.GetType());
+ var reg = this.m_registers[type1][type2];
+ if (true) {
+ reg.poolCount++;
+ contact.m_next = reg.pool;
+ reg.pool = contact;
+ }
+ var destroyFcn = reg.destroyFcn;
+ destroyFcn(contact, this.m_allocator);
+ }
+ b2ContactRegister.b2ContactRegister = function () {};
+ b2ContactResult.b2ContactResult = function () {
+ this.position = new b2Vec2();
+ this.normal = new b2Vec2();
+ this.id = new b2ContactID();
+ };
+ b2ContactSolver.b2ContactSolver = function () {
+ this.m_step = new b2TimeStep();
+ this.m_constraints = new Vector();
+ };
+ b2ContactSolver.prototype.b2ContactSolver = function () {}
+ b2ContactSolver.prototype.Initialize = function (step, contacts, contactCount, allocator) {
+ if (contactCount === undefined) contactCount = 0;
+ var contact;
+ this.m_step.Set(step);
+ this.m_allocator = allocator;
+ var i = 0;
+ var tVec;
+ var tMat;
+ this.m_constraintCount = contactCount;
+ while (this.m_constraints.length < this.m_constraintCount) {
+ this.m_constraints[this.m_constraints.length] = new b2ContactConstraint();
+ }
+ for (i = 0;
+ i < contactCount; ++i) {
+ contact = contacts[i];
+ var fixtureA = contact.m_fixtureA;
+ var fixtureB = contact.m_fixtureB;
+ var shapeA = fixtureA.m_shape;
+ var shapeB = fixtureB.m_shape;
+ var radiusA = shapeA.m_radius;
+ var radiusB = shapeB.m_radius;
+ var bodyA = fixtureA.m_body;
+ var bodyB = fixtureB.m_body;
+ var manifold = contact.GetManifold();
+ var friction = b2Settings.b2MixFriction(fixtureA.GetFriction(), fixtureB.GetFriction());
+ var restitution = b2Settings.b2MixRestitution(fixtureA.GetRestitution(), fixtureB.GetRestitution());
+ var vAX = bodyA.m_linearVelocity.x;
+ var vAY = bodyA.m_linearVelocity.y;
+ var vBX = bodyB.m_linearVelocity.x;
+ var vBY = bodyB.m_linearVelocity.y;
+ var wA = bodyA.m_angularVelocity;
+ var wB = bodyB.m_angularVelocity;
+ b2Settings.b2Assert(manifold.m_pointCount > 0);
+ b2ContactSolver.s_worldManifold.Initialize(manifold, bodyA.m_xf, radiusA, bodyB.m_xf, radiusB);
+ var normalX = b2ContactSolver.s_worldManifold.m_normal.x;
+ var normalY = b2ContactSolver.s_worldManifold.m_normal.y;
+ var cc = this.m_constraints[i];
+ cc.bodyA = bodyA;
+ cc.bodyB = bodyB;
+ cc.manifold = manifold;
+ cc.normal.x = normalX;
+ cc.normal.y = normalY;
+ cc.pointCount = manifold.m_pointCount;
+ cc.friction = friction;
+ cc.restitution = restitution;
+ cc.localPlaneNormal.x = manifold.m_localPlaneNormal.x;
+ cc.localPlaneNormal.y = manifold.m_localPlaneNormal.y;
+ cc.localPoint.x = manifold.m_localPoint.x;
+ cc.localPoint.y = manifold.m_localPoint.y;
+ cc.radius = radiusA + radiusB;
+ cc.type = manifold.m_type;
+ for (var k = 0; k < cc.pointCount; ++k) {
+ var cp = manifold.m_points[k];
+ var ccp = cc.points[k];
+ ccp.normalImpulse = cp.m_normalImpulse;
+ ccp.tangentImpulse = cp.m_tangentImpulse;
+ ccp.localPoint.SetV(cp.m_localPoint);
+ var rAX = ccp.rA.x = b2ContactSolver.s_worldManifold.m_points[k].x - bodyA.m_sweep.c.x;
+ var rAY = ccp.rA.y = b2ContactSolver.s_worldManifold.m_points[k].y - bodyA.m_sweep.c.y;
+ var rBX = ccp.rB.x = b2ContactSolver.s_worldManifold.m_points[k].x - bodyB.m_sweep.c.x;
+ var rBY = ccp.rB.y = b2ContactSolver.s_worldManifold.m_points[k].y - bodyB.m_sweep.c.y;
+ var rnA = rAX * normalY - rAY * normalX;
+ var rnB = rBX * normalY - rBY * normalX;
+ rnA *= rnA;
+ rnB *= rnB;
+ var kNormal = bodyA.m_invMass + bodyB.m_invMass + bodyA.m_invI * rnA + bodyB.m_invI * rnB;
+ ccp.normalMass = 1.0 / kNormal;
+ var kEqualized = bodyA.m_mass * bodyA.m_invMass + bodyB.m_mass * bodyB.m_invMass;
+ kEqualized += bodyA.m_mass * bodyA.m_invI * rnA + bodyB.m_mass * bodyB.m_invI * rnB;
+ ccp.equalizedMass = 1.0 / kEqualized;
+ var tangentX = normalY;
+ var tangentY = (-normalX);
+ var rtA = rAX * tangentY - rAY * tangentX;
+ var rtB = rBX * tangentY - rBY * tangentX;
+ rtA *= rtA;
+ rtB *= rtB;
+ var kTangent = bodyA.m_invMass + bodyB.m_invMass + bodyA.m_invI * rtA + bodyB.m_invI * rtB;
+ ccp.tangentMass = 1.0 / kTangent;
+ ccp.velocityBias = 0.0;
+ var tX = vBX + ((-wB * rBY)) - vAX - ((-wA * rAY));
+ var tY = vBY + (wB * rBX) - vAY - (wA * rAX);
+ var vRel = cc.normal.x * tX + cc.normal.y * tY;
+ if (vRel < (-b2Settings.b2_velocityThreshold)) {
+ ccp.velocityBias += (-cc.restitution * vRel);
+ }
+ }
+ if (cc.pointCount == 2) {
+ var ccp1 = cc.points[0];
+ var ccp2 = cc.points[1];
+ var invMassA = bodyA.m_invMass;
+ var invIA = bodyA.m_invI;
+ var invMassB = bodyB.m_invMass;
+ var invIB = bodyB.m_invI;
+ var rn1A = ccp1.rA.x * normalY - ccp1.rA.y * normalX;
+ var rn1B = ccp1.rB.x * normalY - ccp1.rB.y * normalX;
+ var rn2A = ccp2.rA.x * normalY - ccp2.rA.y * normalX;
+ var rn2B = ccp2.rB.x * normalY - ccp2.rB.y * normalX;
+ var k11 = invMassA + invMassB + invIA * rn1A * rn1A + invIB * rn1B * rn1B;
+ var k22 = invMassA + invMassB + invIA * rn2A * rn2A + invIB * rn2B * rn2B;
+ var k12 = invMassA + invMassB + invIA * rn1A * rn2A + invIB * rn1B * rn2B;
+ var k_maxConditionNumber = 100.0;
+ if (k11 * k11 < k_maxConditionNumber * (k11 * k22 - k12 * k12)) {
+ cc.K.col1.Set(k11, k12);
+ cc.K.col2.Set(k12, k22);
+ cc.K.GetInverse(cc.normalMass);
+ }
+ else {
+ cc.pointCount = 1;
+ }
+ }
+ }
+ }
+ b2ContactSolver.prototype.InitVelocityConstraints = function (step) {
+ var tVec;
+ var tVec2;
+ var tMat;
+ for (var i = 0; i < this.m_constraintCount; ++i) {
+ var c = this.m_constraints[i];
+ var bodyA = c.bodyA;
+ var bodyB = c.bodyB;
+ var invMassA = bodyA.m_invMass;
+ var invIA = bodyA.m_invI;
+ var invMassB = bodyB.m_invMass;
+ var invIB = bodyB.m_invI;
+ var normalX = c.normal.x;
+ var normalY = c.normal.y;
+ var tangentX = normalY;
+ var tangentY = (-normalX);
+ var tX = 0;
+ var j = 0;
+ var tCount = 0;
+ if (step.warmStarting) {
+ tCount = c.pointCount;
+ for (j = 0;
+ j < tCount; ++j) {
+ var ccp = c.points[j];
+ ccp.normalImpulse *= step.dtRatio;
+ ccp.tangentImpulse *= step.dtRatio;
+ var PX = ccp.normalImpulse * normalX + ccp.tangentImpulse * tangentX;
+ var PY = ccp.normalImpulse * normalY + ccp.tangentImpulse * tangentY;
+ bodyA.m_angularVelocity -= invIA * (ccp.rA.x * PY - ccp.rA.y * PX);
+ bodyA.m_linearVelocity.x -= invMassA * PX;
+ bodyA.m_linearVelocity.y -= invMassA * PY;
+ bodyB.m_angularVelocity += invIB * (ccp.rB.x * PY - ccp.rB.y * PX);
+ bodyB.m_linearVelocity.x += invMassB * PX;
+ bodyB.m_linearVelocity.y += invMassB * PY;
+ }
+ }
+ else {
+ tCount = c.pointCount;
+ for (j = 0;
+ j < tCount; ++j) {
+ var ccp2 = c.points[j];
+ ccp2.normalImpulse = 0.0;
+ ccp2.tangentImpulse = 0.0;
+ }
+ }
+ }
+ }
+ b2ContactSolver.prototype.SolveVelocityConstraints = function () {
+ var j = 0;
+ var ccp;
+ var rAX = 0;
+ var rAY = 0;
+ var rBX = 0;
+ var rBY = 0;
+ var dvX = 0;
+ var dvY = 0;
+ var vn = 0;
+ var vt = 0;
+ var lambda = 0;
+ var maxFriction = 0;
+ var newImpulse = 0;
+ var PX = 0;
+ var PY = 0;
+ var dX = 0;
+ var dY = 0;
+ var P1X = 0;
+ var P1Y = 0;
+ var P2X = 0;
+ var P2Y = 0;
+ var tMat;
+ var tVec;
+ for (var i = 0; i < this.m_constraintCount; ++i) {
+ var c = this.m_constraints[i];
+ var bodyA = c.bodyA;
+ var bodyB = c.bodyB;
+ var wA = bodyA.m_angularVelocity;
+ var wB = bodyB.m_angularVelocity;
+ var vA = bodyA.m_linearVelocity;
+ var vB = bodyB.m_linearVelocity;
+ var invMassA = bodyA.m_invMass;
+ var invIA = bodyA.m_invI;
+ var invMassB = bodyB.m_invMass;
+ var invIB = bodyB.m_invI;
+ var normalX = c.normal.x;
+ var normalY = c.normal.y;
+ var tangentX = normalY;
+ var tangentY = (-normalX);
+ var friction = c.friction;
+ var tX = 0;
+ for (j = 0;
+ j < c.pointCount; j++) {
+ ccp = c.points[j];
+ dvX = vB.x - wB * ccp.rB.y - vA.x + wA * ccp.rA.y;
+ dvY = vB.y + wB * ccp.rB.x - vA.y - wA * ccp.rA.x;
+ vt = dvX * tangentX + dvY * tangentY;
+ lambda = ccp.tangentMass * (-vt);
+ maxFriction = friction * ccp.normalImpulse;
+ newImpulse = b2Math.Clamp(ccp.tangentImpulse + lambda, (-maxFriction), maxFriction);
+ lambda = newImpulse - ccp.tangentImpulse;
+ PX = lambda * tangentX;
+ PY = lambda * tangentY;
+ vA.x -= invMassA * PX;
+ vA.y -= invMassA * PY;
+ wA -= invIA * (ccp.rA.x * PY - ccp.rA.y * PX);
+ vB.x += invMassB * PX;
+ vB.y += invMassB * PY;
+ wB += invIB * (ccp.rB.x * PY - ccp.rB.y * PX);
+ ccp.tangentImpulse = newImpulse;
+ }
+ var tCount = parseInt(c.pointCount);
+ if (c.pointCount == 1) {
+ ccp = c.points[0];
+ dvX = vB.x + ((-wB * ccp.rB.y)) - vA.x - ((-wA * ccp.rA.y));
+ dvY = vB.y + (wB * ccp.rB.x) - vA.y - (wA * ccp.rA.x);
+ vn = dvX * normalX + dvY * normalY;
+ lambda = (-ccp.normalMass * (vn - ccp.velocityBias));
+ newImpulse = ccp.normalImpulse + lambda;
+ newImpulse = newImpulse > 0 ? newImpulse : 0.0;
+ lambda = newImpulse - ccp.normalImpulse;
+ PX = lambda * normalX;
+ PY = lambda * normalY;
+ vA.x -= invMassA * PX;
+ vA.y -= invMassA * PY;
+ wA -= invIA * (ccp.rA.x * PY - ccp.rA.y * PX);
+ vB.x += invMassB * PX;
+ vB.y += invMassB * PY;
+ wB += invIB * (ccp.rB.x * PY - ccp.rB.y * PX);
+ ccp.normalImpulse = newImpulse;
+ }
+ else {
+ var cp1 = c.points[0];
+ var cp2 = c.points[1];
+ var aX = cp1.normalImpulse;
+ var aY = cp2.normalImpulse;
+ var dv1X = vB.x - wB * cp1.rB.y - vA.x + wA * cp1.rA.y;
+ var dv1Y = vB.y + wB * cp1.rB.x - vA.y - wA * cp1.rA.x;
+ var dv2X = vB.x - wB * cp2.rB.y - vA.x + wA * cp2.rA.y;
+ var dv2Y = vB.y + wB * cp2.rB.x - vA.y - wA * cp2.rA.x;
+ var vn1 = dv1X * normalX + dv1Y * normalY;
+ var vn2 = dv2X * normalX + dv2Y * normalY;
+ var bX = vn1 - cp1.velocityBias;
+ var bY = vn2 - cp2.velocityBias;
+ tMat = c.K;
+ bX -= tMat.col1.x * aX + tMat.col2.x * aY;
+ bY -= tMat.col1.y * aX + tMat.col2.y * aY;
+ var k_errorTol = 0.001;
+ for (;;) {
+ tMat = c.normalMass;
+ var xX = (-(tMat.col1.x * bX + tMat.col2.x * bY));
+ var xY = (-(tMat.col1.y * bX + tMat.col2.y * bY));
+ if (xX >= 0.0 && xY >= 0.0) {
+ dX = xX - aX;
+ dY = xY - aY;
+ P1X = dX * normalX;
+ P1Y = dX * normalY;
+ P2X = dY * normalX;
+ P2Y = dY * normalY;
+ vA.x -= invMassA * (P1X + P2X);
+ vA.y -= invMassA * (P1Y + P2Y);
+ wA -= invIA * (cp1.rA.x * P1Y - cp1.rA.y * P1X + cp2.rA.x * P2Y - cp2.rA.y * P2X);
+ vB.x += invMassB * (P1X + P2X);
+ vB.y += invMassB * (P1Y + P2Y);
+ wB += invIB * (cp1.rB.x * P1Y - cp1.rB.y * P1X + cp2.rB.x * P2Y - cp2.rB.y * P2X);
+ cp1.normalImpulse = xX;
+ cp2.normalImpulse = xY;
+ break;
+ }
+ xX = (-cp1.normalMass * bX);
+ xY = 0.0;
+ vn1 = 0.0;
+ vn2 = c.K.col1.y * xX + bY;
+ if (xX >= 0.0 && vn2 >= 0.0) {
+ dX = xX - aX;
+ dY = xY - aY;
+ P1X = dX * normalX;
+ P1Y = dX * normalY;
+ P2X = dY * normalX;
+ P2Y = dY * normalY;
+ vA.x -= invMassA * (P1X + P2X);
+ vA.y -= invMassA * (P1Y + P2Y);
+ wA -= invIA * (cp1.rA.x * P1Y - cp1.rA.y * P1X + cp2.rA.x * P2Y - cp2.rA.y * P2X);
+ vB.x += invMassB * (P1X + P2X);
+ vB.y += invMassB * (P1Y + P2Y);
+ wB += invIB * (cp1.rB.x * P1Y - cp1.rB.y * P1X + cp2.rB.x * P2Y - cp2.rB.y * P2X);
+ cp1.normalImpulse = xX;
+ cp2.normalImpulse = xY;
+ break;
+ }
+ xX = 0.0;
+ xY = (-cp2.normalMass * bY);
+ vn1 = c.K.col2.x * xY + bX;
+ vn2 = 0.0;
+ if (xY >= 0.0 && vn1 >= 0.0) {
+ dX = xX - aX;
+ dY = xY - aY;
+ P1X = dX * normalX;
+ P1Y = dX * normalY;
+ P2X = dY * normalX;
+ P2Y = dY * normalY;
+ vA.x -= invMassA * (P1X + P2X);
+ vA.y -= invMassA * (P1Y + P2Y);
+ wA -= invIA * (cp1.rA.x * P1Y - cp1.rA.y * P1X + cp2.rA.x * P2Y - cp2.rA.y * P2X);
+ vB.x += invMassB * (P1X + P2X);
+ vB.y += invMassB * (P1Y + P2Y);
+ wB += invIB * (cp1.rB.x * P1Y - cp1.rB.y * P1X + cp2.rB.x * P2Y - cp2.rB.y * P2X);
+ cp1.normalImpulse = xX;
+ cp2.normalImpulse = xY;
+ break;
+ }
+ xX = 0.0;
+ xY = 0.0;
+ vn1 = bX;
+ vn2 = bY;
+ if (vn1 >= 0.0 && vn2 >= 0.0) {
+ dX = xX - aX;
+ dY = xY - aY;
+ P1X = dX * normalX;
+ P1Y = dX * normalY;
+ P2X = dY * normalX;
+ P2Y = dY * normalY;
+ vA.x -= invMassA * (P1X + P2X);
+ vA.y -= invMassA * (P1Y + P2Y);
+ wA -= invIA * (cp1.rA.x * P1Y - cp1.rA.y * P1X + cp2.rA.x * P2Y - cp2.rA.y * P2X);
+ vB.x += invMassB * (P1X + P2X);
+ vB.y += invMassB * (P1Y + P2Y);
+ wB += invIB * (cp1.rB.x * P1Y - cp1.rB.y * P1X + cp2.rB.x * P2Y - cp2.rB.y * P2X);
+ cp1.normalImpulse = xX;
+ cp2.normalImpulse = xY;
+ break;
+ }
+ break;
+ }
+ }
+ bodyA.m_angularVelocity = wA;
+ bodyB.m_angularVelocity = wB;
+ }
+ }
+ b2ContactSolver.prototype.FinalizeVelocityConstraints = function () {
+ for (var i = 0; i < this.m_constraintCount; ++i) {
+ var c = this.m_constraints[i];
+ var m = c.manifold;
+ for (var j = 0; j < c.pointCount; ++j) {
+ var point1 = m.m_points[j];
+ var point2 = c.points[j];
+ point1.m_normalImpulse = point2.normalImpulse;
+ point1.m_tangentImpulse = point2.tangentImpulse;
+ }
+ }
+ }
+ b2ContactSolver.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var minSeparation = 0.0;
+ for (var i = 0; i < this.m_constraintCount; i++) {
+ var c = this.m_constraints[i];
+ var bodyA = c.bodyA;
+ var bodyB = c.bodyB;
+ var invMassA = bodyA.m_mass * bodyA.m_invMass;
+ var invIA = bodyA.m_mass * bodyA.m_invI;
+ var invMassB = bodyB.m_mass * bodyB.m_invMass;
+ var invIB = bodyB.m_mass * bodyB.m_invI;
+ b2ContactSolver.s_psm.Initialize(c);
+ var normal = b2ContactSolver.s_psm.m_normal;
+ for (var j = 0; j < c.pointCount; j++) {
+ var ccp = c.points[j];
+ var point = b2ContactSolver.s_psm.m_points[j];
+ var separation = b2ContactSolver.s_psm.m_separations[j];
+ var rAX = point.x - bodyA.m_sweep.c.x;
+ var rAY = point.y - bodyA.m_sweep.c.y;
+ var rBX = point.x - bodyB.m_sweep.c.x;
+ var rBY = point.y - bodyB.m_sweep.c.y;
+ minSeparation = minSeparation < separation ? minSeparation : separation;
+ var C = b2Math.Clamp(baumgarte * (separation + b2Settings.b2_linearSlop), (-b2Settings.b2_maxLinearCorrection), 0.0);
+ var impulse = (-ccp.equalizedMass * C);
+ var PX = impulse * normal.x;
+ var PY = impulse * normal.y;bodyA.m_sweep.c.x -= invMassA * PX;
+ bodyA.m_sweep.c.y -= invMassA * PY;
+ bodyA.m_sweep.a -= invIA * (rAX * PY - rAY * PX);
+ bodyA.SynchronizeTransform();
+ bodyB.m_sweep.c.x += invMassB * PX;
+ bodyB.m_sweep.c.y += invMassB * PY;
+ bodyB.m_sweep.a += invIB * (rBX * PY - rBY * PX);
+ bodyB.SynchronizeTransform();
+ }
+ }
+ return minSeparation > (-1.5 * b2Settings.b2_linearSlop);
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.Contacts.b2ContactSolver.s_worldManifold = new b2WorldManifold();
+ Box2D.Dynamics.Contacts.b2ContactSolver.s_psm = new b2PositionSolverManifold();
+ });
+ Box2D.inherit(b2EdgeAndCircleContact, Box2D.Dynamics.Contacts.b2Contact);
+ b2EdgeAndCircleContact.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
+ b2EdgeAndCircleContact.b2EdgeAndCircleContact = function () {
+ Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments);
+ };
+ b2EdgeAndCircleContact.Create = function (allocator) {
+ return new b2EdgeAndCircleContact();
+ }
+ b2EdgeAndCircleContact.Destroy = function (contact, allocator) {}
+ b2EdgeAndCircleContact.prototype.Reset = function (fixtureA, fixtureB) {
+ this.__super.Reset.call(this, fixtureA, fixtureB);
+ }
+ b2EdgeAndCircleContact.prototype.Evaluate = function () {
+ var bA = this.m_fixtureA.GetBody();
+ var bB = this.m_fixtureB.GetBody();
+ this.b2CollideEdgeAndCircle(this.m_manifold, (this.m_fixtureA.GetShape() instanceof b2EdgeShape ? this.m_fixtureA.GetShape() : null), bA.m_xf, (this.m_fixtureB.GetShape() instanceof b2CircleShape ? this.m_fixtureB.GetShape() : null), bB.m_xf);
+ }
+ b2EdgeAndCircleContact.prototype.b2CollideEdgeAndCircle = function (manifold, edge, xf1, circle, xf2) {}
+ Box2D.inherit(b2NullContact, Box2D.Dynamics.Contacts.b2Contact);
+ b2NullContact.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
+ b2NullContact.b2NullContact = function () {
+ Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments);
+ };
+ b2NullContact.prototype.b2NullContact = function () {
+ this.__super.b2Contact.call(this);
+ }
+ b2NullContact.prototype.Evaluate = function () {}
+ Box2D.inherit(b2PolyAndCircleContact, Box2D.Dynamics.Contacts.b2Contact);
+ b2PolyAndCircleContact.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
+ b2PolyAndCircleContact.b2PolyAndCircleContact = function () {
+ Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments);
+ };
+ b2PolyAndCircleContact.Create = function (allocator) {
+ return new b2PolyAndCircleContact();
+ }
+ b2PolyAndCircleContact.Destroy = function (contact, allocator) {}
+ b2PolyAndCircleContact.prototype.Reset = function (fixtureA, fixtureB) {
+ this.__super.Reset.call(this, fixtureA, fixtureB);
+ b2Settings.b2Assert(fixtureA.GetType() == b2Shape.e_polygonShape);
+ b2Settings.b2Assert(fixtureB.GetType() == b2Shape.e_circleShape);
+ }
+ b2PolyAndCircleContact.prototype.Evaluate = function () {
+ var bA = this.m_fixtureA.m_body;
+ var bB = this.m_fixtureB.m_body;
+ b2Collision.CollidePolygonAndCircle(this.m_manifold, (this.m_fixtureA.GetShape() instanceof b2PolygonShape ? this.m_fixtureA.GetShape() : null), bA.m_xf, (this.m_fixtureB.GetShape() instanceof b2CircleShape ? this.m_fixtureB.GetShape() : null), bB.m_xf);
+ }
+ Box2D.inherit(b2PolyAndEdgeContact, Box2D.Dynamics.Contacts.b2Contact);
+ b2PolyAndEdgeContact.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
+ b2PolyAndEdgeContact.b2PolyAndEdgeContact = function () {
+ Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments);
+ };
+ b2PolyAndEdgeContact.Create = function (allocator) {
+ return new b2PolyAndEdgeContact();
+ }
+ b2PolyAndEdgeContact.Destroy = function (contact, allocator) {}
+ b2PolyAndEdgeContact.prototype.Reset = function (fixtureA, fixtureB) {
+ this.__super.Reset.call(this, fixtureA, fixtureB);
+ b2Settings.b2Assert(fixtureA.GetType() == b2Shape.e_polygonShape);
+ b2Settings.b2Assert(fixtureB.GetType() == b2Shape.e_edgeShape);
+ }
+ b2PolyAndEdgeContact.prototype.Evaluate = function () {
+ var bA = this.m_fixtureA.GetBody();
+ var bB = this.m_fixtureB.GetBody();
+ this.b2CollidePolyAndEdge(this.m_manifold, (this.m_fixtureA.GetShape() instanceof b2PolygonShape ? this.m_fixtureA.GetShape() : null), bA.m_xf, (this.m_fixtureB.GetShape() instanceof b2EdgeShape ? this.m_fixtureB.GetShape() : null), bB.m_xf);
+ }
+ b2PolyAndEdgeContact.prototype.b2CollidePolyAndEdge = function (manifold, polygon, xf1, edge, xf2) {}
+ Box2D.inherit(b2PolygonContact, Box2D.Dynamics.Contacts.b2Contact);
+ b2PolygonContact.prototype.__super = Box2D.Dynamics.Contacts.b2Contact.prototype;
+ b2PolygonContact.b2PolygonContact = function () {
+ Box2D.Dynamics.Contacts.b2Contact.b2Contact.apply(this, arguments);
+ };
+ b2PolygonContact.Create = function (allocator) {
+ return new b2PolygonContact();
+ }
+ b2PolygonContact.Destroy = function (contact, allocator) {}
+ b2PolygonContact.prototype.Reset = function (fixtureA, fixtureB) {
+ this.__super.Reset.call(this, fixtureA, fixtureB);
+ }
+ b2PolygonContact.prototype.Evaluate = function () {
+ var bA = this.m_fixtureA.GetBody();
+ var bB = this.m_fixtureB.GetBody();
+ b2Collision.CollidePolygons(this.m_manifold, (this.m_fixtureA.GetShape() instanceof b2PolygonShape ? this.m_fixtureA.GetShape() : null), bA.m_xf, (this.m_fixtureB.GetShape() instanceof b2PolygonShape ? this.m_fixtureB.GetShape() : null), bB.m_xf);
+ }
+ b2PositionSolverManifold.b2PositionSolverManifold = function () {};
+ b2PositionSolverManifold.prototype.b2PositionSolverManifold = function () {
+ this.m_normal = new b2Vec2();
+ this.m_separations = new Vector_a2j_Number(b2Settings.b2_maxManifoldPoints);
+ this.m_points = new Vector(b2Settings.b2_maxManifoldPoints);
+ for (var i = 0; i < b2Settings.b2_maxManifoldPoints; i++) {
+ this.m_points[i] = new b2Vec2();
+ }
+ }
+ b2PositionSolverManifold.prototype.Initialize = function (cc) {
+ b2Settings.b2Assert(cc.pointCount > 0);
+ var i = 0;
+ var clipPointX = 0;
+ var clipPointY = 0;
+ var tMat;
+ var tVec;
+ var planePointX = 0;
+ var planePointY = 0;
+ switch (cc.type) {
+ case b2Manifold.e_circles:
+ {
+ tMat = cc.bodyA.m_xf.R;
+ tVec = cc.localPoint;
+ var pointAX = cc.bodyA.m_xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var pointAY = cc.bodyA.m_xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = cc.bodyB.m_xf.R;
+ tVec = cc.points[0].localPoint;
+ var pointBX = cc.bodyB.m_xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ var pointBY = cc.bodyB.m_xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ var dX = pointBX - pointAX;
+ var dY = pointBY - pointAY;
+ var d2 = dX * dX + dY * dY;
+ if (d2 > Number.MIN_VALUE * Number.MIN_VALUE) {
+ var d = Math.sqrt(d2);
+ this.m_normal.x = dX / d;
+ this.m_normal.y = dY / d;
+ }
+ else {
+ this.m_normal.x = 1.0;
+ this.m_normal.y = 0.0;
+ }
+ this.m_points[0].x = 0.5 * (pointAX + pointBX);
+ this.m_points[0].y = 0.5 * (pointAY + pointBY);
+ this.m_separations[0] = dX * this.m_normal.x + dY * this.m_normal.y - cc.radius;
+ }
+ break;
+ case b2Manifold.e_faceA:
+ {
+ tMat = cc.bodyA.m_xf.R;
+ tVec = cc.localPlaneNormal;
+ this.m_normal.x = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ this.m_normal.y = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = cc.bodyA.m_xf.R;
+ tVec = cc.localPoint;
+ planePointX = cc.bodyA.m_xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ planePointY = cc.bodyA.m_xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = cc.bodyB.m_xf.R;
+ for (i = 0;
+ i < cc.pointCount; ++i) {
+ tVec = cc.points[i].localPoint;
+ clipPointX = cc.bodyB.m_xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ clipPointY = cc.bodyB.m_xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ this.m_separations[i] = (clipPointX - planePointX) * this.m_normal.x + (clipPointY - planePointY) * this.m_normal.y - cc.radius;
+ this.m_points[i].x = clipPointX;
+ this.m_points[i].y = clipPointY;
+ }
+ }
+ break;
+ case b2Manifold.e_faceB:
+ {
+ tMat = cc.bodyB.m_xf.R;
+ tVec = cc.localPlaneNormal;
+ this.m_normal.x = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ this.m_normal.y = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = cc.bodyB.m_xf.R;
+ tVec = cc.localPoint;
+ planePointX = cc.bodyB.m_xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ planePointY = cc.bodyB.m_xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ tMat = cc.bodyA.m_xf.R;
+ for (i = 0;
+ i < cc.pointCount; ++i) {
+ tVec = cc.points[i].localPoint;
+ clipPointX = cc.bodyA.m_xf.position.x + (tMat.col1.x * tVec.x + tMat.col2.x * tVec.y);
+ clipPointY = cc.bodyA.m_xf.position.y + (tMat.col1.y * tVec.x + tMat.col2.y * tVec.y);
+ this.m_separations[i] = (clipPointX - planePointX) * this.m_normal.x + (clipPointY - planePointY) * this.m_normal.y - cc.radius;
+ this.m_points[i].Set(clipPointX, clipPointY);
+ }
+ this.m_normal.x *= (-1);
+ this.m_normal.y *= (-1);
+ }
+ break;
+ }
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.Contacts.b2PositionSolverManifold.circlePointA = new b2Vec2();
+ Box2D.Dynamics.Contacts.b2PositionSolverManifold.circlePointB = new b2Vec2();
+ });
+})();
+(function () {
+ var b2Body = Box2D.Dynamics.b2Body,
+ b2BodyDef = Box2D.Dynamics.b2BodyDef,
+ b2ContactFilter = Box2D.Dynamics.b2ContactFilter,
+ b2ContactImpulse = Box2D.Dynamics.b2ContactImpulse,
+ b2ContactListener = Box2D.Dynamics.b2ContactListener,
+ b2ContactManager = Box2D.Dynamics.b2ContactManager,
+ b2DebugDraw = Box2D.Dynamics.b2DebugDraw,
+ b2DestructionListener = Box2D.Dynamics.b2DestructionListener,
+ b2FilterData = Box2D.Dynamics.b2FilterData,
+ b2Fixture = Box2D.Dynamics.b2Fixture,
+ b2FixtureDef = Box2D.Dynamics.b2FixtureDef,
+ b2Island = Box2D.Dynamics.b2Island,
+ b2TimeStep = Box2D.Dynamics.b2TimeStep,
+ b2World = Box2D.Dynamics.b2World,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3,
+ b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2CircleShape = Box2D.Collision.Shapes.b2CircleShape,
+ b2EdgeChainDef = Box2D.Collision.Shapes.b2EdgeChainDef,
+ b2EdgeShape = Box2D.Collision.Shapes.b2EdgeShape,
+ b2MassData = Box2D.Collision.Shapes.b2MassData,
+ b2PolygonShape = Box2D.Collision.Shapes.b2PolygonShape,
+ b2Shape = Box2D.Collision.Shapes.b2Shape,
+ b2BuoyancyController = Box2D.Dynamics.Controllers.b2BuoyancyController,
+ b2ConstantAccelController = Box2D.Dynamics.Controllers.b2ConstantAccelController,
+ b2ConstantForceController = Box2D.Dynamics.Controllers.b2ConstantForceController,
+ b2Controller = Box2D.Dynamics.Controllers.b2Controller,
+ b2ControllerEdge = Box2D.Dynamics.Controllers.b2ControllerEdge,
+ b2GravityController = Box2D.Dynamics.Controllers.b2GravityController,
+ b2TensorDampingController = Box2D.Dynamics.Controllers.b2TensorDampingController;
+
+ Box2D.inherit(b2BuoyancyController, Box2D.Dynamics.Controllers.b2Controller);
+ b2BuoyancyController.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
+ b2BuoyancyController.b2BuoyancyController = function () {
+ Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
+ this.normal = new b2Vec2(0, (-1));
+ this.offset = 0;
+ this.density = 0;
+ this.velocity = new b2Vec2(0, 0);
+ this.linearDrag = 2;
+ this.angularDrag = 1;
+ this.useDensity = false;
+ this.useWorldGravity = true;
+ this.gravity = null;
+ };
+ b2BuoyancyController.prototype.Step = function (step) {
+ if (!this.m_bodyList) return;
+ if (this.useWorldGravity) {
+ this.gravity = this.GetWorld().GetGravity().Copy();
+ }
+ for (var i = this.m_bodyList; i; i = i.nextBody) {
+ var body = i.body;
+ if (body.IsAwake() == false) {
+ continue;
+ }
+ var areac = new b2Vec2();
+ var massc = new b2Vec2();
+ var area = 0.0;
+ var mass = 0.0;
+ for (var fixture = body.GetFixtureList(); fixture; fixture = fixture.GetNext()) {
+ var sc = new b2Vec2();
+ var sarea = fixture.GetShape().ComputeSubmergedArea(this.normal, this.offset, body.GetTransform(), sc);
+ area += sarea;
+ areac.x += sarea * sc.x;
+ areac.y += sarea * sc.y;
+ var shapeDensity = 0;
+ if (this.useDensity) {
+ shapeDensity = 1;
+ }
+ else {
+ shapeDensity = 1;
+ }
+ mass += sarea * shapeDensity;
+ massc.x += sarea * sc.x * shapeDensity;
+ massc.y += sarea * sc.y * shapeDensity;
+ }
+ areac.x /= area;
+ areac.y /= area;
+ massc.x /= mass;
+ massc.y /= mass;
+ if (area < Number.MIN_VALUE) continue;
+ var buoyancyForce = this.gravity.GetNegative();
+ buoyancyForce.Multiply(this.density * area);
+ body.ApplyForce(buoyancyForce, massc);
+ var dragForce = body.GetLinearVelocityFromWorldPoint(areac);
+ dragForce.Subtract(this.velocity);
+ dragForce.Multiply((-this.linearDrag * area));
+ body.ApplyForce(dragForce, areac);
+ body.ApplyTorque((-body.GetInertia() / body.GetMass() * area * body.GetAngularVelocity() * this.angularDrag));
+ }
+ }
+ b2BuoyancyController.prototype.Draw = function (debugDraw) {
+ var r = 1000;
+ var p1 = new b2Vec2();
+ var p2 = new b2Vec2();
+ p1.x = this.normal.x * this.offset + this.normal.y * r;
+ p1.y = this.normal.y * this.offset - this.normal.x * r;
+ p2.x = this.normal.x * this.offset - this.normal.y * r;
+ p2.y = this.normal.y * this.offset + this.normal.x * r;
+ var color = new b2Color(0, 0, 1);
+ debugDraw.DrawSegment(p1, p2, color);
+ }
+ Box2D.inherit(b2ConstantAccelController, Box2D.Dynamics.Controllers.b2Controller);
+ b2ConstantAccelController.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
+ b2ConstantAccelController.b2ConstantAccelController = function () {
+ Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
+ this.A = new b2Vec2(0, 0);
+ };
+ b2ConstantAccelController.prototype.Step = function (step) {
+ var smallA = new b2Vec2(this.A.x * step.dt, this.A.y * step.dt);
+ for (var i = this.m_bodyList; i; i = i.nextBody) {
+ var body = i.body;
+ if (!body.IsAwake()) continue;
+ body.SetLinearVelocity(new b2Vec2(body.GetLinearVelocity().x + smallA.x, body.GetLinearVelocity().y + smallA.y));
+ }
+ }
+ Box2D.inherit(b2ConstantForceController, Box2D.Dynamics.Controllers.b2Controller);
+ b2ConstantForceController.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
+ b2ConstantForceController.b2ConstantForceController = function () {
+ Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
+ this.F = new b2Vec2(0, 0);
+ };
+ b2ConstantForceController.prototype.Step = function (step) {
+ for (var i = this.m_bodyList; i; i = i.nextBody) {
+ var body = i.body;
+ if (!body.IsAwake()) continue;
+ body.ApplyForce(this.F, body.GetWorldCenter());
+ }
+ }
+ b2Controller.b2Controller = function () {};
+ b2Controller.prototype.Step = function (step) {}
+ b2Controller.prototype.Draw = function (debugDraw) {}
+ b2Controller.prototype.AddBody = function (body) {
+ var edge = new b2ControllerEdge();
+ edge.controller = this;
+ edge.body = body;
+ edge.nextBody = this.m_bodyList;
+ edge.prevBody = null;
+ this.m_bodyList = edge;
+ if (edge.nextBody) edge.nextBody.prevBody = edge;
+ this.m_bodyCount++;
+ edge.nextController = body.m_controllerList;
+ edge.prevController = null;
+ body.m_controllerList = edge;
+ if (edge.nextController) edge.nextController.prevController = edge;
+ body.m_controllerCount++;
+ }
+ b2Controller.prototype.RemoveBody = function (body) {
+ var edge = body.m_controllerList;
+ while (edge && edge.controller != this)
+ edge = edge.nextController;
+ if (edge.prevBody) edge.prevBody.nextBody = edge.nextBody;
+ if (edge.nextBody) edge.nextBody.prevBody = edge.prevBody;
+ if (edge.nextController) edge.nextController.prevController = edge.prevController;
+ if (edge.prevController) edge.prevController.nextController = edge.nextController;
+ if (this.m_bodyList == edge) this.m_bodyList = edge.nextBody;
+ if (body.m_controllerList == edge) body.m_controllerList = edge.nextController;
+ body.m_controllerCount--;
+ this.m_bodyCount--;
+ }
+ b2Controller.prototype.Clear = function () {
+ while (this.m_bodyList)
+ this.RemoveBody(this.m_bodyList.body);
+ }
+ b2Controller.prototype.GetNext = function () {
+ return this.m_next;
+ }
+ b2Controller.prototype.GetWorld = function () {
+ return this.m_world;
+ }
+ b2Controller.prototype.GetBodyList = function () {
+ return this.m_bodyList;
+ }
+ b2ControllerEdge.b2ControllerEdge = function () {};
+ Box2D.inherit(b2GravityController, Box2D.Dynamics.Controllers.b2Controller);
+ b2GravityController.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
+ b2GravityController.b2GravityController = function () {
+ Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
+ this.G = 1;
+ this.invSqr = true;
+ };
+ b2GravityController.prototype.Step = function (step) {
+ var i = null;
+ var body1 = null;
+ var p1 = null;
+ var mass1 = 0;
+ var j = null;
+ var body2 = null;
+ var p2 = null;
+ var dx = 0;
+ var dy = 0;
+ var r2 = 0;
+ var f = null;
+ if (this.invSqr) {
+ for (i = this.m_bodyList;
+ i; i = i.nextBody) {
+ body1 = i.body;
+ p1 = body1.GetWorldCenter();
+ mass1 = body1.GetMass();
+ for (j = this.m_bodyList;
+ j != i; j = j.nextBody) {
+ body2 = j.body;
+ p2 = body2.GetWorldCenter();
+ dx = p2.x - p1.x;
+ dy = p2.y - p1.y;
+ r2 = dx * dx + dy * dy;
+ if (r2 < Number.MIN_VALUE) continue;
+ f = new b2Vec2(dx, dy);
+ f.Multiply(this.G / r2 / Math.sqrt(r2) * mass1 * body2.GetMass());
+ if (body1.IsAwake()) body1.ApplyForce(f, p1);
+ f.Multiply((-1));
+ if (body2.IsAwake()) body2.ApplyForce(f, p2);
+ }
+ }
+ }
+ else {
+ for (i = this.m_bodyList;
+ i; i = i.nextBody) {
+ body1 = i.body;
+ p1 = body1.GetWorldCenter();
+ mass1 = body1.GetMass();
+ for (j = this.m_bodyList;
+ j != i; j = j.nextBody) {
+ body2 = j.body;
+ p2 = body2.GetWorldCenter();
+ dx = p2.x - p1.x;
+ dy = p2.y - p1.y;
+ r2 = dx * dx + dy * dy;
+ if (r2 < Number.MIN_VALUE) continue;
+ f = new b2Vec2(dx, dy);
+ f.Multiply(this.G / r2 * mass1 * body2.GetMass());
+ if (body1.IsAwake()) body1.ApplyForce(f, p1);
+ f.Multiply((-1));
+ if (body2.IsAwake()) body2.ApplyForce(f, p2);
+ }
+ }
+ }
+ }
+ Box2D.inherit(b2TensorDampingController, Box2D.Dynamics.Controllers.b2Controller);
+ b2TensorDampingController.prototype.__super = Box2D.Dynamics.Controllers.b2Controller.prototype;
+ b2TensorDampingController.b2TensorDampingController = function () {
+ Box2D.Dynamics.Controllers.b2Controller.b2Controller.apply(this, arguments);
+ this.T = new b2Mat22();
+ this.maxTimestep = 0;
+ };
+ b2TensorDampingController.prototype.SetAxisAligned = function (xDamping, yDamping) {
+ if (xDamping === undefined) xDamping = 0;
+ if (yDamping === undefined) yDamping = 0;
+ this.T.col1.x = (-xDamping);
+ this.T.col1.y = 0;
+ this.T.col2.x = 0;
+ this.T.col2.y = (-yDamping);
+ if (xDamping > 0 || yDamping > 0) {
+ this.maxTimestep = 1 / Math.max(xDamping, yDamping);
+ }
+ else {
+ this.maxTimestep = 0;
+ }
+ }
+ b2TensorDampingController.prototype.Step = function (step) {
+ var timestep = step.dt;
+ if (timestep <= Number.MIN_VALUE) return;
+ if (timestep > this.maxTimestep && this.maxTimestep > 0) timestep = this.maxTimestep;
+ for (var i = this.m_bodyList; i; i = i.nextBody) {
+ var body = i.body;
+ if (!body.IsAwake()) {
+ continue;
+ }
+ var damping = body.GetWorldVector(b2Math.MulMV(this.T, body.GetLocalVector(body.GetLinearVelocity())));
+ body.SetLinearVelocity(new b2Vec2(body.GetLinearVelocity().x + damping.x * timestep, body.GetLinearVelocity().y + damping.y * timestep));
+ }
+ }
+})();
+(function () {
+ var b2Color = Box2D.Common.b2Color,
+ b2internal = Box2D.Common.b2internal,
+ b2Settings = Box2D.Common.b2Settings,
+ b2Mat22 = Box2D.Common.Math.b2Mat22,
+ b2Mat33 = Box2D.Common.Math.b2Mat33,
+ b2Math = Box2D.Common.Math.b2Math,
+ b2Sweep = Box2D.Common.Math.b2Sweep,
+ b2Transform = Box2D.Common.Math.b2Transform,
+ b2Vec2 = Box2D.Common.Math.b2Vec2,
+ b2Vec3 = Box2D.Common.Math.b2Vec3,
+ b2DistanceJoint = Box2D.Dynamics.Joints.b2DistanceJoint,
+ b2DistanceJointDef = Box2D.Dynamics.Joints.b2DistanceJointDef,
+ b2FrictionJoint = Box2D.Dynamics.Joints.b2FrictionJoint,
+ b2FrictionJointDef = Box2D.Dynamics.Joints.b2FrictionJointDef,
+ b2GearJoint = Box2D.Dynamics.Joints.b2GearJoint,
+ b2GearJointDef = Box2D.Dynamics.Joints.b2GearJointDef,
+ b2Jacobian = Box2D.Dynamics.Joints.b2Jacobian,
+ b2Joint = Box2D.Dynamics.Joints.b2Joint,
+ b2JointDef = Box2D.Dynamics.Joints.b2JointDef,
+ b2JointEdge = Box2D.Dynamics.Joints.b2JointEdge,
+ b2LineJoint = Box2D.Dynamics.Joints.b2LineJoint,
+ b2LineJointDef = Box2D.Dynamics.Joints.b2LineJointDef,
+ b2MouseJoint = Box2D.Dynamics.Joints.b2MouseJoint,
+ b2MouseJointDef = Box2D.Dynamics.Joints.b2MouseJointDef,
+ b2PrismaticJoint = Box2D.Dynamics.Joints.b2PrismaticJoint,
+ b2PrismaticJointDef = Box2D.Dynamics.Joints.b2PrismaticJointDef,
+ b2PulleyJoint = Box2D.Dynamics.Joints.b2PulleyJoint,
+ b2PulleyJointDef = Box2D.Dynamics.Joints.b2PulleyJointDef,
+ b2RevoluteJoint = Box2D.Dynamics.Joints.b2RevoluteJoint,
+ b2RevoluteJointDef = Box2D.Dynamics.Joints.b2RevoluteJointDef,
+ b2WeldJoint = Box2D.Dynamics.Joints.b2WeldJoint,
+ b2WeldJointDef = Box2D.Dynamics.Joints.b2WeldJointDef,
+ b2Body = Box2D.Dynamics.b2Body,
+ b2BodyDef = Box2D.Dynamics.b2BodyDef,
+ b2ContactFilter = Box2D.Dynamics.b2ContactFilter,
+ b2ContactImpulse = Box2D.Dynamics.b2ContactImpulse,
+ b2ContactListener = Box2D.Dynamics.b2ContactListener,
+ b2ContactManager = Box2D.Dynamics.b2ContactManager,
+ b2DebugDraw = Box2D.Dynamics.b2DebugDraw,
+ b2DestructionListener = Box2D.Dynamics.b2DestructionListener,
+ b2FilterData = Box2D.Dynamics.b2FilterData,
+ b2Fixture = Box2D.Dynamics.b2Fixture,
+ b2FixtureDef = Box2D.Dynamics.b2FixtureDef,
+ b2Island = Box2D.Dynamics.b2Island,
+ b2TimeStep = Box2D.Dynamics.b2TimeStep,
+ b2World = Box2D.Dynamics.b2World;
+
+ Box2D.inherit(b2DistanceJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2DistanceJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2DistanceJoint.b2DistanceJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_localAnchor1 = new b2Vec2();
+ this.m_localAnchor2 = new b2Vec2();
+ this.m_u = new b2Vec2();
+ };
+ b2DistanceJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ }
+ b2DistanceJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ }
+ b2DistanceJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_impulse * this.m_u.x, inv_dt * this.m_impulse * this.m_u.y);
+ }
+ b2DistanceJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return 0.0;
+ }
+ b2DistanceJoint.prototype.GetLength = function () {
+ return this.m_length;
+ }
+ b2DistanceJoint.prototype.SetLength = function (length) {
+ if (length === undefined) length = 0;
+ this.m_length = length;
+ }
+ b2DistanceJoint.prototype.GetFrequency = function () {
+ return this.m_frequencyHz;
+ }
+ b2DistanceJoint.prototype.SetFrequency = function (hz) {
+ if (hz === undefined) hz = 0;
+ this.m_frequencyHz = hz;
+ }
+ b2DistanceJoint.prototype.GetDampingRatio = function () {
+ return this.m_dampingRatio;
+ }
+ b2DistanceJoint.prototype.SetDampingRatio = function (ratio) {
+ if (ratio === undefined) ratio = 0;
+ this.m_dampingRatio = ratio;
+ }
+ b2DistanceJoint.prototype.b2DistanceJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ var tMat;
+ var tX = 0;
+ var tY = 0;
+ this.m_localAnchor1.SetV(def.localAnchorA);
+ this.m_localAnchor2.SetV(def.localAnchorB);
+ this.m_length = def.length;
+ this.m_frequencyHz = def.frequencyHz;
+ this.m_dampingRatio = def.dampingRatio;
+ this.m_impulse = 0.0;
+ this.m_gamma = 0.0;
+ this.m_bias = 0.0;
+ }
+ b2DistanceJoint.prototype.InitVelocityConstraints = function (step) {
+ var tMat;
+ var tX = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ this.m_u.x = bB.m_sweep.c.x + r2X - bA.m_sweep.c.x - r1X;
+ this.m_u.y = bB.m_sweep.c.y + r2Y - bA.m_sweep.c.y - r1Y;
+ var length = Math.sqrt(this.m_u.x * this.m_u.x + this.m_u.y * this.m_u.y);
+ if (length > b2Settings.b2_linearSlop) {
+ this.m_u.Multiply(1.0 / length);
+ }
+ else {
+ this.m_u.SetZero();
+ }
+ var cr1u = (r1X * this.m_u.y - r1Y * this.m_u.x);
+ var cr2u = (r2X * this.m_u.y - r2Y * this.m_u.x);
+ var invMass = bA.m_invMass + bA.m_invI * cr1u * cr1u + bB.m_invMass + bB.m_invI * cr2u * cr2u;
+ this.m_mass = invMass != 0.0 ? 1.0 / invMass : 0.0;
+ if (this.m_frequencyHz > 0.0) {
+ var C = length - this.m_length;
+ var omega = 2.0 * Math.PI * this.m_frequencyHz;
+ var d = 2.0 * this.m_mass * this.m_dampingRatio * omega;
+ var k = this.m_mass * omega * omega;
+ this.m_gamma = step.dt * (d + step.dt * k);
+ this.m_gamma = this.m_gamma != 0.0 ? 1 / this.m_gamma : 0.0;
+ this.m_bias = C * step.dt * k * this.m_gamma;
+ this.m_mass = invMass + this.m_gamma;
+ this.m_mass = this.m_mass != 0.0 ? 1.0 / this.m_mass : 0.0;
+ }
+ if (step.warmStarting) {
+ this.m_impulse *= step.dtRatio;
+ var PX = this.m_impulse * this.m_u.x;
+ var PY = this.m_impulse * this.m_u.y;
+ bA.m_linearVelocity.x -= bA.m_invMass * PX;
+ bA.m_linearVelocity.y -= bA.m_invMass * PY;
+ bA.m_angularVelocity -= bA.m_invI * (r1X * PY - r1Y * PX);
+ bB.m_linearVelocity.x += bB.m_invMass * PX;
+ bB.m_linearVelocity.y += bB.m_invMass * PY;
+ bB.m_angularVelocity += bB.m_invI * (r2X * PY - r2Y * PX);
+ }
+ else {
+ this.m_impulse = 0.0;
+ }
+ }
+ b2DistanceJoint.prototype.SolveVelocityConstraints = function (step) {
+ var tMat;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var v1X = bA.m_linearVelocity.x + ((-bA.m_angularVelocity * r1Y));
+ var v1Y = bA.m_linearVelocity.y + (bA.m_angularVelocity * r1X);
+ var v2X = bB.m_linearVelocity.x + ((-bB.m_angularVelocity * r2Y));
+ var v2Y = bB.m_linearVelocity.y + (bB.m_angularVelocity * r2X);
+ var Cdot = (this.m_u.x * (v2X - v1X) + this.m_u.y * (v2Y - v1Y));
+ var impulse = (-this.m_mass * (Cdot + this.m_bias + this.m_gamma * this.m_impulse));
+ this.m_impulse += impulse;
+ var PX = impulse * this.m_u.x;
+ var PY = impulse * this.m_u.y;
+ bA.m_linearVelocity.x -= bA.m_invMass * PX;
+ bA.m_linearVelocity.y -= bA.m_invMass * PY;
+ bA.m_angularVelocity -= bA.m_invI * (r1X * PY - r1Y * PX);
+ bB.m_linearVelocity.x += bB.m_invMass * PX;
+ bB.m_linearVelocity.y += bB.m_invMass * PY;
+ bB.m_angularVelocity += bB.m_invI * (r2X * PY - r2Y * PX);
+ }
+ b2DistanceJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var tMat;
+ if (this.m_frequencyHz > 0.0) {
+ return true;
+ }
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var dX = bB.m_sweep.c.x + r2X - bA.m_sweep.c.x - r1X;
+ var dY = bB.m_sweep.c.y + r2Y - bA.m_sweep.c.y - r1Y;
+ var length = Math.sqrt(dX * dX + dY * dY);
+ dX /= length;
+ dY /= length;
+ var C = length - this.m_length;
+ C = b2Math.Clamp(C, (-b2Settings.b2_maxLinearCorrection), b2Settings.b2_maxLinearCorrection);
+ var impulse = (-this.m_mass * C);
+ this.m_u.Set(dX, dY);
+ var PX = impulse * this.m_u.x;
+ var PY = impulse * this.m_u.y;
+ bA.m_sweep.c.x -= bA.m_invMass * PX;
+ bA.m_sweep.c.y -= bA.m_invMass * PY;
+ bA.m_sweep.a -= bA.m_invI * (r1X * PY - r1Y * PX);
+ bB.m_sweep.c.x += bB.m_invMass * PX;
+ bB.m_sweep.c.y += bB.m_invMass * PY;
+ bB.m_sweep.a += bB.m_invI * (r2X * PY - r2Y * PX);
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ return b2Math.Abs(C) < b2Settings.b2_linearSlop;
+ }
+ Box2D.inherit(b2DistanceJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2DistanceJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2DistanceJointDef.b2DistanceJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ };
+ b2DistanceJointDef.prototype.b2DistanceJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_distanceJoint;
+ this.length = 1.0;
+ this.frequencyHz = 0.0;
+ this.dampingRatio = 0.0;
+ }
+ b2DistanceJointDef.prototype.Initialize = function (bA, bB, anchorA, anchorB) {
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.localAnchorA.SetV(this.bodyA.GetLocalPoint(anchorA));
+ this.localAnchorB.SetV(this.bodyB.GetLocalPoint(anchorB));
+ var dX = anchorB.x - anchorA.x;
+ var dY = anchorB.y - anchorA.y;
+ this.length = Math.sqrt(dX * dX + dY * dY);
+ this.frequencyHz = 0.0;
+ this.dampingRatio = 0.0;
+ }
+ Box2D.inherit(b2FrictionJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2FrictionJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2FrictionJoint.b2FrictionJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_localAnchorA = new b2Vec2();
+ this.m_localAnchorB = new b2Vec2();
+ this.m_linearMass = new b2Mat22();
+ this.m_linearImpulse = new b2Vec2();
+ };
+ b2FrictionJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchorA);
+ }
+ b2FrictionJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchorB);
+ }
+ b2FrictionJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_linearImpulse.x, inv_dt * this.m_linearImpulse.y);
+ }
+ b2FrictionJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return inv_dt * this.m_angularImpulse;
+ }
+ b2FrictionJoint.prototype.SetMaxForce = function (force) {
+ if (force === undefined) force = 0;
+ this.m_maxForce = force;
+ }
+ b2FrictionJoint.prototype.GetMaxForce = function () {
+ return this.m_maxForce;
+ }
+ b2FrictionJoint.prototype.SetMaxTorque = function (torque) {
+ if (torque === undefined) torque = 0;
+ this.m_maxTorque = torque;
+ }
+ b2FrictionJoint.prototype.GetMaxTorque = function () {
+ return this.m_maxTorque;
+ }
+ b2FrictionJoint.prototype.b2FrictionJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ this.m_localAnchorA.SetV(def.localAnchorA);
+ this.m_localAnchorB.SetV(def.localAnchorB);
+ this.m_linearMass.SetZero();
+ this.m_angularMass = 0.0;
+ this.m_linearImpulse.SetZero();
+ this.m_angularImpulse = 0.0;
+ this.m_maxForce = def.maxForce;
+ this.m_maxTorque = def.maxTorque;
+ }
+ b2FrictionJoint.prototype.InitVelocityConstraints = function (step) {
+ var tMat;
+ var tX = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ tMat = bA.m_xf.R;
+ var rAX = this.m_localAnchorA.x - bA.m_sweep.localCenter.x;
+ var rAY = this.m_localAnchorA.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rAX + tMat.col2.x * rAY);
+ rAY = (tMat.col1.y * rAX + tMat.col2.y * rAY);
+ rAX = tX;
+ tMat = bB.m_xf.R;
+ var rBX = this.m_localAnchorB.x - bB.m_sweep.localCenter.x;
+ var rBY = this.m_localAnchorB.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rBX + tMat.col2.x * rBY);
+ rBY = (tMat.col1.y * rBX + tMat.col2.y * rBY);
+ rBX = tX;
+ var mA = bA.m_invMass;
+ var mB = bB.m_invMass;
+ var iA = bA.m_invI;
+ var iB = bB.m_invI;
+ var K = new b2Mat22();
+ K.col1.x = mA + mB;
+ K.col2.x = 0.0;
+ K.col1.y = 0.0;
+ K.col2.y = mA + mB;
+ K.col1.x += iA * rAY * rAY;
+ K.col2.x += (-iA * rAX * rAY);
+ K.col1.y += (-iA * rAX * rAY);
+ K.col2.y += iA * rAX * rAX;
+ K.col1.x += iB * rBY * rBY;
+ K.col2.x += (-iB * rBX * rBY);
+ K.col1.y += (-iB * rBX * rBY);
+ K.col2.y += iB * rBX * rBX;
+ K.GetInverse(this.m_linearMass);
+ this.m_angularMass = iA + iB;
+ if (this.m_angularMass > 0.0) {
+ this.m_angularMass = 1.0 / this.m_angularMass;
+ }
+ if (step.warmStarting) {
+ this.m_linearImpulse.x *= step.dtRatio;
+ this.m_linearImpulse.y *= step.dtRatio;
+ this.m_angularImpulse *= step.dtRatio;
+ var P = this.m_linearImpulse;
+ bA.m_linearVelocity.x -= mA * P.x;
+ bA.m_linearVelocity.y -= mA * P.y;
+ bA.m_angularVelocity -= iA * (rAX * P.y - rAY * P.x + this.m_angularImpulse);
+ bB.m_linearVelocity.x += mB * P.x;
+ bB.m_linearVelocity.y += mB * P.y;
+ bB.m_angularVelocity += iB * (rBX * P.y - rBY * P.x + this.m_angularImpulse);
+ }
+ else {
+ this.m_linearImpulse.SetZero();
+ this.m_angularImpulse = 0.0;
+ }
+ }
+ b2FrictionJoint.prototype.SolveVelocityConstraints = function (step) {
+ var tMat;
+ var tX = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var vA = bA.m_linearVelocity;
+ var wA = bA.m_angularVelocity;
+ var vB = bB.m_linearVelocity;
+ var wB = bB.m_angularVelocity;
+ var mA = bA.m_invMass;
+ var mB = bB.m_invMass;
+ var iA = bA.m_invI;
+ var iB = bB.m_invI;
+ tMat = bA.m_xf.R;
+ var rAX = this.m_localAnchorA.x - bA.m_sweep.localCenter.x;
+ var rAY = this.m_localAnchorA.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rAX + tMat.col2.x * rAY);
+ rAY = (tMat.col1.y * rAX + tMat.col2.y * rAY);
+ rAX = tX;
+ tMat = bB.m_xf.R;
+ var rBX = this.m_localAnchorB.x - bB.m_sweep.localCenter.x;
+ var rBY = this.m_localAnchorB.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rBX + tMat.col2.x * rBY);
+ rBY = (tMat.col1.y * rBX + tMat.col2.y * rBY);
+ rBX = tX;
+ var maxImpulse = 0; {
+ var Cdot = wB - wA;
+ var impulse = (-this.m_angularMass * Cdot);
+ var oldImpulse = this.m_angularImpulse;
+ maxImpulse = step.dt * this.m_maxTorque;
+ this.m_angularImpulse = b2Math.Clamp(this.m_angularImpulse + impulse, (-maxImpulse), maxImpulse);
+ impulse = this.m_angularImpulse - oldImpulse;
+ wA -= iA * impulse;
+ wB += iB * impulse;
+ } {
+ var CdotX = vB.x - wB * rBY - vA.x + wA * rAY;
+ var CdotY = vB.y + wB * rBX - vA.y - wA * rAX;
+ var impulseV = b2Math.MulMV(this.m_linearMass, new b2Vec2((-CdotX), (-CdotY)));
+ var oldImpulseV = this.m_linearImpulse.Copy();
+ this.m_linearImpulse.Add(impulseV);
+ maxImpulse = step.dt * this.m_maxForce;
+ if (this.m_linearImpulse.LengthSquared() > maxImpulse * maxImpulse) {
+ this.m_linearImpulse.Normalize();
+ this.m_linearImpulse.Multiply(maxImpulse);
+ }
+ impulseV = b2Math.SubtractVV(this.m_linearImpulse, oldImpulseV);
+ vA.x -= mA * impulseV.x;
+ vA.y -= mA * impulseV.y;
+ wA -= iA * (rAX * impulseV.y - rAY * impulseV.x);
+ vB.x += mB * impulseV.x;
+ vB.y += mB * impulseV.y;
+ wB += iB * (rBX * impulseV.y - rBY * impulseV.x);
+ }
+ bA.m_angularVelocity = wA;
+ bB.m_angularVelocity = wB;
+ }
+ b2FrictionJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ return true;
+ }
+ Box2D.inherit(b2FrictionJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2FrictionJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2FrictionJointDef.b2FrictionJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ };
+ b2FrictionJointDef.prototype.b2FrictionJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_frictionJoint;
+ this.maxForce = 0.0;
+ this.maxTorque = 0.0;
+ }
+ b2FrictionJointDef.prototype.Initialize = function (bA, bB, anchor) {
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.localAnchorA.SetV(this.bodyA.GetLocalPoint(anchor));
+ this.localAnchorB.SetV(this.bodyB.GetLocalPoint(anchor));
+ }
+ Box2D.inherit(b2GearJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2GearJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2GearJoint.b2GearJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_groundAnchor1 = new b2Vec2();
+ this.m_groundAnchor2 = new b2Vec2();
+ this.m_localAnchor1 = new b2Vec2();
+ this.m_localAnchor2 = new b2Vec2();
+ this.m_J = new b2Jacobian();
+ };
+ b2GearJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ }
+ b2GearJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ }
+ b2GearJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_impulse * this.m_J.linearB.x, inv_dt * this.m_impulse * this.m_J.linearB.y);
+ }
+ b2GearJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ var tMat = this.m_bodyB.m_xf.R;
+ var rX = this.m_localAnchor1.x - this.m_bodyB.m_sweep.localCenter.x;
+ var rY = this.m_localAnchor1.y - this.m_bodyB.m_sweep.localCenter.y;
+ var tX = tMat.col1.x * rX + tMat.col2.x * rY;
+ rY = tMat.col1.y * rX + tMat.col2.y * rY;
+ rX = tX;
+ var PX = this.m_impulse * this.m_J.linearB.x;
+ var PY = this.m_impulse * this.m_J.linearB.y;
+ return inv_dt * (this.m_impulse * this.m_J.angularB - rX * PY + rY * PX);
+ }
+ b2GearJoint.prototype.GetRatio = function () {
+ return this.m_ratio;
+ }
+ b2GearJoint.prototype.SetRatio = function (ratio) {
+ if (ratio === undefined) ratio = 0;
+ this.m_ratio = ratio;
+ }
+ b2GearJoint.prototype.b2GearJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ var type1 = parseInt(def.joint1.m_type);
+ var type2 = parseInt(def.joint2.m_type);
+ this.m_revolute1 = null;
+ this.m_prismatic1 = null;
+ this.m_revolute2 = null;
+ this.m_prismatic2 = null;
+ var coordinate1 = 0;
+ var coordinate2 = 0;
+ this.m_ground1 = def.joint1.GetBodyA();
+ this.m_bodyA = def.joint1.GetBodyB();
+ if (type1 == b2Joint.e_revoluteJoint) {
+ this.m_revolute1 = (def.joint1 instanceof b2RevoluteJoint ? def.joint1 : null);
+ this.m_groundAnchor1.SetV(this.m_revolute1.m_localAnchor1);
+ this.m_localAnchor1.SetV(this.m_revolute1.m_localAnchor2);
+ coordinate1 = this.m_revolute1.GetJointAngle();
+ }
+ else {
+ this.m_prismatic1 = (def.joint1 instanceof b2PrismaticJoint ? def.joint1 : null);
+ this.m_groundAnchor1.SetV(this.m_prismatic1.m_localAnchor1);
+ this.m_localAnchor1.SetV(this.m_prismatic1.m_localAnchor2);
+ coordinate1 = this.m_prismatic1.GetJointTranslation();
+ }
+ this.m_ground2 = def.joint2.GetBodyA();
+ this.m_bodyB = def.joint2.GetBodyB();
+ if (type2 == b2Joint.e_revoluteJoint) {
+ this.m_revolute2 = (def.joint2 instanceof b2RevoluteJoint ? def.joint2 : null);
+ this.m_groundAnchor2.SetV(this.m_revolute2.m_localAnchor1);
+ this.m_localAnchor2.SetV(this.m_revolute2.m_localAnchor2);
+ coordinate2 = this.m_revolute2.GetJointAngle();
+ }
+ else {
+ this.m_prismatic2 = (def.joint2 instanceof b2PrismaticJoint ? def.joint2 : null);
+ this.m_groundAnchor2.SetV(this.m_prismatic2.m_localAnchor1);
+ this.m_localAnchor2.SetV(this.m_prismatic2.m_localAnchor2);
+ coordinate2 = this.m_prismatic2.GetJointTranslation();
+ }
+ this.m_ratio = def.ratio;
+ this.m_constant = coordinate1 + this.m_ratio * coordinate2;
+ this.m_impulse = 0.0;
+ }
+ b2GearJoint.prototype.InitVelocityConstraints = function (step) {
+ var g1 = this.m_ground1;
+ var g2 = this.m_ground2;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var ugX = 0;
+ var ugY = 0;
+ var rX = 0;
+ var rY = 0;
+ var tMat;
+ var tVec;
+ var crug = 0;
+ var tX = 0;
+ var K = 0.0;
+ this.m_J.SetZero();
+ if (this.m_revolute1) {
+ this.m_J.angularA = (-1.0);
+ K += bA.m_invI;
+ }
+ else {
+ tMat = g1.m_xf.R;
+ tVec = this.m_prismatic1.m_localXAxis1;
+ ugX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ ugY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = bA.m_xf.R;
+ rX = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ rY = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = tMat.col1.x * rX + tMat.col2.x * rY;
+ rY = tMat.col1.y * rX + tMat.col2.y * rY;
+ rX = tX;
+ crug = rX * ugY - rY * ugX;
+ this.m_J.linearA.Set((-ugX), (-ugY));
+ this.m_J.angularA = (-crug);
+ K += bA.m_invMass + bA.m_invI * crug * crug;
+ }
+ if (this.m_revolute2) {
+ this.m_J.angularB = (-this.m_ratio);
+ K += this.m_ratio * this.m_ratio * bB.m_invI;
+ }
+ else {
+ tMat = g2.m_xf.R;
+ tVec = this.m_prismatic2.m_localXAxis1;
+ ugX = tMat.col1.x * tVec.x + tMat.col2.x * tVec.y;
+ ugY = tMat.col1.y * tVec.x + tMat.col2.y * tVec.y;
+ tMat = bB.m_xf.R;
+ rX = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ rY = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = tMat.col1.x * rX + tMat.col2.x * rY;
+ rY = tMat.col1.y * rX + tMat.col2.y * rY;
+ rX = tX;
+ crug = rX * ugY - rY * ugX;
+ this.m_J.linearB.Set((-this.m_ratio * ugX), (-this.m_ratio * ugY));
+ this.m_J.angularB = (-this.m_ratio * crug);
+ K += this.m_ratio * this.m_ratio * (bB.m_invMass + bB.m_invI * crug * crug);
+ }
+ this.m_mass = K > 0.0 ? 1.0 / K : 0.0;
+ if (step.warmStarting) {
+ bA.m_linearVelocity.x += bA.m_invMass * this.m_impulse * this.m_J.linearA.x;
+ bA.m_linearVelocity.y += bA.m_invMass * this.m_impulse * this.m_J.linearA.y;
+ bA.m_angularVelocity += bA.m_invI * this.m_impulse * this.m_J.angularA;
+ bB.m_linearVelocity.x += bB.m_invMass * this.m_impulse * this.m_J.linearB.x;
+ bB.m_linearVelocity.y += bB.m_invMass * this.m_impulse * this.m_J.linearB.y;
+ bB.m_angularVelocity += bB.m_invI * this.m_impulse * this.m_J.angularB;
+ }
+ else {
+ this.m_impulse = 0.0;
+ }
+ }
+ b2GearJoint.prototype.SolveVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var Cdot = this.m_J.Compute(bA.m_linearVelocity, bA.m_angularVelocity, bB.m_linearVelocity, bB.m_angularVelocity);
+ var impulse = (-this.m_mass * Cdot);
+ this.m_impulse += impulse;
+ bA.m_linearVelocity.x += bA.m_invMass * impulse * this.m_J.linearA.x;
+ bA.m_linearVelocity.y += bA.m_invMass * impulse * this.m_J.linearA.y;
+ bA.m_angularVelocity += bA.m_invI * impulse * this.m_J.angularA;
+ bB.m_linearVelocity.x += bB.m_invMass * impulse * this.m_J.linearB.x;
+ bB.m_linearVelocity.y += bB.m_invMass * impulse * this.m_J.linearB.y;
+ bB.m_angularVelocity += bB.m_invI * impulse * this.m_J.angularB;
+ }
+ b2GearJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var linearError = 0.0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var coordinate1 = 0;
+ var coordinate2 = 0;
+ if (this.m_revolute1) {
+ coordinate1 = this.m_revolute1.GetJointAngle();
+ }
+ else {
+ coordinate1 = this.m_prismatic1.GetJointTranslation();
+ }
+ if (this.m_revolute2) {
+ coordinate2 = this.m_revolute2.GetJointAngle();
+ }
+ else {
+ coordinate2 = this.m_prismatic2.GetJointTranslation();
+ }
+ var C = this.m_constant - (coordinate1 + this.m_ratio * coordinate2);
+ var impulse = (-this.m_mass * C);
+ bA.m_sweep.c.x += bA.m_invMass * impulse * this.m_J.linearA.x;
+ bA.m_sweep.c.y += bA.m_invMass * impulse * this.m_J.linearA.y;
+ bA.m_sweep.a += bA.m_invI * impulse * this.m_J.angularA;
+ bB.m_sweep.c.x += bB.m_invMass * impulse * this.m_J.linearB.x;
+ bB.m_sweep.c.y += bB.m_invMass * impulse * this.m_J.linearB.y;
+ bB.m_sweep.a += bB.m_invI * impulse * this.m_J.angularB;
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ return linearError < b2Settings.b2_linearSlop;
+ }
+ Box2D.inherit(b2GearJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2GearJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2GearJointDef.b2GearJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ };
+ b2GearJointDef.prototype.b2GearJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_gearJoint;
+ this.joint1 = null;
+ this.joint2 = null;
+ this.ratio = 1.0;
+ }
+ b2Jacobian.b2Jacobian = function () {
+ this.linearA = new b2Vec2();
+ this.linearB = new b2Vec2();
+ };
+ b2Jacobian.prototype.SetZero = function () {
+ this.linearA.SetZero();
+ this.angularA = 0.0;
+ this.linearB.SetZero();
+ this.angularB = 0.0;
+ }
+ b2Jacobian.prototype.Set = function (x1, a1, x2, a2) {
+ if (a1 === undefined) a1 = 0;
+ if (a2 === undefined) a2 = 0;
+ this.linearA.SetV(x1);
+ this.angularA = a1;
+ this.linearB.SetV(x2);
+ this.angularB = a2;
+ }
+ b2Jacobian.prototype.Compute = function (x1, a1, x2, a2) {
+ if (a1 === undefined) a1 = 0;
+ if (a2 === undefined) a2 = 0;
+ return (this.linearA.x * x1.x + this.linearA.y * x1.y) + this.angularA * a1 + (this.linearB.x * x2.x + this.linearB.y * x2.y) + this.angularB * a2;
+ }
+ b2Joint.b2Joint = function () {
+ this.m_edgeA = new b2JointEdge();
+ this.m_edgeB = new b2JointEdge();
+ this.m_localCenterA = new b2Vec2();
+ this.m_localCenterB = new b2Vec2();
+ };
+ b2Joint.prototype.GetType = function () {
+ return this.m_type;
+ }
+ b2Joint.prototype.GetAnchorA = function () {
+ return null;
+ }
+ b2Joint.prototype.GetAnchorB = function () {
+ return null;
+ }
+ b2Joint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return null;
+ }
+ b2Joint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return 0.0;
+ }
+ b2Joint.prototype.GetBodyA = function () {
+ return this.m_bodyA;
+ }
+ b2Joint.prototype.GetBodyB = function () {
+ return this.m_bodyB;
+ }
+ b2Joint.prototype.GetNext = function () {
+ return this.m_next;
+ }
+ b2Joint.prototype.GetUserData = function () {
+ return this.m_userData;
+ }
+ b2Joint.prototype.SetUserData = function (data) {
+ this.m_userData = data;
+ }
+ b2Joint.prototype.IsActive = function () {
+ return this.m_bodyA.IsActive() && this.m_bodyB.IsActive();
+ }
+ b2Joint.Create = function (def, allocator) {
+ var joint = null;
+ switch (def.type) {
+ case b2Joint.e_distanceJoint:
+ {
+ joint = new b2DistanceJoint((def instanceof b2DistanceJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_mouseJoint:
+ {
+ joint = new b2MouseJoint((def instanceof b2MouseJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_prismaticJoint:
+ {
+ joint = new b2PrismaticJoint((def instanceof b2PrismaticJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_revoluteJoint:
+ {
+ joint = new b2RevoluteJoint((def instanceof b2RevoluteJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_pulleyJoint:
+ {
+ joint = new b2PulleyJoint((def instanceof b2PulleyJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_gearJoint:
+ {
+ joint = new b2GearJoint((def instanceof b2GearJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_lineJoint:
+ {
+ joint = new b2LineJoint((def instanceof b2LineJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_weldJoint:
+ {
+ joint = new b2WeldJoint((def instanceof b2WeldJointDef ? def : null));
+ }
+ break;
+ case b2Joint.e_frictionJoint:
+ {
+ joint = new b2FrictionJoint((def instanceof b2FrictionJointDef ? def : null));
+ }
+ break;
+ default:
+ break;
+ }
+ return joint;
+ }
+ b2Joint.Destroy = function (joint, allocator) {}
+ b2Joint.prototype.b2Joint = function (def) {
+ b2Settings.b2Assert(def.bodyA != def.bodyB);
+ this.m_type = def.type;
+ this.m_prev = null;
+ this.m_next = null;
+ this.m_bodyA = def.bodyA;
+ this.m_bodyB = def.bodyB;
+ this.m_collideConnected = def.collideConnected;
+ this.m_islandFlag = false;
+ this.m_userData = def.userData;
+ }
+ b2Joint.prototype.InitVelocityConstraints = function (step) {}
+ b2Joint.prototype.SolveVelocityConstraints = function (step) {}
+ b2Joint.prototype.FinalizeVelocityConstraints = function () {}
+ b2Joint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ return false;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.Joints.b2Joint.e_unknownJoint = 0;
+ Box2D.Dynamics.Joints.b2Joint.e_revoluteJoint = 1;
+ Box2D.Dynamics.Joints.b2Joint.e_prismaticJoint = 2;
+ Box2D.Dynamics.Joints.b2Joint.e_distanceJoint = 3;
+ Box2D.Dynamics.Joints.b2Joint.e_pulleyJoint = 4;
+ Box2D.Dynamics.Joints.b2Joint.e_mouseJoint = 5;
+ Box2D.Dynamics.Joints.b2Joint.e_gearJoint = 6;
+ Box2D.Dynamics.Joints.b2Joint.e_lineJoint = 7;
+ Box2D.Dynamics.Joints.b2Joint.e_weldJoint = 8;
+ Box2D.Dynamics.Joints.b2Joint.e_frictionJoint = 9;
+ Box2D.Dynamics.Joints.b2Joint.e_inactiveLimit = 0;
+ Box2D.Dynamics.Joints.b2Joint.e_atLowerLimit = 1;
+ Box2D.Dynamics.Joints.b2Joint.e_atUpperLimit = 2;
+ Box2D.Dynamics.Joints.b2Joint.e_equalLimits = 3;
+ });
+ b2JointDef.b2JointDef = function () {};
+ b2JointDef.prototype.b2JointDef = function () {
+ this.type = b2Joint.e_unknownJoint;
+ this.userData = null;
+ this.bodyA = null;
+ this.bodyB = null;
+ this.collideConnected = false;
+ }
+ b2JointEdge.b2JointEdge = function () {};
+ Box2D.inherit(b2LineJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2LineJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2LineJoint.b2LineJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_localAnchor1 = new b2Vec2();
+ this.m_localAnchor2 = new b2Vec2();
+ this.m_localXAxis1 = new b2Vec2();
+ this.m_localYAxis1 = new b2Vec2();
+ this.m_axis = new b2Vec2();
+ this.m_perp = new b2Vec2();
+ this.m_K = new b2Mat22();
+ this.m_impulse = new b2Vec2();
+ };
+ b2LineJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ }
+ b2LineJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ }
+ b2LineJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * (this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.x), inv_dt * (this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.y));
+ }
+ b2LineJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return inv_dt * this.m_impulse.y;
+ }
+ b2LineJoint.prototype.GetJointTranslation = function () {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var p1 = bA.GetWorldPoint(this.m_localAnchor1);
+ var p2 = bB.GetWorldPoint(this.m_localAnchor2);
+ var dX = p2.x - p1.x;
+ var dY = p2.y - p1.y;
+ var axis = bA.GetWorldVector(this.m_localXAxis1);
+ var translation = axis.x * dX + axis.y * dY;
+ return translation;
+ }
+ b2LineJoint.prototype.GetJointSpeed = function () {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var p1X = bA.m_sweep.c.x + r1X;
+ var p1Y = bA.m_sweep.c.y + r1Y;
+ var p2X = bB.m_sweep.c.x + r2X;
+ var p2Y = bB.m_sweep.c.y + r2Y;
+ var dX = p2X - p1X;
+ var dY = p2Y - p1Y;
+ var axis = bA.GetWorldVector(this.m_localXAxis1);
+ var v1 = bA.m_linearVelocity;
+ var v2 = bB.m_linearVelocity;
+ var w1 = bA.m_angularVelocity;
+ var w2 = bB.m_angularVelocity;
+ var speed = (dX * ((-w1 * axis.y)) + dY * (w1 * axis.x)) + (axis.x * (((v2.x + ((-w2 * r2Y))) - v1.x) - ((-w1 * r1Y))) + axis.y * (((v2.y + (w2 * r2X)) - v1.y) - (w1 * r1X)));
+ return speed;
+ }
+ b2LineJoint.prototype.IsLimitEnabled = function () {
+ return this.m_enableLimit;
+ }
+ b2LineJoint.prototype.EnableLimit = function (flag) {
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_enableLimit = flag;
+ }
+ b2LineJoint.prototype.GetLowerLimit = function () {
+ return this.m_lowerTranslation;
+ }
+ b2LineJoint.prototype.GetUpperLimit = function () {
+ return this.m_upperTranslation;
+ }
+ b2LineJoint.prototype.SetLimits = function (lower, upper) {
+ if (lower === undefined) lower = 0;
+ if (upper === undefined) upper = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_lowerTranslation = lower;
+ this.m_upperTranslation = upper;
+ }
+ b2LineJoint.prototype.IsMotorEnabled = function () {
+ return this.m_enableMotor;
+ }
+ b2LineJoint.prototype.EnableMotor = function (flag) {
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_enableMotor = flag;
+ }
+ b2LineJoint.prototype.SetMotorSpeed = function (speed) {
+ if (speed === undefined) speed = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_motorSpeed = speed;
+ }
+ b2LineJoint.prototype.GetMotorSpeed = function () {
+ return this.m_motorSpeed;
+ }
+ b2LineJoint.prototype.SetMaxMotorForce = function (force) {
+ if (force === undefined) force = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_maxMotorForce = force;
+ }
+ b2LineJoint.prototype.GetMaxMotorForce = function () {
+ return this.m_maxMotorForce;
+ }
+ b2LineJoint.prototype.GetMotorForce = function () {
+ return this.m_motorImpulse;
+ }
+ b2LineJoint.prototype.b2LineJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ var tMat;
+ var tX = 0;
+ var tY = 0;
+ this.m_localAnchor1.SetV(def.localAnchorA);
+ this.m_localAnchor2.SetV(def.localAnchorB);
+ this.m_localXAxis1.SetV(def.localAxisA);
+ this.m_localYAxis1.x = (-this.m_localXAxis1.y);
+ this.m_localYAxis1.y = this.m_localXAxis1.x;
+ this.m_impulse.SetZero();
+ this.m_motorMass = 0.0;
+ this.m_motorImpulse = 0.0;
+ this.m_lowerTranslation = def.lowerTranslation;
+ this.m_upperTranslation = def.upperTranslation;
+ this.m_maxMotorForce = def.maxMotorForce;
+ this.m_motorSpeed = def.motorSpeed;
+ this.m_enableLimit = def.enableLimit;
+ this.m_enableMotor = def.enableMotor;
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ this.m_axis.SetZero();
+ this.m_perp.SetZero();
+ }
+ b2LineJoint.prototype.InitVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var tX = 0;
+ this.m_localCenterA.SetV(bA.GetLocalCenter());
+ this.m_localCenterB.SetV(bB.GetLocalCenter());
+ var xf1 = bA.GetTransform();
+ var xf2 = bB.GetTransform();
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - this.m_localCenterA.x;
+ var r1Y = this.m_localAnchor1.y - this.m_localCenterA.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - this.m_localCenterB.x;
+ var r2Y = this.m_localAnchor2.y - this.m_localCenterB.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var dX = bB.m_sweep.c.x + r2X - bA.m_sweep.c.x - r1X;
+ var dY = bB.m_sweep.c.y + r2Y - bA.m_sweep.c.y - r1Y;
+ this.m_invMassA = bA.m_invMass;
+ this.m_invMassB = bB.m_invMass;
+ this.m_invIA = bA.m_invI;
+ this.m_invIB = bB.m_invI; {
+ this.m_axis.SetV(b2Math.MulMV(xf1.R, this.m_localXAxis1));
+ this.m_a1 = (dX + r1X) * this.m_axis.y - (dY + r1Y) * this.m_axis.x;
+ this.m_a2 = r2X * this.m_axis.y - r2Y * this.m_axis.x;
+ this.m_motorMass = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_a1 * this.m_a1 + this.m_invIB * this.m_a2 * this.m_a2;
+ this.m_motorMass = this.m_motorMass > Number.MIN_VALUE ? 1.0 / this.m_motorMass : 0.0;
+ } {
+ this.m_perp.SetV(b2Math.MulMV(xf1.R, this.m_localYAxis1));
+ this.m_s1 = (dX + r1X) * this.m_perp.y - (dY + r1Y) * this.m_perp.x;
+ this.m_s2 = r2X * this.m_perp.y - r2Y * this.m_perp.x;
+ var m1 = this.m_invMassA;
+ var m2 = this.m_invMassB;
+ var i1 = this.m_invIA;
+ var i2 = this.m_invIB;
+ this.m_K.col1.x = m1 + m2 + i1 * this.m_s1 * this.m_s1 + i2 * this.m_s2 * this.m_s2;
+ this.m_K.col1.y = i1 * this.m_s1 * this.m_a1 + i2 * this.m_s2 * this.m_a2;
+ this.m_K.col2.x = this.m_K.col1.y;
+ this.m_K.col2.y = m1 + m2 + i1 * this.m_a1 * this.m_a1 + i2 * this.m_a2 * this.m_a2;
+ }
+ if (this.m_enableLimit) {
+ var jointTransition = this.m_axis.x * dX + this.m_axis.y * dY;
+ if (b2Math.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2.0 * b2Settings.b2_linearSlop) {
+ this.m_limitState = b2Joint.e_equalLimits;
+ }
+ else if (jointTransition <= this.m_lowerTranslation) {
+ if (this.m_limitState != b2Joint.e_atLowerLimit) {
+ this.m_limitState = b2Joint.e_atLowerLimit;
+ this.m_impulse.y = 0.0;
+ }
+ }
+ else if (jointTransition >= this.m_upperTranslation) {
+ if (this.m_limitState != b2Joint.e_atUpperLimit) {
+ this.m_limitState = b2Joint.e_atUpperLimit;
+ this.m_impulse.y = 0.0;
+ }
+ }
+ else {
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ this.m_impulse.y = 0.0;
+ }
+ }
+ else {
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ }
+ if (this.m_enableMotor == false) {
+ this.m_motorImpulse = 0.0;
+ }
+ if (step.warmStarting) {
+ this.m_impulse.x *= step.dtRatio;
+ this.m_impulse.y *= step.dtRatio;
+ this.m_motorImpulse *= step.dtRatio;
+ var PX = this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.x;
+ var PY = this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.y) * this.m_axis.y;
+ var L1 = this.m_impulse.x * this.m_s1 + (this.m_motorImpulse + this.m_impulse.y) * this.m_a1;
+ var L2 = this.m_impulse.x * this.m_s2 + (this.m_motorImpulse + this.m_impulse.y) * this.m_a2;
+ bA.m_linearVelocity.x -= this.m_invMassA * PX;
+ bA.m_linearVelocity.y -= this.m_invMassA * PY;
+ bA.m_angularVelocity -= this.m_invIA * L1;
+ bB.m_linearVelocity.x += this.m_invMassB * PX;
+ bB.m_linearVelocity.y += this.m_invMassB * PY;
+ bB.m_angularVelocity += this.m_invIB * L2;
+ }
+ else {
+ this.m_impulse.SetZero();
+ this.m_motorImpulse = 0.0;
+ }
+ }
+ b2LineJoint.prototype.SolveVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var v1 = bA.m_linearVelocity;
+ var w1 = bA.m_angularVelocity;
+ var v2 = bB.m_linearVelocity;
+ var w2 = bB.m_angularVelocity;
+ var PX = 0;
+ var PY = 0;
+ var L1 = 0;
+ var L2 = 0;
+ if (this.m_enableMotor && this.m_limitState != b2Joint.e_equalLimits) {
+ var Cdot = this.m_axis.x * (v2.x - v1.x) + this.m_axis.y * (v2.y - v1.y) + this.m_a2 * w2 - this.m_a1 * w1;
+ var impulse = this.m_motorMass * (this.m_motorSpeed - Cdot);
+ var oldImpulse = this.m_motorImpulse;
+ var maxImpulse = step.dt * this.m_maxMotorForce;
+ this.m_motorImpulse = b2Math.Clamp(this.m_motorImpulse + impulse, (-maxImpulse), maxImpulse);
+ impulse = this.m_motorImpulse - oldImpulse;
+ PX = impulse * this.m_axis.x;
+ PY = impulse * this.m_axis.y;
+ L1 = impulse * this.m_a1;
+ L2 = impulse * this.m_a2;
+ v1.x -= this.m_invMassA * PX;
+ v1.y -= this.m_invMassA * PY;
+ w1 -= this.m_invIA * L1;
+ v2.x += this.m_invMassB * PX;
+ v2.y += this.m_invMassB * PY;
+ w2 += this.m_invIB * L2;
+ }
+ var Cdot1 = this.m_perp.x * (v2.x - v1.x) + this.m_perp.y * (v2.y - v1.y) + this.m_s2 * w2 - this.m_s1 * w1;
+ if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit) {
+ var Cdot2 = this.m_axis.x * (v2.x - v1.x) + this.m_axis.y * (v2.y - v1.y) + this.m_a2 * w2 - this.m_a1 * w1;
+ var f1 = this.m_impulse.Copy();
+ var df = this.m_K.Solve(new b2Vec2(), (-Cdot1), (-Cdot2));
+ this.m_impulse.Add(df);
+ if (this.m_limitState == b2Joint.e_atLowerLimit) {
+ this.m_impulse.y = b2Math.Max(this.m_impulse.y, 0.0);
+ }
+ else if (this.m_limitState == b2Joint.e_atUpperLimit) {
+ this.m_impulse.y = b2Math.Min(this.m_impulse.y, 0.0);
+ }
+ var b = (-Cdot1) - (this.m_impulse.y - f1.y) * this.m_K.col2.x;
+ var f2r = 0;
+ if (this.m_K.col1.x != 0.0) {
+ f2r = b / this.m_K.col1.x + f1.x;
+ }
+ else {
+ f2r = f1.x;
+ }
+ this.m_impulse.x = f2r;
+ df.x = this.m_impulse.x - f1.x;
+ df.y = this.m_impulse.y - f1.y;
+ PX = df.x * this.m_perp.x + df.y * this.m_axis.x;
+ PY = df.x * this.m_perp.y + df.y * this.m_axis.y;
+ L1 = df.x * this.m_s1 + df.y * this.m_a1;
+ L2 = df.x * this.m_s2 + df.y * this.m_a2;
+ v1.x -= this.m_invMassA * PX;
+ v1.y -= this.m_invMassA * PY;
+ w1 -= this.m_invIA * L1;
+ v2.x += this.m_invMassB * PX;
+ v2.y += this.m_invMassB * PY;
+ w2 += this.m_invIB * L2;
+ }
+ else {
+ var df2 = 0;
+ if (this.m_K.col1.x != 0.0) {
+ df2 = ((-Cdot1)) / this.m_K.col1.x;
+ }
+ else {
+ df2 = 0.0;
+ }
+ this.m_impulse.x += df2;
+ PX = df2 * this.m_perp.x;
+ PY = df2 * this.m_perp.y;
+ L1 = df2 * this.m_s1;
+ L2 = df2 * this.m_s2;
+ v1.x -= this.m_invMassA * PX;
+ v1.y -= this.m_invMassA * PY;
+ w1 -= this.m_invIA * L1;
+ v2.x += this.m_invMassB * PX;
+ v2.y += this.m_invMassB * PY;
+ w2 += this.m_invIB * L2;
+ }
+ bA.m_linearVelocity.SetV(v1);
+ bA.m_angularVelocity = w1;
+ bB.m_linearVelocity.SetV(v2);
+ bB.m_angularVelocity = w2;
+ }
+ b2LineJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var limitC = 0;
+ var oldLimitImpulse = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var c1 = bA.m_sweep.c;
+ var a1 = bA.m_sweep.a;
+ var c2 = bB.m_sweep.c;
+ var a2 = bB.m_sweep.a;
+ var tMat;
+ var tX = 0;
+ var m1 = 0;
+ var m2 = 0;
+ var i1 = 0;
+ var i2 = 0;
+ var linearError = 0.0;
+ var angularError = 0.0;
+ var active = false;
+ var C2 = 0.0;
+ var R1 = b2Mat22.FromAngle(a1);
+ var R2 = b2Mat22.FromAngle(a2);
+ tMat = R1;
+ var r1X = this.m_localAnchor1.x - this.m_localCenterA.x;
+ var r1Y = this.m_localAnchor1.y - this.m_localCenterA.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = R2;
+ var r2X = this.m_localAnchor2.x - this.m_localCenterB.x;
+ var r2Y = this.m_localAnchor2.y - this.m_localCenterB.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var dX = c2.x + r2X - c1.x - r1X;
+ var dY = c2.y + r2Y - c1.y - r1Y;
+ if (this.m_enableLimit) {
+ this.m_axis = b2Math.MulMV(R1, this.m_localXAxis1);
+ this.m_a1 = (dX + r1X) * this.m_axis.y - (dY + r1Y) * this.m_axis.x;
+ this.m_a2 = r2X * this.m_axis.y - r2Y * this.m_axis.x;
+ var translation = this.m_axis.x * dX + this.m_axis.y * dY;
+ if (b2Math.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2.0 * b2Settings.b2_linearSlop) {
+ C2 = b2Math.Clamp(translation, (-b2Settings.b2_maxLinearCorrection), b2Settings.b2_maxLinearCorrection);
+ linearError = b2Math.Abs(translation);
+ active = true;
+ }
+ else if (translation <= this.m_lowerTranslation) {
+ C2 = b2Math.Clamp(translation - this.m_lowerTranslation + b2Settings.b2_linearSlop, (-b2Settings.b2_maxLinearCorrection), 0.0);
+ linearError = this.m_lowerTranslation - translation;
+ active = true;
+ }
+ else if (translation >= this.m_upperTranslation) {
+ C2 = b2Math.Clamp(translation - this.m_upperTranslation + b2Settings.b2_linearSlop, 0.0, b2Settings.b2_maxLinearCorrection);
+ linearError = translation - this.m_upperTranslation;
+ active = true;
+ }
+ }
+ this.m_perp = b2Math.MulMV(R1, this.m_localYAxis1);
+ this.m_s1 = (dX + r1X) * this.m_perp.y - (dY + r1Y) * this.m_perp.x;
+ this.m_s2 = r2X * this.m_perp.y - r2Y * this.m_perp.x;
+ var impulse = new b2Vec2();
+ var C1 = this.m_perp.x * dX + this.m_perp.y * dY;
+ linearError = b2Math.Max(linearError, b2Math.Abs(C1));
+ angularError = 0.0;
+ if (active) {
+ m1 = this.m_invMassA;
+ m2 = this.m_invMassB;
+ i1 = this.m_invIA;
+ i2 = this.m_invIB;
+ this.m_K.col1.x = m1 + m2 + i1 * this.m_s1 * this.m_s1 + i2 * this.m_s2 * this.m_s2;
+ this.m_K.col1.y = i1 * this.m_s1 * this.m_a1 + i2 * this.m_s2 * this.m_a2;
+ this.m_K.col2.x = this.m_K.col1.y;
+ this.m_K.col2.y = m1 + m2 + i1 * this.m_a1 * this.m_a1 + i2 * this.m_a2 * this.m_a2;
+ this.m_K.Solve(impulse, (-C1), (-C2));
+ }
+ else {
+ m1 = this.m_invMassA;
+ m2 = this.m_invMassB;
+ i1 = this.m_invIA;
+ i2 = this.m_invIB;
+ var k11 = m1 + m2 + i1 * this.m_s1 * this.m_s1 + i2 * this.m_s2 * this.m_s2;
+ var impulse1 = 0;
+ if (k11 != 0.0) {
+ impulse1 = ((-C1)) / k11;
+ }
+ else {
+ impulse1 = 0.0;
+ }
+ impulse.x = impulse1;
+ impulse.y = 0.0;
+ }
+ var PX = impulse.x * this.m_perp.x + impulse.y * this.m_axis.x;
+ var PY = impulse.x * this.m_perp.y + impulse.y * this.m_axis.y;
+ var L1 = impulse.x * this.m_s1 + impulse.y * this.m_a1;
+ var L2 = impulse.x * this.m_s2 + impulse.y * this.m_a2;
+ c1.x -= this.m_invMassA * PX;
+ c1.y -= this.m_invMassA * PY;
+ a1 -= this.m_invIA * L1;
+ c2.x += this.m_invMassB * PX;
+ c2.y += this.m_invMassB * PY;
+ a2 += this.m_invIB * L2;
+ bA.m_sweep.a = a1;
+ bB.m_sweep.a = a2;
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+
+ return linearError <= b2Settings.b2_linearSlop && angularError <= b2Settings.b2_angularSlop;
+ }
+ Box2D.inherit(b2LineJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2LineJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2LineJointDef.b2LineJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ this.localAxisA = new b2Vec2();
+ };
+ b2LineJointDef.prototype.b2LineJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_lineJoint;
+ this.localAxisA.Set(1.0, 0.0);
+ this.enableLimit = false;
+ this.lowerTranslation = 0.0;
+ this.upperTranslation = 0.0;
+ this.enableMotor = false;
+ this.maxMotorForce = 0.0;
+ this.motorSpeed = 0.0;
+ }
+ b2LineJointDef.prototype.Initialize = function (bA, bB, anchor, axis) {
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.localAnchorA = this.bodyA.GetLocalPoint(anchor);
+ this.localAnchorB = this.bodyB.GetLocalPoint(anchor);
+ this.localAxisA = this.bodyA.GetLocalVector(axis);
+ }
+ Box2D.inherit(b2MouseJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2MouseJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2MouseJoint.b2MouseJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.K = new b2Mat22();
+ this.K1 = new b2Mat22();
+ this.K2 = new b2Mat22();
+ this.m_localAnchor = new b2Vec2();
+ this.m_target = new b2Vec2();
+ this.m_impulse = new b2Vec2();
+ this.m_mass = new b2Mat22();
+ this.m_C = new b2Vec2();
+ };
+ b2MouseJoint.prototype.GetAnchorA = function () {
+ return this.m_target;
+ }
+ b2MouseJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor);
+ }
+ b2MouseJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_impulse.x, inv_dt * this.m_impulse.y);
+ }
+ b2MouseJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return 0.0;
+ }
+ b2MouseJoint.prototype.GetTarget = function () {
+ return this.m_target;
+ }
+ b2MouseJoint.prototype.SetTarget = function (target) {
+ if (this.m_bodyB.IsAwake() == false) {
+ this.m_bodyB.SetAwake(true);
+ }
+ this.m_target = target;
+ }
+ b2MouseJoint.prototype.GetMaxForce = function () {
+ return this.m_maxForce;
+ }
+ b2MouseJoint.prototype.SetMaxForce = function (maxForce) {
+ if (maxForce === undefined) maxForce = 0;
+ this.m_maxForce = maxForce;
+ }
+ b2MouseJoint.prototype.GetFrequency = function () {
+ return this.m_frequencyHz;
+ }
+ b2MouseJoint.prototype.SetFrequency = function (hz) {
+ if (hz === undefined) hz = 0;
+ this.m_frequencyHz = hz;
+ }
+ b2MouseJoint.prototype.GetDampingRatio = function () {
+ return this.m_dampingRatio;
+ }
+ b2MouseJoint.prototype.SetDampingRatio = function (ratio) {
+ if (ratio === undefined) ratio = 0;
+ this.m_dampingRatio = ratio;
+ }
+ b2MouseJoint.prototype.b2MouseJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ this.m_target.SetV(def.target);
+ var tX = this.m_target.x - this.m_bodyB.m_xf.position.x;
+ var tY = this.m_target.y - this.m_bodyB.m_xf.position.y;
+ var tMat = this.m_bodyB.m_xf.R;
+ this.m_localAnchor.x = (tX * tMat.col1.x + tY * tMat.col1.y);
+ this.m_localAnchor.y = (tX * tMat.col2.x + tY * tMat.col2.y);
+ this.m_maxForce = def.maxForce;
+ this.m_impulse.SetZero();
+ this.m_frequencyHz = def.frequencyHz;
+ this.m_dampingRatio = def.dampingRatio;
+ this.m_beta = 0.0;
+ this.m_gamma = 0.0;
+ }
+ b2MouseJoint.prototype.InitVelocityConstraints = function (step) {
+ var b = this.m_bodyB;
+ var mass = b.GetMass();
+ var omega = 2.0 * Math.PI * this.m_frequencyHz;
+ var d = 2.0 * mass * this.m_dampingRatio * omega;
+ var k = mass * omega * omega;
+ this.m_gamma = step.dt * (d + step.dt * k);
+ this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0.0;
+ this.m_beta = step.dt * k * this.m_gamma;
+ var tMat;tMat = b.m_xf.R;
+ var rX = this.m_localAnchor.x - b.m_sweep.localCenter.x;
+ var rY = this.m_localAnchor.y - b.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * rX + tMat.col2.x * rY);rY = (tMat.col1.y * rX + tMat.col2.y * rY);
+ rX = tX;
+ var invMass = b.m_invMass;
+ var invI = b.m_invI;this.K1.col1.x = invMass;
+ this.K1.col2.x = 0.0;
+ this.K1.col1.y = 0.0;
+ this.K1.col2.y = invMass;
+ this.K2.col1.x = invI * rY * rY;
+ this.K2.col2.x = (-invI * rX * rY);
+ this.K2.col1.y = (-invI * rX * rY);
+ this.K2.col2.y = invI * rX * rX;
+ this.K.SetM(this.K1);
+ this.K.AddM(this.K2);
+ this.K.col1.x += this.m_gamma;
+ this.K.col2.y += this.m_gamma;
+ this.K.GetInverse(this.m_mass);
+ this.m_C.x = b.m_sweep.c.x + rX - this.m_target.x;
+ this.m_C.y = b.m_sweep.c.y + rY - this.m_target.y;
+ b.m_angularVelocity *= 0.98;
+ this.m_impulse.x *= step.dtRatio;
+ this.m_impulse.y *= step.dtRatio;
+ b.m_linearVelocity.x += invMass * this.m_impulse.x;
+ b.m_linearVelocity.y += invMass * this.m_impulse.y;
+ b.m_angularVelocity += invI * (rX * this.m_impulse.y - rY * this.m_impulse.x);
+ }
+ b2MouseJoint.prototype.SolveVelocityConstraints = function (step) {
+ var b = this.m_bodyB;
+ var tMat;
+ var tX = 0;
+ var tY = 0;
+ tMat = b.m_xf.R;
+ var rX = this.m_localAnchor.x - b.m_sweep.localCenter.x;
+ var rY = this.m_localAnchor.y - b.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rX + tMat.col2.x * rY);
+ rY = (tMat.col1.y * rX + tMat.col2.y * rY);
+ rX = tX;
+ var CdotX = b.m_linearVelocity.x + ((-b.m_angularVelocity * rY));
+ var CdotY = b.m_linearVelocity.y + (b.m_angularVelocity * rX);
+ tMat = this.m_mass;
+ tX = CdotX + this.m_beta * this.m_C.x + this.m_gamma * this.m_impulse.x;
+ tY = CdotY + this.m_beta * this.m_C.y + this.m_gamma * this.m_impulse.y;
+ var impulseX = (-(tMat.col1.x * tX + tMat.col2.x * tY));
+ var impulseY = (-(tMat.col1.y * tX + tMat.col2.y * tY));
+ var oldImpulseX = this.m_impulse.x;
+ var oldImpulseY = this.m_impulse.y;
+ this.m_impulse.x += impulseX;
+ this.m_impulse.y += impulseY;
+ var maxImpulse = step.dt * this.m_maxForce;
+ if (this.m_impulse.LengthSquared() > maxImpulse * maxImpulse) {
+ this.m_impulse.Multiply(maxImpulse / this.m_impulse.Length());
+ }
+ impulseX = this.m_impulse.x - oldImpulseX;
+ impulseY = this.m_impulse.y - oldImpulseY;
+ b.m_linearVelocity.x += b.m_invMass * impulseX;
+ b.m_linearVelocity.y += b.m_invMass * impulseY;
+ b.m_angularVelocity += b.m_invI * (rX * impulseY - rY * impulseX);
+ }
+ b2MouseJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ return true;
+ }
+ Box2D.inherit(b2MouseJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2MouseJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2MouseJointDef.b2MouseJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.target = new b2Vec2();
+ };
+ b2MouseJointDef.prototype.b2MouseJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_mouseJoint;
+ this.maxForce = 0.0;
+ this.frequencyHz = 5.0;
+ this.dampingRatio = 0.7;
+ }
+ Box2D.inherit(b2PrismaticJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2PrismaticJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2PrismaticJoint.b2PrismaticJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_localAnchor1 = new b2Vec2();
+ this.m_localAnchor2 = new b2Vec2();
+ this.m_localXAxis1 = new b2Vec2();
+ this.m_localYAxis1 = new b2Vec2();
+ this.m_axis = new b2Vec2();
+ this.m_perp = new b2Vec2();
+ this.m_K = new b2Mat33();
+ this.m_impulse = new b2Vec3();
+ };
+ b2PrismaticJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ }
+ b2PrismaticJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ }
+ b2PrismaticJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * (this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.x), inv_dt * (this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.y));
+ }
+ b2PrismaticJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return inv_dt * this.m_impulse.y;
+ }
+ b2PrismaticJoint.prototype.GetJointTranslation = function () {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var p1 = bA.GetWorldPoint(this.m_localAnchor1);
+ var p2 = bB.GetWorldPoint(this.m_localAnchor2);
+ var dX = p2.x - p1.x;
+ var dY = p2.y - p1.y;
+ var axis = bA.GetWorldVector(this.m_localXAxis1);
+ var translation = axis.x * dX + axis.y * dY;
+ return translation;
+ }
+ b2PrismaticJoint.prototype.GetJointSpeed = function () {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var p1X = bA.m_sweep.c.x + r1X;
+ var p1Y = bA.m_sweep.c.y + r1Y;
+ var p2X = bB.m_sweep.c.x + r2X;
+ var p2Y = bB.m_sweep.c.y + r2Y;
+ var dX = p2X - p1X;
+ var dY = p2Y - p1Y;
+ var axis = bA.GetWorldVector(this.m_localXAxis1);
+ var v1 = bA.m_linearVelocity;
+ var v2 = bB.m_linearVelocity;
+ var w1 = bA.m_angularVelocity;
+ var w2 = bB.m_angularVelocity;
+ var speed = (dX * ((-w1 * axis.y)) + dY * (w1 * axis.x)) + (axis.x * (((v2.x + ((-w2 * r2Y))) - v1.x) - ((-w1 * r1Y))) + axis.y * (((v2.y + (w2 * r2X)) - v1.y) - (w1 * r1X)));
+ return speed;
+ }
+ b2PrismaticJoint.prototype.IsLimitEnabled = function () {
+ return this.m_enableLimit;
+ }
+ b2PrismaticJoint.prototype.EnableLimit = function (flag) {
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_enableLimit = flag;
+ }
+ b2PrismaticJoint.prototype.GetLowerLimit = function () {
+ return this.m_lowerTranslation;
+ }
+ b2PrismaticJoint.prototype.GetUpperLimit = function () {
+ return this.m_upperTranslation;
+ }
+ b2PrismaticJoint.prototype.SetLimits = function (lower, upper) {
+ if (lower === undefined) lower = 0;
+ if (upper === undefined) upper = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_lowerTranslation = lower;
+ this.m_upperTranslation = upper;
+ }
+ b2PrismaticJoint.prototype.IsMotorEnabled = function () {
+ return this.m_enableMotor;
+ }
+ b2PrismaticJoint.prototype.EnableMotor = function (flag) {
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_enableMotor = flag;
+ }
+ b2PrismaticJoint.prototype.SetMotorSpeed = function (speed) {
+ if (speed === undefined) speed = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_motorSpeed = speed;
+ }
+ b2PrismaticJoint.prototype.GetMotorSpeed = function () {
+ return this.m_motorSpeed;
+ }
+ b2PrismaticJoint.prototype.SetMaxMotorForce = function (force) {
+ if (force === undefined) force = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_maxMotorForce = force;
+ }
+ b2PrismaticJoint.prototype.GetMotorForce = function () {
+ return this.m_motorImpulse;
+ }
+ b2PrismaticJoint.prototype.b2PrismaticJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ var tMat;
+ var tX = 0;
+ var tY = 0;
+ this.m_localAnchor1.SetV(def.localAnchorA);
+ this.m_localAnchor2.SetV(def.localAnchorB);
+ this.m_localXAxis1.SetV(def.localAxisA);
+ this.m_localYAxis1.x = (-this.m_localXAxis1.y);
+ this.m_localYAxis1.y = this.m_localXAxis1.x;
+ this.m_refAngle = def.referenceAngle;
+ this.m_impulse.SetZero();
+ this.m_motorMass = 0.0;
+ this.m_motorImpulse = 0.0;
+ this.m_lowerTranslation = def.lowerTranslation;
+ this.m_upperTranslation = def.upperTranslation;
+ this.m_maxMotorForce = def.maxMotorForce;
+ this.m_motorSpeed = def.motorSpeed;
+ this.m_enableLimit = def.enableLimit;
+ this.m_enableMotor = def.enableMotor;
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ this.m_axis.SetZero();
+ this.m_perp.SetZero();
+ }
+ b2PrismaticJoint.prototype.InitVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var tX = 0;
+ this.m_localCenterA.SetV(bA.GetLocalCenter());
+ this.m_localCenterB.SetV(bB.GetLocalCenter());
+ var xf1 = bA.GetTransform();
+ var xf2 = bB.GetTransform();
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - this.m_localCenterA.x;
+ var r1Y = this.m_localAnchor1.y - this.m_localCenterA.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - this.m_localCenterB.x;
+ var r2Y = this.m_localAnchor2.y - this.m_localCenterB.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var dX = bB.m_sweep.c.x + r2X - bA.m_sweep.c.x - r1X;
+ var dY = bB.m_sweep.c.y + r2Y - bA.m_sweep.c.y - r1Y;
+ this.m_invMassA = bA.m_invMass;
+ this.m_invMassB = bB.m_invMass;
+ this.m_invIA = bA.m_invI;
+ this.m_invIB = bB.m_invI; {
+ this.m_axis.SetV(b2Math.MulMV(xf1.R, this.m_localXAxis1));
+ this.m_a1 = (dX + r1X) * this.m_axis.y - (dY + r1Y) * this.m_axis.x;
+ this.m_a2 = r2X * this.m_axis.y - r2Y * this.m_axis.x;
+ this.m_motorMass = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_a1 * this.m_a1 + this.m_invIB * this.m_a2 * this.m_a2;
+ if (this.m_motorMass > Number.MIN_VALUE) this.m_motorMass = 1.0 / this.m_motorMass;
+ } {
+ this.m_perp.SetV(b2Math.MulMV(xf1.R, this.m_localYAxis1));
+ this.m_s1 = (dX + r1X) * this.m_perp.y - (dY + r1Y) * this.m_perp.x;
+ this.m_s2 = r2X * this.m_perp.y - r2Y * this.m_perp.x;
+ var m1 = this.m_invMassA;
+ var m2 = this.m_invMassB;
+ var i1 = this.m_invIA;
+ var i2 = this.m_invIB;
+ this.m_K.col1.x = m1 + m2 + i1 * this.m_s1 * this.m_s1 + i2 * this.m_s2 * this.m_s2;
+ this.m_K.col1.y = i1 * this.m_s1 + i2 * this.m_s2;
+ this.m_K.col1.z = i1 * this.m_s1 * this.m_a1 + i2 * this.m_s2 * this.m_a2;
+ this.m_K.col2.x = this.m_K.col1.y;
+ this.m_K.col2.y = i1 + i2;
+ this.m_K.col2.z = i1 * this.m_a1 + i2 * this.m_a2;
+ this.m_K.col3.x = this.m_K.col1.z;
+ this.m_K.col3.y = this.m_K.col2.z;
+ this.m_K.col3.z = m1 + m2 + i1 * this.m_a1 * this.m_a1 + i2 * this.m_a2 * this.m_a2;
+ }
+ if (this.m_enableLimit) {
+ var jointTransition = this.m_axis.x * dX + this.m_axis.y * dY;
+ if (b2Math.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2.0 * b2Settings.b2_linearSlop) {
+ this.m_limitState = b2Joint.e_equalLimits;
+ }
+ else if (jointTransition <= this.m_lowerTranslation) {
+ if (this.m_limitState != b2Joint.e_atLowerLimit) {
+ this.m_limitState = b2Joint.e_atLowerLimit;
+ this.m_impulse.z = 0.0;
+ }
+ }
+ else if (jointTransition >= this.m_upperTranslation) {
+ if (this.m_limitState != b2Joint.e_atUpperLimit) {
+ this.m_limitState = b2Joint.e_atUpperLimit;
+ this.m_impulse.z = 0.0;
+ }
+ }
+ else {
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ this.m_impulse.z = 0.0;
+ }
+ }
+ else {
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ }
+ if (this.m_enableMotor == false) {
+ this.m_motorImpulse = 0.0;
+ }
+ if (step.warmStarting) {
+ this.m_impulse.x *= step.dtRatio;
+ this.m_impulse.y *= step.dtRatio;
+ this.m_motorImpulse *= step.dtRatio;
+ var PX = this.m_impulse.x * this.m_perp.x + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.x;
+ var PY = this.m_impulse.x * this.m_perp.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_axis.y;
+ var L1 = this.m_impulse.x * this.m_s1 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a1;
+ var L2 = this.m_impulse.x * this.m_s2 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a2;
+ bA.m_linearVelocity.x -= this.m_invMassA * PX;
+ bA.m_linearVelocity.y -= this.m_invMassA * PY;
+ bA.m_angularVelocity -= this.m_invIA * L1;
+ bB.m_linearVelocity.x += this.m_invMassB * PX;
+ bB.m_linearVelocity.y += this.m_invMassB * PY;
+ bB.m_angularVelocity += this.m_invIB * L2;
+ }
+ else {
+ this.m_impulse.SetZero();
+ this.m_motorImpulse = 0.0;
+ }
+ }
+ b2PrismaticJoint.prototype.SolveVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var v1 = bA.m_linearVelocity;
+ var w1 = bA.m_angularVelocity;
+ var v2 = bB.m_linearVelocity;
+ var w2 = bB.m_angularVelocity;
+ var PX = 0;
+ var PY = 0;
+ var L1 = 0;
+ var L2 = 0;
+ if (this.m_enableMotor && this.m_limitState != b2Joint.e_equalLimits) {
+ var Cdot = this.m_axis.x * (v2.x - v1.x) + this.m_axis.y * (v2.y - v1.y) + this.m_a2 * w2 - this.m_a1 * w1;
+ var impulse = this.m_motorMass * (this.m_motorSpeed - Cdot);
+ var oldImpulse = this.m_motorImpulse;
+ var maxImpulse = step.dt * this.m_maxMotorForce;
+ this.m_motorImpulse = b2Math.Clamp(this.m_motorImpulse + impulse, (-maxImpulse), maxImpulse);
+ impulse = this.m_motorImpulse - oldImpulse;
+ PX = impulse * this.m_axis.x;
+ PY = impulse * this.m_axis.y;
+ L1 = impulse * this.m_a1;
+ L2 = impulse * this.m_a2;
+ v1.x -= this.m_invMassA * PX;
+ v1.y -= this.m_invMassA * PY;
+ w1 -= this.m_invIA * L1;
+ v2.x += this.m_invMassB * PX;
+ v2.y += this.m_invMassB * PY;
+ w2 += this.m_invIB * L2;
+ }
+ var Cdot1X = this.m_perp.x * (v2.x - v1.x) + this.m_perp.y * (v2.y - v1.y) + this.m_s2 * w2 - this.m_s1 * w1;
+ var Cdot1Y = w2 - w1;
+ if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit) {
+ var Cdot2 = this.m_axis.x * (v2.x - v1.x) + this.m_axis.y * (v2.y - v1.y) + this.m_a2 * w2 - this.m_a1 * w1;
+ var f1 = this.m_impulse.Copy();
+ var df = this.m_K.Solve33(new b2Vec3(), (-Cdot1X), (-Cdot1Y), (-Cdot2));
+ this.m_impulse.Add(df);
+ if (this.m_limitState == b2Joint.e_atLowerLimit) {
+ this.m_impulse.z = b2Math.Max(this.m_impulse.z, 0.0);
+ }
+ else if (this.m_limitState == b2Joint.e_atUpperLimit) {
+ this.m_impulse.z = b2Math.Min(this.m_impulse.z, 0.0);
+ }
+ var bX = (-Cdot1X) - (this.m_impulse.z - f1.z) * this.m_K.col3.x;
+ var bY = (-Cdot1Y) - (this.m_impulse.z - f1.z) * this.m_K.col3.y;
+ var f2r = this.m_K.Solve22(new b2Vec2(), bX, bY);
+ f2r.x += f1.x;
+ f2r.y += f1.y;
+ this.m_impulse.x = f2r.x;
+ this.m_impulse.y = f2r.y;
+ df.x = this.m_impulse.x - f1.x;
+ df.y = this.m_impulse.y - f1.y;
+ df.z = this.m_impulse.z - f1.z;
+ PX = df.x * this.m_perp.x + df.z * this.m_axis.x;
+ PY = df.x * this.m_perp.y + df.z * this.m_axis.y;
+ L1 = df.x * this.m_s1 + df.y + df.z * this.m_a1;
+ L2 = df.x * this.m_s2 + df.y + df.z * this.m_a2;
+ v1.x -= this.m_invMassA * PX;
+ v1.y -= this.m_invMassA * PY;
+ w1 -= this.m_invIA * L1;
+ v2.x += this.m_invMassB * PX;
+ v2.y += this.m_invMassB * PY;
+ w2 += this.m_invIB * L2;
+ }
+ else {
+ var df2 = this.m_K.Solve22(new b2Vec2(), (-Cdot1X), (-Cdot1Y));
+ this.m_impulse.x += df2.x;
+ this.m_impulse.y += df2.y;
+ PX = df2.x * this.m_perp.x;
+ PY = df2.x * this.m_perp.y;
+ L1 = df2.x * this.m_s1 + df2.y;
+ L2 = df2.x * this.m_s2 + df2.y;
+ v1.x -= this.m_invMassA * PX;
+ v1.y -= this.m_invMassA * PY;
+ w1 -= this.m_invIA * L1;
+ v2.x += this.m_invMassB * PX;
+ v2.y += this.m_invMassB * PY;
+ w2 += this.m_invIB * L2;
+ }
+ bA.m_linearVelocity.SetV(v1);
+ bA.m_angularVelocity = w1;
+ bB.m_linearVelocity.SetV(v2);
+ bB.m_angularVelocity = w2;
+ }
+ b2PrismaticJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var limitC = 0;
+ var oldLimitImpulse = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var c1 = bA.m_sweep.c;
+ var a1 = bA.m_sweep.a;
+ var c2 = bB.m_sweep.c;
+ var a2 = bB.m_sweep.a;
+ var tMat;
+ var tX = 0;
+ var m1 = 0;
+ var m2 = 0;
+ var i1 = 0;
+ var i2 = 0;
+ var linearError = 0.0;
+ var angularError = 0.0;
+ var active = false;
+ var C2 = 0.0;
+ var R1 = b2Mat22.FromAngle(a1);
+ var R2 = b2Mat22.FromAngle(a2);
+ tMat = R1;
+ var r1X = this.m_localAnchor1.x - this.m_localCenterA.x;
+ var r1Y = this.m_localAnchor1.y - this.m_localCenterA.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = R2;
+ var r2X = this.m_localAnchor2.x - this.m_localCenterB.x;
+ var r2Y = this.m_localAnchor2.y - this.m_localCenterB.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var dX = c2.x + r2X - c1.x - r1X;
+ var dY = c2.y + r2Y - c1.y - r1Y;
+ if (this.m_enableLimit) {
+ this.m_axis = b2Math.MulMV(R1, this.m_localXAxis1);
+ this.m_a1 = (dX + r1X) * this.m_axis.y - (dY + r1Y) * this.m_axis.x;
+ this.m_a2 = r2X * this.m_axis.y - r2Y * this.m_axis.x;
+ var translation = this.m_axis.x * dX + this.m_axis.y * dY;
+ if (b2Math.Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2.0 * b2Settings.b2_linearSlop) {
+ C2 = b2Math.Clamp(translation, (-b2Settings.b2_maxLinearCorrection), b2Settings.b2_maxLinearCorrection);
+ linearError = b2Math.Abs(translation);
+ active = true;
+ }
+ else if (translation <= this.m_lowerTranslation) {
+ C2 = b2Math.Clamp(translation - this.m_lowerTranslation + b2Settings.b2_linearSlop, (-b2Settings.b2_maxLinearCorrection), 0.0);
+ linearError = this.m_lowerTranslation - translation;
+ active = true;
+ }
+ else if (translation >= this.m_upperTranslation) {
+ C2 = b2Math.Clamp(translation - this.m_upperTranslation + b2Settings.b2_linearSlop, 0.0, b2Settings.b2_maxLinearCorrection);
+ linearError = translation - this.m_upperTranslation;
+ active = true;
+ }
+ }
+ this.m_perp = b2Math.MulMV(R1, this.m_localYAxis1);
+ this.m_s1 = (dX + r1X) * this.m_perp.y - (dY + r1Y) * this.m_perp.x;
+ this.m_s2 = r2X * this.m_perp.y - r2Y * this.m_perp.x;
+ var impulse = new b2Vec3();
+ var C1X = this.m_perp.x * dX + this.m_perp.y * dY;
+ var C1Y = a2 - a1 - this.m_refAngle;
+ linearError = b2Math.Max(linearError, b2Math.Abs(C1X));
+ angularError = b2Math.Abs(C1Y);
+ if (active) {
+ m1 = this.m_invMassA;
+ m2 = this.m_invMassB;
+ i1 = this.m_invIA;
+ i2 = this.m_invIB;
+ this.m_K.col1.x = m1 + m2 + i1 * this.m_s1 * this.m_s1 + i2 * this.m_s2 * this.m_s2;
+ this.m_K.col1.y = i1 * this.m_s1 + i2 * this.m_s2;
+ this.m_K.col1.z = i1 * this.m_s1 * this.m_a1 + i2 * this.m_s2 * this.m_a2;
+ this.m_K.col2.x = this.m_K.col1.y;
+ this.m_K.col2.y = i1 + i2;
+ this.m_K.col2.z = i1 * this.m_a1 + i2 * this.m_a2;
+ this.m_K.col3.x = this.m_K.col1.z;
+ this.m_K.col3.y = this.m_K.col2.z;
+ this.m_K.col3.z = m1 + m2 + i1 * this.m_a1 * this.m_a1 + i2 * this.m_a2 * this.m_a2;
+ this.m_K.Solve33(impulse, (-C1X), (-C1Y), (-C2));
+ }
+ else {
+ m1 = this.m_invMassA;
+ m2 = this.m_invMassB;
+ i1 = this.m_invIA;
+ i2 = this.m_invIB;
+ var k11 = m1 + m2 + i1 * this.m_s1 * this.m_s1 + i2 * this.m_s2 * this.m_s2;
+ var k12 = i1 * this.m_s1 + i2 * this.m_s2;
+ var k22 = i1 + i2;
+ this.m_K.col1.Set(k11, k12, 0.0);
+ this.m_K.col2.Set(k12, k22, 0.0);
+ var impulse1 = this.m_K.Solve22(new b2Vec2(), (-C1X), (-C1Y));
+ impulse.x = impulse1.x;
+ impulse.y = impulse1.y;
+ impulse.z = 0.0;
+ }
+ var PX = impulse.x * this.m_perp.x + impulse.z * this.m_axis.x;
+ var PY = impulse.x * this.m_perp.y + impulse.z * this.m_axis.y;
+ var L1 = impulse.x * this.m_s1 + impulse.y + impulse.z * this.m_a1;
+ var L2 = impulse.x * this.m_s2 + impulse.y + impulse.z * this.m_a2;
+ c1.x -= this.m_invMassA * PX;
+ c1.y -= this.m_invMassA * PY;
+ a1 -= this.m_invIA * L1;
+ c2.x += this.m_invMassB * PX;
+ c2.y += this.m_invMassB * PY;
+ a2 += this.m_invIB * L2;
+ bA.m_sweep.a = a1;
+ bB.m_sweep.a = a2;
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ return linearError <= b2Settings.b2_linearSlop && angularError <= b2Settings.b2_angularSlop;
+ }
+ Box2D.inherit(b2PrismaticJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2PrismaticJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2PrismaticJointDef.b2PrismaticJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ this.localAxisA = new b2Vec2();
+ };
+ b2PrismaticJointDef.prototype.b2PrismaticJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_prismaticJoint;
+ this.localAxisA.Set(1.0, 0.0);
+ this.referenceAngle = 0.0;
+ this.enableLimit = false;
+ this.lowerTranslation = 0.0;
+ this.upperTranslation = 0.0;
+ this.enableMotor = false;
+ this.maxMotorForce = 0.0;
+ this.motorSpeed = 0.0;
+ }
+ b2PrismaticJointDef.prototype.Initialize = function (bA, bB, anchor, axis) {
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.localAnchorA = this.bodyA.GetLocalPoint(anchor);
+ this.localAnchorB = this.bodyB.GetLocalPoint(anchor);
+ this.localAxisA = this.bodyA.GetLocalVector(axis);
+ this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle();
+ }
+ Box2D.inherit(b2PulleyJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2PulleyJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2PulleyJoint.b2PulleyJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_groundAnchor1 = new b2Vec2();
+ this.m_groundAnchor2 = new b2Vec2();
+ this.m_localAnchor1 = new b2Vec2();
+ this.m_localAnchor2 = new b2Vec2();
+ this.m_u1 = new b2Vec2();
+ this.m_u2 = new b2Vec2();
+ };
+ b2PulleyJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ }
+ b2PulleyJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ }
+ b2PulleyJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_impulse * this.m_u2.x, inv_dt * this.m_impulse * this.m_u2.y);
+ }
+ b2PulleyJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return 0.0;
+ }
+ b2PulleyJoint.prototype.GetGroundAnchorA = function () {
+ var a = this.m_ground.m_xf.position.Copy();
+ a.Add(this.m_groundAnchor1);
+ return a;
+ }
+ b2PulleyJoint.prototype.GetGroundAnchorB = function () {
+ var a = this.m_ground.m_xf.position.Copy();
+ a.Add(this.m_groundAnchor2);
+ return a;
+ }
+ b2PulleyJoint.prototype.GetLength1 = function () {
+ var p = this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ var sX = this.m_ground.m_xf.position.x + this.m_groundAnchor1.x;
+ var sY = this.m_ground.m_xf.position.y + this.m_groundAnchor1.y;
+ var dX = p.x - sX;
+ var dY = p.y - sY;
+ return Math.sqrt(dX * dX + dY * dY);
+ }
+ b2PulleyJoint.prototype.GetLength2 = function () {
+ var p = this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ var sX = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x;
+ var sY = this.m_ground.m_xf.position.y + this.m_groundAnchor2.y;
+ var dX = p.x - sX;
+ var dY = p.y - sY;
+ return Math.sqrt(dX * dX + dY * dY);
+ }
+ b2PulleyJoint.prototype.GetRatio = function () {
+ return this.m_ratio;
+ }
+ b2PulleyJoint.prototype.b2PulleyJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ var tMat;
+ var tX = 0;
+ var tY = 0;
+ this.m_ground = this.m_bodyA.m_world.m_groundBody;
+ this.m_groundAnchor1.x = def.groundAnchorA.x - this.m_ground.m_xf.position.x;
+ this.m_groundAnchor1.y = def.groundAnchorA.y - this.m_ground.m_xf.position.y;
+ this.m_groundAnchor2.x = def.groundAnchorB.x - this.m_ground.m_xf.position.x;
+ this.m_groundAnchor2.y = def.groundAnchorB.y - this.m_ground.m_xf.position.y;
+ this.m_localAnchor1.SetV(def.localAnchorA);
+ this.m_localAnchor2.SetV(def.localAnchorB);
+ this.m_ratio = def.ratio;
+ this.m_constant = def.lengthA + this.m_ratio * def.lengthB;
+ this.m_maxLength1 = b2Math.Min(def.maxLengthA, this.m_constant - this.m_ratio * b2PulleyJoint.b2_minPulleyLength);
+ this.m_maxLength2 = b2Math.Min(def.maxLengthB, (this.m_constant - b2PulleyJoint.b2_minPulleyLength) / this.m_ratio);
+ this.m_impulse = 0.0;
+ this.m_limitImpulse1 = 0.0;
+ this.m_limitImpulse2 = 0.0;
+ }
+ b2PulleyJoint.prototype.InitVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var p1X = bA.m_sweep.c.x + r1X;
+ var p1Y = bA.m_sweep.c.y + r1Y;
+ var p2X = bB.m_sweep.c.x + r2X;
+ var p2Y = bB.m_sweep.c.y + r2Y;
+ var s1X = this.m_ground.m_xf.position.x + this.m_groundAnchor1.x;
+ var s1Y = this.m_ground.m_xf.position.y + this.m_groundAnchor1.y;
+ var s2X = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x;
+ var s2Y = this.m_ground.m_xf.position.y + this.m_groundAnchor2.y;
+ this.m_u1.Set(p1X - s1X, p1Y - s1Y);
+ this.m_u2.Set(p2X - s2X, p2Y - s2Y);
+ var length1 = this.m_u1.Length();
+ var length2 = this.m_u2.Length();
+ if (length1 > b2Settings.b2_linearSlop) {
+ this.m_u1.Multiply(1.0 / length1);
+ }
+ else {
+ this.m_u1.SetZero();
+ }
+ if (length2 > b2Settings.b2_linearSlop) {
+ this.m_u2.Multiply(1.0 / length2);
+ }
+ else {
+ this.m_u2.SetZero();
+ }
+ var C = this.m_constant - length1 - this.m_ratio * length2;
+ if (C > 0.0) {
+ this.m_state = b2Joint.e_inactiveLimit;
+ this.m_impulse = 0.0;
+ }
+ else {
+ this.m_state = b2Joint.e_atUpperLimit;
+ }
+ if (length1 < this.m_maxLength1) {
+ this.m_limitState1 = b2Joint.e_inactiveLimit;
+ this.m_limitImpulse1 = 0.0;
+ }
+ else {
+ this.m_limitState1 = b2Joint.e_atUpperLimit;
+ }
+ if (length2 < this.m_maxLength2) {
+ this.m_limitState2 = b2Joint.e_inactiveLimit;
+ this.m_limitImpulse2 = 0.0;
+ }
+ else {
+ this.m_limitState2 = b2Joint.e_atUpperLimit;
+ }
+ var cr1u1 = r1X * this.m_u1.y - r1Y * this.m_u1.x;
+ var cr2u2 = r2X * this.m_u2.y - r2Y * this.m_u2.x;
+ this.m_limitMass1 = bA.m_invMass + bA.m_invI * cr1u1 * cr1u1;
+ this.m_limitMass2 = bB.m_invMass + bB.m_invI * cr2u2 * cr2u2;
+ this.m_pulleyMass = this.m_limitMass1 + this.m_ratio * this.m_ratio * this.m_limitMass2;
+ this.m_limitMass1 = 1.0 / this.m_limitMass1;
+ this.m_limitMass2 = 1.0 / this.m_limitMass2;
+ this.m_pulleyMass = 1.0 / this.m_pulleyMass;
+ if (step.warmStarting) {
+ this.m_impulse *= step.dtRatio;
+ this.m_limitImpulse1 *= step.dtRatio;
+ this.m_limitImpulse2 *= step.dtRatio;
+ var P1X = ((-this.m_impulse) - this.m_limitImpulse1) * this.m_u1.x;
+ var P1Y = ((-this.m_impulse) - this.m_limitImpulse1) * this.m_u1.y;
+ var P2X = ((-this.m_ratio * this.m_impulse) - this.m_limitImpulse2) * this.m_u2.x;
+ var P2Y = ((-this.m_ratio * this.m_impulse) - this.m_limitImpulse2) * this.m_u2.y;
+ bA.m_linearVelocity.x += bA.m_invMass * P1X;
+ bA.m_linearVelocity.y += bA.m_invMass * P1Y;
+ bA.m_angularVelocity += bA.m_invI * (r1X * P1Y - r1Y * P1X);
+ bB.m_linearVelocity.x += bB.m_invMass * P2X;
+ bB.m_linearVelocity.y += bB.m_invMass * P2Y;
+ bB.m_angularVelocity += bB.m_invI * (r2X * P2Y - r2Y * P2X);
+ }
+ else {
+ this.m_impulse = 0.0;
+ this.m_limitImpulse1 = 0.0;
+ this.m_limitImpulse2 = 0.0;
+ }
+ }
+ b2PulleyJoint.prototype.SolveVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ var tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var v1X = 0;
+ var v1Y = 0;
+ var v2X = 0;
+ var v2Y = 0;
+ var P1X = 0;
+ var P1Y = 0;
+ var P2X = 0;
+ var P2Y = 0;
+ var Cdot = 0;
+ var impulse = 0;
+ var oldImpulse = 0;
+ if (this.m_state == b2Joint.e_atUpperLimit) {
+ v1X = bA.m_linearVelocity.x + ((-bA.m_angularVelocity * r1Y));
+ v1Y = bA.m_linearVelocity.y + (bA.m_angularVelocity * r1X);
+ v2X = bB.m_linearVelocity.x + ((-bB.m_angularVelocity * r2Y));
+ v2Y = bB.m_linearVelocity.y + (bB.m_angularVelocity * r2X);
+ Cdot = (-(this.m_u1.x * v1X + this.m_u1.y * v1Y)) - this.m_ratio * (this.m_u2.x * v2X + this.m_u2.y * v2Y);
+ impulse = this.m_pulleyMass * ((-Cdot));
+ oldImpulse = this.m_impulse;
+ this.m_impulse = b2Math.Max(0.0, this.m_impulse + impulse);
+ impulse = this.m_impulse - oldImpulse;
+ P1X = (-impulse * this.m_u1.x);
+ P1Y = (-impulse * this.m_u1.y);
+ P2X = (-this.m_ratio * impulse * this.m_u2.x);
+ P2Y = (-this.m_ratio * impulse * this.m_u2.y);
+ bA.m_linearVelocity.x += bA.m_invMass * P1X;
+ bA.m_linearVelocity.y += bA.m_invMass * P1Y;
+ bA.m_angularVelocity += bA.m_invI * (r1X * P1Y - r1Y * P1X);
+ bB.m_linearVelocity.x += bB.m_invMass * P2X;
+ bB.m_linearVelocity.y += bB.m_invMass * P2Y;
+ bB.m_angularVelocity += bB.m_invI * (r2X * P2Y - r2Y * P2X);
+ }
+ if (this.m_limitState1 == b2Joint.e_atUpperLimit) {
+ v1X = bA.m_linearVelocity.x + ((-bA.m_angularVelocity * r1Y));
+ v1Y = bA.m_linearVelocity.y + (bA.m_angularVelocity * r1X);
+ Cdot = (-(this.m_u1.x * v1X + this.m_u1.y * v1Y));
+ impulse = (-this.m_limitMass1 * Cdot);
+ oldImpulse = this.m_limitImpulse1;
+ this.m_limitImpulse1 = b2Math.Max(0.0, this.m_limitImpulse1 + impulse);
+ impulse = this.m_limitImpulse1 - oldImpulse;
+ P1X = (-impulse * this.m_u1.x);
+ P1Y = (-impulse * this.m_u1.y);
+ bA.m_linearVelocity.x += bA.m_invMass * P1X;
+ bA.m_linearVelocity.y += bA.m_invMass * P1Y;
+ bA.m_angularVelocity += bA.m_invI * (r1X * P1Y - r1Y * P1X);
+ }
+ if (this.m_limitState2 == b2Joint.e_atUpperLimit) {
+ v2X = bB.m_linearVelocity.x + ((-bB.m_angularVelocity * r2Y));
+ v2Y = bB.m_linearVelocity.y + (bB.m_angularVelocity * r2X);
+ Cdot = (-(this.m_u2.x * v2X + this.m_u2.y * v2Y));
+ impulse = (-this.m_limitMass2 * Cdot);
+ oldImpulse = this.m_limitImpulse2;
+ this.m_limitImpulse2 = b2Math.Max(0.0, this.m_limitImpulse2 + impulse);
+ impulse = this.m_limitImpulse2 - oldImpulse;
+ P2X = (-impulse * this.m_u2.x);
+ P2Y = (-impulse * this.m_u2.y);
+ bB.m_linearVelocity.x += bB.m_invMass * P2X;
+ bB.m_linearVelocity.y += bB.m_invMass * P2Y;
+ bB.m_angularVelocity += bB.m_invI * (r2X * P2Y - r2Y * P2X);
+ }
+ }
+ b2PulleyJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var s1X = this.m_ground.m_xf.position.x + this.m_groundAnchor1.x;
+ var s1Y = this.m_ground.m_xf.position.y + this.m_groundAnchor1.y;
+ var s2X = this.m_ground.m_xf.position.x + this.m_groundAnchor2.x;
+ var s2Y = this.m_ground.m_xf.position.y + this.m_groundAnchor2.y;
+ var r1X = 0;
+ var r1Y = 0;
+ var r2X = 0;
+ var r2Y = 0;
+ var p1X = 0;
+ var p1Y = 0;
+ var p2X = 0;
+ var p2Y = 0;
+ var length1 = 0;
+ var length2 = 0;
+ var C = 0;
+ var impulse = 0;
+ var oldImpulse = 0;
+ var oldLimitPositionImpulse = 0;
+ var tX = 0;
+ var linearError = 0.0;
+ if (this.m_state == b2Joint.e_atUpperLimit) {
+ tMat = bA.m_xf.R;
+ r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ p1X = bA.m_sweep.c.x + r1X;
+ p1Y = bA.m_sweep.c.y + r1Y;
+ p2X = bB.m_sweep.c.x + r2X;
+ p2Y = bB.m_sweep.c.y + r2Y;
+ this.m_u1.Set(p1X - s1X, p1Y - s1Y);
+ this.m_u2.Set(p2X - s2X, p2Y - s2Y);
+ length1 = this.m_u1.Length();
+ length2 = this.m_u2.Length();
+ if (length1 > b2Settings.b2_linearSlop) {
+ this.m_u1.Multiply(1.0 / length1);
+ }
+ else {
+ this.m_u1.SetZero();
+ }
+ if (length2 > b2Settings.b2_linearSlop) {
+ this.m_u2.Multiply(1.0 / length2);
+ }
+ else {
+ this.m_u2.SetZero();
+ }
+ C = this.m_constant - length1 - this.m_ratio * length2;
+ linearError = b2Math.Max(linearError, (-C));
+ C = b2Math.Clamp(C + b2Settings.b2_linearSlop, (-b2Settings.b2_maxLinearCorrection), 0.0);
+ impulse = (-this.m_pulleyMass * C);
+ p1X = (-impulse * this.m_u1.x);
+ p1Y = (-impulse * this.m_u1.y);
+ p2X = (-this.m_ratio * impulse * this.m_u2.x);
+ p2Y = (-this.m_ratio * impulse * this.m_u2.y);
+ bA.m_sweep.c.x += bA.m_invMass * p1X;
+ bA.m_sweep.c.y += bA.m_invMass * p1Y;
+ bA.m_sweep.a += bA.m_invI * (r1X * p1Y - r1Y * p1X);
+ bB.m_sweep.c.x += bB.m_invMass * p2X;
+ bB.m_sweep.c.y += bB.m_invMass * p2Y;
+ bB.m_sweep.a += bB.m_invI * (r2X * p2Y - r2Y * p2X);
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ }
+ if (this.m_limitState1 == b2Joint.e_atUpperLimit) {
+ tMat = bA.m_xf.R;
+ r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ p1X = bA.m_sweep.c.x + r1X;
+ p1Y = bA.m_sweep.c.y + r1Y;
+ this.m_u1.Set(p1X - s1X, p1Y - s1Y);
+ length1 = this.m_u1.Length();
+ if (length1 > b2Settings.b2_linearSlop) {
+ this.m_u1.x *= 1.0 / length1;
+ this.m_u1.y *= 1.0 / length1;
+ }
+ else {
+ this.m_u1.SetZero();
+ }
+ C = this.m_maxLength1 - length1;
+ linearError = b2Math.Max(linearError, (-C));
+ C = b2Math.Clamp(C + b2Settings.b2_linearSlop, (-b2Settings.b2_maxLinearCorrection), 0.0);
+ impulse = (-this.m_limitMass1 * C);
+ p1X = (-impulse * this.m_u1.x);
+ p1Y = (-impulse * this.m_u1.y);
+ bA.m_sweep.c.x += bA.m_invMass * p1X;
+ bA.m_sweep.c.y += bA.m_invMass * p1Y;
+ bA.m_sweep.a += bA.m_invI * (r1X * p1Y - r1Y * p1X);
+ bA.SynchronizeTransform();
+ }
+ if (this.m_limitState2 == b2Joint.e_atUpperLimit) {
+ tMat = bB.m_xf.R;
+ r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ p2X = bB.m_sweep.c.x + r2X;
+ p2Y = bB.m_sweep.c.y + r2Y;
+ this.m_u2.Set(p2X - s2X, p2Y - s2Y);
+ length2 = this.m_u2.Length();
+ if (length2 > b2Settings.b2_linearSlop) {
+ this.m_u2.x *= 1.0 / length2;
+ this.m_u2.y *= 1.0 / length2;
+ }
+ else {
+ this.m_u2.SetZero();
+ }
+ C = this.m_maxLength2 - length2;
+ linearError = b2Math.Max(linearError, (-C));
+ C = b2Math.Clamp(C + b2Settings.b2_linearSlop, (-b2Settings.b2_maxLinearCorrection), 0.0);
+ impulse = (-this.m_limitMass2 * C);
+ p2X = (-impulse * this.m_u2.x);
+ p2Y = (-impulse * this.m_u2.y);
+ bB.m_sweep.c.x += bB.m_invMass * p2X;
+ bB.m_sweep.c.y += bB.m_invMass * p2Y;
+ bB.m_sweep.a += bB.m_invI * (r2X * p2Y - r2Y * p2X);
+ bB.SynchronizeTransform();
+ }
+ return linearError < b2Settings.b2_linearSlop;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.Joints.b2PulleyJoint.b2_minPulleyLength = 2.0;
+ });
+ Box2D.inherit(b2PulleyJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2PulleyJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2PulleyJointDef.b2PulleyJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.groundAnchorA = new b2Vec2();
+ this.groundAnchorB = new b2Vec2();
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ };
+ b2PulleyJointDef.prototype.b2PulleyJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_pulleyJoint;
+ this.groundAnchorA.Set((-1.0), 1.0);
+ this.groundAnchorB.Set(1.0, 1.0);
+ this.localAnchorA.Set((-1.0), 0.0);
+ this.localAnchorB.Set(1.0, 0.0);
+ this.lengthA = 0.0;
+ this.maxLengthA = 0.0;
+ this.lengthB = 0.0;
+ this.maxLengthB = 0.0;
+ this.ratio = 1.0;
+ this.collideConnected = true;
+ }
+ b2PulleyJointDef.prototype.Initialize = function (bA, bB, gaA, gaB, anchorA, anchorB, r) {
+ if (r === undefined) r = 0;
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.groundAnchorA.SetV(gaA);
+ this.groundAnchorB.SetV(gaB);
+ this.localAnchorA = this.bodyA.GetLocalPoint(anchorA);
+ this.localAnchorB = this.bodyB.GetLocalPoint(anchorB);
+ var d1X = anchorA.x - gaA.x;
+ var d1Y = anchorA.y - gaA.y;
+ this.lengthA = Math.sqrt(d1X * d1X + d1Y * d1Y);
+ var d2X = anchorB.x - gaB.x;
+ var d2Y = anchorB.y - gaB.y;
+ this.lengthB = Math.sqrt(d2X * d2X + d2Y * d2Y);
+ this.ratio = r;
+ var C = this.lengthA + this.ratio * this.lengthB;
+ this.maxLengthA = C - this.ratio * b2PulleyJoint.b2_minPulleyLength;
+ this.maxLengthB = (C - b2PulleyJoint.b2_minPulleyLength) / this.ratio;
+ }
+ Box2D.inherit(b2RevoluteJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2RevoluteJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2RevoluteJoint.b2RevoluteJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.K = new b2Mat22();
+ this.K1 = new b2Mat22();
+ this.K2 = new b2Mat22();
+ this.K3 = new b2Mat22();
+ this.impulse3 = new b2Vec3();
+ this.impulse2 = new b2Vec2();
+ this.reduced = new b2Vec2();
+ this.m_localAnchor1 = new b2Vec2();
+ this.m_localAnchor2 = new b2Vec2();
+ this.m_impulse = new b2Vec3();
+ this.m_mass = new b2Mat33();
+ };
+ b2RevoluteJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchor1);
+ }
+ b2RevoluteJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchor2);
+ }
+ b2RevoluteJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_impulse.x, inv_dt * this.m_impulse.y);
+ }
+ b2RevoluteJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return inv_dt * this.m_impulse.z;
+ }
+ b2RevoluteJoint.prototype.GetJointAngle = function () {
+ return this.m_bodyB.m_sweep.a - this.m_bodyA.m_sweep.a - this.m_referenceAngle;
+ }
+ b2RevoluteJoint.prototype.GetJointSpeed = function () {
+ return this.m_bodyB.m_angularVelocity - this.m_bodyA.m_angularVelocity;
+ }
+ b2RevoluteJoint.prototype.IsLimitEnabled = function () {
+ return this.m_enableLimit;
+ }
+ b2RevoluteJoint.prototype.EnableLimit = function (flag) {
+ this.m_enableLimit = flag;
+ }
+ b2RevoluteJoint.prototype.GetLowerLimit = function () {
+ return this.m_lowerAngle;
+ }
+ b2RevoluteJoint.prototype.GetUpperLimit = function () {
+ return this.m_upperAngle;
+ }
+ b2RevoluteJoint.prototype.SetLimits = function (lower, upper) {
+
+ if (lower === undefined) lower = 0;
+ if (upper === undefined) upper = 0;
+ this.m_lowerAngle = lower;
+ this.m_upperAngle = upper;
+ }
+ b2RevoluteJoint.prototype.IsMotorEnabled = function () {
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ return this.m_enableMotor;
+ }
+ b2RevoluteJoint.prototype.EnableMotor = function (flag) {
+ this.m_enableMotor = flag;
+ }
+ b2RevoluteJoint.prototype.SetMotorSpeed = function (speed) {
+ if (speed === undefined) speed = 0;
+ this.m_bodyA.SetAwake(true);
+ this.m_bodyB.SetAwake(true);
+ this.m_motorSpeed = speed;
+ }
+ b2RevoluteJoint.prototype.GetMotorSpeed = function () {
+ return this.m_motorSpeed;
+ }
+ b2RevoluteJoint.prototype.SetMaxMotorTorque = function (torque) {
+ if (torque === undefined) torque = 0;
+ this.m_maxMotorTorque = torque;
+ }
+ b2RevoluteJoint.prototype.GetMotorTorque = function () {
+ return this.m_maxMotorTorque;
+ }
+ b2RevoluteJoint.prototype.b2RevoluteJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ this.m_localAnchor1.SetV(def.localAnchorA);
+ this.m_localAnchor2.SetV(def.localAnchorB);
+ this.m_referenceAngle = def.referenceAngle;
+ this.m_impulse.SetZero();
+ this.m_motorImpulse = 0.0;
+ this.m_lowerAngle = def.lowerAngle;
+ this.m_upperAngle = def.upperAngle;
+ this.m_maxMotorTorque = def.maxMotorTorque;
+ this.m_motorSpeed = def.motorSpeed;
+ this.m_enableLimit = def.enableLimit;
+ this.m_enableMotor = def.enableMotor;
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ }
+ b2RevoluteJoint.prototype.InitVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var tX = 0;
+ if (this.m_enableMotor || this.m_enableLimit) {}
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var m1 = bA.m_invMass;
+ var m2 = bB.m_invMass;
+ var i1 = bA.m_invI;
+ var i2 = bB.m_invI;
+ this.m_mass.col1.x = m1 + m2 + r1Y * r1Y * i1 + r2Y * r2Y * i2;
+ this.m_mass.col2.x = (-r1Y * r1X * i1) - r2Y * r2X * i2;
+ this.m_mass.col3.x = (-r1Y * i1) - r2Y * i2;
+ this.m_mass.col1.y = this.m_mass.col2.x;
+ this.m_mass.col2.y = m1 + m2 + r1X * r1X * i1 + r2X * r2X * i2;
+ this.m_mass.col3.y = r1X * i1 + r2X * i2;
+ this.m_mass.col1.z = this.m_mass.col3.x;
+ this.m_mass.col2.z = this.m_mass.col3.y;
+ this.m_mass.col3.z = i1 + i2;
+ this.m_motorMass = 1.0 / (i1 + i2);
+ if (this.m_enableMotor == false) {
+ this.m_motorImpulse = 0.0;
+ }
+ if (this.m_enableLimit) {
+ var jointAngle = bB.m_sweep.a - bA.m_sweep.a - this.m_referenceAngle;
+ if (b2Math.Abs(this.m_upperAngle - this.m_lowerAngle) < 2.0 * b2Settings.b2_angularSlop) {
+ this.m_limitState = b2Joint.e_equalLimits;
+ }
+ else if (jointAngle <= this.m_lowerAngle) {
+ if (this.m_limitState != b2Joint.e_atLowerLimit) {
+ this.m_impulse.z = 0.0;
+ }
+ this.m_limitState = b2Joint.e_atLowerLimit;
+ }
+ else if (jointAngle >= this.m_upperAngle) {
+ if (this.m_limitState != b2Joint.e_atUpperLimit) {
+ this.m_impulse.z = 0.0;
+ }
+ this.m_limitState = b2Joint.e_atUpperLimit;
+ }
+ else {
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ this.m_impulse.z = 0.0;
+ }
+ }
+ else {
+ this.m_limitState = b2Joint.e_inactiveLimit;
+ }
+ if (step.warmStarting) {
+ this.m_impulse.x *= step.dtRatio;
+ this.m_impulse.y *= step.dtRatio;
+ this.m_motorImpulse *= step.dtRatio;
+ var PX = this.m_impulse.x;
+ var PY = this.m_impulse.y;
+ bA.m_linearVelocity.x -= m1 * PX;
+ bA.m_linearVelocity.y -= m1 * PY;
+ bA.m_angularVelocity -= i1 * ((r1X * PY - r1Y * PX) + this.m_motorImpulse + this.m_impulse.z);
+ bB.m_linearVelocity.x += m2 * PX;
+ bB.m_linearVelocity.y += m2 * PY;
+ bB.m_angularVelocity += i2 * ((r2X * PY - r2Y * PX) + this.m_motorImpulse + this.m_impulse.z);
+ }
+ else {
+ this.m_impulse.SetZero();
+ this.m_motorImpulse = 0.0;
+ }
+ }
+ b2RevoluteJoint.prototype.SolveVelocityConstraints = function (step) {
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var tMat;
+ var tX = 0;
+ var newImpulse = 0;
+ var r1X = 0;
+ var r1Y = 0;
+ var r2X = 0;
+ var r2Y = 0;
+ var v1 = bA.m_linearVelocity;
+ var w1 = bA.m_angularVelocity;
+ var v2 = bB.m_linearVelocity;
+ var w2 = bB.m_angularVelocity;
+ var m1 = bA.m_invMass;
+ var m2 = bB.m_invMass;
+ var i1 = bA.m_invI;
+ var i2 = bB.m_invI;
+ if (this.m_enableMotor && this.m_limitState != b2Joint.e_equalLimits) {
+ var Cdot = w2 - w1 - this.m_motorSpeed;
+ var impulse = this.m_motorMass * ((-Cdot));
+ var oldImpulse = this.m_motorImpulse;
+ var maxImpulse = step.dt * this.m_maxMotorTorque;
+ this.m_motorImpulse = b2Math.Clamp(this.m_motorImpulse + impulse, (-maxImpulse), maxImpulse);
+ impulse = this.m_motorImpulse - oldImpulse;
+ w1 -= i1 * impulse;
+ w2 += i2 * impulse;
+ }
+ if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit) {
+ tMat = bA.m_xf.R;
+ r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var Cdot1X = v2.x + ((-w2 * r2Y)) - v1.x - ((-w1 * r1Y));
+ var Cdot1Y = v2.y + (w2 * r2X) - v1.y - (w1 * r1X);
+ var Cdot2 = w2 - w1;
+ this.m_mass.Solve33(this.impulse3, (-Cdot1X), (-Cdot1Y), (-Cdot2));
+ if (this.m_limitState == b2Joint.e_equalLimits) {
+ this.m_impulse.Add(this.impulse3);
+ }
+ else if (this.m_limitState == b2Joint.e_atLowerLimit) {
+ newImpulse = this.m_impulse.z + this.impulse3.z;
+ if (newImpulse < 0.0) {
+ this.m_mass.Solve22(this.reduced, (-Cdot1X), (-Cdot1Y));
+ this.impulse3.x = this.reduced.x;
+ this.impulse3.y = this.reduced.y;
+ this.impulse3.z = (-this.m_impulse.z);
+ this.m_impulse.x += this.reduced.x;
+ this.m_impulse.y += this.reduced.y;
+ this.m_impulse.z = 0.0;
+ }
+ }
+ else if (this.m_limitState == b2Joint.e_atUpperLimit) {
+ newImpulse = this.m_impulse.z + this.impulse3.z;
+ if (newImpulse > 0.0) {
+ this.m_mass.Solve22(this.reduced, (-Cdot1X), (-Cdot1Y));
+ this.impulse3.x = this.reduced.x;
+ this.impulse3.y = this.reduced.y;
+ this.impulse3.z = (-this.m_impulse.z);
+ this.m_impulse.x += this.reduced.x;
+ this.m_impulse.y += this.reduced.y;
+ this.m_impulse.z = 0.0;
+ }
+ }
+ v1.x -= m1 * this.impulse3.x;
+ v1.y -= m1 * this.impulse3.y;
+ w1 -= i1 * (r1X * this.impulse3.y - r1Y * this.impulse3.x + this.impulse3.z);
+ v2.x += m2 * this.impulse3.x;
+ v2.y += m2 * this.impulse3.y;
+ w2 += i2 * (r2X * this.impulse3.y - r2Y * this.impulse3.x + this.impulse3.z);
+ }
+ else {
+ tMat = bA.m_xf.R;
+ r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var CdotX = v2.x + ((-w2 * r2Y)) - v1.x - ((-w1 * r1Y));
+ var CdotY = v2.y + (w2 * r2X) - v1.y - (w1 * r1X);
+ this.m_mass.Solve22(this.impulse2, (-CdotX), (-CdotY));
+ this.m_impulse.x += this.impulse2.x;
+ this.m_impulse.y += this.impulse2.y;
+ v1.x -= m1 * this.impulse2.x;
+ v1.y -= m1 * this.impulse2.y;
+ w1 -= i1 * (r1X * this.impulse2.y - r1Y * this.impulse2.x);
+ v2.x += m2 * this.impulse2.x;
+ v2.y += m2 * this.impulse2.y;
+ w2 += i2 * (r2X * this.impulse2.y - r2Y * this.impulse2.x);
+ }
+ bA.m_linearVelocity.SetV(v1);
+ bA.m_angularVelocity = w1;
+ bB.m_linearVelocity.SetV(v2);
+ bB.m_angularVelocity = w2;
+ }
+ b2RevoluteJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var oldLimitImpulse = 0;
+ var C = 0;
+ var tMat;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var angularError = 0.0;
+ var positionError = 0.0;
+ var tX = 0;
+ var impulseX = 0;
+ var impulseY = 0;
+ if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit) {
+ var angle = bB.m_sweep.a - bA.m_sweep.a - this.m_referenceAngle;
+ var limitImpulse = 0.0;
+ if (this.m_limitState == b2Joint.e_equalLimits) {
+ C = b2Math.Clamp(angle - this.m_lowerAngle, (-b2Settings.b2_maxAngularCorrection), b2Settings.b2_maxAngularCorrection);
+ limitImpulse = (-this.m_motorMass * C);
+ angularError = b2Math.Abs(C);
+ }
+ else if (this.m_limitState == b2Joint.e_atLowerLimit) {
+ C = angle - this.m_lowerAngle;
+ angularError = (-C);
+ C = b2Math.Clamp(C + b2Settings.b2_angularSlop, (-b2Settings.b2_maxAngularCorrection), 0.0);
+ limitImpulse = (-this.m_motorMass * C);
+ }
+ else if (this.m_limitState == b2Joint.e_atUpperLimit) {
+ C = angle - this.m_upperAngle;
+ angularError = C;
+ C = b2Math.Clamp(C - b2Settings.b2_angularSlop, 0.0, b2Settings.b2_maxAngularCorrection);
+ limitImpulse = (-this.m_motorMass * C);
+ }
+ bA.m_sweep.a -= bA.m_invI * limitImpulse;
+ bB.m_sweep.a += bB.m_invI * limitImpulse;
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ } {
+ tMat = bA.m_xf.R;
+ var r1X = this.m_localAnchor1.x - bA.m_sweep.localCenter.x;
+ var r1Y = this.m_localAnchor1.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r1X + tMat.col2.x * r1Y);
+ r1Y = (tMat.col1.y * r1X + tMat.col2.y * r1Y);
+ r1X = tX;
+ tMat = bB.m_xf.R;
+ var r2X = this.m_localAnchor2.x - bB.m_sweep.localCenter.x;
+ var r2Y = this.m_localAnchor2.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * r2X + tMat.col2.x * r2Y);
+ r2Y = (tMat.col1.y * r2X + tMat.col2.y * r2Y);
+ r2X = tX;
+ var CX = bB.m_sweep.c.x + r2X - bA.m_sweep.c.x - r1X;
+ var CY = bB.m_sweep.c.y + r2Y - bA.m_sweep.c.y - r1Y;
+ var CLengthSquared = CX * CX + CY * CY;
+ var CLength = Math.sqrt(CLengthSquared);
+ positionError = CLength;
+ var invMass1 = bA.m_invMass;
+ var invMass2 = bB.m_invMass;
+ var invI1 = bA.m_invI;
+ var invI2 = bB.m_invI;
+ var k_allowedStretch = 10.0 * b2Settings.b2_linearSlop;
+ if (CLengthSquared > k_allowedStretch * k_allowedStretch) {
+ var uX = CX / CLength;
+ var uY = CY / CLength;
+ var k = invMass1 + invMass2;
+ var m = 1.0 / k;
+ impulseX = m * ((-CX));
+ impulseY = m * ((-CY));
+ var k_beta = 0.5;
+ bA.m_sweep.c.x -= k_beta * invMass1 * impulseX;
+ bA.m_sweep.c.y -= k_beta * invMass1 * impulseY;
+ bB.m_sweep.c.x += k_beta * invMass2 * impulseX;
+ bB.m_sweep.c.y += k_beta * invMass2 * impulseY;
+ CX = bB.m_sweep.c.x + r2X - bA.m_sweep.c.x - r1X;
+ CY = bB.m_sweep.c.y + r2Y - bA.m_sweep.c.y - r1Y;
+ }
+ this.K1.col1.x = invMass1 + invMass2;
+ this.K1.col2.x = 0.0;
+ this.K1.col1.y = 0.0;
+ this.K1.col2.y = invMass1 + invMass2;
+ this.K2.col1.x = invI1 * r1Y * r1Y;
+ this.K2.col2.x = (-invI1 * r1X * r1Y);
+ this.K2.col1.y = (-invI1 * r1X * r1Y);
+ this.K2.col2.y = invI1 * r1X * r1X;
+ this.K3.col1.x = invI2 * r2Y * r2Y;
+ this.K3.col2.x = (-invI2 * r2X * r2Y);
+ this.K3.col1.y = (-invI2 * r2X * r2Y);
+ this.K3.col2.y = invI2 * r2X * r2X;
+ this.K.SetM(this.K1);
+ this.K.AddM(this.K2);
+ this.K.AddM(this.K3);
+ this.K.Solve(b2RevoluteJoint.tImpulse, (-CX), (-CY));
+ impulseX = b2RevoluteJoint.tImpulse.x;
+ impulseY = b2RevoluteJoint.tImpulse.y;
+ bA.m_sweep.c.x -= bA.m_invMass * impulseX;
+ bA.m_sweep.c.y -= bA.m_invMass * impulseY;
+ bA.m_sweep.a -= bA.m_invI * (r1X * impulseY - r1Y * impulseX);
+ bB.m_sweep.c.x += bB.m_invMass * impulseX;
+ bB.m_sweep.c.y += bB.m_invMass * impulseY;
+ bB.m_sweep.a += bB.m_invI * (r2X * impulseY - r2Y * impulseX);
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ }
+ return positionError <= b2Settings.b2_linearSlop && angularError <= b2Settings.b2_angularSlop;
+ }
+ Box2D.postDefs.push(function () {
+ Box2D.Dynamics.Joints.b2RevoluteJoint.tImpulse = new b2Vec2();
+ });
+ Box2D.inherit(b2RevoluteJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2RevoluteJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2RevoluteJointDef.b2RevoluteJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ };
+ b2RevoluteJointDef.prototype.b2RevoluteJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_revoluteJoint;
+ this.localAnchorA.Set(0.0, 0.0);
+ this.localAnchorB.Set(0.0, 0.0);
+ this.referenceAngle = 0.0;
+ this.lowerAngle = 0.0;
+ this.upperAngle = 0.0;
+ this.maxMotorTorque = 0.0;
+ this.motorSpeed = 0.0;
+ this.enableLimit = false;
+ this.enableMotor = false;
+ }
+ b2RevoluteJointDef.prototype.Initialize = function (bA, bB, anchor) {
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.localAnchorA = this.bodyA.GetLocalPoint(anchor);
+ this.localAnchorB = this.bodyB.GetLocalPoint(anchor);
+ this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle();
+ }
+ Box2D.inherit(b2WeldJoint, Box2D.Dynamics.Joints.b2Joint);
+ b2WeldJoint.prototype.__super = Box2D.Dynamics.Joints.b2Joint.prototype;
+ b2WeldJoint.b2WeldJoint = function () {
+ Box2D.Dynamics.Joints.b2Joint.b2Joint.apply(this, arguments);
+ this.m_localAnchorA = new b2Vec2();
+ this.m_localAnchorB = new b2Vec2();
+ this.m_impulse = new b2Vec3();
+ this.m_mass = new b2Mat33();
+ };
+ b2WeldJoint.prototype.GetAnchorA = function () {
+ return this.m_bodyA.GetWorldPoint(this.m_localAnchorA);
+ }
+ b2WeldJoint.prototype.GetAnchorB = function () {
+ return this.m_bodyB.GetWorldPoint(this.m_localAnchorB);
+ }
+ b2WeldJoint.prototype.GetReactionForce = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return new b2Vec2(inv_dt * this.m_impulse.x, inv_dt * this.m_impulse.y);
+ }
+ b2WeldJoint.prototype.GetReactionTorque = function (inv_dt) {
+ if (inv_dt === undefined) inv_dt = 0;
+ return inv_dt * this.m_impulse.z;
+ }
+ b2WeldJoint.prototype.b2WeldJoint = function (def) {
+ this.__super.b2Joint.call(this, def);
+ this.m_localAnchorA.SetV(def.localAnchorA);
+ this.m_localAnchorB.SetV(def.localAnchorB);
+ this.m_referenceAngle = def.referenceAngle;
+ this.m_impulse.SetZero();
+ this.m_mass = new b2Mat33();
+ }
+ b2WeldJoint.prototype.InitVelocityConstraints = function (step) {
+ var tMat;
+ var tX = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ tMat = bA.m_xf.R;
+ var rAX = this.m_localAnchorA.x - bA.m_sweep.localCenter.x;
+ var rAY = this.m_localAnchorA.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rAX + tMat.col2.x * rAY);
+ rAY = (tMat.col1.y * rAX + tMat.col2.y * rAY);
+ rAX = tX;
+ tMat = bB.m_xf.R;
+ var rBX = this.m_localAnchorB.x - bB.m_sweep.localCenter.x;
+ var rBY = this.m_localAnchorB.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rBX + tMat.col2.x * rBY);
+ rBY = (tMat.col1.y * rBX + tMat.col2.y * rBY);
+ rBX = tX;
+ var mA = bA.m_invMass;
+ var mB = bB.m_invMass;
+ var iA = bA.m_invI;
+ var iB = bB.m_invI;
+ this.m_mass.col1.x = mA + mB + rAY * rAY * iA + rBY * rBY * iB;
+ this.m_mass.col2.x = (-rAY * rAX * iA) - rBY * rBX * iB;
+ this.m_mass.col3.x = (-rAY * iA) - rBY * iB;
+ this.m_mass.col1.y = this.m_mass.col2.x;
+ this.m_mass.col2.y = mA + mB + rAX * rAX * iA + rBX * rBX * iB;
+ this.m_mass.col3.y = rAX * iA + rBX * iB;
+ this.m_mass.col1.z = this.m_mass.col3.x;
+ this.m_mass.col2.z = this.m_mass.col3.y;
+ this.m_mass.col3.z = iA + iB;
+ if (step.warmStarting) {
+ this.m_impulse.x *= step.dtRatio;
+ this.m_impulse.y *= step.dtRatio;
+ this.m_impulse.z *= step.dtRatio;
+ bA.m_linearVelocity.x -= mA * this.m_impulse.x;
+ bA.m_linearVelocity.y -= mA * this.m_impulse.y;
+ bA.m_angularVelocity -= iA * (rAX * this.m_impulse.y - rAY * this.m_impulse.x + this.m_impulse.z);
+ bB.m_linearVelocity.x += mB * this.m_impulse.x;
+ bB.m_linearVelocity.y += mB * this.m_impulse.y;
+ bB.m_angularVelocity += iB * (rBX * this.m_impulse.y - rBY * this.m_impulse.x + this.m_impulse.z);
+ }
+ else {
+ this.m_impulse.SetZero();
+ }
+ }
+ b2WeldJoint.prototype.SolveVelocityConstraints = function (step) {
+ var tMat;
+ var tX = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ var vA = bA.m_linearVelocity;
+ var wA = bA.m_angularVelocity;
+ var vB = bB.m_linearVelocity;
+ var wB = bB.m_angularVelocity;
+ var mA = bA.m_invMass;
+ var mB = bB.m_invMass;
+ var iA = bA.m_invI;
+ var iB = bB.m_invI;
+ tMat = bA.m_xf.R;
+ var rAX = this.m_localAnchorA.x - bA.m_sweep.localCenter.x;
+ var rAY = this.m_localAnchorA.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rAX + tMat.col2.x * rAY);
+ rAY = (tMat.col1.y * rAX + tMat.col2.y * rAY);
+ rAX = tX;
+ tMat = bB.m_xf.R;
+ var rBX = this.m_localAnchorB.x - bB.m_sweep.localCenter.x;
+ var rBY = this.m_localAnchorB.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rBX + tMat.col2.x * rBY);
+ rBY = (tMat.col1.y * rBX + tMat.col2.y * rBY);
+ rBX = tX;
+ var Cdot1X = vB.x - wB * rBY - vA.x + wA * rAY;
+ var Cdot1Y = vB.y + wB * rBX - vA.y - wA * rAX;
+ var Cdot2 = wB - wA;
+ var impulse = new b2Vec3();
+ this.m_mass.Solve33(impulse, (-Cdot1X), (-Cdot1Y), (-Cdot2));
+ this.m_impulse.Add(impulse);
+ vA.x -= mA * impulse.x;
+ vA.y -= mA * impulse.y;
+ wA -= iA * (rAX * impulse.y - rAY * impulse.x + impulse.z);
+ vB.x += mB * impulse.x;
+ vB.y += mB * impulse.y;
+ wB += iB * (rBX * impulse.y - rBY * impulse.x + impulse.z);
+ bA.m_angularVelocity = wA;
+ bB.m_angularVelocity = wB;
+ }
+ b2WeldJoint.prototype.SolvePositionConstraints = function (baumgarte) {
+ if (baumgarte === undefined) baumgarte = 0;
+ var tMat;
+ var tX = 0;
+ var bA = this.m_bodyA;
+ var bB = this.m_bodyB;
+ tMat = bA.m_xf.R;
+ var rAX = this.m_localAnchorA.x - bA.m_sweep.localCenter.x;
+ var rAY = this.m_localAnchorA.y - bA.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rAX + tMat.col2.x * rAY);
+ rAY = (tMat.col1.y * rAX + tMat.col2.y * rAY);
+ rAX = tX;
+ tMat = bB.m_xf.R;
+ var rBX = this.m_localAnchorB.x - bB.m_sweep.localCenter.x;
+ var rBY = this.m_localAnchorB.y - bB.m_sweep.localCenter.y;
+ tX = (tMat.col1.x * rBX + tMat.col2.x * rBY);
+ rBY = (tMat.col1.y * rBX + tMat.col2.y * rBY);
+ rBX = tX;
+ var mA = bA.m_invMass;
+ var mB = bB.m_invMass;
+ var iA = bA.m_invI;
+ var iB = bB.m_invI;
+ var C1X = bB.m_sweep.c.x + rBX - bA.m_sweep.c.x - rAX;
+ var C1Y = bB.m_sweep.c.y + rBY - bA.m_sweep.c.y - rAY;
+ var C2 = bB.m_sweep.a - bA.m_sweep.a - this.m_referenceAngle;
+ var k_allowedStretch = 10.0 * b2Settings.b2_linearSlop;
+ var positionError = Math.sqrt(C1X * C1X + C1Y * C1Y);
+ var angularError = b2Math.Abs(C2);
+ if (positionError > k_allowedStretch) {
+ iA *= 1.0;
+ iB *= 1.0;
+ }
+ this.m_mass.col1.x = mA + mB + rAY * rAY * iA + rBY * rBY * iB;
+ this.m_mass.col2.x = (-rAY * rAX * iA) - rBY * rBX * iB;
+ this.m_mass.col3.x = (-rAY * iA) - rBY * iB;
+ this.m_mass.col1.y = this.m_mass.col2.x;
+ this.m_mass.col2.y = mA + mB + rAX * rAX * iA + rBX * rBX * iB;
+ this.m_mass.col3.y = rAX * iA + rBX * iB;
+ this.m_mass.col1.z = this.m_mass.col3.x;
+ this.m_mass.col2.z = this.m_mass.col3.y;
+ this.m_mass.col3.z = iA + iB;
+ var impulse = new b2Vec3();
+ this.m_mass.Solve33(impulse, (-C1X), (-C1Y), (-C2));
+ bA.m_sweep.c.x -= mA * impulse.x;
+ bA.m_sweep.c.y -= mA * impulse.y;
+ bA.m_sweep.a -= iA * (rAX * impulse.y - rAY * impulse.x + impulse.z);
+ bB.m_sweep.c.x += mB * impulse.x;
+ bB.m_sweep.c.y += mB * impulse.y;
+ bB.m_sweep.a += iB * (rBX * impulse.y - rBY * impulse.x + impulse.z);
+ bA.SynchronizeTransform();
+ bB.SynchronizeTransform();
+ return positionError <= b2Settings.b2_linearSlop && angularError <= b2Settings.b2_angularSlop;
+ }
+ Box2D.inherit(b2WeldJointDef, Box2D.Dynamics.Joints.b2JointDef);
+ b2WeldJointDef.prototype.__super = Box2D.Dynamics.Joints.b2JointDef.prototype;
+ b2WeldJointDef.b2WeldJointDef = function () {
+ Box2D.Dynamics.Joints.b2JointDef.b2JointDef.apply(this, arguments);
+ this.localAnchorA = new b2Vec2();
+ this.localAnchorB = new b2Vec2();
+ };
+ b2WeldJointDef.prototype.b2WeldJointDef = function () {
+ this.__super.b2JointDef.call(this);
+ this.type = b2Joint.e_weldJoint;
+ this.referenceAngle = 0.0;
+ }
+ b2WeldJointDef.prototype.Initialize = function (bA, bB, anchor) {
+ this.bodyA = bA;
+ this.bodyB = bB;
+ this.localAnchorA.SetV(this.bodyA.GetLocalPoint(anchor));
+ this.localAnchorB.SetV(this.bodyB.GetLocalPoint(anchor));
+ this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle();
+ }
+})();
+(function () {
+ var b2DebugDraw = Box2D.Dynamics.b2DebugDraw;
+ b2DebugDraw.b2DebugDraw = function () {
+ this.m_drawScale = 1.0;
+ this.m_lineThickness = 1.0;
+ this.m_alpha = 1.0;
+ this.m_fillAlpha = 1.0;
+ this.m_xformScale = 1.0;
+ var __this = this;
+ //#WORKAROUND
+ this.m_sprite = {
+ graphics: {
+ clear: function () {
+ __this.m_ctx.clearRect(0, 0, __this.m_ctx.canvas.width, __this.m_ctx.canvas.height)
+ }
+ }
+ };
+ };
+ b2DebugDraw.prototype._color = function (color, alpha) {
+ return "rgba(" + ((color & 0xFF0000) >> 16) + "," + ((color & 0xFF00) >> 8) + "," + (color & 0xFF) + "," + alpha + ")";
+ };
+ b2DebugDraw.prototype.b2DebugDraw = function () {
+ this.m_drawFlags = 0;
+ };
+ b2DebugDraw.prototype.SetFlags = function (flags) {
+ if (flags === undefined) flags = 0;
+ this.m_drawFlags = flags;
+ };
+ b2DebugDraw.prototype.GetFlags = function () {
+ return this.m_drawFlags;
+ };
+ b2DebugDraw.prototype.AppendFlags = function (flags) {
+ if (flags === undefined) flags = 0;
+ this.m_drawFlags |= flags;
+ };
+ b2DebugDraw.prototype.ClearFlags = function (flags) {
+ if (flags === undefined) flags = 0;
+ this.m_drawFlags &= ~flags;
+ };
+ b2DebugDraw.prototype.SetSprite = function (sprite) {
+ this.m_ctx = sprite;
+ };
+ b2DebugDraw.prototype.GetSprite = function () {
+ return this.m_ctx;
+ };
+ b2DebugDraw.prototype.SetDrawScale = function (drawScale) {
+ if (drawScale === undefined) drawScale = 0;
+ this.m_drawScale = drawScale;
+ };
+ b2DebugDraw.prototype.GetDrawScale = function () {
+ return this.m_drawScale;
+ };
+ b2DebugDraw.prototype.SetLineThickness = function (lineThickness) {
+ if (lineThickness === undefined) lineThickness = 0;
+ this.m_lineThickness = lineThickness;
+ this.m_ctx.strokeWidth = lineThickness;
+ };
+ b2DebugDraw.prototype.GetLineThickness = function () {
+ return this.m_lineThickness;
+ };
+ b2DebugDraw.prototype.SetAlpha = function (alpha) {
+ if (alpha === undefined) alpha = 0;
+ this.m_alpha = alpha;
+ };
+ b2DebugDraw.prototype.GetAlpha = function () {
+ return this.m_alpha;
+ };
+ b2DebugDraw.prototype.SetFillAlpha = function (alpha) {
+ if (alpha === undefined) alpha = 0;
+ this.m_fillAlpha = alpha;
+ };
+ b2DebugDraw.prototype.GetFillAlpha = function () {
+ return this.m_fillAlpha;
+ };
+ b2DebugDraw.prototype.SetXFormScale = function (xformScale) {
+ if (xformScale === undefined) xformScale = 0;
+ this.m_xformScale = xformScale;
+ };
+ b2DebugDraw.prototype.GetXFormScale = function () {
+ return this.m_xformScale;
+ };
+ b2DebugDraw.prototype.DrawPolygon = function (vertices, vertexCount, color) {
+ if (!vertexCount) return;
+ var s = this.m_ctx;
+ var drawScale = this.m_drawScale;
+ s.beginPath();
+ s.strokeStyle = this._color(color.color, this.m_alpha);
+ s.moveTo(vertices[0].x * drawScale, vertices[0].y * drawScale);
+ for (var i = 1; i < vertexCount; i++) {
+ s.lineTo(vertices[i].x * drawScale, vertices[i].y * drawScale);
+ }
+ s.lineTo(vertices[0].x * drawScale, vertices[0].y * drawScale);
+ s.closePath();
+ s.stroke();
+ };
+ b2DebugDraw.prototype.DrawSolidPolygon = function (vertices, vertexCount, color) {
+ if (!vertexCount) return;
+ var s = this.m_ctx;
+ var drawScale = this.m_drawScale;
+ s.beginPath();
+ s.strokeStyle = this._color(color.color, this.m_alpha);
+ s.fillStyle = this._color(color.color, this.m_fillAlpha);
+ s.moveTo(vertices[0].x * drawScale, vertices[0].y * drawScale);
+ for (var i = 1; i < vertexCount; i++) {
+ s.lineTo(vertices[i].x * drawScale, vertices[i].y * drawScale);
+ }
+ s.lineTo(vertices[0].x * drawScale, vertices[0].y * drawScale);
+ s.closePath();
+ s.fill();
+ s.stroke();
+ };
+ b2DebugDraw.prototype.DrawCircle = function (center, radius, color) {
+ if (!radius) return;
+ var s = this.m_ctx;
+ var drawScale = this.m_drawScale;
+ s.beginPath();
+ s.strokeStyle = this._color(color.color, this.m_alpha);
+ s.arc(center.x * drawScale, center.y * drawScale, radius * drawScale, 0, Math.PI * 2, true);
+ s.closePath();
+ s.stroke();
+ };
+ b2DebugDraw.prototype.DrawSolidCircle = function (center, radius, axis, color) {
+ if (!radius) return;
+ var s = this.m_ctx,
+ drawScale = this.m_drawScale,
+ cx = center.x * drawScale,
+ cy = center.y * drawScale;
+ s.moveTo(0, 0);
+ s.beginPath();
+ s.strokeStyle = this._color(color.color, this.m_alpha);
+ s.fillStyle = this._color(color.color, this.m_fillAlpha);
+ s.arc(cx, cy, radius * drawScale, 0, Math.PI * 2, true);
+ s.moveTo(cx, cy);
+ s.lineTo((center.x + axis.x * radius) * drawScale, (center.y + axis.y * radius) * drawScale);
+ s.closePath();
+ s.fill();
+ s.stroke();
+ };
+ b2DebugDraw.prototype.DrawSegment = function (p1, p2, color) {
+ var s = this.m_ctx,
+ drawScale = this.m_drawScale;
+ s.strokeStyle = this._color(color.color, this.m_alpha);
+ s.beginPath();
+ s.moveTo(p1.x * drawScale, p1.y * drawScale);
+ s.lineTo(p2.x * drawScale, p2.y * drawScale);
+ s.closePath();
+ s.stroke();
+ };
+ b2DebugDraw.prototype.DrawTransform = function (xf) {
+ var s = this.m_ctx,
+ drawScale = this.m_drawScale;
+ s.beginPath();
+ s.strokeStyle = this._color(0xff0000, this.m_alpha);
+ s.moveTo(xf.position.x * drawScale, xf.position.y * drawScale);
+ s.lineTo((xf.position.x + this.m_xformScale * xf.R.col1.x) * drawScale, (xf.position.y + this.m_xformScale * xf.R.col1.y) * drawScale);
+
+ s.strokeStyle = this._color(0xff00, this.m_alpha);
+ s.moveTo(xf.position.x * drawScale, xf.position.y * drawScale);
+ s.lineTo((xf.position.x + this.m_xformScale * xf.R.col2.x) * drawScale, (xf.position.y + this.m_xformScale * xf.R.col2.y) * drawScale);
+ s.closePath();
+ s.stroke();
+ };
+})(); //post-definitions
+var i;
+for (i = 0; i < Box2D.postDefs.length; ++i) Box2D.postDefs[i]();
+delete Box2D.postDefs;
+
+
+ return Box2D;
+});
\ No newline at end of file
diff --git a/lib/Chuck/Chuck.js b/lib/Chuck/Chuck.js
new file mode 100644
index 0000000..f0b8334
--- /dev/null
+++ b/lib/Chuck/Chuck.js
@@ -0,0 +1,13 @@
+define(["Chuck/Processor"], function(Processor){
+ var Chuck = {};
+
+ Chuck.init = function(){
+ var processor = new Processor();
+ }
+
+ Chuck.processRequest = function(package){
+ console.log(package);
+ }
+
+ return Chuck;
+});
\ No newline at end of file
diff --git a/lib/Chuck/Physics/Engine.js b/lib/Chuck/Physics/Engine.js
new file mode 100644
index 0000000..e67ab38
--- /dev/null
+++ b/lib/Chuck/Physics/Engine.js
@@ -0,0 +1,67 @@
+define(["Chuck/Settings", "Box2D/Box2D"], function(Settings, Box2D){
+
+ function Engine () {
+ this._world;
+ this.init();
+ }
+
+ Engine.prototype.init = function() {
+ this._world = new Box2D.Dynamics.b2World(new Box2D.Common.Math.b2Vec2(0, Settings.Box2D_GRAVITY), Settings.Box2D_ALLOW_SLEEP);
+
+ if(Settings.IS_BROWSER_ENVIRONMENT) {
+ this.setupDebugDraw();
+ }
+ }
+
+ Engine.prototype.getWorld = function() {
+ return this._world;
+ }
+
+ Engine.prototype.setCollisionDetector = function(me) {
+ /*
+ var cd = new Chuck.Collision.Detector(me);
+ var listener = cd.getListener();
+ this._world.SetContactListener(listener);*/
+ }
+
+ Engine.prototype.setupDebugDraw = function() {
+ var debugSprite = Settings.DEBUG_DRAW_CANVAS_SPRITE;
+ console.log(debugSprite);
+
+ // set debug draw
+ var dbgDraw = new Box2D.Dynamics.b2DebugDraw();
+
+ dbgDraw.SetSprite(debugSprite);
+ dbgDraw.SetDrawScale(Settings.RATIO);
+ dbgDraw.SetAlpha(0.5);
+ dbgDraw.SetFillAlpha(0.1);
+ dbgDraw.SetLineThickness(0);
+
+ dbgDraw.SetFlags(null
+ | dbgDraw.e_shapeBit
+ //| b2DebugDraw.e_jointBit
+ //| b2DebugDraw.e_coreShapeBit
+ //| b2DebugDraw.e_aabbBit
+ //| b2DebugDraw.e_centerOfMassBit
+ //| b2DebugDraw.e_obbBit
+ //| b2DebugDraw.e_pairBit
+ );
+
+ this._world.SetDebugDraw(dbgDraw);
+
+ this._world.SetWarmStarting(true);
+ console.log('Debug Draw was set up');
+ }
+
+ Engine.prototype.createBody = function(bodyDef) {
+ return this._world.CreateBody(bodyDef);
+ }
+
+ Engine.prototype.update = function() {
+ this._world.Step(Settings.Box2D_TIME_STEP, Settings.Box2D_VELOCITY_ITERATIONS, Settings.Box2D_POSITION_ITERATIONS);
+ this._world.ClearForces();
+ this._world.DrawDebugData();
+ }
+
+ return Engine;
+})
\ No newline at end of file
diff --git a/lib/Chuck/Processor.js b/lib/Chuck/Processor.js
new file mode 100644
index 0000000..b77824f
--- /dev/null
+++ b/lib/Chuck/Processor.js
@@ -0,0 +1,118 @@
+define(["Chuck/Physics/Engine", "Box2D/Box2D"], function(PhysicsEngine, Box2D){
+
+ function Processor () {
+ this._me;
+ this._physicsEngine;
+ this._camera;
+ this._repository;
+ this._inputControlUnit;
+ this._keyboardInput;
+
+ this.init();
+ };
+
+ Processor.prototype.init = function() {
+
+ this._physicsEngine = new PhysicsEngine();
+
+/*
+ var fixDef = new Box2D.Dynamics.b2FixtureDef;
+ fixDef.density = 1.0;
+ fixDef.friction = 0.99;
+ fixDef.restitution = .51;
+
+ var bodyDef = new Box2D.Dynamics.b2BodyDef;
+ bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
+ fixDef.shape = new Box2D.Collision.Shapes.b2PolygonShape;
+ fixDef.shape.SetAsBox(0.4, 0.4);
+
+ this._physicsEngine.createBody(bodyDef).CreateFixture(fixDef);
+ bodyDef.position.x = 2;
+ bodyDef.position.y = 3;
+
+ console.log('bodying');*/
+
+
+ ///------
+
+ var world = this._physicsEngine.getWorld();
+
+ var fixDef = new Box2D.Dynamics.b2FixtureDef;
+ fixDef.density = 1.0;
+ fixDef.friction = 0.99;
+ fixDef.restitution = .51;
+
+ var bodyDef = new Box2D.Dynamics.b2BodyDef;
+
+ // create ground
+ bodyDef.type = Box2D.Dynamics.b2Body.b2_staticBody;
+ fixDef.shape = new Box2D.Collision.Shapes.b2PolygonShape;
+ fixDef.shape.SetAsBox(20, 2);
+
+ bodyDef.position.Set(10, 400 / 30 + 1.8);
+
+ world.CreateBody(bodyDef).CreateFixture(fixDef);
+ bodyDef.position.Set(10, -1.8);
+
+ world.CreateBody(bodyDef).CreateFixture(fixDef);
+ fixDef.shape.SetAsBox(2, 14);
+
+ bodyDef.position.Set(-1.8, 13);
+ world.CreateBody(bodyDef).CreateFixture(fixDef);
+
+ bodyDef.position.Set(21.8, 13);
+ world.CreateBody(bodyDef).CreateFixture(fixDef);
+
+ // create some objects
+ bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
+
+ for(var i = 0; i < 5; i++) {
+ fixDef.shape = new Box2D.Collision.Shapes.b2PolygonShape;
+ fixDef.shape.SetAsBox(0.4, 0.4);
+
+ bodyDef.position.x = ((i + 1) * 2) % 8;
+ bodyDef.position.y = 3;
+
+ bodyDef.userData = {
+ 'bodyId': i + ''
+ };
+
+ world.CreateBody(bodyDef).CreateFixture(fixDef);
+ }
+
+ /*
+ this._me = new Chuck.Player(this._physicsEngine, this._repository);
+ //this._camera = Camera.getInstance()
+ //this._repository = Repository.getInstance();
+ this._physicsEngine.setCollisionDetector(this._me);
+ this._keyboardInput = new Chuck.Control.KeyboardInput();
+ this._inputControlUnit = new Chuck.Control.InputControlUnit(this._keyboardInput, this._me);
+
+ new Chuck.Loader.Level(this._physicsEngine);
+ //new Items();
+
+ this._me.spawn(100, 0);
+ //this._camera.follow(this._me);
+*/
+ setInterval(this._update, 1000/60, this);
+ //View.getInstance().getSprite().addEventListener(Event.ENTER_FRAME, this._update)
+ }
+
+ Processor.prototype.getPhysicsEngine = function() {
+ return this._physicsEngine;
+ }
+
+ Processor.prototype.getMe = function() {
+ return this._me;
+ }
+
+ Processor.prototype._update = function(self) {
+ self._physicsEngine.update();
+ //self._repository.update();
+ //self._keyboardInput.update();
+ //self._me.update();
+ //self._camera.update();
+ }
+
+ return Processor;
+});
diff --git a/lib/Chuck/Settings.js b/lib/Chuck/Settings.js
new file mode 100644
index 0000000..7b15e18
--- /dev/null
+++ b/lib/Chuck/Settings.js
@@ -0,0 +1,54 @@
+define(function() {
+
+ var Settings = {
+ STAGE_WIDTH : 600,
+ STAGE_HEIGHT : 400,
+
+ // BOX2D INITIALATORS
+ RATIO : 35,
+ BOX2D_WORLD_AABB_SIZE : 3000,
+ BOX2D_ALLOW_SLEEP : true,
+ BOX2D_GRAVITY : 16,
+ BOX2D_VELOCITY_ITERATIONS : 5,
+ BOX2D_POSITION_ITERATIONS : 5,
+ BOX2D_TIME_STEP : 1 / 30,
+
+ // GRAPHIC PATHS
+ GRAPHICS_PATH : 'img',
+ GRAPHICS_SUBPATH_ITEMS : 'Items',
+ GRAPHICS_SUBPATH_CHARACTERS : 'Characters',
+
+ TILE_SIZE : 15,
+
+ // GAME PLAY
+ WALK_SPEED : 2.5,
+ RUN_SPEED : 4.0,
+ FLY_SPEED : 3.2,
+ JUMP_SPEED : 3.0,
+
+ // restitution : bouncyness, friction : rubbing, density : mass
+ TILE_FRICTION : 0.99,
+ TILE_RESTITUTION : 0.1,
+
+ PLAYER_DENSITY : 0.96,
+ PLAYER_FRICTION : 5,
+ PLAYER_MOTION_FRICTION : 0.1,
+ PLAYER_RESTITUTION : 0.0,
+ PLAYER_LINEAR_DAMPING : .5,
+
+
+ ITEM_DENSITY : 0.9,
+ ITEM_FRICTION : 0.99,
+ ITEM_RESTITUTION : 0.02,
+
+ // debug draw
+ DEBUG_DRAW_CANVAS_SPRITE: isBrowserEnvironment() ? document.getElementById("canvas").getContext("2d") : undefined,
+ IS_BROWSER_ENVIRONMENT: isBrowserEnvironment()
+ };
+
+ function isBrowserEnvironment(){
+ return typeof window !== 'undefined';
+ }
+
+ return Settings;
+})
\ No newline at end of file
diff --git a/node_modules/.bin/r.js b/node_modules/.bin/r.js
new file mode 120000
index 0000000..2075b60
--- /dev/null
+++ b/node_modules/.bin/r.js
@@ -0,0 +1 @@
+../requirejs/bin/r.js
\ No newline at end of file
diff --git a/node_modules/node-static/LICENSE b/node_modules/node-static/LICENSE
new file mode 100644
index 0000000..91f6632
--- /dev/null
+++ b/node_modules/node-static/LICENSE
@@ -0,0 +1,20 @@
+Copyright (c) 2010 Alexis Sellier
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/node-static/README.md b/node_modules/node-static/README.md
new file mode 100644
index 0000000..013bde1
--- /dev/null
+++ b/node_modules/node-static/README.md
@@ -0,0 +1,141 @@
+node-static
+===========
+
+> a simple, *rfc 2616 compliant* file streaming module for [node](http://nodejs.org)
+
+node-static has an in-memory file cache, making it highly efficient.
+node-static understands and supports *conditional GET* and *HEAD* requests.
+node-static was inspired by some of the other static-file serving modules out there,
+such as node-paperboy and antinode.
+
+synopsis
+--------
+
+ var static = require('node-static');
+
+ //
+ // Create a node-static server instance to serve the './public' folder
+ //
+ var file = new(static.Server)('./public');
+
+ require('http').createServer(function (request, response) {
+ request.addListener('end', function () {
+ //
+ // Serve files!
+ //
+ file.serve(request, response);
+ });
+ }).listen(8080);
+
+API
+---
+
+### Creating a node-static Server #
+
+Creating a file server instance is as simple as:
+
+ new static.Server();
+
+This will serve files in the current directory. If you want to serve files in a specific
+directory, pass it as the first argument:
+
+ new static.Server('./public');
+
+You can also specify how long the client is supposed to cache the files node-static serves:
+
+ new static.Server('./public', { cache: 3600 });
+
+This will set the `Cache-Control` header, telling clients to cache the file for an hour.
+This is the default setting.
+
+### Serving files under a directory #
+
+To serve files under a directory, simply call the `serve` method on a `Server` instance, passing it
+the HTTP request and response object:
+
+ var fileServer = new static.Server('./public');
+
+ require('http').createServer(function (request, response) {
+ request.addListener('end', function () {
+ fileServer.serve(request, response);
+ });
+ }).listen(8080);
+
+### Serving specific files #
+
+If you want to serve a specific file, like an error page for example, use the `serveFile` method:
+
+ fileServer.serveFile('/error.html', 500, {}, request, response);
+
+This will serve the `error.html` file, from under the file root directory, with a `500` status code.
+For example, you could serve an error page, when the initial request wasn't found:
+
+ require('http').createServer(function (request, response) {
+ request.addListener('end', function () {
+ fileServer.serve(request, response, function (e, res) {
+ if (e && (e.status === 404)) { // If the file wasn't found
+ fileServer.serveFile('/not-found.html', 404, {}, request, response);
+ }
+ });
+ });
+ }).listen(8080);
+
+More on intercepting errors bellow.
+
+### Intercepting errors & Listening #
+
+An optional callback can be passed as last argument, it will be called every time a file
+has been served successfully, or if there was an error serving the file:
+
+ var fileServer = new static.Server('./public');
+
+ require('http').createServer(function (request, response) {
+ request.addListener('end', function () {
+ fileServer.serve(request, response, function (err, result) {
+ if (err) { // There was an error serving the file
+ sys.error("Error serving " + request.url + " - " + err.message);
+
+ // Respond to the client
+ response.writeHead(err.status, err.headers);
+ response.end();
+ }
+ });
+ });
+ }).listen(8080);
+
+Note that if you pass a callback, and there is an error serving the file, node-static
+*will not* respond to the client. This gives you the opportunity to re-route the request,
+or handle it differently.
+
+For example, you may want to interpret a request as a static request, but if the file isn't found,
+send it to an application.
+
+If you only want to *listen* for errors, you can use *event listeners*:
+
+ fileServer.serve(request, response).addListener('error', function (err) {
+ sys.error("Error serving " + request.url + " - " + err.message);
+ });
+
+With this method, you don't have to explicitly send the response back, in case of an error.
+
+### Options when creating an instance of `Server` #
+
+#### `cache` #
+
+Sets the `Cache-Control` header.
+
+example: `{ cache: 7200 }`
+
+Passing a number will set the cache duration to that number of seconds.
+Passing `false` will disable the `Cache-Control` header.
+
+> Defaults to `3600`
+
+#### `headers` #
+
+Sets response headers.
+
+example: `{ 'X-Hello': 'World!' }`
+
+> defaults to `{}`
+
diff --git a/node_modules/node-static/benchmark/node-static-0.3.0.txt b/node_modules/node-static/benchmark/node-static-0.3.0.txt
new file mode 100644
index 0000000..c6083ea
--- /dev/null
+++ b/node_modules/node-static/benchmark/node-static-0.3.0.txt
@@ -0,0 +1,43 @@
+This is ApacheBench, Version 2.3 <$Revision: 655654 $>
+Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+Licensed to The Apache Software Foundation, http://www.apache.org/
+
+Benchmarking 127.0.0.1 (be patient)
+
+
+Server Software: node-static/0.3.0
+Server Hostname: 127.0.0.1
+Server Port: 8080
+
+Document Path: /lib/node-static.js
+Document Length: 6038 bytes
+
+Concurrency Level: 20
+Time taken for tests: 2.323 seconds
+Complete requests: 10000
+Failed requests: 0
+Write errors: 0
+Total transferred: 63190000 bytes
+HTML transferred: 60380000 bytes
+Requests per second: 4304.67 [#/sec] (mean)
+Time per request: 4.646 [ms] (mean)
+Time per request: 0.232 [ms] (mean, across all concurrent requests)
+Transfer rate: 26563.66 [Kbytes/sec] received
+
+Connection Times (ms)
+ min mean[+/-sd] median max
+Connect: 0 0 0.2 0 3
+Processing: 1 4 1.4 4 28
+Waiting: 1 4 1.3 4 18
+Total: 2 5 1.5 4 28
+
+Percentage of the requests served within a certain time (ms)
+ 50% 4
+ 66% 5
+ 75% 5
+ 80% 5
+ 90% 5
+ 95% 6
+ 98% 8
+ 99% 9
+ 100% 28 (longest request)
diff --git a/node_modules/node-static/examples/file-server.js b/node_modules/node-static/examples/file-server.js
new file mode 100644
index 0000000..f133b80
--- /dev/null
+++ b/node_modules/node-static/examples/file-server.js
@@ -0,0 +1,25 @@
+var static = require('../lib/node-static');
+
+//
+// Create a node-static server to serve the current directory
+//
+var file = new(static.Server)('.', { cache: 7200, headers: {'X-Hello':'World!'} });
+
+require('http').createServer(function (request, response) {
+ request.addListener('end', function () {
+ //
+ // Serve files!
+ //
+ file.serve(request, response, function (err, res) {
+ if (err) { // An error as occured
+ console.error("> Error serving " + request.url + " - " + err.message);
+ response.writeHead(err.status, err.headers);
+ response.end();
+ } else { // The file was served successfully
+ console.log("> " + request.url + " - " + res.message);
+ }
+ });
+ });
+}).listen(8080);
+
+console.log("> node-static is listening on http://127.0.0.1:8080");
diff --git a/node_modules/node-static/lib/node-static.js b/node_modules/node-static/lib/node-static.js
new file mode 100644
index 0000000..6c668b1
--- /dev/null
+++ b/node_modules/node-static/lib/node-static.js
@@ -0,0 +1,252 @@
+var fs = require('fs'),
+ events = require('events'),
+ buffer = require('buffer'),
+ http = require('http'),
+ url = require('url'),
+ path = require('path');
+
+this.version = [0, 6, 0];
+
+var mime = require('./node-static/mime');
+var util = require('./node-static/util');
+
+var serverInfo = 'node-static/' + this.version.join('.');
+
+// In-memory file store
+this.store = {};
+this.indexStore = {};
+
+this.Server = function (root, options) {
+ if (root && (typeof(root) === 'object')) { options = root, root = null }
+
+ this.root = path.resolve(root || '.');
+ this.options = options || {};
+ this.cache = 3600;
+
+ this.defaultHeaders = {};
+ this.options.headers = this.options.headers || {};
+
+ if ('cache' in this.options) {
+ if (typeof(this.options.cache) === 'number') {
+ this.cache = this.options.cache;
+ } else if (! this.options.cache) {
+ this.cache = false;
+ }
+ }
+
+ if (this.cache !== false) {
+ this.defaultHeaders['Cache-Control'] = 'max-age=' + this.cache;
+ }
+ this.defaultHeaders['Server'] = serverInfo;
+
+ for (var k in this.defaultHeaders) {
+ this.options.headers[k] = this.options.headers[k] ||
+ this.defaultHeaders[k];
+ }
+};
+
+this.Server.prototype.serveDir = function (pathname, req, res, finish) {
+ var htmlIndex = path.join(pathname, 'index.html'),
+ that = this;
+
+ fs.stat(htmlIndex, function (e, stat) {
+ if (!e) {
+ that.respond(null, 200, {}, [htmlIndex], stat, req, res, finish);
+ } else {
+ if (pathname in exports.store) {
+ streamFiles(exports.indexStore[pathname].files);
+ } else {
+ // Stream a directory of files as a single file.
+ fs.readFile(path.join(pathname, 'index.json'), function (e, contents) {
+ if (e) { return finish(404, {}) }
+ var index = JSON.parse(contents);
+ exports.indexStore[pathname] = index;
+ streamFiles(index.files);
+ });
+ }
+ }
+ });
+ function streamFiles(files) {
+ util.mstat(pathname, files, function (e, stat) {
+ that.respond(pathname, 200, {}, files, stat, req, res, finish);
+ });
+ }
+};
+this.Server.prototype.serveFile = function (pathname, status, headers, req, res) {
+ var that = this;
+ var promise = new(events.EventEmitter);
+
+ pathname = this.resolve(pathname);
+
+ fs.stat(pathname, function (e, stat) {
+ if (e) {
+ return promise.emit('error', e);
+ }
+ that.respond(null, status, headers, [pathname], stat, req, res, function (status, headers) {
+ that.finish(status, headers, req, res, promise);
+ });
+ });
+ return promise;
+};
+this.Server.prototype.finish = function (status, headers, req, res, promise, callback) {
+ var result = {
+ status: status,
+ headers: headers,
+ message: http.STATUS_CODES[status]
+ };
+
+ headers['Server'] = serverInfo;
+
+ if (!status || status >= 400) {
+ if (callback) {
+ callback(result);
+ } else {
+ if (promise.listeners('error').length > 0) {
+ promise.emit('error', result);
+ }
+ res.writeHead(status, headers);
+ res.end();
+ }
+ } else {
+ // Don't end the request here, if we're streaming;
+ // it's taken care of in `prototype.stream`.
+ if (status !== 200 || req.method !== 'GET') {
+ res.writeHead(status, headers);
+ res.end();
+ }
+ callback && callback(null, result);
+ promise.emit('success', result);
+ }
+};
+
+this.Server.prototype.servePath = function (pathname, status, headers, req, res, finish) {
+ var that = this,
+ promise = new(events.EventEmitter);
+
+ pathname = this.resolve(pathname);
+
+ // Only allow GET and HEAD requests
+ if (req.method !== 'GET' && req.method !== 'HEAD') {
+ finish(405, { 'Allow': 'GET, HEAD' });
+ return promise;
+ }
+
+ // Make sure we're not trying to access a
+ // file outside of the root.
+ if (pathname.indexOf(that.root) === 0) {
+ fs.stat(pathname, function (e, stat) {
+ if (e) {
+ finish(404, {});
+ } else if (stat.isFile()) { // Stream a single file.
+ that.respond(null, status, headers, [pathname], stat, req, res, finish);
+ } else if (stat.isDirectory()) { // Stream a directory of files.
+ that.serveDir(pathname, req, res, finish);
+ } else {
+ finish(400, {});
+ }
+ });
+ } else {
+ // Forbidden
+ finish(403, {});
+ }
+ return promise;
+};
+this.Server.prototype.resolve = function (pathname) {
+ return path.resolve(path.join(this.root, pathname));
+};
+this.Server.prototype.serve = function (req, res, callback) {
+ var that = this,
+ promise = new(events.EventEmitter);
+
+ var pathname = decodeURI(url.parse(req.url).pathname);
+
+ var finish = function (status, headers) {
+ that.finish(status, headers, req, res, promise, callback);
+ };
+
+ process.nextTick(function () {
+ that.servePath(pathname, 200, {}, req, res, finish).on('success', function (result) {
+ promise.emit('success', result);
+ }).on('error', function (err) {
+ promise.emit('error');
+ });
+ });
+ if (! callback) { return promise }
+};
+
+this.Server.prototype.respond = function (pathname, status, _headers, files, stat, req, res, finish) {
+ var mtime = Date.parse(stat.mtime),
+ key = pathname || files[0],
+ headers = {};
+
+ // Copy default headers
+ for (var k in this.options.headers) { headers[k] = this.options.headers[k] }
+
+ headers['Etag'] = JSON.stringify([stat.ino, stat.size, mtime].join('-'));
+ headers['Date'] = new(Date)().toUTCString();
+ headers['Last-Modified'] = new(Date)(stat.mtime).toUTCString();
+
+ // Conditional GET
+ // If the "If-Modified-Since" or "If-None-Match" headers
+ // match the conditions, send a 304 Not Modified.
+ if (req.headers['if-none-match'] === headers['Etag'] ||
+ Date.parse(req.headers['if-modified-since']) >= mtime) {
+ finish(304, headers);
+ } else if (req.method === 'HEAD') {
+ finish(200, headers);
+ } else {
+ var fileExtension = path.extname(files[0]).slice(1).toLowerCase();
+ headers['Content-Length'] = stat.size;
+ headers['Content-Type'] = mime.contentTypes[fileExtension] ||
+ 'application/octet-stream';
+
+ for (var k in _headers) { headers[k] = _headers[k] }
+
+ res.writeHead(status, headers);
+
+ // If the file was cached and it's not older
+ // than what's on disk, serve the cached version.
+ if (this.cache && (key in exports.store) &&
+ exports.store[key].stat.mtime >= stat.mtime) {
+ res.end(exports.store[key].buffer);
+ finish(status, headers);
+ } else {
+ this.stream(pathname, files, new(buffer.Buffer)(stat.size), res, function (e, buffer) {
+ if (e) { return finish(500, {}) }
+ exports.store[key] = {
+ stat: stat,
+ buffer: buffer,
+ timestamp: Date.now()
+ };
+ finish(status, headers);
+ });
+ }
+ }
+};
+
+this.Server.prototype.stream = function (pathname, files, buffer, res, callback) {
+ (function streamFile(files, offset) {
+ var file = files.shift();
+
+ if (file) {
+ file = file[0] === '/' ? file : path.join(pathname || '.', file);
+
+ // Stream the file to the client
+ fs.createReadStream(file, {
+ flags: 'r',
+ mode: 0666
+ }).on('data', function (chunk) {
+ chunk.copy(buffer, offset);
+ offset += chunk.length;
+ }).on('close', function () {
+ streamFile(files, offset);
+ }).on('error', function (err) {
+ callback(err);
+ console.error(err);
+ }).pipe(res, { end: false });
+ } else {
+ res.end();
+ callback(null, buffer, offset);
+ }
+ })(files.slice(0), 0);
+};
diff --git a/node_modules/node-static/lib/node-static/mime.js b/node_modules/node-static/lib/node-static/mime.js
new file mode 100644
index 0000000..dc2f79b
--- /dev/null
+++ b/node_modules/node-static/lib/node-static/mime.js
@@ -0,0 +1,140 @@
+this.contentTypes = {
+ "aiff": "audio/x-aiff",
+ "arj": "application/x-arj-compressed",
+ "asf": "video/x-ms-asf",
+ "asx": "video/x-ms-asx",
+ "au": "audio/ulaw",
+ "avi": "video/x-msvideo",
+ "bcpio": "application/x-bcpio",
+ "ccad": "application/clariscad",
+ "cod": "application/vnd.rim.cod",
+ "com": "application/x-msdos-program",
+ "cpio": "application/x-cpio",
+ "cpt": "application/mac-compactpro",
+ "csh": "application/x-csh",
+ "css": "text/css",
+ "deb": "application/x-debian-package",
+ "dl": "video/dl",
+ "doc": "application/msword",
+ "drw": "application/drafting",
+ "dvi": "application/x-dvi",
+ "dwg": "application/acad",
+ "dxf": "application/dxf",
+ "dxr": "application/x-director",
+ "etx": "text/x-setext",
+ "ez": "application/andrew-inset",
+ "fli": "video/x-fli",
+ "flv": "video/x-flv",
+ "gif": "image/gif",
+ "gl": "video/gl",
+ "gtar": "application/x-gtar",
+ "gz": "application/x-gzip",
+ "hdf": "application/x-hdf",
+ "hqx": "application/mac-binhex40",
+ "htm": "text/html",
+ "html": "text/html",
+ "ice": "x-conference/x-cooltalk",
+ "ico": "image/x-icon",
+ "ief": "image/ief",
+ "igs": "model/iges",
+ "ips": "application/x-ipscript",
+ "ipx": "application/x-ipix",
+ "jad": "text/vnd.sun.j2me.app-descriptor",
+ "jar": "application/java-archive",
+ "jpeg": "image/jpeg",
+ "jpg": "image/jpeg",
+ "js": "text/javascript",
+ "json": "application/json",
+ "latex": "application/x-latex",
+ "less": "text/css",
+ "lsp": "application/x-lisp",
+ "lzh": "application/octet-stream",
+ "m": "text/plain",
+ "m3u": "audio/x-mpegurl",
+ "man": "application/x-troff-man",
+ "manifest": "text/cache-manifest",
+ "me": "application/x-troff-me",
+ "midi": "audio/midi",
+ "mif": "application/x-mif",
+ "mime": "www/mime",
+ "movie": "video/x-sgi-movie",
+ "mp4": "video/mp4",
+ "mpg": "video/mpeg",
+ "mpga": "audio/mpeg",
+ "ms": "application/x-troff-ms",
+ "nc": "application/x-netcdf",
+ "oda": "application/oda",
+ "ogm": "application/ogg",
+ "pbm": "image/x-portable-bitmap",
+ "pdf": "application/pdf",
+ "pgm": "image/x-portable-graymap",
+ "pgn": "application/x-chess-pgn",
+ "pgp": "application/pgp",
+ "pm": "application/x-perl",
+ "png": "image/png",
+ "pnm": "image/x-portable-anymap",
+ "ppm": "image/x-portable-pixmap",
+ "ppz": "application/vnd.ms-powerpoint",
+ "pre": "application/x-freelance",
+ "prt": "application/pro_eng",
+ "ps": "application/postscript",
+ "qt": "video/quicktime",
+ "ra": "audio/x-realaudio",
+ "rar": "application/x-rar-compressed",
+ "ras": "image/x-cmu-raster",
+ "rgb": "image/x-rgb",
+ "rm": "audio/x-pn-realaudio",
+ "rpm": "audio/x-pn-realaudio-plugin",
+ "rtf": "text/rtf",
+ "rtx": "text/richtext",
+ "scm": "application/x-lotusscreencam",
+ "set": "application/set",
+ "sgml": "text/sgml",
+ "sh": "application/x-sh",
+ "shar": "application/x-shar",
+ "silo": "model/mesh",
+ "sit": "application/x-stuffit",
+ "skt": "application/x-koan",
+ "smil": "application/smil",
+ "snd": "audio/basic",
+ "sol": "application/solids",
+ "spl": "application/x-futuresplash",
+ "src": "application/x-wais-source",
+ "stl": "application/SLA",
+ "stp": "application/STEP",
+ "sv4cpio": "application/x-sv4cpio",
+ "sv4crc": "application/x-sv4crc",
+ "svg": "image/svg+xml",
+ "swf": "application/x-shockwave-flash",
+ "tar": "application/x-tar",
+ "tcl": "application/x-tcl",
+ "tex": "application/x-tex",
+ "texinfo": "application/x-texinfo",
+ "tgz": "application/x-tar-gz",
+ "tiff": "image/tiff",
+ "tr": "application/x-troff",
+ "tsi": "audio/TSP-audio",
+ "tsp": "application/dsptype",
+ "tsv": "text/tab-separated-values",
+ "txt": "text/plain",
+ "unv": "application/i-deas",
+ "ustar": "application/x-ustar",
+ "vcd": "application/x-cdlink",
+ "vda": "application/vda",
+ "vivo": "video/vnd.vivo",
+ "vrm": "x-world/x-vrml",
+ "wav": "audio/x-wav",
+ "wax": "audio/x-ms-wax",
+ "wma": "audio/x-ms-wma",
+ "wmv": "video/x-ms-wmv",
+ "wmx": "video/x-ms-wmx",
+ "wrl": "model/vrml",
+ "wvx": "video/x-ms-wvx",
+ "xbm": "image/x-xbitmap",
+ "xlw": "application/vnd.ms-excel",
+ "xml": "text/xml",
+ "xpm": "image/x-xpixmap",
+ "xwd": "image/x-xwindowdump",
+ "xyz": "chemical/x-pdb",
+ "zip": "application/zip"
+};
diff --git a/node_modules/node-static/lib/node-static/util.js b/node_modules/node-static/lib/node-static/util.js
new file mode 100644
index 0000000..8dd8e04
--- /dev/null
+++ b/node_modules/node-static/lib/node-static/util.js
@@ -0,0 +1,30 @@
+var fs = require('fs'),
+ path = require('path');
+
+this.mstat = function (dir, files, callback) {
+ (function mstat(files, stats) {
+ var file = files.shift();
+
+ if (file) {
+ fs.stat(path.join(dir, file), function (e, stat) {
+ if (e) {
+ callback(e);
+ } else {
+ mstat(files, stats.concat([stat]));
+ }
+ });
+ } else {
+ callback(null, {
+ size: stats.reduce(function (total, stat) {
+ return total + stat.size;
+ }, 0),
+ mtime: stats.reduce(function (latest, stat) {
+ return latest > stat.mtime ? latest : stat.mtime;
+ }, 0),
+ ino: stats.reduce(function (total, stat) {
+ return total + stat.ino;
+ }, 0)
+ });
+ }
+ })(files.slice(0), []);
+};
diff --git a/node_modules/node-static/package.json b/node_modules/node-static/package.json
new file mode 100644
index 0000000..0835ec0
--- /dev/null
+++ b/node_modules/node-static/package.json
@@ -0,0 +1,43 @@
+{
+ "name": "node-static",
+ "description": "simple, compliant file streaming module for node",
+ "url": "http://github.com/cloudhead/node-static",
+ "keywords": [
+ "http",
+ "static",
+ "file",
+ "server"
+ ],
+ "author": {
+ "name": "Alexis Sellier",
+ "email": "self@cloudhead.net"
+ },
+ "contributors": [
+ {
+ "name": "Pablo Cantero",
+ "email": "pablo@pablocantero.com"
+ }
+ ],
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/cloudhead/node-static.git"
+ },
+ "main": "./lib/node-static",
+ "license": "MIT",
+ "dependencies": {},
+ "version": "0.6.0",
+ "engines": {
+ "node": ">= 0.4.1"
+ },
+ "_id": "node-static@0.6.0",
+ "devDependencies": {},
+ "optionalDependencies": {},
+ "_engineSupported": true,
+ "_npmVersion": "1.1.9",
+ "_nodeVersion": "v0.6.13",
+ "_defaultsLoaded": true,
+ "dist": {
+ "shasum": "25024f29b5177b69afdbde315fcebdf9563ce072"
+ },
+ "_from": "node-static@>= 0.6.0"
+}
diff --git a/node_modules/requirejs/.npmignore b/node_modules/requirejs/.npmignore
new file mode 100644
index 0000000..b43bf86
--- /dev/null
+++ b/node_modules/requirejs/.npmignore
@@ -0,0 +1 @@
+README.md
diff --git a/node_modules/requirejs/bin/r.js b/node_modules/requirejs/bin/r.js
new file mode 100755
index 0000000..1047972
--- /dev/null
+++ b/node_modules/requirejs/bin/r.js
@@ -0,0 +1,15472 @@
+#!/usr/bin/env node
+/**
+ * @license r.js 2.0.2 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*
+ * This is a bootstrap script to allow running RequireJS in the command line
+ * in either a Java/Rhino or Node environment. It is modified by the top-level
+ * dist.js file to inject other files to completely enable this file. It is
+ * the shell of the r.js file.
+ */
+
+/*jslint evil: true, nomen: true, sloppy: true */
+/*global readFile: true, process: false, Packages: false, print: false,
+console: false, java: false, module: false, requirejsVars */
+
+var requirejs, require, define;
+(function (console, args, readFileFunc) {
+
+ var fileName, env, fs, vm, path, exec, rhinoContext, dir, nodeRequire,
+ nodeDefine, exists, reqMain, loadedOptimizedLib, existsForNode,
+ version = '2.0.2',
+ jsSuffixRegExp = /\.js$/,
+ commandOption = '',
+ useLibLoaded = {},
+ //Used by jslib/rhino/args.js
+ rhinoArgs = args,
+ readFile = typeof readFileFunc !== 'undefined' ? readFileFunc : null;
+
+ function showHelp() {
+ console.log('See https://github.com/jrburke/r.js for usage.');
+ }
+
+ if (typeof Packages !== 'undefined') {
+ env = 'rhino';
+
+ fileName = args[0];
+
+ if (fileName && fileName.indexOf('-') === 0) {
+ commandOption = fileName.substring(1);
+ fileName = args[1];
+ }
+
+ //Set up execution context.
+ rhinoContext = Packages.org.mozilla.javascript.ContextFactory.getGlobal().enterContext();
+
+ exec = function (string, name) {
+ return rhinoContext.evaluateString(this, string, name, 0, null);
+ };
+
+ exists = function (fileName) {
+ return (new java.io.File(fileName)).exists();
+ };
+
+ //Define a console.log for easier logging. Don't
+ //get fancy though.
+ if (typeof console === 'undefined') {
+ console = {
+ log: function () {
+ print.apply(undefined, arguments);
+ }
+ };
+ }
+ } else if (typeof process !== 'undefined') {
+ env = 'node';
+
+ //Get the fs module via Node's require before it
+ //gets replaced. Used in require/node.js
+ fs = require('fs');
+ vm = require('vm');
+ path = require('path');
+ //In Node 0.7+ existsSync is on fs.
+ existsForNode = fs.existsSync || path.existsSync;
+
+ nodeRequire = require;
+ nodeDefine = define;
+ reqMain = require.main;
+
+ //Temporarily hide require and define to allow require.js to define
+ //them.
+ require = undefined;
+ define = undefined;
+
+ readFile = function (path) {
+ return fs.readFileSync(path, 'utf8');
+ };
+
+ exec = function (string, name) {
+ return vm.runInThisContext(this.requirejsVars.require.makeNodeWrapper(string),
+ name ? fs.realpathSync(name) : '');
+ };
+
+ exists = function (fileName) {
+ return existsForNode(fileName);
+ };
+
+
+ fileName = process.argv[2];
+
+ if (fileName && fileName.indexOf('-') === 0) {
+ commandOption = fileName.substring(1);
+ fileName = process.argv[3];
+ }
+ }
+
+ /** vim: et:ts=4:sw=4:sts=4
+ * @license RequireJS 2.0.2 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+/*jslint regexp: true, nomen: true */
+/*global window, navigator, document, importScripts, jQuery, setTimeout, opera */
+
+
+(function (global) {
+ 'use strict';
+
+ var version = '2.0.2',
+ commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
+ cjsRequireRegExp = /require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
+ jsSuffixRegExp = /\.js$/,
+ currDirRegExp = /^\.\//,
+ ostring = Object.prototype.toString,
+ ap = Array.prototype,
+ aps = ap.slice,
+ apsp = ap.splice,
+ isBrowser = !!(typeof window !== 'undefined' && navigator && document),
+ isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
+ //PS3 indicates loaded and complete, but need to wait for complete
+ //specifically. Sequence is 'loading', 'loaded', execution,
+ // then 'complete'. The UA check is unfortunate, but not sure how
+ //to feature test w/o causing perf issues.
+ readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
+ /^complete$/ : /^(complete|loaded)$/,
+ defContextName = '_',
+ //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
+ isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
+ contexts = {},
+ cfg = {},
+ globalDefQueue = [],
+ useInteractive = false,
+ req, s, head, baseElement, dataMain, src,
+ interactiveScript, currentlyAddingScript, mainScript, subPath;
+
+ function isFunction(it) {
+ return ostring.call(it) === '[object Function]';
+ }
+
+ function isArray(it) {
+ return ostring.call(it) === '[object Array]';
+ }
+
+ /**
+ * Helper function for iterating over an array. If the func returns
+ * a true value, it will break out of the loop.
+ */
+ function each(ary, func) {
+ if (ary) {
+ var i;
+ for (i = 0; i < ary.length; i += 1) {
+ if (ary[i] && func(ary[i], i, ary)) {
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Helper function for iterating over an array backwards. If the func
+ * returns a true value, it will break out of the loop.
+ */
+ function eachReverse(ary, func) {
+ if (ary) {
+ var i;
+ for (i = ary.length - 1; i > -1; i -= 1) {
+ if (ary[i] && func(ary[i], i, ary)) {
+ break;
+ }
+ }
+ }
+ }
+
+ function hasProp(obj, prop) {
+ return obj.hasOwnProperty(prop);
+ }
+
+ /**
+ * Cycles over properties in an object and calls a function for each
+ * property value. If the function returns a truthy value, then the
+ * iteration is stopped.
+ */
+ function eachProp(obj, func) {
+ var prop;
+ for (prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ if (func(obj[prop], prop)) {
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Simple function to mix in properties from source into target,
+ * but only if target does not already have a property of the same name.
+ * This is not robust in IE for transferring methods that match
+ * Object.prototype names, but the uses of mixin here seem unlikely to
+ * trigger a problem related to that.
+ */
+ function mixin(target, source, force, deepStringMixin) {
+ if (source) {
+ eachProp(source, function (value, prop) {
+ if (force || !hasProp(target, prop)) {
+ if (deepStringMixin && typeof value !== 'string') {
+ if (!target[prop]) {
+ target[prop] = {};
+ }
+ mixin(target[prop], value, force, deepStringMixin);
+ } else {
+ target[prop] = value;
+ }
+ }
+ });
+ }
+ return target;
+ }
+
+ //Similar to Function.prototype.bind, but the 'this' object is specified
+ //first, since it is easier to read/figure out what 'this' will be.
+ function bind(obj, fn) {
+ return function () {
+ return fn.apply(obj, arguments);
+ };
+ }
+
+ function scripts() {
+ return document.getElementsByTagName('script');
+ }
+
+ //Allow getting a global that expressed in
+ //dot notation, like 'a.b.c'.
+ function getGlobal(value) {
+ if (!value) {
+ return value;
+ }
+ var g = global;
+ each(value.split('.'), function (part) {
+ g = g[part];
+ });
+ return g;
+ }
+
+ function makeContextModuleFunc(func, relMap, enableBuildCallback) {
+ return function () {
+ //A version of a require function that passes a moduleName
+ //value for items that may need to
+ //look up paths relative to the moduleName
+ var args = aps.call(arguments, 0), lastArg;
+ if (enableBuildCallback &&
+ isFunction((lastArg = args[args.length - 1]))) {
+ lastArg.__requireJsBuild = true;
+ }
+ args.push(relMap);
+ return func.apply(null, args);
+ };
+ }
+
+ function addRequireMethods(req, context, relMap) {
+ each([
+ ['toUrl'],
+ ['undef'],
+ ['defined', 'requireDefined'],
+ ['specified', 'requireSpecified']
+ ], function (item) {
+ var prop = item[1] || item[0];
+ req[item[0]] = context ? makeContextModuleFunc(context[prop], relMap) :
+ //If no context, then use default context. Reference from
+ //contexts instead of early binding to default context, so
+ //that during builds, the latest instance of the default
+ //context with its config gets used.
+ function () {
+ var ctx = contexts[defContextName];
+ return ctx[prop].apply(ctx, arguments);
+ };
+ });
+ }
+
+ /**
+ * Constructs an error with a pointer to an URL with more information.
+ * @param {String} id the error ID that maps to an ID on a web page.
+ * @param {String} message human readable error.
+ * @param {Error} [err] the original error, if there is one.
+ *
+ * @returns {Error}
+ */
+ function makeError(id, msg, err, requireModules) {
+ var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
+ e.requireType = id;
+ e.requireModules = requireModules;
+ if (err) {
+ e.originalError = err;
+ }
+ return e;
+ }
+
+ if (typeof define !== 'undefined') {
+ //If a define is already in play via another AMD loader,
+ //do not overwrite.
+ return;
+ }
+
+ if (typeof requirejs !== 'undefined') {
+ if (isFunction(requirejs)) {
+ //Do not overwrite and existing requirejs instance.
+ return;
+ }
+ cfg = requirejs;
+ requirejs = undefined;
+ }
+
+ //Allow for a require config object
+ if (typeof require !== 'undefined' && !isFunction(require)) {
+ //assume it is a config object.
+ cfg = require;
+ require = undefined;
+ }
+
+ function newContext(contextName) {
+ var config = {
+ waitSeconds: 7,
+ baseUrl: './',
+ paths: {},
+ pkgs: {},
+ shim: {}
+ },
+ registry = {},
+ undefEvents = {},
+ defQueue = [],
+ defined = {},
+ urlFetched = {},
+ requireCounter = 1,
+ unnormalizedCounter = 1,
+ //Used to track the order in which modules
+ //should be executed, by the order they
+ //load. Important for consistent cycle resolution
+ //behavior.
+ waitAry = [],
+ inCheckLoaded, Module, context, handlers,
+ checkLoadedTimeoutId;
+
+ /**
+ * Trims the . and .. from an array of path segments.
+ * It will keep a leading path segment if a .. will become
+ * the first path segment, to help with module name lookups,
+ * which act like paths, but can be remapped. But the end result,
+ * all paths that use this function should look normalized.
+ * NOTE: this method MODIFIES the input array.
+ * @param {Array} ary the array of path segments.
+ */
+ function trimDots(ary) {
+ var i, part;
+ for (i = 0; ary[i]; i+= 1) {
+ part = ary[i];
+ if (part === '.') {
+ ary.splice(i, 1);
+ i -= 1;
+ } else if (part === '..') {
+ if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
+ //End of the line. Keep at least one non-dot
+ //path segment at the front so it can be mapped
+ //correctly to disk. Otherwise, there is likely
+ //no path mapping for a path starting with '..'.
+ //This can still fail, but catches the most reasonable
+ //uses of ..
+ break;
+ } else if (i > 0) {
+ ary.splice(i - 1, 2);
+ i -= 2;
+ }
+ }
+ }
+ }
+
+ /**
+ * Given a relative module name, like ./something, normalize it to
+ * a real name that can be mapped to a path.
+ * @param {String} name the relative name
+ * @param {String} baseName a real name that the name arg is relative
+ * to.
+ * @param {Boolean} applyMap apply the map config to the value. Should
+ * only be done if this normalization is for a dependency ID.
+ * @returns {String} normalized name
+ */
+ function normalize(name, baseName, applyMap) {
+ var baseParts = baseName && baseName.split('/'),
+ map = config.map,
+ starMap = map && map['*'],
+ pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
+ foundMap;
+
+ //Adjust any relative paths.
+ if (name && name.charAt(0) === '.') {
+ //If have a base name, try to normalize against it,
+ //otherwise, assume it is a top-level require that will
+ //be relative to baseUrl in the end.
+ if (baseName) {
+ if (config.pkgs[baseName]) {
+ //If the baseName is a package name, then just treat it as one
+ //name to concat the name with.
+ baseParts = [baseName];
+ } else {
+ //Convert baseName to array, and lop off the last part,
+ //so that . matches that 'directory' and not name of the baseName's
+ //module. For instance, baseName of 'one/two/three', maps to
+ //'one/two/three.js', but we want the directory, 'one/two' for
+ //this normalization.
+ baseParts = baseParts.slice(0, baseParts.length - 1);
+ }
+
+ name = baseParts.concat(name.split('/'));
+ trimDots(name);
+
+ //Some use of packages may use a . path to reference the
+ //'main' module name, so normalize for that.
+ pkgConfig = config.pkgs[(pkgName = name[0])];
+ name = name.join('/');
+ if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
+ name = pkgName;
+ }
+ } else if (name.indexOf('./') === 0) {
+ // No baseName, so this is ID is resolved relative
+ // to baseUrl, pull off the leading dot.
+ name = name.substring(2);
+ }
+ }
+
+ //Apply map config if available.
+ if (applyMap && (baseParts || starMap) && map) {
+ nameParts = name.split('/');
+
+ for (i = nameParts.length; i > 0; i -= 1) {
+ nameSegment = nameParts.slice(0, i).join('/');
+
+ if (baseParts) {
+ //Find the longest baseName segment match in the config.
+ //So, do joins on the biggest to smallest lengths of baseParts.
+ for (j = baseParts.length; j > 0; j -= 1) {
+ mapValue = map[baseParts.slice(0, j).join('/')];
+
+ //baseName segment has config, find if it has one for
+ //this name.
+ if (mapValue) {
+ mapValue = mapValue[nameSegment];
+ if (mapValue) {
+ //Match, update name to the new value.
+ foundMap = mapValue;
+ break;
+ }
+ }
+ }
+ }
+
+ if (!foundMap && starMap && starMap[nameSegment]) {
+ foundMap = starMap[nameSegment];
+ }
+
+ if (foundMap) {
+ nameParts.splice(0, i, foundMap);
+ name = nameParts.join('/');
+ break;
+ }
+ }
+ }
+
+ return name;
+ }
+
+ function removeScript(name) {
+ if (isBrowser) {
+ each(scripts(), function (scriptNode) {
+ if (scriptNode.getAttribute('data-requiremodule') === name &&
+ scriptNode.getAttribute('data-requirecontext') === context.contextName) {
+ scriptNode.parentNode.removeChild(scriptNode);
+ return true;
+ }
+ });
+ }
+ }
+
+ function hasPathFallback(id) {
+ var pathConfig = config.paths[id];
+ if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
+ removeScript(id);
+ //Pop off the first array value, since it failed, and
+ //retry
+ pathConfig.shift();
+ context.undef(id);
+ context.require([id]);
+ return true;
+ }
+ }
+
+ /**
+ * Creates a module mapping that includes plugin prefix, module
+ * name, and path. If parentModuleMap is provided it will
+ * also normalize the name via require.normalize()
+ *
+ * @param {String} name the module name
+ * @param {String} [parentModuleMap] parent module map
+ * for the module name, used to resolve relative names.
+ * @param {Boolean} isNormalized: is the ID already normalized.
+ * This is true if this call is done for a define() module ID.
+ * @param {Boolean} applyMap: apply the map config to the ID.
+ * Should only be true if this map is for a dependency.
+ *
+ * @returns {Object}
+ */
+ function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
+ var index = name ? name.indexOf('!') : -1,
+ prefix = null,
+ parentName = parentModuleMap ? parentModuleMap.name : null,
+ originalName = name,
+ isDefine = true,
+ normalizedName = '',
+ url, pluginModule, suffix;
+
+ //If no name, then it means it is a require call, generate an
+ //internal name.
+ if (!name) {
+ isDefine = false;
+ name = '_@r' + (requireCounter += 1);
+ }
+
+ if (index !== -1) {
+ prefix = name.substring(0, index);
+ name = name.substring(index + 1, name.length);
+ }
+
+ if (prefix) {
+ prefix = normalize(prefix, parentName, applyMap);
+ pluginModule = defined[prefix];
+ }
+
+ //Account for relative paths if there is a base name.
+ if (name) {
+ if (prefix) {
+ if (pluginModule && pluginModule.normalize) {
+ //Plugin is loaded, use its normalize method.
+ normalizedName = pluginModule.normalize(name, function (name) {
+ return normalize(name, parentName, applyMap);
+ });
+ } else {
+ normalizedName = normalize(name, parentName, applyMap);
+ }
+ } else {
+ //A regular module.
+ normalizedName = normalize(name, parentName, applyMap);
+
+ //Calculate url for the module, if it has a name.
+ //Use name here since nameToUrl also calls normalize,
+ //and for relative names that are outside the baseUrl
+ //this causes havoc. Was thinking of just removing
+ //parentModuleMap to avoid extra normalization, but
+ //normalize() still does a dot removal because of
+ //issue #142, so just pass in name here and redo
+ //the normalization. Paths outside baseUrl are just
+ //messy to support.
+ url = context.nameToUrl(name, null, parentModuleMap);
+ }
+ }
+
+ //If the id is a plugin id that cannot be determined if it needs
+ //normalization, stamp it with a unique ID so two matching relative
+ //ids that may conflict can be separate.
+ suffix = prefix && !pluginModule && !isNormalized ?
+ '_unnormalized' + (unnormalizedCounter += 1) :
+ '';
+
+ return {
+ prefix: prefix,
+ name: normalizedName,
+ parentMap: parentModuleMap,
+ unnormalized: !!suffix,
+ url: url,
+ originalName: originalName,
+ isDefine: isDefine,
+ id: (prefix ?
+ prefix + '!' + normalizedName :
+ normalizedName) + suffix
+ };
+ }
+
+ function getModule(depMap) {
+ var id = depMap.id,
+ mod = registry[id];
+
+ if (!mod) {
+ mod = registry[id] = new context.Module(depMap);
+ }
+
+ return mod;
+ }
+
+ function on(depMap, name, fn) {
+ var id = depMap.id,
+ mod = registry[id];
+
+ if (hasProp(defined, id) &&
+ (!mod || mod.defineEmitComplete)) {
+ if (name === 'defined') {
+ fn(defined[id]);
+ }
+ } else {
+ getModule(depMap).on(name, fn);
+ }
+ }
+
+ function onError(err, errback) {
+ var ids = err.requireModules,
+ notified = false;
+
+ if (errback) {
+ errback(err);
+ } else {
+ each(ids, function (id) {
+ var mod = registry[id];
+ if (mod) {
+ //Set error on module, so it skips timeout checks.
+ mod.error = err;
+ if (mod.events.error) {
+ notified = true;
+ mod.emit('error', err);
+ }
+ }
+ });
+
+ if (!notified) {
+ req.onError(err);
+ }
+ }
+ }
+
+ /**
+ * Internal method to transfer globalQueue items to this context's
+ * defQueue.
+ */
+ function takeGlobalQueue() {
+ //Push all the globalDefQueue items into the context's defQueue
+ if (globalDefQueue.length) {
+ //Array splice in the values since the context code has a
+ //local var ref to defQueue, so cannot just reassign the one
+ //on context.
+ apsp.apply(defQueue,
+ [defQueue.length - 1, 0].concat(globalDefQueue));
+ globalDefQueue = [];
+ }
+ }
+
+ /**
+ * Helper function that creates a require function object to give to
+ * modules that ask for it as a dependency. It needs to be specific
+ * per module because of the implication of path mappings that may
+ * need to be relative to the module name.
+ */
+ function makeRequire(mod, enableBuildCallback, altRequire) {
+ var relMap = mod && mod.map,
+ modRequire = makeContextModuleFunc(altRequire || context.require,
+ relMap,
+ enableBuildCallback);
+
+ addRequireMethods(modRequire, context, relMap);
+ modRequire.isBrowser = isBrowser;
+
+ return modRequire;
+ }
+
+ handlers = {
+ 'require': function (mod) {
+ return makeRequire(mod);
+ },
+ 'exports': function (mod) {
+ mod.usingExports = true;
+ if (mod.map.isDefine) {
+ return (mod.exports = defined[mod.map.id] = {});
+ }
+ },
+ 'module': function (mod) {
+ return (mod.module = {
+ id: mod.map.id,
+ uri: mod.map.url,
+ config: function () {
+ return (config.config && config.config[mod.map.id]) || {};
+ },
+ exports: defined[mod.map.id]
+ });
+ }
+ };
+
+ function removeWaiting(id) {
+ //Clean up machinery used for waiting modules.
+ delete registry[id];
+
+ each(waitAry, function (mod, i) {
+ if (mod.map.id === id) {
+ waitAry.splice(i, 1);
+ if (!mod.defined) {
+ context.waitCount -= 1;
+ }
+ return true;
+ }
+ });
+ }
+
+ function findCycle(mod, traced) {
+ var id = mod.map.id,
+ depArray = mod.depMaps,
+ foundModule;
+
+ //Do not bother with unitialized modules or not yet enabled
+ //modules.
+ if (!mod.inited) {
+ return;
+ }
+
+ //Found the cycle.
+ if (traced[id]) {
+ return mod;
+ }
+
+ traced[id] = true;
+
+ //Trace through the dependencies.
+ each(depArray, function (depMap) {
+ var depId = depMap.id,
+ depMod = registry[depId];
+
+ if (!depMod) {
+ return;
+ }
+
+ if (!depMod.inited || !depMod.enabled) {
+ //Dependency is not inited, so this cannot
+ //be used to determine a cycle.
+ foundModule = null;
+ delete traced[id];
+ return true;
+ }
+
+ //mixin traced to a new object for each dependency, so that
+ //sibling dependencies in this object to not generate a
+ //false positive match on a cycle. Ideally an Object.create
+ //type of prototype delegation would be used here, but
+ //optimizing for file size vs. execution speed since hopefully
+ //the trees are small for circular dependency scans relative
+ //to the full app perf.
+ return (foundModule = findCycle(depMod, mixin({}, traced)));
+ });
+
+ return foundModule;
+ }
+
+ function forceExec(mod, traced, uninited) {
+ var id = mod.map.id,
+ depArray = mod.depMaps;
+
+ if (!mod.inited || !mod.map.isDefine) {
+ return;
+ }
+
+ if (traced[id]) {
+ return defined[id];
+ }
+
+ traced[id] = mod;
+
+ each(depArray, function(depMap) {
+ var depId = depMap.id,
+ depMod = registry[depId],
+ value;
+
+ if (handlers[depId]) {
+ return;
+ }
+
+ if (depMod) {
+ if (!depMod.inited || !depMod.enabled) {
+ //Dependency is not inited,
+ //so this module cannot be
+ //given a forced value yet.
+ uninited[id] = true;
+ return;
+ }
+
+ //Get the value for the current dependency
+ value = forceExec(depMod, traced, uninited);
+
+ //Even with forcing it may not be done,
+ //in particular if the module is waiting
+ //on a plugin resource.
+ if (!uninited[depId]) {
+ mod.defineDepById(depId, value);
+ }
+ }
+ });
+
+ mod.check(true);
+
+ return defined[id];
+ }
+
+ function modCheck(mod) {
+ mod.check();
+ }
+
+ function checkLoaded() {
+ var waitInterval = config.waitSeconds * 1000,
+ //It is possible to disable the wait interval by using waitSeconds of 0.
+ expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
+ noLoads = [],
+ stillLoading = false,
+ needCycleCheck = true,
+ map, modId, err, usingPathFallback;
+
+ //Do not bother if this call was a result of a cycle break.
+ if (inCheckLoaded) {
+ return;
+ }
+
+ inCheckLoaded = true;
+
+ //Figure out the state of all the modules.
+ eachProp(registry, function (mod) {
+ map = mod.map;
+ modId = map.id;
+
+ //Skip things that are not enabled or in error state.
+ if (!mod.enabled) {
+ return;
+ }
+
+ if (!mod.error) {
+ //If the module should be executed, and it has not
+ //been inited and time is up, remember it.
+ if (!mod.inited && expired) {
+ if (hasPathFallback(modId)) {
+ usingPathFallback = true;
+ stillLoading = true;
+ } else {
+ noLoads.push(modId);
+ removeScript(modId);
+ }
+ } else if (!mod.inited && mod.fetched && map.isDefine) {
+ stillLoading = true;
+ if (!map.prefix) {
+ //No reason to keep looking for unfinished
+ //loading. If the only stillLoading is a
+ //plugin resource though, keep going,
+ //because it may be that a plugin resource
+ //is waiting on a non-plugin cycle.
+ return (needCycleCheck = false);
+ }
+ }
+ }
+ });
+
+ if (expired && noLoads.length) {
+ //If wait time expired, throw error of unloaded modules.
+ err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
+ err.contextName = context.contextName;
+ return onError(err);
+ }
+
+ //Not expired, check for a cycle.
+ if (needCycleCheck) {
+
+ each(waitAry, function (mod) {
+ if (mod.defined) {
+ return;
+ }
+
+ var cycleMod = findCycle(mod, {}),
+ traced = {};
+
+ if (cycleMod) {
+ forceExec(cycleMod, traced, {});
+
+ //traced modules may have been
+ //removed from the registry, but
+ //their listeners still need to
+ //be called.
+ eachProp(traced, modCheck);
+ }
+ });
+
+ //Now that dependencies have
+ //been satisfied, trigger the
+ //completion check that then
+ //notifies listeners.
+ eachProp(registry, modCheck);
+ }
+
+ //If still waiting on loads, and the waiting load is something
+ //other than a plugin resource, or there are still outstanding
+ //scripts, then just try back later.
+ if ((!expired || usingPathFallback) && stillLoading) {
+ //Something is still waiting to load. Wait for it, but only
+ //if a timeout is not already in effect.
+ if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
+ checkLoadedTimeoutId = setTimeout(function () {
+ checkLoadedTimeoutId = 0;
+ checkLoaded();
+ }, 50);
+ }
+ }
+
+ inCheckLoaded = false;
+ }
+
+ Module = function (map) {
+ this.events = undefEvents[map.id] || {};
+ this.map = map;
+ this.shim = config.shim[map.id];
+ this.depExports = [];
+ this.depMaps = [];
+ this.depMatched = [];
+ this.pluginMaps = {};
+ this.depCount = 0;
+
+ /* this.exports this.factory
+ this.depMaps = [],
+ this.enabled, this.fetched
+ */
+ };
+
+ Module.prototype = {
+ init: function(depMaps, factory, errback, options) {
+ options = options || {};
+
+ //Do not do more inits if already done. Can happen if there
+ //are multiple define calls for the same module. That is not
+ //a normal, common case, but it is also not unexpected.
+ if (this.inited) {
+ return;
+ }
+
+ this.factory = factory;
+
+ if (errback) {
+ //Register for errors on this module.
+ this.on('error', errback);
+ } else if (this.events.error) {
+ //If no errback already, but there are error listeners
+ //on this module, set up an errback to pass to the deps.
+ errback = bind(this, function (err) {
+ this.emit('error', err);
+ });
+ }
+
+ //Do a copy of the dependency array, so that
+ //source inputs are not modified. For example
+ //"shim" deps are passed in here directly, and
+ //doing a direct modification of the depMaps array
+ //would affect that config.
+ this.depMaps = depMaps && depMaps.slice(0);
+ this.depMaps.rjsSkipMap = depMaps.rjsSkipMap;
+
+ this.errback = errback;
+
+ //Indicate this module has be initialized
+ this.inited = true;
+
+ this.ignore = options.ignore;
+
+ //Could have option to init this module in enabled mode,
+ //or could have been previously marked as enabled. However,
+ //the dependencies are not known until init is called. So
+ //if enabled previously, now trigger dependencies as enabled.
+ if (options.enabled || this.enabled) {
+ //Enable this module and dependencies.
+ //Will call this.check()
+ this.enable();
+ } else {
+ this.check();
+ }
+ },
+
+ defineDepById: function (id, depExports) {
+ var i;
+
+ //Find the index for this dependency.
+ each(this.depMaps, function (map, index) {
+ if (map.id === id) {
+ i = index;
+ return true;
+ }
+ });
+
+ return this.defineDep(i, depExports);
+ },
+
+ defineDep: function (i, depExports) {
+ //Because of cycles, defined callback for a given
+ //export can be called more than once.
+ if (!this.depMatched[i]) {
+ this.depMatched[i] = true;
+ this.depCount -= 1;
+ this.depExports[i] = depExports;
+ }
+ },
+
+ fetch: function () {
+ if (this.fetched) {
+ return;
+ }
+ this.fetched = true;
+
+ context.startTime = (new Date()).getTime();
+
+ var map = this.map;
+
+ //If the manager is for a plugin managed resource,
+ //ask the plugin to load it now.
+ if (this.shim) {
+ makeRequire(this, true)(this.shim.deps || [], bind(this, function () {
+ return map.prefix ? this.callPlugin() : this.load();
+ }));
+ } else {
+ //Regular dependency.
+ return map.prefix ? this.callPlugin() : this.load();
+ }
+ },
+
+ load: function() {
+ var url = this.map.url;
+
+ //Regular dependency.
+ if (!urlFetched[url]) {
+ urlFetched[url] = true;
+ context.load(this.map.id, url);
+ }
+ },
+
+ /**
+ * Checks is the module is ready to define itself, and if so,
+ * define it. If the silent argument is true, then it will just
+ * define, but not notify listeners, and not ask for a context-wide
+ * check of all loaded modules. That is useful for cycle breaking.
+ */
+ check: function (silent) {
+ if (!this.enabled || this.enabling) {
+ return;
+ }
+
+ var id = this.map.id,
+ depExports = this.depExports,
+ exports = this.exports,
+ factory = this.factory,
+ err, cjsModule;
+
+ if (!this.inited) {
+ this.fetch();
+ } else if (this.error) {
+ this.emit('error', this.error);
+ } else if (!this.defining) {
+ //The factory could trigger another require call
+ //that would result in checking this module to
+ //define itself again. If already in the process
+ //of doing that, skip this work.
+ this.defining = true;
+
+ if (this.depCount < 1 && !this.defined) {
+ if (isFunction(factory)) {
+ //If there is an error listener, favor passing
+ //to that instead of throwing an error.
+ if (this.events.error) {
+ try {
+ exports = context.execCb(id, factory, depExports, exports);
+ } catch (e) {
+ err = e;
+ }
+ } else {
+ exports = context.execCb(id, factory, depExports, exports);
+ }
+
+ if (this.map.isDefine) {
+ //If setting exports via 'module' is in play,
+ //favor that over return value and exports. After that,
+ //favor a non-undefined return value over exports use.
+ cjsModule = this.module;
+ if (cjsModule &&
+ cjsModule.exports !== undefined &&
+ //Make sure it is not already the exports value
+ cjsModule.exports !== this.exports) {
+ exports = cjsModule.exports;
+ } else if (exports === undefined && this.usingExports) {
+ //exports already set the defined value.
+ exports = this.exports;
+ }
+ }
+
+ if (err) {
+ err.requireMap = this.map;
+ err.requireModules = [this.map.id];
+ err.requireType = 'define';
+ return onError((this.error = err));
+ }
+
+ } else {
+ //Just a literal value
+ exports = factory;
+ }
+
+ this.exports = exports;
+
+ if (this.map.isDefine && !this.ignore) {
+ defined[id] = exports;
+
+ if (req.onResourceLoad) {
+ req.onResourceLoad(context, this.map, this.depMaps);
+ }
+ }
+
+ //Clean up
+ delete registry[id];
+
+ this.defined = true;
+ context.waitCount -= 1;
+ if (context.waitCount === 0) {
+ //Clear the wait array used for cycles.
+ waitAry = [];
+ }
+ }
+
+ //Finished the define stage. Allow calling check again
+ //to allow define notifications below in the case of a
+ //cycle.
+ this.defining = false;
+
+ if (!silent) {
+ if (this.defined && !this.defineEmitted) {
+ this.defineEmitted = true;
+ this.emit('defined', this.exports);
+ this.defineEmitComplete = true;
+ }
+ }
+ }
+ },
+
+ callPlugin: function() {
+ var map = this.map,
+ id = map.id,
+ pluginMap = makeModuleMap(map.prefix, null, false, true);
+
+ on(pluginMap, 'defined', bind(this, function (plugin) {
+ var name = this.map.name,
+ parentName = this.map.parentMap ? this.map.parentMap.name : null,
+ load, normalizedMap, normalizedMod;
+
+ //If current map is not normalized, wait for that
+ //normalized name to load instead of continuing.
+ if (this.map.unnormalized) {
+ //Normalize the ID if the plugin allows it.
+ if (plugin.normalize) {
+ name = plugin.normalize(name, function (name) {
+ return normalize(name, parentName, true);
+ }) || '';
+ }
+
+ normalizedMap = makeModuleMap(map.prefix + '!' + name,
+ this.map.parentMap,
+ false,
+ true);
+ on(normalizedMap,
+ 'defined', bind(this, function (value) {
+ this.init([], function () { return value; }, null, {
+ enabled: true,
+ ignore: true
+ });
+ }));
+ normalizedMod = registry[normalizedMap.id];
+ if (normalizedMod) {
+ if (this.events.error) {
+ normalizedMod.on('error', bind(this, function (err) {
+ this.emit('error', err);
+ }));
+ }
+ normalizedMod.enable();
+ }
+
+ return;
+ }
+
+ load = bind(this, function (value) {
+ this.init([], function () { return value; }, null, {
+ enabled: true
+ });
+ });
+
+ load.error = bind(this, function (err) {
+ this.inited = true;
+ this.error = err;
+ err.requireModules = [id];
+
+ //Remove temp unnormalized modules for this module,
+ //since they will never be resolved otherwise now.
+ eachProp(registry, function (mod) {
+ if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
+ removeWaiting(mod.map.id);
+ }
+ });
+
+ onError(err);
+ });
+
+ //Allow plugins to load other code without having to know the
+ //context or how to 'complete' the load.
+ load.fromText = function (moduleName, text) {
+ /*jslint evil: true */
+ var hasInteractive = useInteractive;
+
+ //Turn off interactive script matching for IE for any define
+ //calls in the text, then turn it back on at the end.
+ if (hasInteractive) {
+ useInteractive = false;
+ }
+
+ //Prime the system by creating a module instance for
+ //it.
+ getModule(makeModuleMap(moduleName));
+
+ req.exec(text);
+
+ if (hasInteractive) {
+ useInteractive = true;
+ }
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ };
+
+ //Use parentName here since the plugin's name is not reliable,
+ //could be some weird string with no path that actually wants to
+ //reference the parentName's path.
+ plugin.load(map.name, makeRequire(map.parentMap, true, function (deps, cb) {
+ deps.rjsSkipMap = true;
+ return context.require(deps, cb);
+ }), load, config);
+ }));
+
+ context.enable(pluginMap, this);
+ this.pluginMaps[pluginMap.id] = pluginMap;
+ },
+
+ enable: function () {
+ this.enabled = true;
+
+ if (!this.waitPushed) {
+ waitAry.push(this);
+ context.waitCount += 1;
+ this.waitPushed = true;
+ }
+
+ //Set flag mentioning that the module is enabling,
+ //so that immediate calls to the defined callbacks
+ //for dependencies do not trigger inadvertent load
+ //with the depCount still being zero.
+ this.enabling = true;
+
+ //Enable each dependency
+ each(this.depMaps, bind(this, function (depMap, i) {
+ var id, mod, handler;
+
+ if (typeof depMap === 'string') {
+ //Dependency needs to be converted to a depMap
+ //and wired up to this module.
+ depMap = makeModuleMap(depMap,
+ (this.map.isDefine ? this.map : this.map.parentMap),
+ false,
+ !this.depMaps.rjsSkipMap);
+ this.depMaps[i] = depMap;
+
+ handler = handlers[depMap.id];
+
+ if (handler) {
+ this.depExports[i] = handler(this);
+ return;
+ }
+
+ this.depCount += 1;
+
+ on(depMap, 'defined', bind(this, function (depExports) {
+ this.defineDep(i, depExports);
+ this.check();
+ }));
+
+ if (this.errback) {
+ on(depMap, 'error', this.errback);
+ }
+ }
+
+ id = depMap.id;
+ mod = registry[id];
+
+ //Skip special modules like 'require', 'exports', 'module'
+ //Also, don't call enable if it is already enabled,
+ //important in circular dependency cases.
+ if (!handlers[id] && mod && !mod.enabled) {
+ context.enable(depMap, this);
+ }
+ }));
+
+ //Enable each plugin that is used in
+ //a dependency
+ eachProp(this.pluginMaps, bind(this, function (pluginMap) {
+ var mod = registry[pluginMap.id];
+ if (mod && !mod.enabled) {
+ context.enable(pluginMap, this);
+ }
+ }));
+
+ this.enabling = false;
+
+ this.check();
+ },
+
+ on: function(name, cb) {
+ var cbs = this.events[name];
+ if (!cbs) {
+ cbs = this.events[name] = [];
+ }
+ cbs.push(cb);
+ },
+
+ emit: function (name, evt) {
+ each(this.events[name], function (cb) {
+ cb(evt);
+ });
+ if (name === 'error') {
+ //Now that the error handler was triggered, remove
+ //the listeners, since this broken Module instance
+ //can stay around for a while in the registry/waitAry.
+ delete this.events[name];
+ }
+ }
+ };
+
+ function callGetModule(args) {
+ getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
+ }
+
+ function removeListener(node, func, name, ieName) {
+ //Favor detachEvent because of IE9
+ //issue, see attachEvent/addEventListener comment elsewhere
+ //in this file.
+ if (node.detachEvent && !isOpera) {
+ //Probably IE. If not it will throw an error, which will be
+ //useful to know.
+ if (ieName) {
+ node.detachEvent(ieName, func);
+ }
+ } else {
+ node.removeEventListener(name, func, false);
+ }
+ }
+
+ /**
+ * Given an event from a script node, get the requirejs info from it,
+ * and then removes the event listeners on the node.
+ * @param {Event} evt
+ * @returns {Object}
+ */
+ function getScriptData(evt) {
+ //Using currentTarget instead of target for Firefox 2.0's sake. Not
+ //all old browsers will be supported, but this one was easy enough
+ //to support and still makes sense.
+ var node = evt.currentTarget || evt.srcElement;
+
+ //Remove the listeners once here.
+ removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
+ removeListener(node, context.onScriptError, 'error');
+
+ return {
+ node: node,
+ id: node && node.getAttribute('data-requiremodule')
+ };
+ }
+
+ return (context = {
+ config: config,
+ contextName: contextName,
+ registry: registry,
+ defined: defined,
+ urlFetched: urlFetched,
+ waitCount: 0,
+ defQueue: defQueue,
+ Module: Module,
+ makeModuleMap: makeModuleMap,
+
+ /**
+ * Set a configuration for the context.
+ * @param {Object} cfg config object to integrate.
+ */
+ configure: function (cfg) {
+ //Make sure the baseUrl ends in a slash.
+ if (cfg.baseUrl) {
+ if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
+ cfg.baseUrl += '/';
+ }
+ }
+
+ //Save off the paths and packages since they require special processing,
+ //they are additive.
+ var pkgs = config.pkgs,
+ shim = config.shim,
+ paths = config.paths,
+ map = config.map;
+
+ //Mix in the config values, favoring the new values over
+ //existing ones in context.config.
+ mixin(config, cfg, true);
+
+ //Merge paths.
+ config.paths = mixin(paths, cfg.paths, true);
+
+ //Merge map
+ if (cfg.map) {
+ config.map = mixin(map || {}, cfg.map, true, true);
+ }
+
+ //Merge shim
+ if (cfg.shim) {
+ eachProp(cfg.shim, function (value, id) {
+ //Normalize the structure
+ if (isArray(value)) {
+ value = {
+ deps: value
+ };
+ }
+ if (value.exports && !value.exports.__buildReady) {
+ value.exports = context.makeShimExports(value.exports);
+ }
+ shim[id] = value;
+ });
+ config.shim = shim;
+ }
+
+ //Adjust packages if necessary.
+ if (cfg.packages) {
+ each(cfg.packages, function (pkgObj) {
+ var location;
+
+ pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
+ location = pkgObj.location;
+
+ //Create a brand new object on pkgs, since currentPackages can
+ //be passed in again, and config.pkgs is the internal transformed
+ //state for all package configs.
+ pkgs[pkgObj.name] = {
+ name: pkgObj.name,
+ location: location || pkgObj.name,
+ //Remove leading dot in main, so main paths are normalized,
+ //and remove any trailing .js, since different package
+ //envs have different conventions: some use a module name,
+ //some use a file name.
+ main: (pkgObj.main || 'main')
+ .replace(currDirRegExp, '')
+ .replace(jsSuffixRegExp, '')
+ };
+ });
+
+ //Done with modifications, assing packages back to context config
+ config.pkgs = pkgs;
+ }
+
+ //If there are any "waiting to execute" modules in the registry,
+ //update the maps for them, since their info, like URLs to load,
+ //may have changed.
+ eachProp(registry, function (mod, id) {
+ mod.map = makeModuleMap(id);
+ });
+
+ //If a deps array or a config callback is specified, then call
+ //require with those args. This is useful when require is defined as a
+ //config object before require.js is loaded.
+ if (cfg.deps || cfg.callback) {
+ context.require(cfg.deps || [], cfg.callback);
+ }
+ },
+
+ makeShimExports: function (exports) {
+ var func;
+ if (typeof exports === 'string') {
+ func = function () {
+ return getGlobal(exports);
+ };
+ //Save the exports for use in nodefine checking.
+ func.exports = exports;
+ return func;
+ } else {
+ return function () {
+ return exports.apply(global, arguments);
+ };
+ }
+ },
+
+ requireDefined: function (id, relMap) {
+ return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
+ },
+
+ requireSpecified: function (id, relMap) {
+ id = makeModuleMap(id, relMap, false, true).id;
+ return hasProp(defined, id) || hasProp(registry, id);
+ },
+
+ require: function (deps, callback, errback, relMap) {
+ var moduleName, id, map, requireMod, args;
+ if (typeof deps === 'string') {
+ if (isFunction(callback)) {
+ //Invalid call
+ return onError(makeError('requireargs', 'Invalid require call'), errback);
+ }
+
+ //Synchronous access to one module. If require.get is
+ //available (as in the Node adapter), prefer that.
+ //In this case deps is the moduleName and callback is
+ //the relMap
+ if (req.get) {
+ return req.get(context, deps, callback);
+ }
+
+ //Just return the module wanted. In this scenario, the
+ //second arg (if passed) is just the relMap.
+ moduleName = deps;
+ relMap = callback;
+
+ //Normalize module name, if it contains . or ..
+ map = makeModuleMap(moduleName, relMap, false, true);
+ id = map.id;
+
+ if (!hasProp(defined, id)) {
+ return onError(makeError('notloaded', 'Module name "' +
+ id +
+ '" has not been loaded yet for context: ' +
+ contextName));
+ }
+ return defined[id];
+ }
+
+ //Callback require. Normalize args. if callback or errback is
+ //not a function, it means it is a relMap. Test errback first.
+ if (errback && !isFunction(errback)) {
+ relMap = errback;
+ errback = undefined;
+ }
+ if (callback && !isFunction(callback)) {
+ relMap = callback;
+ callback = undefined;
+ }
+
+ //Any defined modules in the global queue, intake them now.
+ takeGlobalQueue();
+
+ //Make sure any remaining defQueue items get properly processed.
+ while (defQueue.length) {
+ args = defQueue.shift();
+ if (args[0] === null) {
+ return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
+ } else {
+ //args are id, deps, factory. Should be normalized by the
+ //define() function.
+ callGetModule(args);
+ }
+ }
+
+ //Mark all the dependencies as needing to be loaded.
+ requireMod = getModule(makeModuleMap(null, relMap));
+
+ requireMod.init(deps, callback, errback, {
+ enabled: true
+ });
+
+ checkLoaded();
+
+ return context.require;
+ },
+
+ undef: function (id) {
+ var map = makeModuleMap(id, null, true),
+ mod = registry[id];
+
+ delete defined[id];
+ delete urlFetched[map.url];
+ delete undefEvents[id];
+
+ if (mod) {
+ //Hold on to listeners in case the
+ //module will be attempted to be reloaded
+ //using a different config.
+ if (mod.events.defined) {
+ undefEvents[id] = mod.events;
+ }
+
+ removeWaiting(id);
+ }
+ },
+
+ /**
+ * Called to enable a module if it is still in the registry
+ * awaiting enablement. parent module is passed in for context,
+ * used by the optimizer.
+ */
+ enable: function (depMap, parent) {
+ var mod = registry[depMap.id];
+ if (mod) {
+ getModule(depMap).enable();
+ }
+ },
+
+ /**
+ * Internal method used by environment adapters to complete a load event.
+ * A load event could be a script load or just a load pass from a synchronous
+ * load call.
+ * @param {String} moduleName the name of the module to potentially complete.
+ */
+ completeLoad: function (moduleName) {
+ var shim = config.shim[moduleName] || {},
+ shExports = shim.exports && shim.exports.exports,
+ found, args, mod;
+
+ takeGlobalQueue();
+
+ while (defQueue.length) {
+ args = defQueue.shift();
+ if (args[0] === null) {
+ args[0] = moduleName;
+ //If already found an anonymous module and bound it
+ //to this name, then this is some other anon module
+ //waiting for its completeLoad to fire.
+ if (found) {
+ break;
+ }
+ found = true;
+ } else if (args[0] === moduleName) {
+ //Found matching define call for this script!
+ found = true;
+ }
+
+ callGetModule(args);
+ }
+
+ //Do this after the cycle of callGetModule in case the result
+ //of those calls/init calls changes the registry.
+ mod = registry[moduleName];
+
+ if (!found &&
+ !defined[moduleName] &&
+ mod && !mod.inited) {
+ if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
+ if (hasPathFallback(moduleName)) {
+ return;
+ } else {
+ return onError(makeError('nodefine',
+ 'No define call for ' + moduleName,
+ null,
+ [moduleName]));
+ }
+ } else {
+ //A script that does not call define(), so just simulate
+ //the call for it.
+ callGetModule([moduleName, (shim.deps || []), shim.exports]);
+ }
+ }
+
+ checkLoaded();
+ },
+
+ /**
+ * Converts a module name + .extension into an URL path.
+ * *Requires* the use of a module name. It does not support using
+ * plain URLs like nameToUrl.
+ */
+ toUrl: function (moduleNamePlusExt, relModuleMap) {
+ var index = moduleNamePlusExt.lastIndexOf('.'),
+ ext = null;
+
+ if (index !== -1) {
+ ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
+ moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
+ }
+
+ return context.nameToUrl(moduleNamePlusExt, ext, relModuleMap);
+ },
+
+ /**
+ * Converts a module name to a file path. Supports cases where
+ * moduleName may actually be just an URL.
+ */
+ nameToUrl: function (moduleName, ext, relModuleMap) {
+ var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
+ parentPath;
+
+ //Normalize module name if have a base relative module name to work from.
+ moduleName = normalize(moduleName, relModuleMap && relModuleMap.id, true);
+
+ //If a colon is in the URL, it indicates a protocol is used and it is just
+ //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
+ //or ends with .js, then assume the user meant to use an url and not a module id.
+ //The slash is important for protocol-less URLs as well as full paths.
+ if (req.jsExtRegExp.test(moduleName)) {
+ //Just a plain path, not module name lookup, so just return it.
+ //Add extension if it is included. This is a bit wonky, only non-.js things pass
+ //an extension, this method probably needs to be reworked.
+ url = moduleName + (ext || '');
+ } else {
+ //A module that needs to be converted to a path.
+ paths = config.paths;
+ pkgs = config.pkgs;
+
+ syms = moduleName.split('/');
+ //For each module name segment, see if there is a path
+ //registered for it. Start with most specific name
+ //and work up from it.
+ for (i = syms.length; i > 0; i -= 1) {
+ parentModule = syms.slice(0, i).join('/');
+ pkg = pkgs[parentModule];
+ parentPath = paths[parentModule];
+ if (parentPath) {
+ //If an array, it means there are a few choices,
+ //Choose the one that is desired
+ if (isArray(parentPath)) {
+ parentPath = parentPath[0];
+ }
+ syms.splice(0, i, parentPath);
+ break;
+ } else if (pkg) {
+ //If module name is just the package name, then looking
+ //for the main module.
+ if (moduleName === pkg.name) {
+ pkgPath = pkg.location + '/' + pkg.main;
+ } else {
+ pkgPath = pkg.location;
+ }
+ syms.splice(0, i, pkgPath);
+ break;
+ }
+ }
+
+ //Join the path parts together, then figure out if baseUrl is needed.
+ url = syms.join('/') + (ext || '.js');
+ url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
+ }
+
+ return config.urlArgs ? url +
+ ((url.indexOf('?') === -1 ? '?' : '&') +
+ config.urlArgs) : url;
+ },
+
+ //Delegates to req.load. Broken out as a separate function to
+ //allow overriding in the optimizer.
+ load: function (id, url) {
+ req.load(context, id, url);
+ },
+
+ /**
+ * Executes a module callack function. Broken out as a separate function
+ * solely to allow the build system to sequence the files in the built
+ * layer in the right sequence.
+ *
+ * @private
+ */
+ execCb: function (name, callback, args, exports) {
+ return callback.apply(exports, args);
+ },
+
+ /**
+ * callback for script loads, used to check status of loading.
+ *
+ * @param {Event} evt the event from the browser for the script
+ * that was loaded.
+ */
+ onScriptLoad: function (evt) {
+ //Using currentTarget instead of target for Firefox 2.0's sake. Not
+ //all old browsers will be supported, but this one was easy enough
+ //to support and still makes sense.
+ if (evt.type === 'load' ||
+ (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
+ //Reset interactive script so a script node is not held onto for
+ //to long.
+ interactiveScript = null;
+
+ //Pull out the name of the module and the context.
+ var data = getScriptData(evt);
+ context.completeLoad(data.id);
+ }
+ },
+
+ /**
+ * Callback for script errors.
+ */
+ onScriptError: function (evt) {
+ var data = getScriptData(evt);
+ if (!hasPathFallback(data.id)) {
+ return onError(makeError('scripterror', 'Script error', evt, [data.id]));
+ }
+ }
+ });
+ }
+
+ /**
+ * Main entry point.
+ *
+ * If the only argument to require is a string, then the module that
+ * is represented by that string is fetched for the appropriate context.
+ *
+ * If the first argument is an array, then it will be treated as an array
+ * of dependency string names to fetch. An optional function callback can
+ * be specified to execute when all of those dependencies are available.
+ *
+ * Make a local req variable to help Caja compliance (it assumes things
+ * on a require that are not standardized), and to give a short
+ * name for minification/local scope use.
+ */
+ req = requirejs = function (deps, callback, errback, optional) {
+
+ //Find the right context, use default
+ var contextName = defContextName,
+ context, config;
+
+ // Determine if have config object in the call.
+ if (!isArray(deps) && typeof deps !== 'string') {
+ // deps is a config object
+ config = deps;
+ if (isArray(callback)) {
+ // Adjust args if there are dependencies
+ deps = callback;
+ callback = errback;
+ errback = optional;
+ } else {
+ deps = [];
+ }
+ }
+
+ if (config && config.context) {
+ contextName = config.context;
+ }
+
+ context = contexts[contextName];
+ if (!context) {
+ context = contexts[contextName] = req.s.newContext(contextName);
+ }
+
+ if (config) {
+ context.configure(config);
+ }
+
+ return context.require(deps, callback, errback);
+ };
+
+ /**
+ * Support require.config() to make it easier to cooperate with other
+ * AMD loaders on globally agreed names.
+ */
+ req.config = function (config) {
+ return req(config);
+ };
+
+ /**
+ * Export require as a global, but only if it does not already exist.
+ */
+ if (!require) {
+ require = req;
+ }
+
+ req.version = version;
+
+ //Used to filter out dependencies that are already paths.
+ req.jsExtRegExp = /^\/|:|\?|\.js$/;
+ req.isBrowser = isBrowser;
+ s = req.s = {
+ contexts: contexts,
+ newContext: newContext
+ };
+
+ //Create default context.
+ req({});
+
+ //Exports some context-sensitive methods on global require, using
+ //default context if no context specified.
+ addRequireMethods(req);
+
+ if (isBrowser) {
+ head = s.head = document.getElementsByTagName('head')[0];
+ //If BASE tag is in play, using appendChild is a problem for IE6.
+ //When that browser dies, this can be removed. Details in this jQuery bug:
+ //http://dev.jquery.com/ticket/2709
+ baseElement = document.getElementsByTagName('base')[0];
+ if (baseElement) {
+ head = s.head = baseElement.parentNode;
+ }
+ }
+
+ /**
+ * Any errors that require explicitly generates will be passed to this
+ * function. Intercept/override it if you want custom error handling.
+ * @param {Error} err the error object.
+ */
+ req.onError = function (err) {
+ throw err;
+ };
+
+ /**
+ * Does the request to load a module for the browser case.
+ * Make this a separate function to allow other environments
+ * to override it.
+ *
+ * @param {Object} context the require context to find state.
+ * @param {String} moduleName the name of the module.
+ * @param {Object} url the URL to the module.
+ */
+ req.load = function (context, moduleName, url) {
+ var config = (context && context.config) || {},
+ node;
+ if (isBrowser) {
+ //In the browser so use a script tag
+ node = config.xhtml ?
+ document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
+ document.createElement('script');
+ node.type = config.scriptType || 'text/javascript';
+ node.charset = 'utf-8';
+
+ node.setAttribute('data-requirecontext', context.contextName);
+ node.setAttribute('data-requiremodule', moduleName);
+
+ //Set up load listener. Test attachEvent first because IE9 has
+ //a subtle issue in its addEventListener and script onload firings
+ //that do not match the behavior of all other browsers with
+ //addEventListener support, which fire the onload event for a
+ //script right after the script execution. See:
+ //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
+ //UNFORTUNATELY Opera implements attachEvent but does not follow the script
+ //script execution mode.
+ if (node.attachEvent &&
+ //Check if node.attachEvent is artificially added by custom script or
+ //natively supported by browser
+ //read https://github.com/jrburke/requirejs/issues/187
+ //if we can NOT find [native code] then it must NOT natively supported.
+ //in IE8, node.attachEvent does not have toString()
+ //Note the test for "[native code" with no closing brace, see:
+ //https://github.com/jrburke/requirejs/issues/273
+ !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
+ !isOpera) {
+ //Probably IE. IE (at least 6-8) do not fire
+ //script onload right after executing the script, so
+ //we cannot tie the anonymous define call to a name.
+ //However, IE reports the script as being in 'interactive'
+ //readyState at the time of the define call.
+ useInteractive = true;
+
+ node.attachEvent('onreadystatechange', context.onScriptLoad);
+ //It would be great to add an error handler here to catch
+ //404s in IE9+. However, onreadystatechange will fire before
+ //the error handler, so that does not help. If addEvenListener
+ //is used, then IE will fire error before load, but we cannot
+ //use that pathway given the connect.microsoft.com issue
+ //mentioned above about not doing the 'script execute,
+ //then fire the script load event listener before execute
+ //next script' that other browsers do.
+ //Best hope: IE10 fixes the issues,
+ //and then destroys all installs of IE 6-9.
+ //node.attachEvent('onerror', context.onScriptError);
+ } else {
+ node.addEventListener('load', context.onScriptLoad, false);
+ node.addEventListener('error', context.onScriptError, false);
+ }
+ node.src = url;
+
+ //For some cache cases in IE 6-8, the script executes before the end
+ //of the appendChild execution, so to tie an anonymous define
+ //call to the module name (which is stored on the node), hold on
+ //to a reference to this node, but clear after the DOM insertion.
+ currentlyAddingScript = node;
+ if (baseElement) {
+ head.insertBefore(node, baseElement);
+ } else {
+ head.appendChild(node);
+ }
+ currentlyAddingScript = null;
+
+ return node;
+ } else if (isWebWorker) {
+ //In a web worker, use importScripts. This is not a very
+ //efficient use of importScripts, importScripts will block until
+ //its script is downloaded and evaluated. However, if web workers
+ //are in play, the expectation that a build has been done so that
+ //only one script needs to be loaded anyway. This may need to be
+ //reevaluated if other use cases become common.
+ importScripts(url);
+
+ //Account for anonymous modules
+ context.completeLoad(moduleName);
+ }
+ };
+
+ function getInteractiveScript() {
+ if (interactiveScript && interactiveScript.readyState === 'interactive') {
+ return interactiveScript;
+ }
+
+ eachReverse(scripts(), function (script) {
+ if (script.readyState === 'interactive') {
+ return (interactiveScript = script);
+ }
+ });
+ return interactiveScript;
+ }
+
+ //Look for a data-main script attribute, which could also adjust the baseUrl.
+ if (isBrowser) {
+ //Figure out baseUrl. Get it from the script tag with require.js in it.
+ eachReverse(scripts(), function (script) {
+ //Set the 'head' where we can append children by
+ //using the script's parent.
+ if (!head) {
+ head = script.parentNode;
+ }
+
+ //Look for a data-main attribute to set main script for the page
+ //to load. If it is there, the path to data main becomes the
+ //baseUrl, if it is not already set.
+ dataMain = script.getAttribute('data-main');
+ if (dataMain) {
+
+ //Pull off the directory of data-main for use as the
+ //baseUrl.
+ src = dataMain.split('/');
+ mainScript = src.pop();
+ subPath = src.length ? src.join('/') + '/' : './';
+
+ //Set final baseUrl if there is not already an explicit one.
+ if (!cfg.baseUrl) {
+ cfg.baseUrl = subPath;
+ }
+
+ //Strip off any trailing .js since dataMain is now
+ //like a module name.
+ dataMain = mainScript.replace(jsSuffixRegExp, '');
+
+ //Put the data-main script in the files to load.
+ cfg.deps = cfg.deps ? cfg.deps.concat(dataMain) : [dataMain];
+
+ return true;
+ }
+ });
+ }
+
+ /**
+ * The function that handles definitions of modules. Differs from
+ * require() in that a string for the module should be the first argument,
+ * and the function to execute after dependencies are loaded should
+ * return a value to define the module corresponding to the first argument's
+ * name.
+ */
+ define = function (name, deps, callback) {
+ var node, context;
+
+ //Allow for anonymous functions
+ if (typeof name !== 'string') {
+ //Adjust args appropriately
+ callback = deps;
+ deps = name;
+ name = null;
+ }
+
+ //This module may not have dependencies
+ if (!isArray(deps)) {
+ callback = deps;
+ deps = [];
+ }
+
+ //If no name, and callback is a function, then figure out if it a
+ //CommonJS thing with dependencies.
+ if (!deps.length && isFunction(callback)) {
+ //Remove comments from the callback string,
+ //look for require calls, and pull them into the dependencies,
+ //but only if there are function args.
+ if (callback.length) {
+ callback
+ .toString()
+ .replace(commentRegExp, '')
+ .replace(cjsRequireRegExp, function (match, dep) {
+ deps.push(dep);
+ });
+
+ //May be a CommonJS thing even without require calls, but still
+ //could use exports, and module. Avoid doing exports and module
+ //work though if it just needs require.
+ //REQUIRES the function to expect the CommonJS variables in the
+ //order listed below.
+ deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
+ }
+ }
+
+ //If in IE 6-8 and hit an anonymous define() call, do the interactive
+ //work.
+ if (useInteractive) {
+ node = currentlyAddingScript || getInteractiveScript();
+ if (node) {
+ if (!name) {
+ name = node.getAttribute('data-requiremodule');
+ }
+ context = contexts[node.getAttribute('data-requirecontext')];
+ }
+ }
+
+ //Always save off evaluating the def call until the script onload handler.
+ //This allows multiple modules to be in a file without prematurely
+ //tracing dependencies, and allows for anonymous module support,
+ //where the module name is not known until the script onload event
+ //occurs. If no context, use the global queue, and get it processed
+ //in the onscript load callback.
+ (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
+ };
+
+ define.amd = {
+ jQuery: true
+ };
+
+
+ /**
+ * Executes the text. Normally just uses eval, but can be modified
+ * to use a better, environment-specific call. Only used for transpiling
+ * loader plugins, not for plain JS modules.
+ * @param {String} text the text to execute/evaluate.
+ */
+ req.exec = function (text) {
+ /*jslint evil: true */
+ return eval(text);
+ };
+
+ //Set up with config info.
+ req(cfg);
+}(this));
+
+
+ if (env === 'rhino') {
+ /**
+ * @license RequireJS rhino Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint */
+/*global require: false, java: false, load: false */
+
+(function () {
+ 'use strict';
+ require.load = function (context, moduleName, url) {
+
+ load(url);
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ };
+
+}());
+ } else if (env === 'node') {
+ this.requirejsVars = {
+ require: require,
+ requirejs: require,
+ define: define,
+ nodeRequire: nodeRequire
+ };
+ require.nodeRequire = nodeRequire;
+
+ /**
+ * @license RequireJS node Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint regexp: false */
+/*global require: false, define: false, requirejsVars: false, process: false */
+
+/**
+ * This adapter assumes that x.js has loaded it and set up
+ * some variables. This adapter just allows limited RequireJS
+ * usage from within the requirejs directory. The general
+ * node adapater is r.js.
+ */
+
+(function () {
+ 'use strict';
+
+ var nodeReq = requirejsVars.nodeRequire,
+ req = requirejsVars.require,
+ def = requirejsVars.define,
+ fs = nodeReq('fs'),
+ path = nodeReq('path'),
+ vm = nodeReq('vm'),
+ //In Node 0.7+ existsSync is on fs.
+ exists = fs.existsSync || path.existsSync;
+
+ //Supply an implementation that allows synchronous get of a module.
+ req.get = function (context, moduleName, relModuleMap) {
+ if (moduleName === "require" || moduleName === "exports" || moduleName === "module") {
+ req.onError(new Error("Explicit require of " + moduleName + " is not allowed."));
+ }
+
+ var ret,
+ moduleMap = context.makeModuleMap(moduleName, relModuleMap);
+
+ //Normalize module name, if it contains . or ..
+ moduleName = moduleMap.id;
+
+ if (context.defined.hasOwnProperty(moduleName)) {
+ ret = context.defined[moduleName];
+ } else {
+ if (ret === undefined) {
+ //Try to dynamically fetch it.
+ req.load(context, moduleName, moduleMap.url);
+ //The above call is sync, so can do the next thing safely.
+ ret = context.defined[moduleName];
+ }
+ }
+
+ return ret;
+ };
+
+ //Add wrapper around the code so that it gets the requirejs
+ //API instead of the Node API, and it is done lexically so
+ //that it survives later execution.
+ req.makeNodeWrapper = function (contents) {
+ return '(function (require, requirejs, define) { ' +
+ contents +
+ '\n}(requirejsVars.require, requirejsVars.requirejs, requirejsVars.define));';
+ };
+
+ req.load = function (context, moduleName, url) {
+ var contents, err;
+
+ if (exists(url)) {
+ contents = fs.readFileSync(url, 'utf8');
+
+ contents = req.makeNodeWrapper(contents);
+ try {
+ vm.runInThisContext(contents, fs.realpathSync(url));
+ } catch (e) {
+ err = new Error('Evaluating ' + url + ' as module "' +
+ moduleName + '" failed with error: ' + e);
+ err.originalError = e;
+ err.moduleName = moduleName;
+ err.fileName = url;
+ return req.onError(err);
+ }
+ } else {
+ def(moduleName, function () {
+ try {
+ return (context.config.nodeRequire || req.nodeRequire)(moduleName);
+ } catch (e) {
+ err = new Error('Calling node\'s require("' +
+ moduleName + '") failed with error: ' + e);
+ err.originalError = e;
+ err.moduleName = moduleName;
+ return req.onError(err);
+ }
+ });
+ }
+
+ //Support anonymous modules.
+ context.completeLoad(moduleName);
+ };
+
+ //Override to provide the function wrapper for define/require.
+ req.exec = function (text) {
+ /*jslint evil: true */
+ text = req.makeNodeWrapper(text);
+ return eval(text);
+ };
+}());
+
+ }
+
+ //Support a default file name to execute. Useful for hosted envs
+ //like Joyent where it defaults to a server.js as the only executed
+ //script. But only do it if this is not an optimization run.
+ if (commandOption !== 'o' && (!fileName || !jsSuffixRegExp.test(fileName))) {
+ fileName = 'main.js';
+ }
+
+ /**
+ * Loads the library files that can be used for the optimizer, or for other
+ * tasks.
+ */
+ function loadLib() {
+ /**
+ * @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global Packages: false, process: false, window: false, navigator: false,
+ document: false, define: false */
+
+/**
+ * A plugin that modifies any /env/ path to be the right path based on
+ * the host environment. Right now only works for Node, Rhino and browser.
+ */
+(function () {
+ var pathRegExp = /(\/|^)env\/|\{env\}/,
+ env = 'unknown';
+
+ if (typeof Packages !== 'undefined') {
+ env = 'rhino';
+ } else if (typeof process !== 'undefined') {
+ env = 'node';
+ } else if (typeof window !== "undefined" && navigator && document) {
+ env = 'browser';
+ }
+
+ define('env', {
+ load: function (name, req, load, config) {
+ //Allow override in the config.
+ if (config.env) {
+ env = config.env;
+ }
+
+ name = name.replace(pathRegExp, function (match, prefix) {
+ if (match.indexOf('{') === -1) {
+ return prefix + env + '/';
+ } else {
+ return env;
+ }
+ });
+
+ req([name], function (mod) {
+ load(mod);
+ });
+ }
+ });
+}());
+if(env === 'node') {
+/**
+ * @license RequireJS Copyright (c) 2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, load: false */
+
+//Needed so that rhino/assert can return a stub for uglify's consolidator.js
+define('node/assert', ['assert'], function (assert) {
+ return assert;
+});
+
+}
+
+if(env === 'rhino') {
+/**
+ * @license RequireJS Copyright (c) 2012, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, load: false */
+
+//Just a stub for use with uglify's consolidator.js
+define('rhino/assert', function () {
+ return {};
+});
+
+}
+
+if(env === 'node') {
+/**
+ * @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, process: false */
+
+define('node/args', function () {
+ //Do not return the "node" or "r.js" arguments
+ var args = process.argv.slice(2);
+
+ //Ignore any command option used for rq.js
+ if (args[0] && args[0].indexOf('-' === 0)) {
+ args = args.slice(1);
+ }
+
+ return args;
+});
+
+}
+
+if(env === 'rhino') {
+/**
+ * @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, process: false */
+
+var jsLibRhinoArgs = (typeof rhinoArgs !== 'undefined' && rhinoArgs) || [].concat(Array.prototype.slice.call(arguments, 0));
+
+define('rhino/args', function () {
+ var args = jsLibRhinoArgs;
+
+ //Ignore any command option used for rq.js
+ if (args[0] && args[0].indexOf('-' === 0)) {
+ args = args.slice(1);
+ }
+
+ return args;
+});
+
+}
+
+if(env === 'node') {
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, console: false */
+
+define('node/load', ['fs'], function (fs) {
+ function load(fileName) {
+ var contents = fs.readFileSync(fileName, 'utf8');
+ process.compile(contents, fileName);
+ }
+
+ return load;
+});
+
+}
+
+if(env === 'rhino') {
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, load: false */
+
+define('rhino/load', function () {
+ return load;
+});
+
+}
+
+if(env === 'node') {
+/**
+ * @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint plusplus: false, octal:false, strict: false */
+/*global define: false, process: false */
+
+define('node/file', ['fs', 'path'], function (fs, path) {
+
+ var isWindows = process.platform === 'win32',
+ windowsDriveRegExp = /^[a-zA-Z]\:\/$/,
+ file;
+
+ function frontSlash(path) {
+ return path.replace(/\\/g, '/');
+ }
+
+ function exists(path) {
+ if (isWindows && path.charAt(path.length - 1) === '/' &&
+ path.charAt(path.length - 2) !== ':') {
+ path = path.substring(0, path.length - 1);
+ }
+
+ try {
+ fs.statSync(path);
+ return true;
+ } catch (e) {
+ return false;
+ }
+ }
+
+ function mkDir(dir) {
+ if (!exists(dir) && (!isWindows || !windowsDriveRegExp.test(dir))) {
+ fs.mkdirSync(dir, 511);
+ }
+ }
+
+ function mkFullDir(dir) {
+ var parts = dir.split('/'),
+ currDir = '',
+ first = true;
+
+ parts.forEach(function (part) {
+ //First part may be empty string if path starts with a slash.
+ currDir += part + '/';
+ first = false;
+
+ if (part) {
+ mkDir(currDir);
+ }
+ });
+ }
+
+ file = {
+ backSlashRegExp: /\\/g,
+ exclusionRegExp: /^\./,
+ getLineSeparator: function () {
+ return '/';
+ },
+
+ exists: function (fileName) {
+ return exists(fileName);
+ },
+
+ parent: function (fileName) {
+ var parts = fileName.split('/');
+ parts.pop();
+ return parts.join('/');
+ },
+
+ /**
+ * Gets the absolute file path as a string, normalized
+ * to using front slashes for path separators.
+ * @param {String} fileName
+ */
+ absPath: function (fileName) {
+ return frontSlash(path.normalize(frontSlash(fs.realpathSync(fileName))));
+ },
+
+ normalize: function (fileName) {
+ return frontSlash(path.normalize(fileName));
+ },
+
+ isFile: function (path) {
+ return fs.statSync(path).isFile();
+ },
+
+ isDirectory: function (path) {
+ return fs.statSync(path).isDirectory();
+ },
+
+ getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths) {
+ //summary: Recurses startDir and finds matches to the files that match regExpFilters.include
+ //and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
+ //and it will be treated as the "include" case.
+ //Ignores files/directories that start with a period (.) unless exclusionRegExp
+ //is set to another value.
+ var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+ i, stat, filePath, ok, dirFiles, fileName;
+
+ topDir = startDir;
+
+ regExpInclude = regExpFilters.include || regExpFilters;
+ regExpExclude = regExpFilters.exclude || null;
+
+ if (file.exists(topDir)) {
+ dirFileArray = fs.readdirSync(topDir);
+ for (i = 0; i < dirFileArray.length; i++) {
+ fileName = dirFileArray[i];
+ filePath = path.join(topDir, fileName);
+ stat = fs.statSync(filePath);
+ if (stat.isFile()) {
+ if (makeUnixPaths) {
+ //Make sure we have a JS string.
+ if (filePath.indexOf("/") === -1) {
+ filePath = frontSlash(filePath);
+ }
+ }
+
+ ok = true;
+ if (regExpInclude) {
+ ok = filePath.match(regExpInclude);
+ }
+ if (ok && regExpExclude) {
+ ok = !filePath.match(regExpExclude);
+ }
+
+ if (ok && (!file.exclusionRegExp ||
+ !file.exclusionRegExp.test(fileName))) {
+ files.push(filePath);
+ }
+ } else if (stat.isDirectory() &&
+ (!file.exclusionRegExp || !file.exclusionRegExp.test(fileName))) {
+ dirFiles = this.getFilteredFileList(filePath, regExpFilters, makeUnixPaths);
+ files.push.apply(files, dirFiles);
+ }
+ }
+ }
+
+ return files; //Array
+ },
+
+ copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
+ //summary: copies files from srcDir to destDir using the regExpFilter to determine if the
+ //file should be copied. Returns a list file name strings of the destinations that were copied.
+ regExpFilter = regExpFilter || /\w/;
+
+ //Normalize th directory names, but keep front slashes.
+ //path module on windows now returns backslashed paths.
+ srcDir = frontSlash(path.normalize(srcDir));
+ destDir = frontSlash(path.normalize(destDir));
+
+ var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+ copiedFiles = [], i, srcFileName, destFileName;
+
+ for (i = 0; i < fileNames.length; i++) {
+ srcFileName = fileNames[i];
+ destFileName = srcFileName.replace(srcDir, destDir);
+
+ if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+ copiedFiles.push(destFileName);
+ }
+ }
+
+ return copiedFiles.length ? copiedFiles : null; //Array or null
+ },
+
+ copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+ //summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
+ //srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
+ var parentDir;
+
+ //logger.trace("Src filename: " + srcFileName);
+ //logger.trace("Dest filename: " + destFileName);
+
+ //If onlyCopyNew is true, then compare dates and only copy if the src is newer
+ //than dest.
+ if (onlyCopyNew) {
+ if (file.exists(destFileName) && fs.statSync(destFileName).mtime.getTime() >= fs.statSync(srcFileName).mtime.getTime()) {
+ return false; //Boolean
+ }
+ }
+
+ //Make sure destination dir exists.
+ parentDir = path.dirname(destFileName);
+ if (!file.exists(parentDir)) {
+ mkFullDir(parentDir);
+ }
+
+ fs.writeFileSync(destFileName, fs.readFileSync(srcFileName, 'binary'), 'binary');
+
+ return true; //Boolean
+ },
+
+ /**
+ * Renames a file. May fail if "to" already exists or is on another drive.
+ */
+ renameFile: function (from, to) {
+ return fs.renameSync(from, to);
+ },
+
+ /**
+ * Reads a *text* file.
+ */
+ readFile: function (/*String*/path, /*String?*/encoding) {
+ if (encoding === 'utf-8') {
+ encoding = 'utf8';
+ }
+ if (!encoding) {
+ encoding = 'utf8';
+ }
+
+ var text = fs.readFileSync(path, encoding);
+
+ //Hmm, would not expect to get A BOM, but it seems to happen,
+ //remove it just in case.
+ if (text.indexOf('\uFEFF') === 0) {
+ text = text.substring(1, text.length);
+ }
+
+ return text;
+ },
+
+ saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+ //summary: saves a *text* file using UTF-8 encoding.
+ file.saveFile(fileName, fileContents, "utf8");
+ },
+
+ saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+ //summary: saves a *text* file.
+ var parentDir;
+
+ if (encoding === 'utf-8') {
+ encoding = 'utf8';
+ }
+ if (!encoding) {
+ encoding = 'utf8';
+ }
+
+ //Make sure destination directories exist.
+ parentDir = path.dirname(fileName);
+ if (!file.exists(parentDir)) {
+ mkFullDir(parentDir);
+ }
+
+ fs.writeFileSync(fileName, fileContents, encoding);
+ },
+
+ deleteFile: function (/*String*/fileName) {
+ //summary: deletes a file or directory if it exists.
+ var files, i, stat;
+ if (file.exists(fileName)) {
+ stat = fs.statSync(fileName);
+ if (stat.isDirectory()) {
+ files = fs.readdirSync(fileName);
+ for (i = 0; i < files.length; i++) {
+ this.deleteFile(path.join(fileName, files[i]));
+ }
+ fs.rmdirSync(fileName);
+ } else {
+ fs.unlinkSync(fileName);
+ }
+ }
+ }
+ };
+
+ return file;
+
+});
+
+}
+
+if(env === 'rhino') {
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+//Helper functions to deal with file I/O.
+
+/*jslint plusplus: false, strict: false */
+/*global java: false, define: false */
+
+define('rhino/file', function () {
+ var file = {
+ backSlashRegExp: /\\/g,
+
+ exclusionRegExp: /^\./,
+
+ getLineSeparator: function () {
+ return file.lineSeparator;
+ },
+
+ lineSeparator: java.lang.System.getProperty("line.separator"), //Java String
+
+ exists: function (fileName) {
+ return (new java.io.File(fileName)).exists();
+ },
+
+ parent: function (fileName) {
+ return file.absPath((new java.io.File(fileName)).getParentFile());
+ },
+
+ normalize: function (fileName) {
+ return file.absPath(fileName);
+ },
+
+ isFile: function (path) {
+ return (new java.io.File(path)).isFile();
+ },
+
+ isDirectory: function (path) {
+ return (new java.io.File(path)).isDirectory();
+ },
+
+ /**
+ * Gets the absolute file path as a string, normalized
+ * to using front slashes for path separators.
+ * @param {java.io.File||String} file
+ */
+ absPath: function (fileObj) {
+ if (typeof fileObj === "string") {
+ fileObj = new java.io.File(fileObj);
+ }
+ return (fileObj.getCanonicalPath() + "").replace(file.backSlashRegExp, "/");
+ },
+
+ getFilteredFileList: function (/*String*/startDir, /*RegExp*/regExpFilters, /*boolean?*/makeUnixPaths, /*boolean?*/startDirIsJavaObject) {
+ //summary: Recurses startDir and finds matches to the files that match regExpFilters.include
+ //and do not match regExpFilters.exclude. Or just one regexp can be passed in for regExpFilters,
+ //and it will be treated as the "include" case.
+ //Ignores files/directories that start with a period (.) unless exclusionRegExp
+ //is set to another value.
+ var files = [], topDir, regExpInclude, regExpExclude, dirFileArray,
+ i, fileObj, filePath, ok, dirFiles;
+
+ topDir = startDir;
+ if (!startDirIsJavaObject) {
+ topDir = new java.io.File(startDir);
+ }
+
+ regExpInclude = regExpFilters.include || regExpFilters;
+ regExpExclude = regExpFilters.exclude || null;
+
+ if (topDir.exists()) {
+ dirFileArray = topDir.listFiles();
+ for (i = 0; i < dirFileArray.length; i++) {
+ fileObj = dirFileArray[i];
+ if (fileObj.isFile()) {
+ filePath = fileObj.getPath();
+ if (makeUnixPaths) {
+ //Make sure we have a JS string.
+ filePath = String(filePath);
+ if (filePath.indexOf("/") === -1) {
+ filePath = filePath.replace(/\\/g, "/");
+ }
+ }
+
+ ok = true;
+ if (regExpInclude) {
+ ok = filePath.match(regExpInclude);
+ }
+ if (ok && regExpExclude) {
+ ok = !filePath.match(regExpExclude);
+ }
+
+ if (ok && (!file.exclusionRegExp ||
+ !file.exclusionRegExp.test(fileObj.getName()))) {
+ files.push(filePath);
+ }
+ } else if (fileObj.isDirectory() &&
+ (!file.exclusionRegExp || !file.exclusionRegExp.test(fileObj.getName()))) {
+ dirFiles = this.getFilteredFileList(fileObj, regExpFilters, makeUnixPaths, true);
+ files.push.apply(files, dirFiles);
+ }
+ }
+ }
+
+ return files; //Array
+ },
+
+ copyDir: function (/*String*/srcDir, /*String*/destDir, /*RegExp?*/regExpFilter, /*boolean?*/onlyCopyNew) {
+ //summary: copies files from srcDir to destDir using the regExpFilter to determine if the
+ //file should be copied. Returns a list file name strings of the destinations that were copied.
+ regExpFilter = regExpFilter || /\w/;
+
+ var fileNames = file.getFilteredFileList(srcDir, regExpFilter, true),
+ copiedFiles = [], i, srcFileName, destFileName;
+
+ for (i = 0; i < fileNames.length; i++) {
+ srcFileName = fileNames[i];
+ destFileName = srcFileName.replace(srcDir, destDir);
+
+ if (file.copyFile(srcFileName, destFileName, onlyCopyNew)) {
+ copiedFiles.push(destFileName);
+ }
+ }
+
+ return copiedFiles.length ? copiedFiles : null; //Array or null
+ },
+
+ copyFile: function (/*String*/srcFileName, /*String*/destFileName, /*boolean?*/onlyCopyNew) {
+ //summary: copies srcFileName to destFileName. If onlyCopyNew is set, it only copies the file if
+ //srcFileName is newer than destFileName. Returns a boolean indicating if the copy occurred.
+ var destFile = new java.io.File(destFileName), srcFile, parentDir,
+ srcChannel, destChannel;
+
+ //logger.trace("Src filename: " + srcFileName);
+ //logger.trace("Dest filename: " + destFileName);
+
+ //If onlyCopyNew is true, then compare dates and only copy if the src is newer
+ //than dest.
+ if (onlyCopyNew) {
+ srcFile = new java.io.File(srcFileName);
+ if (destFile.exists() && destFile.lastModified() >= srcFile.lastModified()) {
+ return false; //Boolean
+ }
+ }
+
+ //Make sure destination dir exists.
+ parentDir = destFile.getParentFile();
+ if (!parentDir.exists()) {
+ if (!parentDir.mkdirs()) {
+ throw "Could not create directory: " + parentDir.getCanonicalPath();
+ }
+ }
+
+ //Java's version of copy file.
+ srcChannel = new java.io.FileInputStream(srcFileName).getChannel();
+ destChannel = new java.io.FileOutputStream(destFileName).getChannel();
+ destChannel.transferFrom(srcChannel, 0, srcChannel.size());
+ srcChannel.close();
+ destChannel.close();
+
+ return true; //Boolean
+ },
+
+ /**
+ * Renames a file. May fail if "to" already exists or is on another drive.
+ */
+ renameFile: function (from, to) {
+ return (new java.io.File(from)).renameTo((new java.io.File(to)));
+ },
+
+ readFile: function (/*String*/path, /*String?*/encoding) {
+ //A file read function that can deal with BOMs
+ encoding = encoding || "utf-8";
+ var fileObj = new java.io.File(path),
+ input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(fileObj), encoding)),
+ stringBuffer, line;
+ try {
+ stringBuffer = new java.lang.StringBuffer();
+ line = input.readLine();
+
+ // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+ // http://www.unicode.org/faq/utf_bom.html
+
+ // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
+ // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+ if (line && line.length() && line.charAt(0) === 0xfeff) {
+ // Eat the BOM, since we've already found the encoding on this file,
+ // and we plan to concatenating this buffer with others; the BOM should
+ // only appear at the top of a file.
+ line = line.substring(1);
+ }
+ while (line !== null) {
+ stringBuffer.append(line);
+ stringBuffer.append(file.lineSeparator);
+ line = input.readLine();
+ }
+ //Make sure we return a JavaScript string and not a Java string.
+ return String(stringBuffer.toString()); //String
+ } finally {
+ input.close();
+ }
+ },
+
+ saveUtf8File: function (/*String*/fileName, /*String*/fileContents) {
+ //summary: saves a file using UTF-8 encoding.
+ file.saveFile(fileName, fileContents, "utf-8");
+ },
+
+ saveFile: function (/*String*/fileName, /*String*/fileContents, /*String?*/encoding) {
+ //summary: saves a file.
+ var outFile = new java.io.File(fileName), outWriter, parentDir, os;
+
+ parentDir = outFile.getAbsoluteFile().getParentFile();
+ if (!parentDir.exists()) {
+ if (!parentDir.mkdirs()) {
+ throw "Could not create directory: " + parentDir.getAbsolutePath();
+ }
+ }
+
+ if (encoding) {
+ outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile), encoding);
+ } else {
+ outWriter = new java.io.OutputStreamWriter(new java.io.FileOutputStream(outFile));
+ }
+
+ os = new java.io.BufferedWriter(outWriter);
+ try {
+ os.write(fileContents);
+ } finally {
+ os.close();
+ }
+ },
+
+ deleteFile: function (/*String*/fileName) {
+ //summary: deletes a file or directory if it exists.
+ var fileObj = new java.io.File(fileName), files, i;
+ if (fileObj.exists()) {
+ if (fileObj.isDirectory()) {
+ files = fileObj.listFiles();
+ for (i = 0; i < files.length; i++) {
+ this.deleteFile(files[i]);
+ }
+ }
+ fileObj["delete"]();
+ }
+ }
+ };
+
+ return file;
+});
+
+}
+
+if(env === 'node') {
+/*global process */
+define('node/quit', function () {
+ 'use strict';
+ return function (code) {
+ return process.exit(code);
+ };
+});
+}
+
+if(env === 'rhino') {
+/*global quit */
+define('rhino/quit', function () {
+ 'use strict';
+ return function (code) {
+ return quit(code);
+ };
+});
+
+}
+/**
+ * @license Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint plusplus: true */
+/*global define */
+
+define('lang', function () {
+ 'use strict';
+
+ var lang = {
+ backSlashRegExp: /\\/g,
+ ostring: Object.prototype.toString,
+
+ isArray: Array.isArray || function (it) {
+ return lang.ostring.call(it) === "[object Array]";
+ },
+
+ isFunction: function(it) {
+ return lang.ostring.call(it) === "[object Function]";
+ },
+
+ isRegExp: function(it) {
+ return it && it instanceof RegExp;
+ },
+
+ _mixin: function(dest, source, override){
+ var name;
+ for (name in source) {
+ if(source.hasOwnProperty(name)
+ && (override || !dest.hasOwnProperty(name))) {
+ dest[name] = source[name];
+ }
+ }
+
+ return dest; // Object
+ },
+
+ /**
+ * mixin({}, obj1, obj2) is allowed. If the last argument is a boolean,
+ * then the source objects properties are force copied over to dest.
+ */
+ mixin: function(dest){
+ var parameters = Array.prototype.slice.call(arguments),
+ override, i, l;
+
+ if (!dest) { dest = {}; }
+
+ if (parameters.length > 2 && typeof arguments[parameters.length-1] === 'boolean') {
+ override = parameters.pop();
+ }
+
+ for (i = 1, l = parameters.length; i < l; i++) {
+ lang._mixin(dest, parameters[i], override);
+ }
+ return dest; // Object
+ },
+
+ delegate: (function () {
+ // boodman/crockford delegation w/ cornford optimization
+ function TMP() {}
+ return function (obj, props) {
+ TMP.prototype = obj;
+ var tmp = new TMP();
+ TMP.prototype = null;
+ if (props) {
+ lang.mixin(tmp, props);
+ }
+ return tmp; // Object
+ };
+ }()),
+
+ /**
+ * Helper function for iterating over an array. If the func returns
+ * a true value, it will break out of the loop.
+ */
+ each: function each(ary, func) {
+ if (ary) {
+ var i;
+ for (i = 0; i < ary.length; i += 1) {
+ if (func(ary[i], i, ary)) {
+ break;
+ }
+ }
+ }
+ },
+
+ /**
+ * Cycles over properties in an object and calls a function for each
+ * property value. If the function returns a truthy value, then the
+ * iteration is stopped.
+ */
+ eachProp: function eachProp(obj, func) {
+ var prop;
+ for (prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ if (func(obj[prop], prop)) {
+ break;
+ }
+ }
+ }
+ },
+
+ //Similar to Function.prototype.bind, but the "this" object is specified
+ //first, since it is easier to read/figure out what "this" will be.
+ bind: function bind(obj, fn) {
+ return function () {
+ return fn.apply(obj, arguments);
+ };
+ },
+
+ //Escapes a content string to be be a string that has characters escaped
+ //for inclusion as part of a JS string.
+ jsEscape: function (content) {
+ return content.replace(/(["'\\])/g, '\\$1')
+ .replace(/[\f]/g, "\\f")
+ .replace(/[\b]/g, "\\b")
+ .replace(/[\n]/g, "\\n")
+ .replace(/[\t]/g, "\\t")
+ .replace(/[\r]/g, "\\r");
+ }
+ };
+ return lang;
+});
+
+if(env === 'node') {
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, console: false */
+
+define('node/print', function () {
+ function print(msg) {
+ console.log(msg);
+ }
+
+ return print;
+});
+
+}
+
+if(env === 'rhino') {
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint strict: false */
+/*global define: false, print: false */
+
+define('rhino/print', function () {
+ return print;
+});
+
+}
+/**
+ * @license RequireJS Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/requirejs for details
+ */
+
+/*jslint nomen: false, strict: false */
+/*global define: false */
+
+define('logger', ['env!env/print'], function (print) {
+ var logger = {
+ TRACE: 0,
+ INFO: 1,
+ WARN: 2,
+ ERROR: 3,
+ SILENT: 4,
+ level: 0,
+ logPrefix: "",
+
+ logLevel: function( level ) {
+ this.level = level;
+ },
+
+ trace: function (message) {
+ if (this.level <= this.TRACE) {
+ this._print(message);
+ }
+ },
+
+ info: function (message) {
+ if (this.level <= this.INFO) {
+ this._print(message);
+ }
+ },
+
+ warn: function (message) {
+ if (this.level <= this.WARN) {
+ this._print(message);
+ }
+ },
+
+ error: function (message) {
+ if (this.level <= this.ERROR) {
+ this._print(message);
+ }
+ },
+
+ _print: function (message) {
+ this._sysPrint((this.logPrefix ? (this.logPrefix + " ") : "") + message);
+ },
+
+ _sysPrint: function (message) {
+ print(message);
+ }
+ };
+
+ return logger;
+});
+//Just a blank file to use when building the optimizer with the optimizer,
+//so that the build does not attempt to inline some env modules,
+//like Node's fs and path.
+
+//Just a blank file to use when building the optimizer with the optimizer,
+//so that the build does not attempt to inline some env modules,
+//like Node's fs and path.
+
+//Commit d72ed0a000c455290fde6f8114fe38f4aaf31469 on May 15, 2012
+define('esprima', ['exports'], function(exports) {
+/*
+ Copyright (C) 2012 Ariya Hidayat
+ Copyright (C) 2012 Mathias Bynens
+ Copyright (C) 2012 Joost-Wim Boekesteijn
+ Copyright (C) 2012 Kris Kowal
+ Copyright (C) 2012 Yusuke Suzuki
+ Copyright (C) 2012 Arpad Borsos
+ Copyright (C) 2011 Ariya Hidayat
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*jslint bitwise:true plusplus:true */
+/*global esprima:true, exports:true,
+throwError: true, createLiteral: true, generateStatement: true,
+parseAssignmentExpression: true, parseBlock: true, parseExpression: true,
+parseFunctionDeclaration: true, parseFunctionExpression: true,
+parseFunctionSourceElements: true, parseVariableIdentifier: true,
+parseLeftHandSideExpression: true,
+parseStatement: true, parseSourceElement: true */
+
+(function (exports) {
+ 'use strict';
+
+ var Token,
+ TokenName,
+ Syntax,
+ PropertyKind,
+ Messages,
+ Regex,
+ source,
+ strict,
+ index,
+ lineNumber,
+ lineStart,
+ length,
+ buffer,
+ state,
+ extra;
+
+ Token = {
+ BooleanLiteral: 1,
+ EOF: 2,
+ Identifier: 3,
+ Keyword: 4,
+ NullLiteral: 5,
+ NumericLiteral: 6,
+ Punctuator: 7,
+ StringLiteral: 8
+ };
+
+ TokenName = {};
+ TokenName[Token.BooleanLiteral] = 'Boolean';
+ TokenName[Token.EOF] = '';
+ TokenName[Token.Identifier] = 'Identifier';
+ TokenName[Token.Keyword] = 'Keyword';
+ TokenName[Token.NullLiteral] = 'Null';
+ TokenName[Token.NumericLiteral] = 'Numeric';
+ TokenName[Token.Punctuator] = 'Punctuator';
+ TokenName[Token.StringLiteral] = 'String';
+
+ Syntax = {
+ AssignmentExpression: 'AssignmentExpression',
+ ArrayExpression: 'ArrayExpression',
+ BlockStatement: 'BlockStatement',
+ BinaryExpression: 'BinaryExpression',
+ BreakStatement: 'BreakStatement',
+ CallExpression: 'CallExpression',
+ CatchClause: 'CatchClause',
+ ConditionalExpression: 'ConditionalExpression',
+ ContinueStatement: 'ContinueStatement',
+ DoWhileStatement: 'DoWhileStatement',
+ DebuggerStatement: 'DebuggerStatement',
+ EmptyStatement: 'EmptyStatement',
+ ExpressionStatement: 'ExpressionStatement',
+ ForStatement: 'ForStatement',
+ ForInStatement: 'ForInStatement',
+ FunctionDeclaration: 'FunctionDeclaration',
+ FunctionExpression: 'FunctionExpression',
+ Identifier: 'Identifier',
+ IfStatement: 'IfStatement',
+ Literal: 'Literal',
+ LabeledStatement: 'LabeledStatement',
+ LogicalExpression: 'LogicalExpression',
+ MemberExpression: 'MemberExpression',
+ NewExpression: 'NewExpression',
+ ObjectExpression: 'ObjectExpression',
+ Program: 'Program',
+ Property: 'Property',
+ ReturnStatement: 'ReturnStatement',
+ SequenceExpression: 'SequenceExpression',
+ SwitchStatement: 'SwitchStatement',
+ SwitchCase: 'SwitchCase',
+ ThisExpression: 'ThisExpression',
+ ThrowStatement: 'ThrowStatement',
+ TryStatement: 'TryStatement',
+ UnaryExpression: 'UnaryExpression',
+ UpdateExpression: 'UpdateExpression',
+ VariableDeclaration: 'VariableDeclaration',
+ VariableDeclarator: 'VariableDeclarator',
+ WhileStatement: 'WhileStatement',
+ WithStatement: 'WithStatement'
+ };
+
+ PropertyKind = {
+ Data: 1,
+ Get: 2,
+ Set: 4
+ };
+
+ // Error messages should be identical to V8.
+ Messages = {
+ UnexpectedToken: 'Unexpected token %0',
+ UnexpectedNumber: 'Unexpected number',
+ UnexpectedString: 'Unexpected string',
+ UnexpectedIdentifier: 'Unexpected identifier',
+ UnexpectedReserved: 'Unexpected reserved word',
+ UnexpectedEOS: 'Unexpected end of input',
+ NewlineAfterThrow: 'Illegal newline after throw',
+ InvalidRegExp: 'Invalid regular expression',
+ UnterminatedRegExp: 'Invalid regular expression: missing /',
+ InvalidLHSInAssignment: 'Invalid left-hand side in assignment',
+ InvalidLHSInForIn: 'Invalid left-hand side in for-in',
+ NoCatchOrFinally: 'Missing catch or finally after try',
+ UnknownLabel: 'Undefined label \'%0\'',
+ Redeclaration: '%0 \'%1\' has already been declared',
+ IllegalContinue: 'Illegal continue statement',
+ IllegalBreak: 'Illegal break statement',
+ IllegalReturn: 'Illegal return statement',
+ StrictModeWith: 'Strict mode code may not include a with statement',
+ StrictCatchVariable: 'Catch variable may not be eval or arguments in strict mode',
+ StrictVarName: 'Variable name may not be eval or arguments in strict mode',
+ StrictParamName: 'Parameter name eval or arguments is not allowed in strict mode',
+ StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+ StrictFunctionName: 'Function name may not be eval or arguments in strict mode',
+ StrictOctalLiteral: 'Octal literals are not allowed in strict mode.',
+ StrictDelete: 'Delete of an unqualified identifier in strict mode.',
+ StrictDuplicateProperty: 'Duplicate data property in object literal not allowed in strict mode',
+ AccessorDataProperty: 'Object literal may not have data and accessor property with the same name',
+ AccessorGetSet: 'Object literal may not have multiple get/set accessors with the same name',
+ StrictLHSAssignment: 'Assignment to eval or arguments is not allowed in strict mode',
+ StrictLHSPostfix: 'Postfix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictLHSPrefix: 'Prefix increment/decrement may not have eval or arguments operand in strict mode',
+ StrictReservedWord: 'Use of future reserved word in strict mode'
+ };
+
+ // See also tools/generate-unicode-regex.py.
+ Regex = {
+ NonAsciiIdentifierStart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]'),
+ NonAsciiIdentifierPart: new RegExp('[\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u05d0-\u05ea\u05f0-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u0800-\u082d\u0840-\u085b\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0900-\u0963\u0966-\u096f\u0971-\u0977\u0979-\u097f\u0981-\u0983\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7\u09c8\u09cb-\u09ce\u09d7\u09dc\u09dd\u09df-\u09e3\u09e6-\u09f1\u0a01-\u0a03\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b5c\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c58\u0c59\u0c60-\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1\u0cf2\u0d02\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d60-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d82\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772\u1773\u1780-\u17d3\u17d7\u17dc\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u1820-\u1877\u1880-\u18aa\u18b0-\u18f5\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1b00-\u1b4b\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1cf6\u1d00-\u1de6\u1dfc-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c\u200d\u203f\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua697\ua69f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua827\ua840-\ua873\ua880-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua900-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a\uaa7b\uaa80-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabea\uabec\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc]')
+ };
+
+ // Ensure the condition is true, otherwise throw an error.
+ // This is only to have a better contract semantic, i.e. another safety net
+ // to catch a logic error. The condition shall be fulfilled in normal case.
+ // Do NOT use this to enforce a certain condition on any user input.
+
+ function assert(condition, message) {
+ if (!condition) {
+ throw new Error('ASSERT: ' + message);
+ }
+ }
+
+ function sliceSource(from, to) {
+ return source.slice(from, to);
+ }
+
+ if (typeof 'esprima'[0] === 'undefined') {
+ sliceSource = function sliceArraySource(from, to) {
+ return source.slice(from, to).join('');
+ };
+ }
+
+ function isDecimalDigit(ch) {
+ return '0123456789'.indexOf(ch) >= 0;
+ }
+
+ function isHexDigit(ch) {
+ return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
+ }
+
+ function isOctalDigit(ch) {
+ return '01234567'.indexOf(ch) >= 0;
+ }
+
+
+ // 7.2 White Space
+
+ function isWhiteSpace(ch) {
+ return (ch === ' ') || (ch === '\u0009') || (ch === '\u000B') ||
+ (ch === '\u000C') || (ch === '\u00A0') ||
+ (ch.charCodeAt(0) >= 0x1680 &&
+ '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(ch) >= 0);
+ }
+
+ // 7.3 Line Terminators
+
+ function isLineTerminator(ch) {
+ return (ch === '\n' || ch === '\r' || ch === '\u2028' || ch === '\u2029');
+ }
+
+ // 7.6 Identifier Names and Identifiers
+
+ function isIdentifierStart(ch) {
+ return (ch === '$') || (ch === '_') || (ch === '\\') ||
+ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+ ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierStart.test(ch));
+ }
+
+ function isIdentifierPart(ch) {
+ return (ch === '$') || (ch === '_') || (ch === '\\') ||
+ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
+ ((ch >= '0') && (ch <= '9')) ||
+ ((ch.charCodeAt(0) >= 0x80) && Regex.NonAsciiIdentifierPart.test(ch));
+ }
+
+ // 7.6.1.2 Future Reserved Words
+
+ function isFutureReservedWord(id) {
+ switch (id) {
+
+ // Future reserved words.
+ case 'class':
+ case 'enum':
+ case 'export':
+ case 'extends':
+ case 'import':
+ case 'super':
+ return true;
+ }
+
+ return false;
+ }
+
+ function isStrictModeReservedWord(id) {
+ switch (id) {
+
+ // Strict Mode reserved words.
+ case 'implements':
+ case 'interface':
+ case 'package':
+ case 'private':
+ case 'protected':
+ case 'public':
+ case 'static':
+ case 'yield':
+ case 'let':
+ return true;
+ }
+
+ return false;
+ }
+
+ function isRestrictedWord(id) {
+ return id === 'eval' || id === 'arguments';
+ }
+
+ // 7.6.1.1 Keywords
+
+ function isKeyword(id) {
+ var keyword = false;
+ switch (id.length) {
+ case 2:
+ keyword = (id === 'if') || (id === 'in') || (id === 'do');
+ break;
+ case 3:
+ keyword = (id === 'var') || (id === 'for') || (id === 'new') || (id === 'try');
+ break;
+ case 4:
+ keyword = (id === 'this') || (id === 'else') || (id === 'case') || (id === 'void') || (id === 'with');
+ break;
+ case 5:
+ keyword = (id === 'while') || (id === 'break') || (id === 'catch') || (id === 'throw');
+ break;
+ case 6:
+ keyword = (id === 'return') || (id === 'typeof') || (id === 'delete') || (id === 'switch');
+ break;
+ case 7:
+ keyword = (id === 'default') || (id === 'finally');
+ break;
+ case 8:
+ keyword = (id === 'function') || (id === 'continue') || (id === 'debugger');
+ break;
+ case 10:
+ keyword = (id === 'instanceof');
+ break;
+ }
+
+ if (keyword) {
+ return true;
+ }
+
+ switch (id) {
+ // Future reserved words.
+ // 'const' is specialized as Keyword in V8.
+ case 'const':
+ return true;
+
+ // For compatiblity to SpiderMonkey and ES.next
+ case 'yield':
+ case 'let':
+ return true;
+ }
+
+ if (strict && isStrictModeReservedWord(id)) {
+ return true;
+ }
+
+ return isFutureReservedWord(id);
+ }
+
+ // Return the next character and move forward.
+
+ function nextChar() {
+ return source[index++];
+ }
+
+ // 7.4 Comments
+
+ function skipComment() {
+ var ch, blockComment, lineComment;
+
+ blockComment = false;
+ lineComment = false;
+
+ while (index < length) {
+ ch = source[index];
+
+ if (lineComment) {
+ ch = nextChar();
+ if (isLineTerminator(ch)) {
+ lineComment = false;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ }
+ } else if (blockComment) {
+ if (isLineTerminator(ch)) {
+ if (ch === '\r' && source[index + 1] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ ++index;
+ lineStart = index;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ ch = nextChar();
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ if (ch === '*') {
+ ch = source[index];
+ if (ch === '/') {
+ ++index;
+ blockComment = false;
+ }
+ }
+ }
+ } else if (ch === '/') {
+ ch = source[index + 1];
+ if (ch === '/') {
+ index += 2;
+ lineComment = true;
+ } else if (ch === '*') {
+ index += 2;
+ blockComment = true;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ break;
+ }
+ } else if (isWhiteSpace(ch)) {
+ ++index;
+ } else if (isLineTerminator(ch)) {
+ ++index;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ } else {
+ break;
+ }
+ }
+ }
+
+ function scanHexEscape(prefix) {
+ var i, len, ch, code = 0;
+
+ len = (prefix === 'u') ? 4 : 2;
+ for (i = 0; i < len; ++i) {
+ if (index < length && isHexDigit(source[index])) {
+ ch = nextChar();
+ code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
+ } else {
+ return '';
+ }
+ }
+ return String.fromCharCode(code);
+ }
+
+ function scanIdentifier() {
+ var ch, start, id, restore;
+
+ ch = source[index];
+ if (!isIdentifierStart(ch)) {
+ return;
+ }
+
+ start = index;
+ if (ch === '\\') {
+ ++index;
+ if (source[index] !== 'u') {
+ return;
+ }
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ if (ch === '\\' || !isIdentifierStart(ch)) {
+ return;
+ }
+ id = ch;
+ } else {
+ index = restore;
+ id = 'u';
+ }
+ } else {
+ id = nextChar();
+ }
+
+ while (index < length) {
+ ch = source[index];
+ if (!isIdentifierPart(ch)) {
+ break;
+ }
+ if (ch === '\\') {
+ ++index;
+ if (source[index] !== 'u') {
+ return;
+ }
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ if (ch === '\\' || !isIdentifierPart(ch)) {
+ return;
+ }
+ id += ch;
+ } else {
+ index = restore;
+ id += 'u';
+ }
+ } else {
+ id += nextChar();
+ }
+ }
+
+ // There is no keyword or literal with only one character.
+ // Thus, it must be an identifier.
+ if (id.length === 1) {
+ return {
+ type: Token.Identifier,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (isKeyword(id)) {
+ return {
+ type: Token.Keyword,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.1 Null Literals
+
+ if (id === 'null') {
+ return {
+ type: Token.NullLiteral,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.2 Boolean Literals
+
+ if (id === 'true' || id === 'false') {
+ return {
+ type: Token.BooleanLiteral,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ return {
+ type: Token.Identifier,
+ value: id,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.7 Punctuators
+
+ function scanPunctuator() {
+ var start = index,
+ ch1 = source[index],
+ ch2,
+ ch3,
+ ch4;
+
+ // Check for most common single-character punctuators.
+
+ if (ch1 === ';' || ch1 === '{' || ch1 === '}') {
+ ++index;
+ return {
+ type: Token.Punctuator,
+ value: ch1,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === ',' || ch1 === '(' || ch1 === ')') {
+ ++index;
+ return {
+ type: Token.Punctuator,
+ value: ch1,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // Dot (.) can also start a floating-point number, hence the need
+ // to check the next character.
+
+ ch2 = source[index + 1];
+ if (ch1 === '.' && !isDecimalDigit(ch2)) {
+ return {
+ type: Token.Punctuator,
+ value: nextChar(),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // Peek more characters.
+
+ ch3 = source[index + 2];
+ ch4 = source[index + 3];
+
+ // 4-character punctuator: >>>=
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
+ if (ch4 === '=') {
+ index += 4;
+ return {
+ type: Token.Punctuator,
+ value: '>>>=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // 3-character punctuators: === !== >>> <<= >>=
+
+ if (ch1 === '=' && ch2 === '=' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '===',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '!' && ch2 === '=' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '!==',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '>') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '>>>',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '<' && ch2 === '<' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '<<=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ if (ch1 === '>' && ch2 === '>' && ch3 === '=') {
+ index += 3;
+ return {
+ type: Token.Punctuator,
+ value: '>>=',
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 2-character punctuators: <= >= == != ++ -- << >> && ||
+ // += -= *= %= &= |= ^= /=
+
+ if (ch2 === '=') {
+ if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
+ index += 2;
+ return {
+ type: Token.Punctuator,
+ value: ch1 + ch2,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ if (ch1 === ch2 && ('+-<>&|'.indexOf(ch1) >= 0)) {
+ if ('+-<>&|'.indexOf(ch2) >= 0) {
+ index += 2;
+ return {
+ type: Token.Punctuator,
+ value: ch1 + ch2,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // The remaining 1-character punctuators.
+
+ if ('[]<>+-*%&|^!~?:=/'.indexOf(ch1) >= 0) {
+ return {
+ type: Token.Punctuator,
+ value: nextChar(),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+ }
+
+ // 7.8.3 Numeric Literals
+
+ function scanNumericLiteral() {
+ var number, start, ch;
+
+ ch = source[index];
+ assert(isDecimalDigit(ch) || (ch === '.'),
+ 'Numeric literal must start with a decimal digit or a decimal point');
+
+ start = index;
+ number = '';
+ if (ch !== '.') {
+ number = nextChar();
+ ch = source[index];
+
+ // Hex number starts with '0x'.
+ // Octal number starts with '0'.
+ if (number === '0') {
+ if (ch === 'x' || ch === 'X') {
+ number += nextChar();
+ while (index < length) {
+ ch = source[index];
+ if (!isHexDigit(ch)) {
+ break;
+ }
+ number += nextChar();
+ }
+
+ if (number.length <= 2) {
+ // only 0x
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+ return {
+ type: Token.NumericLiteral,
+ value: parseInt(number, 16),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ } else if (isOctalDigit(ch)) {
+ number += nextChar();
+ while (index < length) {
+ ch = source[index];
+ if (!isOctalDigit(ch)) {
+ break;
+ }
+ number += nextChar();
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch) || isDecimalDigit(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+ return {
+ type: Token.NumericLiteral,
+ value: parseInt(number, 8),
+ octal: true,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // decimal number starts with '0' such as '09' is illegal.
+ if (isDecimalDigit(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += nextChar();
+ }
+ }
+
+ if (ch === '.') {
+ number += nextChar();
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += nextChar();
+ }
+ }
+
+ if (ch === 'e' || ch === 'E') {
+ number += nextChar();
+
+ ch = source[index];
+ if (ch === '+' || ch === '-') {
+ number += nextChar();
+ }
+
+ ch = source[index];
+ if (isDecimalDigit(ch)) {
+ number += nextChar();
+ while (index < length) {
+ ch = source[index];
+ if (!isDecimalDigit(ch)) {
+ break;
+ }
+ number += nextChar();
+ }
+ } else {
+ ch = 'character ' + ch;
+ if (index >= length) {
+ ch = '';
+ }
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ if (index < length) {
+ ch = source[index];
+ if (isIdentifierStart(ch)) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ }
+
+ return {
+ type: Token.NumericLiteral,
+ value: parseFloat(number),
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ // 7.8.4 String Literals
+
+ function scanStringLiteral() {
+ var str = '', quote, start, ch, code, unescaped, restore, octal = false;
+
+ quote = source[index];
+ assert((quote === '\'' || quote === '"'),
+ 'String literal must starts with a quote');
+
+ start = index;
+ ++index;
+
+ while (index < length) {
+ ch = nextChar();
+
+ if (ch === quote) {
+ quote = '';
+ break;
+ } else if (ch === '\\') {
+ ch = nextChar();
+ if (!isLineTerminator(ch)) {
+ switch (ch) {
+ case 'n':
+ str += '\n';
+ break;
+ case 'r':
+ str += '\r';
+ break;
+ case 't':
+ str += '\t';
+ break;
+ case 'u':
+ case 'x':
+ restore = index;
+ unescaped = scanHexEscape(ch);
+ if (unescaped) {
+ str += unescaped;
+ } else {
+ index = restore;
+ str += ch;
+ }
+ break;
+ case 'b':
+ str += '\b';
+ break;
+ case 'f':
+ str += '\f';
+ break;
+ case 'v':
+ str += '\v';
+ break;
+
+ default:
+ if (isOctalDigit(ch)) {
+ code = '01234567'.indexOf(ch);
+
+ // \0 is not octal escape sequence
+ if (code !== 0) {
+ octal = true;
+ }
+
+ if (index < length && isOctalDigit(source[index])) {
+ octal = true;
+ code = code * 8 + '01234567'.indexOf(nextChar());
+
+ // 3 digits are only allowed when string starts
+ // with 0, 1, 2, 3
+ if ('0123'.indexOf(ch) >= 0 &&
+ index < length &&
+ isOctalDigit(source[index])) {
+ code = code * 8 + '01234567'.indexOf(nextChar());
+ }
+ }
+ str += String.fromCharCode(code);
+ } else {
+ str += ch;
+ }
+ break;
+ }
+ } else {
+ ++lineNumber;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ }
+ } else if (isLineTerminator(ch)) {
+ break;
+ } else {
+ str += ch;
+ }
+ }
+
+ if (quote !== '') {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ return {
+ type: Token.StringLiteral,
+ value: str,
+ octal: octal,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [start, index]
+ };
+ }
+
+ function scanRegExp() {
+ var str = '', ch, start, pattern, flags, value, classMarker = false, restore;
+
+ buffer = null;
+ skipComment();
+
+ start = index;
+ ch = source[index];
+ assert(ch === '/', 'Regular expression literal must start with a slash');
+ str = nextChar();
+
+ while (index < length) {
+ ch = nextChar();
+ str += ch;
+ if (classMarker) {
+ if (ch === ']') {
+ classMarker = false;
+ }
+ } else {
+ if (ch === '\\') {
+ ch = nextChar();
+ // ECMA-262 7.8.5
+ if (isLineTerminator(ch)) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+ str += ch;
+ }
+ else if (ch === '/') {
+ break;
+ }
+ else if (ch === '[') {
+ classMarker = true;
+ }
+ else if (isLineTerminator(ch)) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+ }
+ }
+
+ if (str.length === 1) {
+ throwError({}, Messages.UnterminatedRegExp);
+ }
+
+ // Exclude leading and trailing slash.
+ pattern = str.substr(1, str.length - 2);
+
+ flags = '';
+ while (index < length) {
+ ch = source[index];
+ if (!isIdentifierPart(ch)) {
+ break;
+ }
+
+ ++index;
+ if (ch === '\\' && index < length) {
+ ch = source[index];
+ if (ch === 'u') {
+ ++index;
+ restore = index;
+ ch = scanHexEscape('u');
+ if (ch) {
+ flags += ch;
+ str += '\\u';
+ for (; restore < index; ++restore) {
+ str += source[restore];
+ }
+ } else {
+ index = restore;
+ flags += 'u';
+ str += '\\u';
+ }
+ } else {
+ str += '\\';
+ }
+ } else {
+ flags += ch;
+ str += ch;
+ }
+ }
+
+ try {
+ value = new RegExp(pattern, flags);
+ } catch (e) {
+ throwError({}, Messages.InvalidRegExp);
+ }
+
+ return {
+ literal: str,
+ value: value,
+ range: [start, index]
+ };
+ }
+
+ function isIdentifierName(token) {
+ return token.type === Token.Identifier ||
+ token.type === Token.Keyword ||
+ token.type === Token.BooleanLiteral ||
+ token.type === Token.NullLiteral;
+ }
+
+ function advance() {
+ var ch, token;
+
+ skipComment();
+
+ if (index >= length) {
+ return {
+ type: Token.EOF,
+ lineNumber: lineNumber,
+ lineStart: lineStart,
+ range: [index, index]
+ };
+ }
+
+ token = scanPunctuator();
+ if (typeof token !== 'undefined') {
+ return token;
+ }
+
+ ch = source[index];
+
+ if (ch === '\'' || ch === '"') {
+ return scanStringLiteral();
+ }
+
+ if (ch === '.' || isDecimalDigit(ch)) {
+ return scanNumericLiteral();
+ }
+
+ token = scanIdentifier();
+ if (typeof token !== 'undefined') {
+ return token;
+ }
+
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+
+ function lex() {
+ var token;
+
+ if (buffer) {
+ index = buffer.range[1];
+ lineNumber = buffer.lineNumber;
+ lineStart = buffer.lineStart;
+ token = buffer;
+ buffer = null;
+ return token;
+ }
+
+ buffer = null;
+ return advance();
+ }
+
+ function lookahead() {
+ var pos, line, start;
+
+ if (buffer !== null) {
+ return buffer;
+ }
+
+ pos = index;
+ line = lineNumber;
+ start = lineStart;
+ buffer = advance();
+ index = pos;
+ lineNumber = line;
+ lineStart = start;
+
+ return buffer;
+ }
+
+ // Return true if there is a line terminator before the next token.
+
+ function peekLineTerminator() {
+ var pos, line, start, found;
+
+ pos = index;
+ line = lineNumber;
+ start = lineStart;
+ skipComment();
+ found = lineNumber !== line;
+ index = pos;
+ lineNumber = line;
+ lineStart = start;
+
+ return found;
+ }
+
+ // Throw an exception
+
+ function throwError(token, messageFormat) {
+ var error,
+ args = Array.prototype.slice.call(arguments, 2),
+ msg = messageFormat.replace(
+ /%(\d)/g,
+ function (whole, index) {
+ return args[index] || '';
+ }
+ );
+
+ if (typeof token.lineNumber === 'number') {
+ error = new Error('Line ' + token.lineNumber + ': ' + msg);
+ error.index = token.range[0];
+ error.lineNumber = token.lineNumber;
+ error.column = token.range[0] - lineStart + 1;
+ } else {
+ error = new Error('Line ' + lineNumber + ': ' + msg);
+ error.index = index;
+ error.lineNumber = lineNumber;
+ error.column = index - lineStart + 1;
+ }
+
+ throw error;
+ }
+
+ function throwErrorTolerant() {
+ var error;
+ try {
+ throwError.apply(null, arguments);
+ } catch (e) {
+ if (extra.errors) {
+ extra.errors.push(e);
+ } else {
+ throw e;
+ }
+ }
+ }
+
+
+ // Throw an exception because of the token.
+
+ function throwUnexpected(token) {
+ var s;
+
+ if (token.type === Token.EOF) {
+ throwError(token, Messages.UnexpectedEOS);
+ }
+
+ if (token.type === Token.NumericLiteral) {
+ throwError(token, Messages.UnexpectedNumber);
+ }
+
+ if (token.type === Token.StringLiteral) {
+ throwError(token, Messages.UnexpectedString);
+ }
+
+ if (token.type === Token.Identifier) {
+ throwError(token, Messages.UnexpectedIdentifier);
+ }
+
+ if (token.type === Token.Keyword) {
+ if (isFutureReservedWord(token.value)) {
+ throwError(token, Messages.UnexpectedReserved);
+ } else if (strict && isStrictModeReservedWord(token.value)) {
+ throwError(token, Messages.StrictReservedWord);
+ }
+ throwError(token, Messages.UnexpectedToken, token.value);
+ }
+
+ // BooleanLiteral, NullLiteral, or Punctuator.
+ throwError(token, Messages.UnexpectedToken, token.value);
+ }
+
+ // Expect the next token to match the specified punctuator.
+ // If not, an exception will be thrown.
+
+ function expect(value) {
+ var token = lex();
+ if (token.type !== Token.Punctuator || token.value !== value) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Expect the next token to match the specified keyword.
+ // If not, an exception will be thrown.
+
+ function expectKeyword(keyword) {
+ var token = lex();
+ if (token.type !== Token.Keyword || token.value !== keyword) {
+ throwUnexpected(token);
+ }
+ }
+
+ // Return true if the next token matches the specified punctuator.
+
+ function match(value) {
+ var token = lookahead();
+ return token.type === Token.Punctuator && token.value === value;
+ }
+
+ // Return true if the next token matches the specified keyword
+
+ function matchKeyword(keyword) {
+ var token = lookahead();
+ return token.type === Token.Keyword && token.value === keyword;
+ }
+
+ // Return true if the next token is an assignment operator
+
+ function matchAssign() {
+ var token = lookahead(),
+ op = token.value;
+
+ if (token.type !== Token.Punctuator) {
+ return false;
+ }
+ return op === '=' ||
+ op === '*=' ||
+ op === '/=' ||
+ op === '%=' ||
+ op === '+=' ||
+ op === '-=' ||
+ op === '<<=' ||
+ op === '>>=' ||
+ op === '>>>=' ||
+ op === '&=' ||
+ op === '^=' ||
+ op === '|=';
+ }
+
+ function consumeSemicolon() {
+ var token, line;
+
+ // Catch the very common case first.
+ if (source[index] === ';') {
+ lex();
+ return;
+ }
+
+ line = lineNumber;
+ skipComment();
+ if (lineNumber !== line) {
+ return;
+ }
+
+ if (match(';')) {
+ lex();
+ return;
+ }
+
+ token = lookahead();
+ if (token.type !== Token.EOF && !match('}')) {
+ throwUnexpected(token);
+ }
+ return;
+ }
+
+ // Return true if provided expression is LeftHandSideExpression
+
+ function isLeftHandSide(expr) {
+ switch (expr.type) {
+ case 'AssignmentExpression':
+ case 'BinaryExpression':
+ case 'ConditionalExpression':
+ case 'LogicalExpression':
+ case 'SequenceExpression':
+ case 'UnaryExpression':
+ case 'UpdateExpression':
+ return false;
+ }
+ return true;
+ }
+
+ // 11.1.4 Array Initialiser
+
+ function parseArrayInitialiser() {
+ var elements = [],
+ undef;
+
+ expect('[');
+
+ while (!match(']')) {
+ if (match(',')) {
+ lex();
+ elements.push(undef);
+ } else {
+ elements.push(parseAssignmentExpression());
+
+ if (!match(']')) {
+ expect(',');
+ }
+ }
+ }
+
+ expect(']');
+
+ return {
+ type: Syntax.ArrayExpression,
+ elements: elements
+ };
+ }
+
+ // 11.1.5 Object Initialiser
+
+ function parsePropertyFunction(param, first) {
+ var previousStrict, body;
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (first && strict && isRestrictedWord(param[0].name)) {
+ throwError(first, Messages.StrictParamName);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionExpression,
+ id: null,
+ params: param,
+ body: body
+ };
+ }
+
+ function parseObjectPropertyKey() {
+ var token = lex();
+
+ // Note: This function is called only from parseObjectProperty(), where
+ // EOF and Punctuator tokens are already filtered out.
+
+ if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
+ if (strict && token.octal) {
+ throwError(token, Messages.StrictOctalLiteral);
+ }
+ return createLiteral(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseObjectProperty() {
+ var token, key, id, param;
+
+ token = lookahead();
+
+ if (token.type === Token.Identifier) {
+
+ id = parseObjectPropertyKey();
+
+ // Property Assignment: Getter and Setter.
+
+ if (token.value === 'get' && !match(':')) {
+ key = parseObjectPropertyKey();
+ expect('(');
+ expect(')');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction([]),
+ kind: 'get'
+ };
+ } else if (token.value === 'set' && !match(':')) {
+ key = parseObjectPropertyKey();
+ expect('(');
+ token = lookahead();
+ if (token.type !== Token.Identifier) {
+ throwUnexpected(lex());
+ }
+ param = [ parseVariableIdentifier() ];
+ expect(')');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parsePropertyFunction(param, token),
+ kind: 'set'
+ };
+ } else {
+ expect(':');
+ return {
+ type: Syntax.Property,
+ key: id,
+ value: parseAssignmentExpression(),
+ kind: 'init'
+ };
+ }
+ } else if (token.type === Token.EOF || token.type === Token.Punctuator) {
+ throwUnexpected(token);
+ } else {
+ key = parseObjectPropertyKey();
+ expect(':');
+ return {
+ type: Syntax.Property,
+ key: key,
+ value: parseAssignmentExpression(),
+ kind: 'init'
+ };
+ }
+ }
+
+ function parseObjectInitialiser() {
+ var token, properties = [], property, name, kind, map = {}, toString = String;
+
+ expect('{');
+
+ while (!match('}')) {
+ property = parseObjectProperty();
+
+ if (property.key.type === Syntax.Identifier) {
+ name = property.key.name;
+ } else {
+ name = toString(property.key.value);
+ }
+ kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
+ if (Object.prototype.hasOwnProperty.call(map, name)) {
+ if (map[name] === PropertyKind.Data) {
+ if (strict && kind === PropertyKind.Data) {
+ throwErrorTolerant({}, Messages.StrictDuplicateProperty);
+ } else if (kind !== PropertyKind.Data) {
+ throwError({}, Messages.AccessorDataProperty);
+ }
+ } else {
+ if (kind === PropertyKind.Data) {
+ throwError({}, Messages.AccessorDataProperty);
+ } else if (map[name] & kind) {
+ throwError({}, Messages.AccessorGetSet);
+ }
+ }
+ map[name] |= kind;
+ } else {
+ map[name] = kind;
+ }
+
+ properties.push(property);
+
+ if (!match('}')) {
+ expect(',');
+ }
+ }
+
+ expect('}');
+
+ return {
+ type: Syntax.ObjectExpression,
+ properties: properties
+ };
+ }
+
+ // 11.1 Primary Expressions
+
+ function parsePrimaryExpression() {
+ var expr,
+ token = lookahead(),
+ type = token.type;
+
+ if (type === Token.Identifier) {
+ return {
+ type: Syntax.Identifier,
+ name: lex().value
+ };
+ }
+
+ if (type === Token.StringLiteral || type === Token.NumericLiteral) {
+ if (strict && token.octal) {
+ throwErrorTolerant(token, Messages.StrictOctalLiteral);
+ }
+ return createLiteral(lex());
+ }
+
+ if (type === Token.Keyword) {
+ if (matchKeyword('this')) {
+ lex();
+ return {
+ type: Syntax.ThisExpression
+ };
+ }
+
+ if (matchKeyword('function')) {
+ return parseFunctionExpression();
+ }
+ }
+
+ if (type === Token.BooleanLiteral) {
+ lex();
+ token.value = (token.value === 'true');
+ return createLiteral(token);
+ }
+
+ if (type === Token.NullLiteral) {
+ lex();
+ token.value = null;
+ return createLiteral(token);
+ }
+
+ if (match('[')) {
+ return parseArrayInitialiser();
+ }
+
+ if (match('{')) {
+ return parseObjectInitialiser();
+ }
+
+ if (match('(')) {
+ lex();
+ state.lastParenthesized = expr = parseExpression();
+ expect(')');
+ return expr;
+ }
+
+ if (match('/') || match('/=')) {
+ return createLiteral(scanRegExp());
+ }
+
+ return throwUnexpected(lex());
+ }
+
+ // 11.2 Left-Hand-Side Expressions
+
+ function parseArguments() {
+ var args = [];
+
+ expect('(');
+
+ if (!match(')')) {
+ while (index < length) {
+ args.push(parseAssignmentExpression());
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ return args;
+ }
+
+ function parseNonComputedProperty() {
+ var token = lex();
+
+ if (!isIdentifierName(token)) {
+ throwUnexpected(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseNonComputedMember(object) {
+ return {
+ type: Syntax.MemberExpression,
+ computed: false,
+ object: object,
+ property: parseNonComputedProperty()
+ };
+ }
+
+ function parseComputedMember(object) {
+ var property, expr;
+
+ expect('[');
+ property = parseExpression();
+ expr = {
+ type: Syntax.MemberExpression,
+ computed: true,
+ object: object,
+ property: property
+ };
+ expect(']');
+ return expr;
+ }
+
+ function parseCallMember(object) {
+ return {
+ type: Syntax.CallExpression,
+ callee: object,
+ 'arguments': parseArguments()
+ };
+ }
+
+ function parseNewExpression() {
+ var expr;
+
+ expectKeyword('new');
+
+ expr = {
+ type: Syntax.NewExpression,
+ callee: parseLeftHandSideExpression(),
+ 'arguments': []
+ };
+
+ if (match('(')) {
+ expr['arguments'] = parseArguments();
+ }
+
+ return expr;
+ }
+
+ function parseLeftHandSideExpressionAllowCall() {
+ var useNew, expr;
+
+ useNew = matchKeyword('new');
+ expr = useNew ? parseNewExpression() : parsePrimaryExpression();
+
+ while (index < length) {
+ if (match('.')) {
+ lex();
+ expr = parseNonComputedMember(expr);
+ } else if (match('[')) {
+ expr = parseComputedMember(expr);
+ } else if (match('(')) {
+ expr = parseCallMember(expr);
+ } else {
+ break;
+ }
+ }
+
+ return expr;
+ }
+
+ function parseLeftHandSideExpression() {
+ var useNew, expr;
+
+ useNew = matchKeyword('new');
+ expr = useNew ? parseNewExpression() : parsePrimaryExpression();
+
+ while (index < length) {
+ if (match('.')) {
+ lex();
+ expr = parseNonComputedMember(expr);
+ } else if (match('[')) {
+ expr = parseComputedMember(expr);
+ } else {
+ break;
+ }
+ }
+
+ return expr;
+ }
+
+ // 11.3 Postfix Expressions
+
+ function parsePostfixExpression() {
+ var expr = parseLeftHandSideExpressionAllowCall();
+
+ if ((match('++') || match('--')) && !peekLineTerminator()) {
+ // 11.3.1, 11.3.2
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwError({}, Messages.StrictLHSPostfix);
+ }
+ expr = {
+ type: Syntax.UpdateExpression,
+ operator: lex().value,
+ argument: expr,
+ prefix: false
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.4 Unary Operators
+
+ function parseUnaryExpression() {
+ var token, expr;
+
+ if (match('++') || match('--')) {
+ token = lex();
+ expr = parseUnaryExpression();
+ // 11.4.4, 11.4.5
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwError({}, Messages.StrictLHSPrefix);
+ }
+ expr = {
+ type: Syntax.UpdateExpression,
+ operator: token.value,
+ argument: expr,
+ prefix: true
+ };
+ return expr;
+ }
+
+ if (match('+') || match('-') || match('~') || match('!')) {
+ expr = {
+ type: Syntax.UnaryExpression,
+ operator: lex().value,
+ argument: parseUnaryExpression()
+ };
+ return expr;
+ }
+
+ if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
+ expr = {
+ type: Syntax.UnaryExpression,
+ operator: lex().value,
+ argument: parseUnaryExpression()
+ };
+ if (strict && expr.operator === 'delete' && expr.argument.type === Syntax.Identifier) {
+ throwErrorTolerant({}, Messages.StrictDelete);
+ }
+ return expr;
+ }
+
+ return parsePostfixExpression();
+ }
+
+ // 11.5 Multiplicative Operators
+
+ function parseMultiplicativeExpression() {
+ var expr = parseUnaryExpression();
+
+ while (match('*') || match('/') || match('%')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseUnaryExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.6 Additive Operators
+
+ function parseAdditiveExpression() {
+ var expr = parseMultiplicativeExpression();
+
+ while (match('+') || match('-')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseMultiplicativeExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.7 Bitwise Shift Operators
+
+ function parseShiftExpression() {
+ var expr = parseAdditiveExpression();
+
+ while (match('<<') || match('>>') || match('>>>')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseAdditiveExpression()
+ };
+ }
+
+ return expr;
+ }
+ // 11.8 Relational Operators
+
+ function parseRelationalExpression() {
+ var expr, previousAllowIn;
+
+ previousAllowIn = state.allowIn;
+ state.allowIn = true;
+ expr = parseShiftExpression();
+ state.allowIn = previousAllowIn;
+
+ if (match('<') || match('>') || match('<=') || match('>=')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseRelationalExpression()
+ };
+ } else if (state.allowIn && matchKeyword('in')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: 'in',
+ left: expr,
+ right: parseRelationalExpression()
+ };
+ } else if (matchKeyword('instanceof')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: 'instanceof',
+ left: expr,
+ right: parseRelationalExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.9 Equality Operators
+
+ function parseEqualityExpression() {
+ var expr = parseRelationalExpression();
+
+ while (match('==') || match('!=') || match('===') || match('!==')) {
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseRelationalExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.10 Binary Bitwise Operators
+
+ function parseBitwiseANDExpression() {
+ var expr = parseEqualityExpression();
+
+ while (match('&')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '&',
+ left: expr,
+ right: parseEqualityExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseBitwiseORExpression() {
+ var expr = parseBitwiseANDExpression();
+
+ while (match('|')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '|',
+ left: expr,
+ right: parseBitwiseANDExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseBitwiseXORExpression() {
+ var expr = parseBitwiseORExpression();
+
+ while (match('^')) {
+ lex();
+ expr = {
+ type: Syntax.BinaryExpression,
+ operator: '^',
+ left: expr,
+ right: parseBitwiseORExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.11 Binary Logical Operators
+
+ function parseLogicalANDExpression() {
+ var expr = parseBitwiseXORExpression();
+
+ while (match('&&')) {
+ lex();
+ expr = {
+ type: Syntax.LogicalExpression,
+ operator: '&&',
+ left: expr,
+ right: parseBitwiseXORExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ function parseLogicalORExpression() {
+ var expr = parseLogicalANDExpression();
+
+ while (match('||')) {
+ lex();
+ expr = {
+ type: Syntax.LogicalExpression,
+ operator: '||',
+ left: expr,
+ right: parseLogicalANDExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.12 Conditional Operator
+
+ function parseConditionalExpression() {
+ var expr, previousAllowIn, consequent;
+
+ expr = parseLogicalORExpression();
+
+ if (match('?')) {
+ lex();
+ previousAllowIn = state.allowIn;
+ state.allowIn = true;
+ consequent = parseAssignmentExpression();
+ state.allowIn = previousAllowIn;
+ expect(':');
+
+ expr = {
+ type: Syntax.ConditionalExpression,
+ test: expr,
+ consequent: consequent,
+ alternate: parseAssignmentExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.13 Assignment Operators
+
+ function parseAssignmentExpression() {
+ var expr;
+
+ expr = parseConditionalExpression();
+
+ if (matchAssign()) {
+ // LeftHandSideExpression
+ if (state.lastParenthesized !== expr && !isLeftHandSide(expr)) {
+ throwError({}, Messages.InvalidLHSInAssignment);
+ }
+
+ // 11.13.1
+ if (strict && expr.type === Syntax.Identifier && isRestrictedWord(expr.name)) {
+ throwError({}, Messages.StrictLHSAssignment);
+ }
+
+ expr = {
+ type: Syntax.AssignmentExpression,
+ operator: lex().value,
+ left: expr,
+ right: parseAssignmentExpression()
+ };
+ }
+
+ return expr;
+ }
+
+ // 11.14 Comma Operator
+
+ function parseExpression() {
+ var expr = parseAssignmentExpression();
+
+ if (match(',')) {
+ expr = {
+ type: Syntax.SequenceExpression,
+ expressions: [ expr ]
+ };
+
+ while (index < length) {
+ if (!match(',')) {
+ break;
+ }
+ lex();
+ expr.expressions.push(parseAssignmentExpression());
+ }
+
+ }
+ return expr;
+ }
+
+ // 12.1 Block
+
+ function parseStatementList() {
+ var list = [],
+ statement;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ statement = parseSourceElement();
+ if (typeof statement === 'undefined') {
+ break;
+ }
+ list.push(statement);
+ }
+
+ return list;
+ }
+
+ function parseBlock() {
+ var block;
+
+ expect('{');
+
+ block = parseStatementList();
+
+ expect('}');
+
+ return {
+ type: Syntax.BlockStatement,
+ body: block
+ };
+ }
+
+ // 12.2 Variable Statement
+
+ function parseVariableIdentifier() {
+ var token = lex();
+
+ if (token.type !== Token.Identifier) {
+ throwUnexpected(token);
+ }
+
+ return {
+ type: Syntax.Identifier,
+ name: token.value
+ };
+ }
+
+ function parseVariableDeclaration(kind) {
+ var id = parseVariableIdentifier(),
+ init = null;
+
+ // 12.2.1
+ if (strict && isRestrictedWord(id.name)) {
+ throwErrorTolerant({}, Messages.StrictVarName);
+ }
+
+ if (kind === 'const') {
+ expect('=');
+ init = parseAssignmentExpression();
+ } else if (match('=')) {
+ lex();
+ init = parseAssignmentExpression();
+ }
+
+ return {
+ type: Syntax.VariableDeclarator,
+ id: id,
+ init: init
+ };
+ }
+
+ function parseVariableDeclarationList(kind) {
+ var list = [];
+
+ while (index < length) {
+ list.push(parseVariableDeclaration(kind));
+ if (!match(',')) {
+ break;
+ }
+ lex();
+ }
+
+ return list;
+ }
+
+ function parseVariableStatement() {
+ var declarations;
+
+ expectKeyword('var');
+
+ declarations = parseVariableDeclarationList();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: declarations,
+ kind: 'var'
+ };
+ }
+
+ // kind may be `const` or `let`
+ // Both are experimental and not in the specification yet.
+ // see http://wiki.ecmascript.org/doku.php?id=harmony:const
+ // and http://wiki.ecmascript.org/doku.php?id=harmony:let
+ function parseConstLetDeclaration(kind) {
+ var declarations;
+
+ expectKeyword(kind);
+
+ declarations = parseVariableDeclarationList(kind);
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: declarations,
+ kind: kind
+ };
+ }
+
+ // 12.3 Empty Statement
+
+ function parseEmptyStatement() {
+ expect(';');
+
+ return {
+ type: Syntax.EmptyStatement
+ };
+ }
+
+ // 12.4 Expression Statement
+
+ function parseExpressionStatement() {
+ var expr = parseExpression();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ExpressionStatement,
+ expression: expr
+ };
+ }
+
+ // 12.5 If statement
+
+ function parseIfStatement() {
+ var test, consequent, alternate;
+
+ expectKeyword('if');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ consequent = parseStatement();
+
+ if (matchKeyword('else')) {
+ lex();
+ alternate = parseStatement();
+ } else {
+ alternate = null;
+ }
+
+ return {
+ type: Syntax.IfStatement,
+ test: test,
+ consequent: consequent,
+ alternate: alternate
+ };
+ }
+
+ // 12.6 Iteration Statements
+
+ function parseDoWhileStatement() {
+ var body, test, oldInIteration;
+
+ expectKeyword('do');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ expectKeyword('while');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ if (match(';')) {
+ lex();
+ }
+
+ return {
+ type: Syntax.DoWhileStatement,
+ body: body,
+ test: test
+ };
+ }
+
+ function parseWhileStatement() {
+ var test, body, oldInIteration;
+
+ expectKeyword('while');
+
+ expect('(');
+
+ test = parseExpression();
+
+ expect(')');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ return {
+ type: Syntax.WhileStatement,
+ test: test,
+ body: body
+ };
+ }
+
+ function parseForVariableDeclaration() {
+ var token = lex();
+
+ return {
+ type: Syntax.VariableDeclaration,
+ declarations: parseVariableDeclarationList(),
+ kind: token.value
+ };
+ }
+
+ function parseForStatement() {
+ var init, test, update, left, right, body, oldInIteration;
+
+ init = test = update = null;
+
+ expectKeyword('for');
+
+ expect('(');
+
+ if (match(';')) {
+ lex();
+ } else {
+ if (matchKeyword('var') || matchKeyword('let')) {
+ state.allowIn = false;
+ init = parseForVariableDeclaration();
+ state.allowIn = true;
+
+ if (init.declarations.length === 1 && matchKeyword('in')) {
+ lex();
+ left = init;
+ right = parseExpression();
+ init = null;
+ }
+ } else {
+ state.allowIn = false;
+ init = parseExpression();
+ state.allowIn = true;
+
+ if (matchKeyword('in')) {
+ // LeftHandSideExpression
+ if (matchKeyword('in') && (state.lastParenthesized !== init && !isLeftHandSide(init))) {
+ throwError({}, Messages.InvalidLHSInForIn);
+ }
+ lex();
+ left = init;
+ right = parseExpression();
+ init = null;
+ }
+ }
+
+ if (typeof left === 'undefined') {
+ expect(';');
+ }
+ }
+
+ if (typeof left === 'undefined') {
+
+ if (!match(';')) {
+ test = parseExpression();
+ }
+ expect(';');
+
+ if (!match(')')) {
+ update = parseExpression();
+ }
+ }
+
+ expect(')');
+
+ oldInIteration = state.inIteration;
+ state.inIteration = true;
+
+ body = parseStatement();
+
+ state.inIteration = oldInIteration;
+
+ if (typeof left === 'undefined') {
+ return {
+ type: Syntax.ForStatement,
+ init: init,
+ test: test,
+ update: update,
+ body: body
+ };
+ }
+
+ return {
+ type: Syntax.ForInStatement,
+ left: left,
+ right: right,
+ body: body,
+ each: false
+ };
+ }
+
+ // 12.7 The continue statement
+
+ function parseContinueStatement() {
+ var token, label = null;
+
+ expectKeyword('continue');
+
+ // Optimize the most common form: 'continue;'.
+ if (source[index] === ';') {
+ lex();
+
+ if (!state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: null
+ };
+ }
+
+ if (peekLineTerminator()) {
+ if (!state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: null
+ };
+ }
+
+ token = lookahead();
+ if (token.type === Token.Identifier) {
+ label = parseVariableIdentifier();
+
+ if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
+ throwError({}, Messages.UnknownLabel, label.name);
+ }
+ }
+
+ consumeSemicolon();
+
+ if (label === null && !state.inIteration) {
+ throwError({}, Messages.IllegalContinue);
+ }
+
+ return {
+ type: Syntax.ContinueStatement,
+ label: label
+ };
+ }
+
+ // 12.8 The break statement
+
+ function parseBreakStatement() {
+ var token, label = null;
+
+ expectKeyword('break');
+
+ // Optimize the most common form: 'break;'.
+ if (source[index] === ';') {
+ lex();
+
+ if (!(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: null
+ };
+ }
+
+ if (peekLineTerminator()) {
+ if (!(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: null
+ };
+ }
+
+ token = lookahead();
+ if (token.type === Token.Identifier) {
+ label = parseVariableIdentifier();
+
+ if (!Object.prototype.hasOwnProperty.call(state.labelSet, label.name)) {
+ throwError({}, Messages.UnknownLabel, label.name);
+ }
+ }
+
+ consumeSemicolon();
+
+ if (label === null && !(state.inIteration || state.inSwitch)) {
+ throwError({}, Messages.IllegalBreak);
+ }
+
+ return {
+ type: Syntax.BreakStatement,
+ label: label
+ };
+ }
+
+ // 12.9 The return statement
+
+ function parseReturnStatement() {
+ var token, argument = null;
+
+ expectKeyword('return');
+
+ if (!state.inFunctionBody) {
+ throwErrorTolerant({}, Messages.IllegalReturn);
+ }
+
+ // 'return' followed by a space and an identifier is very common.
+ if (source[index] === ' ') {
+ if (isIdentifierStart(source[index + 1])) {
+ argument = parseExpression();
+ consumeSemicolon();
+ return {
+ type: Syntax.ReturnStatement,
+ argument: argument
+ };
+ }
+ }
+
+ if (peekLineTerminator()) {
+ return {
+ type: Syntax.ReturnStatement,
+ argument: null
+ };
+ }
+
+ if (!match(';')) {
+ token = lookahead();
+ if (!match('}') && token.type !== Token.EOF) {
+ argument = parseExpression();
+ }
+ }
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ReturnStatement,
+ argument: argument
+ };
+ }
+
+ // 12.10 The with statement
+
+ function parseWithStatement() {
+ var object, body;
+
+ if (strict) {
+ throwErrorTolerant({}, Messages.StrictModeWith);
+ }
+
+ expectKeyword('with');
+
+ expect('(');
+
+ object = parseExpression();
+
+ expect(')');
+
+ body = parseStatement();
+
+ return {
+ type: Syntax.WithStatement,
+ object: object,
+ body: body
+ };
+ }
+
+ // 12.10 The swith statement
+
+ function parseSwitchCase() {
+ var test,
+ consequent = [],
+ statement;
+
+ if (matchKeyword('default')) {
+ lex();
+ test = null;
+ } else {
+ expectKeyword('case');
+ test = parseExpression();
+ }
+ expect(':');
+
+ while (index < length) {
+ if (match('}') || matchKeyword('default') || matchKeyword('case')) {
+ break;
+ }
+ statement = parseStatement();
+ if (typeof statement === 'undefined') {
+ break;
+ }
+ consequent.push(statement);
+ }
+
+ return {
+ type: Syntax.SwitchCase,
+ test: test,
+ consequent: consequent
+ };
+ }
+
+ function parseSwitchStatement() {
+ var discriminant, cases, oldInSwitch;
+
+ expectKeyword('switch');
+
+ expect('(');
+
+ discriminant = parseExpression();
+
+ expect(')');
+
+ expect('{');
+
+ if (match('}')) {
+ lex();
+ return {
+ type: Syntax.SwitchStatement,
+ discriminant: discriminant
+ };
+ }
+
+ cases = [];
+
+ oldInSwitch = state.inSwitch;
+ state.inSwitch = true;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ cases.push(parseSwitchCase());
+ }
+
+ state.inSwitch = oldInSwitch;
+
+ expect('}');
+
+ return {
+ type: Syntax.SwitchStatement,
+ discriminant: discriminant,
+ cases: cases
+ };
+ }
+
+ // 12.13 The throw statement
+
+ function parseThrowStatement() {
+ var argument;
+
+ expectKeyword('throw');
+
+ if (peekLineTerminator()) {
+ throwError({}, Messages.NewlineAfterThrow);
+ }
+
+ argument = parseExpression();
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ThrowStatement,
+ argument: argument
+ };
+ }
+
+ // 12.14 The try statement
+
+ function parseCatchClause() {
+ var param;
+
+ expectKeyword('catch');
+
+ expect('(');
+ if (!match(')')) {
+ param = parseExpression();
+ // 12.14.1
+ if (strict && param.type === Syntax.Identifier && isRestrictedWord(param.name)) {
+ throwErrorTolerant({}, Messages.StrictCatchVariable);
+ }
+ }
+ expect(')');
+
+ return {
+ type: Syntax.CatchClause,
+ param: param,
+ guard: null,
+ body: parseBlock()
+ };
+ }
+
+ function parseTryStatement() {
+ var block, handlers = [], finalizer = null;
+
+ expectKeyword('try');
+
+ block = parseBlock();
+
+ if (matchKeyword('catch')) {
+ handlers.push(parseCatchClause());
+ }
+
+ if (matchKeyword('finally')) {
+ lex();
+ finalizer = parseBlock();
+ }
+
+ if (handlers.length === 0 && !finalizer) {
+ throwError({}, Messages.NoCatchOrFinally);
+ }
+
+ return {
+ type: Syntax.TryStatement,
+ block: block,
+ handlers: handlers,
+ finalizer: finalizer
+ };
+ }
+
+ // 12.15 The debugger statement
+
+ function parseDebuggerStatement() {
+ expectKeyword('debugger');
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.DebuggerStatement
+ };
+ }
+
+ // 12 Statements
+
+ function parseStatement() {
+ var token = lookahead(),
+ expr,
+ labeledBody;
+
+ if (token.type === Token.EOF) {
+ throwUnexpected(token);
+ }
+
+ if (token.type === Token.Punctuator) {
+ switch (token.value) {
+ case ';':
+ return parseEmptyStatement();
+ case '{':
+ return parseBlock();
+ case '(':
+ return parseExpressionStatement();
+ default:
+ break;
+ }
+ }
+
+ if (token.type === Token.Keyword) {
+ switch (token.value) {
+ case 'break':
+ return parseBreakStatement();
+ case 'continue':
+ return parseContinueStatement();
+ case 'debugger':
+ return parseDebuggerStatement();
+ case 'do':
+ return parseDoWhileStatement();
+ case 'for':
+ return parseForStatement();
+ case 'function':
+ return parseFunctionDeclaration();
+ case 'if':
+ return parseIfStatement();
+ case 'return':
+ return parseReturnStatement();
+ case 'switch':
+ return parseSwitchStatement();
+ case 'throw':
+ return parseThrowStatement();
+ case 'try':
+ return parseTryStatement();
+ case 'var':
+ return parseVariableStatement();
+ case 'while':
+ return parseWhileStatement();
+ case 'with':
+ return parseWithStatement();
+ default:
+ break;
+ }
+ }
+
+ expr = parseExpression();
+
+ // 12.12 Labelled Statements
+ if ((expr.type === Syntax.Identifier) && match(':')) {
+ lex();
+
+ if (Object.prototype.hasOwnProperty.call(state.labelSet, expr.name)) {
+ throwError({}, Messages.Redeclaration, 'Label', expr.name);
+ }
+
+ state.labelSet[expr.name] = true;
+ labeledBody = parseStatement();
+ delete state.labelSet[expr.name];
+
+ return {
+ type: Syntax.LabeledStatement,
+ label: expr,
+ body: labeledBody
+ };
+ }
+
+ consumeSemicolon();
+
+ return {
+ type: Syntax.ExpressionStatement,
+ expression: expr
+ };
+ }
+
+ // 13 Function Definition
+
+ function parseFunctionSourceElements() {
+ var sourceElement, sourceElements = [], token, directive, firstRestricted,
+ oldLabelSet, oldInIteration, oldInSwitch, oldInFunctionBody;
+
+ expect('{');
+
+ while (index < length) {
+ token = lookahead();
+ if (token.type !== Token.StringLiteral) {
+ break;
+ }
+
+ sourceElement = parseSourceElement();
+ sourceElements.push(sourceElement);
+ if (sourceElement.expression.type !== Syntax.Literal) {
+ // this is not directive
+ break;
+ }
+ directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
+ if (directive === 'use strict') {
+ strict = true;
+ if (firstRestricted) {
+ throwError(firstRestricted, Messages.StrictOctalLiteral);
+ }
+ } else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+
+ oldLabelSet = state.labelSet;
+ oldInIteration = state.inIteration;
+ oldInSwitch = state.inSwitch;
+ oldInFunctionBody = state.inFunctionBody;
+
+ state.labelSet = {};
+ state.inIteration = false;
+ state.inSwitch = false;
+ state.inFunctionBody = true;
+
+ while (index < length) {
+ if (match('}')) {
+ break;
+ }
+ sourceElement = parseSourceElement();
+ if (typeof sourceElement === 'undefined') {
+ break;
+ }
+ sourceElements.push(sourceElement);
+ }
+
+ expect('}');
+
+ state.labelSet = oldLabelSet;
+ state.inIteration = oldInIteration;
+ state.inSwitch = oldInSwitch;
+ state.inFunctionBody = oldInFunctionBody;
+
+ return {
+ type: Syntax.BlockStatement,
+ body: sourceElements
+ };
+ }
+
+ function parseFunctionDeclaration() {
+ var id, param, params = [], body, token, firstRestricted, message, previousStrict, paramSet;
+
+ expectKeyword('function');
+ token = lookahead();
+ id = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwError(token, Messages.StrictFunctionName);
+ }
+ } else {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictFunctionName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ }
+ }
+
+ expect('(');
+
+ if (!match(')')) {
+ paramSet = {};
+ while (index < length) {
+ token = lookahead();
+ param = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwError(token, Messages.StrictParamName);
+ }
+ if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ throwError(token, Messages.StrictParamDupe);
+ }
+ } else if (!firstRestricted) {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ }
+ params.push(param);
+ paramSet[param.name] = true;
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (strict && firstRestricted) {
+ throwError(firstRestricted, message);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionDeclaration,
+ id: id,
+ params: params,
+ body: body
+ };
+ }
+
+ function parseFunctionExpression() {
+ var token, id = null, firstRestricted, message, param, params = [], body, previousStrict, paramSet;
+
+ expectKeyword('function');
+
+ if (!match('(')) {
+ token = lookahead();
+ id = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwError(token, Messages.StrictFunctionName);
+ }
+ } else {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictFunctionName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ }
+ }
+ }
+
+ expect('(');
+
+ if (!match(')')) {
+ paramSet = {};
+ while (index < length) {
+ token = lookahead();
+ param = parseVariableIdentifier();
+ if (strict) {
+ if (isRestrictedWord(token.value)) {
+ throwError(token, Messages.StrictParamName);
+ }
+ if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ throwError(token, Messages.StrictParamDupe);
+ }
+ } else if (!firstRestricted) {
+ if (isRestrictedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamName;
+ } else if (isStrictModeReservedWord(token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictReservedWord;
+ } else if (Object.prototype.hasOwnProperty.call(paramSet, token.value)) {
+ firstRestricted = token;
+ message = Messages.StrictParamDupe;
+ }
+ }
+ params.push(param);
+ paramSet[param.name] = true;
+ if (match(')')) {
+ break;
+ }
+ expect(',');
+ }
+ }
+
+ expect(')');
+
+ previousStrict = strict;
+ body = parseFunctionSourceElements();
+ if (strict && firstRestricted) {
+ throwError(firstRestricted, message);
+ }
+ strict = previousStrict;
+
+ return {
+ type: Syntax.FunctionExpression,
+ id: id,
+ params: params,
+ body: body
+ };
+ }
+
+ // 14 Program
+
+ function parseSourceElement() {
+ var token = lookahead();
+
+ if (token.type === Token.Keyword) {
+ switch (token.value) {
+ case 'const':
+ case 'let':
+ return parseConstLetDeclaration(token.value);
+ case 'function':
+ return parseFunctionDeclaration();
+ default:
+ return parseStatement();
+ }
+ }
+
+ if (token.type !== Token.EOF) {
+ return parseStatement();
+ }
+ }
+
+ function parseSourceElements() {
+ var sourceElement, sourceElements = [], token, directive, firstRestricted;
+
+ while (index < length) {
+ token = lookahead();
+ if (token.type !== Token.StringLiteral) {
+ break;
+ }
+
+ sourceElement = parseSourceElement();
+ sourceElements.push(sourceElement);
+ if (sourceElement.expression.type !== Syntax.Literal) {
+ // this is not directive
+ break;
+ }
+ directive = sliceSource(token.range[0] + 1, token.range[1] - 1);
+ if (directive === 'use strict') {
+ strict = true;
+ if (firstRestricted) {
+ throwError(firstRestricted, Messages.StrictOctalLiteral);
+ }
+ } else {
+ if (!firstRestricted && token.octal) {
+ firstRestricted = token;
+ }
+ }
+ }
+
+ while (index < length) {
+ sourceElement = parseSourceElement();
+ if (typeof sourceElement === 'undefined') {
+ break;
+ }
+ sourceElements.push(sourceElement);
+ }
+ return sourceElements;
+ }
+
+ function parseProgram() {
+ var program;
+ strict = false;
+ program = {
+ type: Syntax.Program,
+ body: parseSourceElements()
+ };
+ return program;
+ }
+
+ // The following functions are needed only when the option to preserve
+ // the comments is active.
+
+ function addComment(start, end, type, value) {
+ assert(typeof start === 'number', 'Comment must have valid position');
+
+ // Because the way the actual token is scanned, often the comments
+ // (if any) are skipped twice during the lexical analysis.
+ // Thus, we need to skip adding a comment if the comment array already
+ // handled it.
+ if (extra.comments.length > 0) {
+ if (extra.comments[extra.comments.length - 1].range[1] > start) {
+ return;
+ }
+ }
+
+ extra.comments.push({
+ range: [start, end],
+ type: type,
+ value: value
+ });
+ }
+
+ function scanComment() {
+ var comment, ch, start, blockComment, lineComment;
+
+ comment = '';
+ blockComment = false;
+ lineComment = false;
+
+ while (index < length) {
+ ch = source[index];
+
+ if (lineComment) {
+ ch = nextChar();
+ if (index >= length) {
+ lineComment = false;
+ comment += ch;
+ addComment(start, index, 'Line', comment);
+ } else if (isLineTerminator(ch)) {
+ lineComment = false;
+ addComment(start, index, 'Line', comment);
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ comment = '';
+ } else {
+ comment += ch;
+ }
+ } else if (blockComment) {
+ if (isLineTerminator(ch)) {
+ if (ch === '\r' && source[index + 1] === '\n') {
+ ++index;
+ comment += '\r\n';
+ } else {
+ comment += ch;
+ }
+ ++lineNumber;
+ ++index;
+ lineStart = index;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ ch = nextChar();
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ comment += ch;
+ if (ch === '*') {
+ ch = source[index];
+ if (ch === '/') {
+ comment = comment.substr(0, comment.length - 1);
+ blockComment = false;
+ ++index;
+ addComment(start, index, 'Block', comment);
+ comment = '';
+ }
+ }
+ }
+ } else if (ch === '/') {
+ ch = source[index + 1];
+ if (ch === '/') {
+ start = index;
+ index += 2;
+ lineComment = true;
+ } else if (ch === '*') {
+ start = index;
+ index += 2;
+ blockComment = true;
+ if (index >= length) {
+ throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+ }
+ } else {
+ break;
+ }
+ } else if (isWhiteSpace(ch)) {
+ ++index;
+ } else if (isLineTerminator(ch)) {
+ ++index;
+ if (ch === '\r' && source[index] === '\n') {
+ ++index;
+ }
+ ++lineNumber;
+ lineStart = index;
+ } else {
+ break;
+ }
+ }
+ }
+
+ function collectToken() {
+ var token = extra.advance(),
+ range,
+ value;
+
+ if (token.type !== Token.EOF) {
+ range = [token.range[0], token.range[1]];
+ value = sliceSource(token.range[0], token.range[1]);
+ extra.tokens.push({
+ type: TokenName[token.type],
+ value: value,
+ range: range
+ });
+ }
+
+ return token;
+ }
+
+ function collectRegex() {
+ var pos, regex, token;
+
+ skipComment();
+
+ pos = index;
+ regex = extra.scanRegExp();
+
+ // Pop the previous token, which is likely '/' or '/='
+ if (extra.tokens.length > 0) {
+ token = extra.tokens[extra.tokens.length - 1];
+ if (token.range[0] === pos && token.type === 'Punctuator') {
+ if (token.value === '/' || token.value === '/=') {
+ extra.tokens.pop();
+ }
+ }
+ }
+
+ extra.tokens.push({
+ type: 'RegularExpression',
+ value: regex.literal,
+ range: [pos, index]
+ });
+
+ return regex;
+ }
+
+ function createLiteral(token) {
+ return {
+ type: Syntax.Literal,
+ value: token.value
+ };
+ }
+
+ function createRawLiteral(token) {
+ return {
+ type: Syntax.Literal,
+ value: token.value,
+ raw: sliceSource(token.range[0], token.range[1])
+ };
+ }
+
+ function wrapTrackingFunction(range, loc) {
+
+ return function (parseFunction) {
+
+ function isBinary(node) {
+ return node.type === Syntax.LogicalExpression ||
+ node.type === Syntax.BinaryExpression;
+ }
+
+ function visit(node) {
+ if (isBinary(node.left)) {
+ visit(node.left);
+ }
+ if (isBinary(node.right)) {
+ visit(node.right);
+ }
+
+ if (range && typeof node.range === 'undefined') {
+ node.range = [node.left.range[0], node.right.range[1]];
+ }
+ if (loc && typeof node.loc === 'undefined') {
+ node.loc = {
+ start: node.left.loc.start,
+ end: node.right.loc.end
+ };
+ }
+ }
+
+ return function () {
+ var node, rangeInfo, locInfo;
+
+ skipComment();
+ rangeInfo = [index, 0];
+ locInfo = {
+ start: {
+ line: lineNumber,
+ column: index - lineStart
+ }
+ };
+
+ node = parseFunction.apply(null, arguments);
+ if (typeof node !== 'undefined') {
+
+ if (range) {
+ rangeInfo[1] = index;
+ node.range = rangeInfo;
+ }
+
+ if (loc) {
+ locInfo.end = {
+ line: lineNumber,
+ column: index - lineStart
+ };
+ node.loc = locInfo;
+ }
+
+ if (isBinary(node)) {
+ visit(node);
+ }
+
+ if (node.type === Syntax.MemberExpression) {
+ if (typeof node.object.range !== 'undefined') {
+ node.range[0] = node.object.range[0];
+ }
+ if (typeof node.object.loc !== 'undefined') {
+ node.loc.start = node.object.loc.start;
+ }
+ }
+ return node;
+ }
+ };
+
+ };
+ }
+
+ function patch() {
+
+ var wrapTracking;
+
+ if (extra.comments) {
+ extra.skipComment = skipComment;
+ skipComment = scanComment;
+ }
+
+ if (extra.raw) {
+ extra.createLiteral = createLiteral;
+ createLiteral = createRawLiteral;
+ }
+
+ if (extra.range || extra.loc) {
+
+ wrapTracking = wrapTrackingFunction(extra.range, extra.loc);
+
+ extra.parseAdditiveExpression = parseAdditiveExpression;
+ extra.parseAssignmentExpression = parseAssignmentExpression;
+ extra.parseBitwiseANDExpression = parseBitwiseANDExpression;
+ extra.parseBitwiseORExpression = parseBitwiseORExpression;
+ extra.parseBitwiseXORExpression = parseBitwiseXORExpression;
+ extra.parseBlock = parseBlock;
+ extra.parseFunctionSourceElements = parseFunctionSourceElements;
+ extra.parseCallMember = parseCallMember;
+ extra.parseCatchClause = parseCatchClause;
+ extra.parseComputedMember = parseComputedMember;
+ extra.parseConditionalExpression = parseConditionalExpression;
+ extra.parseConstLetDeclaration = parseConstLetDeclaration;
+ extra.parseEqualityExpression = parseEqualityExpression;
+ extra.parseExpression = parseExpression;
+ extra.parseForVariableDeclaration = parseForVariableDeclaration;
+ extra.parseFunctionDeclaration = parseFunctionDeclaration;
+ extra.parseFunctionExpression = parseFunctionExpression;
+ extra.parseLogicalANDExpression = parseLogicalANDExpression;
+ extra.parseLogicalORExpression = parseLogicalORExpression;
+ extra.parseMultiplicativeExpression = parseMultiplicativeExpression;
+ extra.parseNewExpression = parseNewExpression;
+ extra.parseNonComputedMember = parseNonComputedMember;
+ extra.parseNonComputedProperty = parseNonComputedProperty;
+ extra.parseObjectProperty = parseObjectProperty;
+ extra.parseObjectPropertyKey = parseObjectPropertyKey;
+ extra.parsePostfixExpression = parsePostfixExpression;
+ extra.parsePrimaryExpression = parsePrimaryExpression;
+ extra.parseProgram = parseProgram;
+ extra.parsePropertyFunction = parsePropertyFunction;
+ extra.parseRelationalExpression = parseRelationalExpression;
+ extra.parseStatement = parseStatement;
+ extra.parseShiftExpression = parseShiftExpression;
+ extra.parseSwitchCase = parseSwitchCase;
+ extra.parseUnaryExpression = parseUnaryExpression;
+ extra.parseVariableDeclaration = parseVariableDeclaration;
+ extra.parseVariableIdentifier = parseVariableIdentifier;
+
+ parseAdditiveExpression = wrapTracking(extra.parseAdditiveExpression);
+ parseAssignmentExpression = wrapTracking(extra.parseAssignmentExpression);
+ parseBitwiseANDExpression = wrapTracking(extra.parseBitwiseANDExpression);
+ parseBitwiseORExpression = wrapTracking(extra.parseBitwiseORExpression);
+ parseBitwiseXORExpression = wrapTracking(extra.parseBitwiseXORExpression);
+ parseBlock = wrapTracking(extra.parseBlock);
+ parseFunctionSourceElements = wrapTracking(extra.parseFunctionSourceElements);
+ parseCallMember = wrapTracking(extra.parseCallMember);
+ parseCatchClause = wrapTracking(extra.parseCatchClause);
+ parseComputedMember = wrapTracking(extra.parseComputedMember);
+ parseConditionalExpression = wrapTracking(extra.parseConditionalExpression);
+ parseConstLetDeclaration = wrapTracking(extra.parseConstLetDeclaration);
+ parseEqualityExpression = wrapTracking(extra.parseEqualityExpression);
+ parseExpression = wrapTracking(extra.parseExpression);
+ parseForVariableDeclaration = wrapTracking(extra.parseForVariableDeclaration);
+ parseFunctionDeclaration = wrapTracking(extra.parseFunctionDeclaration);
+ parseFunctionExpression = wrapTracking(extra.parseFunctionExpression);
+ parseLogicalANDExpression = wrapTracking(extra.parseLogicalANDExpression);
+ parseLogicalORExpression = wrapTracking(extra.parseLogicalORExpression);
+ parseMultiplicativeExpression = wrapTracking(extra.parseMultiplicativeExpression);
+ parseNewExpression = wrapTracking(extra.parseNewExpression);
+ parseNonComputedMember = wrapTracking(extra.parseNonComputedMember);
+ parseNonComputedProperty = wrapTracking(extra.parseNonComputedProperty);
+ parseObjectProperty = wrapTracking(extra.parseObjectProperty);
+ parseObjectPropertyKey = wrapTracking(extra.parseObjectPropertyKey);
+ parsePostfixExpression = wrapTracking(extra.parsePostfixExpression);
+ parsePrimaryExpression = wrapTracking(extra.parsePrimaryExpression);
+ parseProgram = wrapTracking(extra.parseProgram);
+ parsePropertyFunction = wrapTracking(extra.parsePropertyFunction);
+ parseRelationalExpression = wrapTracking(extra.parseRelationalExpression);
+ parseStatement = wrapTracking(extra.parseStatement);
+ parseShiftExpression = wrapTracking(extra.parseShiftExpression);
+ parseSwitchCase = wrapTracking(extra.parseSwitchCase);
+ parseUnaryExpression = wrapTracking(extra.parseUnaryExpression);
+ parseVariableDeclaration = wrapTracking(extra.parseVariableDeclaration);
+ parseVariableIdentifier = wrapTracking(extra.parseVariableIdentifier);
+ }
+
+ if (typeof extra.tokens !== 'undefined') {
+ extra.advance = advance;
+ extra.scanRegExp = scanRegExp;
+
+ advance = collectToken;
+ scanRegExp = collectRegex;
+ }
+ }
+
+ function unpatch() {
+ if (typeof extra.skipComment === 'function') {
+ skipComment = extra.skipComment;
+ }
+
+ if (extra.raw) {
+ createLiteral = extra.createLiteral;
+ }
+
+ if (extra.range || extra.loc) {
+ parseAdditiveExpression = extra.parseAdditiveExpression;
+ parseAssignmentExpression = extra.parseAssignmentExpression;
+ parseBitwiseANDExpression = extra.parseBitwiseANDExpression;
+ parseBitwiseORExpression = extra.parseBitwiseORExpression;
+ parseBitwiseXORExpression = extra.parseBitwiseXORExpression;
+ parseBlock = extra.parseBlock;
+ parseFunctionSourceElements = extra.parseFunctionSourceElements;
+ parseCallMember = extra.parseCallMember;
+ parseCatchClause = extra.parseCatchClause;
+ parseComputedMember = extra.parseComputedMember;
+ parseConditionalExpression = extra.parseConditionalExpression;
+ parseConstLetDeclaration = extra.parseConstLetDeclaration;
+ parseEqualityExpression = extra.parseEqualityExpression;
+ parseExpression = extra.parseExpression;
+ parseForVariableDeclaration = extra.parseForVariableDeclaration;
+ parseFunctionDeclaration = extra.parseFunctionDeclaration;
+ parseFunctionExpression = extra.parseFunctionExpression;
+ parseLogicalANDExpression = extra.parseLogicalANDExpression;
+ parseLogicalORExpression = extra.parseLogicalORExpression;
+ parseMultiplicativeExpression = extra.parseMultiplicativeExpression;
+ parseNewExpression = extra.parseNewExpression;
+ parseNonComputedMember = extra.parseNonComputedMember;
+ parseNonComputedProperty = extra.parseNonComputedProperty;
+ parseObjectProperty = extra.parseObjectProperty;
+ parseObjectPropertyKey = extra.parseObjectPropertyKey;
+ parsePrimaryExpression = extra.parsePrimaryExpression;
+ parsePostfixExpression = extra.parsePostfixExpression;
+ parseProgram = extra.parseProgram;
+ parsePropertyFunction = extra.parsePropertyFunction;
+ parseRelationalExpression = extra.parseRelationalExpression;
+ parseStatement = extra.parseStatement;
+ parseShiftExpression = extra.parseShiftExpression;
+ parseSwitchCase = extra.parseSwitchCase;
+ parseUnaryExpression = extra.parseUnaryExpression;
+ parseVariableDeclaration = extra.parseVariableDeclaration;
+ parseVariableIdentifier = extra.parseVariableIdentifier;
+ }
+
+ if (typeof extra.scanRegExp === 'function') {
+ advance = extra.advance;
+ scanRegExp = extra.scanRegExp;
+ }
+ }
+
+ function stringToArray(str) {
+ var length = str.length,
+ result = [],
+ i;
+ for (i = 0; i < length; ++i) {
+ result[i] = str.charAt(i);
+ }
+ return result;
+ }
+
+ function parse(code, options) {
+ var program, toString;
+
+ toString = String;
+ if (typeof code !== 'string' && !(code instanceof String)) {
+ code = toString(code);
+ }
+
+ source = code;
+ index = 0;
+ lineNumber = (source.length > 0) ? 1 : 0;
+ lineStart = 0;
+ length = source.length;
+ buffer = null;
+ state = {
+ allowIn: true,
+ labelSet: {},
+ lastParenthesized: null,
+ inFunctionBody: false,
+ inIteration: false,
+ inSwitch: false
+ };
+
+ extra = {};
+ if (typeof options !== 'undefined') {
+ extra.range = (typeof options.range === 'boolean') && options.range;
+ extra.loc = (typeof options.loc === 'boolean') && options.loc;
+ extra.raw = (typeof options.raw === 'boolean') && options.raw;
+ if (typeof options.tokens === 'boolean' && options.tokens) {
+ extra.tokens = [];
+ }
+ if (typeof options.comment === 'boolean' && options.comment) {
+ extra.comments = [];
+ }
+ if (typeof options.tolerant === 'boolean' && options.tolerant) {
+ extra.errors = [];
+ }
+ }
+
+ if (length > 0) {
+ if (typeof source[0] === 'undefined') {
+ // Try first to convert to a string. This is good as fast path
+ // for old IE which understands string indexing for string
+ // literals only and not for string object.
+ if (code instanceof String) {
+ source = code.valueOf();
+ }
+
+ // Force accessing the characters via an array.
+ if (typeof source[0] === 'undefined') {
+ source = stringToArray(code);
+ }
+ }
+ }
+
+ patch();
+ try {
+ program = parseProgram();
+ if (typeof extra.comments !== 'undefined') {
+ program.comments = extra.comments;
+ }
+ if (typeof extra.tokens !== 'undefined') {
+ program.tokens = extra.tokens;
+ }
+ if (typeof extra.errors !== 'undefined') {
+ program.errors = extra.errors;
+ }
+ } catch (e) {
+ throw e;
+ } finally {
+ unpatch();
+ extra = {};
+ }
+
+ return program;
+ }
+
+ // Sync with package.json.
+ exports.version = '1.0.0-dev';
+
+ exports.parse = parse;
+
+ // Deep copy.
+ exports.Syntax = (function () {
+ var name, types = {};
+
+ if (typeof Object.create === 'function') {
+ types = Object.create(null);
+ }
+
+ for (name in Syntax) {
+ if (Syntax.hasOwnProperty(name)) {
+ types[name] = Syntax[name];
+ }
+ }
+
+ if (typeof Object.freeze === 'function') {
+ Object.freeze(types);
+ }
+
+ return types;
+ }());
+
+}(typeof exports === 'undefined' ? (esprima = {}) : exports));
+/* vim: set sw=4 ts=4 et tw=80 : */
+});
+define('uglifyjs/consolidator', ["require", "exports", "module", "./parse-js", "./process"], function(require, exports, module) {
+/**
+ * @preserve Copyright 2012 Robert Gust-Bardon .
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/**
+ * @fileoverview Enhances UglifyJS with consolidation of null, Boolean, and String values.
+ *
Also known as aliasing, this feature has been deprecated in the Closure Compiler since its
+ * initial release, where it is unavailable from the CLI. The Closure Compiler allows one to log and
+ * influence this process. In contrast, this implementation does not introduce
+ * any variable declarations in global code and derives String values from
+ * identifier names used as property accessors.
+ *
Consolidating literals may worsen the data compression ratio when an encoding
+ * transformation is applied. For instance, jQuery 1.7.1 takes 248235 bytes.
+ * Building it with
+ * UglifyJS v1.2.5 results in 93647 bytes (37.73% of the original) which are
+ * then compressed to 33154 bytes (13.36% of the original) using gzip(1). Building it with the same
+ * version of UglifyJS 1.2.5 patched with the implementation of consolidation
+ * results in 80784 bytes (a decrease of 12863 bytes, i.e. 13.74%, in comparison
+ * to the aforementioned 93647 bytes) which are then compressed to 34013 bytes
+ * (an increase of 859 bytes, i.e. 2.59%, in comparison to the aforementioned
+ * 33154 bytes).
+ */
+
+/*global console:false, exports:true, module:false, require:false */
+/*jshint sub:true */
+/**
+ * Consolidates null, Boolean, and String values found inside an AST.
+ * @param {!TSyntacticCodeUnit} oAbstractSyntaxTree An array-like object
+ * representing an AST.
+ * @return {!TSyntacticCodeUnit} An array-like object representing an AST with its null, Boolean, and
+ * String values consolidated.
+ */
+// TODO(user) Consolidation of mathematical values found in numeric literals.
+// TODO(user) Unconsolidation.
+// TODO(user) Consolidation of ECMA-262 6th Edition programs.
+// TODO(user) Rewrite in ECMA-262 6th Edition.
+exports['ast_consolidate'] = function(oAbstractSyntaxTree) {
+ 'use strict';
+ /*jshint bitwise:true, curly:true, eqeqeq:true, forin:true, immed:true,
+ latedef:true, newcap:true, noarge:true, noempty:true, nonew:true,
+ onevar:true, plusplus:true, regexp:true, undef:true, strict:true,
+ sub:false, trailing:true */
+
+ var _,
+ /**
+ * A record consisting of data about one or more source elements.
+ * @constructor
+ * @nosideeffects
+ */
+ TSourceElementsData = function() {
+ /**
+ * The category of the elements.
+ * @type {number}
+ * @see ESourceElementCategories
+ */
+ this.nCategory = ESourceElementCategories.N_OTHER;
+ /**
+ * The number of occurrences (within the elements) of each primitive
+ * value that could be consolidated.
+ * @type {!Array.>}
+ */
+ this.aCount = [];
+ this.aCount[EPrimaryExpressionCategories.N_IDENTIFIER_NAMES] = {};
+ this.aCount[EPrimaryExpressionCategories.N_STRING_LITERALS] = {};
+ this.aCount[EPrimaryExpressionCategories.N_NULL_AND_BOOLEAN_LITERALS] =
+ {};
+ /**
+ * Identifier names found within the elements.
+ * @type {!Array.}
+ */
+ this.aIdentifiers = [];
+ /**
+ * Prefixed representation Strings of each primitive value that could be
+ * consolidated within the elements.
+ * @type {!Array.}
+ */
+ this.aPrimitiveValues = [];
+ },
+ /**
+ * A record consisting of data about a primitive value that could be
+ * consolidated.
+ * @constructor
+ * @nosideeffects
+ */
+ TPrimitiveValue = function() {
+ /**
+ * The difference in the number of terminal symbols between the original
+ * source text and the one with the primitive value consolidated. If the
+ * difference is positive, the primitive value is considered worthwhile.
+ * @type {number}
+ */
+ this.nSaving = 0;
+ /**
+ * An identifier name of the variable that will be declared and assigned
+ * the primitive value if the primitive value is consolidated.
+ * @type {string}
+ */
+ this.sName = '';
+ },
+ /**
+ * A record consisting of data on what to consolidate within the range of
+ * source elements that is currently being considered.
+ * @constructor
+ * @nosideeffects
+ */
+ TSolution = function() {
+ /**
+ * An object whose keys are prefixed representation Strings of each
+ * primitive value that could be consolidated within the elements and
+ * whose values are corresponding data about those primitive values.
+ * @type {!Object.}
+ * @see TPrimitiveValue
+ */
+ this.oPrimitiveValues = {};
+ /**
+ * The difference in the number of terminal symbols between the original
+ * source text and the one with all the worthwhile primitive values
+ * consolidated.
+ * @type {number}
+ * @see TPrimitiveValue#nSaving
+ */
+ this.nSavings = 0;
+ },
+ /**
+ * The processor of ASTs found
+ * in UglifyJS.
+ * @namespace
+ * @type {!TProcessor}
+ */
+ oProcessor = (/** @type {!TProcessor} */ require('./process')),
+ /**
+ * A record consisting of a number of constants that represent the
+ * difference in the number of terminal symbols between a source text with
+ * a modified syntactic code unit and the original one.
+ * @namespace
+ * @type {!Object.}
+ */
+ oWeights = {
+ /**
+ * The difference in the number of punctuators required by the bracket
+ * notation and the dot notation.
+ *
'[]'.length - '.'.length
+ * @const
+ * @type {number}
+ */
+ N_PROPERTY_ACCESSOR: 1,
+ /**
+ * The number of punctuators required by a variable declaration with an
+ * initialiser.
+ *
':'.length + ';'.length
+ * @const
+ * @type {number}
+ */
+ N_VARIABLE_DECLARATION: 2,
+ /**
+ * The number of terminal symbols required to introduce a variable
+ * statement (excluding its variable declaration list).
+ *
'var '.length
+ * @const
+ * @type {number}
+ */
+ N_VARIABLE_STATEMENT_AFFIXATION: 4,
+ /**
+ * The number of terminal symbols needed to enclose source elements
+ * within a function call with no argument values to a function with an
+ * empty parameter list.
+ *
'(function(){}());'.length
+ * @const
+ * @type {number}
+ */
+ N_CLOSURE: 17
+ },
+ /**
+ * Categories of primary expressions from which primitive values that
+ * could be consolidated are derivable.
+ * @namespace
+ * @enum {number}
+ */
+ EPrimaryExpressionCategories = {
+ /**
+ * Identifier names used as property accessors.
+ * @type {number}
+ */
+ N_IDENTIFIER_NAMES: 0,
+ /**
+ * String literals.
+ * @type {number}
+ */
+ N_STRING_LITERALS: 1,
+ /**
+ * Null and Boolean literals.
+ * @type {number}
+ */
+ N_NULL_AND_BOOLEAN_LITERALS: 2
+ },
+ /**
+ * Prefixes of primitive values that could be consolidated.
+ * The String values of the prefixes must have same number of characters.
+ * The prefixes must not be used in any properties defined in any version
+ * of ECMA-262.
+ * @namespace
+ * @enum {string}
+ */
+ EValuePrefixes = {
+ /**
+ * Identifies String values.
+ * @type {string}
+ */
+ S_STRING: '#S',
+ /**
+ * Identifies null and Boolean values.
+ * @type {string}
+ */
+ S_SYMBOLIC: '#O'
+ },
+ /**
+ * Categories of source elements in terms of their appropriateness of
+ * having their primitive values consolidated.
+ * @namespace
+ * @enum {number}
+ */
+ ESourceElementCategories = {
+ /**
+ * Identifies a source element that includes the {@code with} statement.
+ * @type {number}
+ */
+ N_WITH: 0,
+ /**
+ * Identifies a source element that includes the {@code eval} identifier name.
+ * @type {number}
+ */
+ N_EVAL: 1,
+ /**
+ * Identifies a source element that must be excluded from the process
+ * unless its whole scope is examined.
+ * @type {number}
+ */
+ N_EXCLUDABLE: 2,
+ /**
+ * Identifies source elements not posing any problems.
+ * @type {number}
+ */
+ N_OTHER: 3
+ },
+ /**
+ * The list of literals (other than the String ones) whose primitive
+ * values can be consolidated.
+ * @const
+ * @type {!Array.}
+ */
+ A_OTHER_SUBSTITUTABLE_LITERALS = [
+ 'null', // The null literal.
+ 'false', // The Boolean literal {@code false}.
+ 'true' // The Boolean literal {@code true}.
+ ];
+
+ (/**
+ * Consolidates all worthwhile primitive values in a syntactic code unit.
+ * @param {!TSyntacticCodeUnit} oSyntacticCodeUnit An array-like object
+ * representing the branch of the abstract syntax tree representing the
+ * syntactic code unit along with its scope.
+ * @see TPrimitiveValue#nSaving
+ */
+ function fExamineSyntacticCodeUnit(oSyntacticCodeUnit) {
+ var _,
+ /**
+ * Indicates whether the syntactic code unit represents global code.
+ * @type {boolean}
+ */
+ bIsGlobal = 'toplevel' === oSyntacticCodeUnit[0],
+ /**
+ * Indicates whether the whole scope is being examined.
+ * @type {boolean}
+ */
+ bIsWhollyExaminable = !bIsGlobal,
+ /**
+ * An array-like object representing source elements that constitute a
+ * syntactic code unit.
+ * @type {!TSyntacticCodeUnit}
+ */
+ oSourceElements,
+ /**
+ * A record consisting of data about the source element that is
+ * currently being examined.
+ * @type {!TSourceElementsData}
+ */
+ oSourceElementData,
+ /**
+ * The scope of the syntactic code unit.
+ * @type {!TScope}
+ */
+ oScope,
+ /**
+ * An instance of an object that allows the traversal of an AST.
+ * @type {!TWalker}
+ */
+ oWalker,
+ /**
+ * An object encompassing collections of functions used during the
+ * traversal of an AST.
+ * @namespace
+ * @type {!Object.>}
+ */
+ oWalkers = {
+ /**
+ * A collection of functions used during the surveyance of source
+ * elements.
+ * @namespace
+ * @type {!Object.}
+ */
+ oSurveySourceElement: {
+ /**#nocode+*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name. Adds the identifier of the function and its formal
+ * parameters to the list of identifier names found.
+ * @param {string} sIdentifier The identifier of the function.
+ * @param {!Array.} aFormalParameterList Formal parameters.
+ * @param {!TSyntacticCodeUnit} oFunctionBody Function code.
+ */
+ 'defun': function(
+ sIdentifier,
+ aFormalParameterList,
+ oFunctionBody) {
+ fClassifyAsExcludable();
+ fAddIdentifier(sIdentifier);
+ aFormalParameterList.forEach(fAddIdentifier);
+ },
+ /**
+ * Increments the count of the number of occurrences of the String
+ * value that is equivalent to the sequence of terminal symbols
+ * that constitute the encountered identifier name.
+ * @param {!TSyntacticCodeUnit} oExpression The nonterminal
+ * MemberExpression.
+ * @param {string} sIdentifierName The identifier name used as the
+ * property accessor.
+ * @return {!Array} The encountered branch of an AST with its nonterminal
+ * MemberExpression traversed.
+ */
+ 'dot': function(oExpression, sIdentifierName) {
+ fCountPrimaryExpression(
+ EPrimaryExpressionCategories.N_IDENTIFIER_NAMES,
+ EValuePrefixes.S_STRING + sIdentifierName);
+ return ['dot', oWalker.walk(oExpression), sIdentifierName];
+ },
+ /**
+ * Adds the optional identifier of the function and its formal
+ * parameters to the list of identifier names found.
+ * @param {?string} sIdentifier The optional identifier of the
+ * function.
+ * @param {!Array.} aFormalParameterList Formal parameters.
+ * @param {!TSyntacticCodeUnit} oFunctionBody Function code.
+ */
+ 'function': function(
+ sIdentifier,
+ aFormalParameterList,
+ oFunctionBody) {
+ if ('string' === typeof sIdentifier) {
+ fAddIdentifier(sIdentifier);
+ }
+ aFormalParameterList.forEach(fAddIdentifier);
+ },
+ /**
+ * Either increments the count of the number of occurrences of the
+ * encountered null or Boolean value or classifies a source element
+ * as containing the {@code eval} identifier name.
+ * @param {string} sIdentifier The identifier encountered.
+ */
+ 'name': function(sIdentifier) {
+ if (-1 !== A_OTHER_SUBSTITUTABLE_LITERALS.indexOf(sIdentifier)) {
+ fCountPrimaryExpression(
+ EPrimaryExpressionCategories.N_NULL_AND_BOOLEAN_LITERALS,
+ EValuePrefixes.S_SYMBOLIC + sIdentifier);
+ } else {
+ if ('eval' === sIdentifier) {
+ oSourceElementData.nCategory =
+ ESourceElementCategories.N_EVAL;
+ }
+ fAddIdentifier(sIdentifier);
+ }
+ },
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name.
+ * @param {TSyntacticCodeUnit} oExpression The expression whose
+ * value is to be returned.
+ */
+ 'return': function(oExpression) {
+ fClassifyAsExcludable();
+ },
+ /**
+ * Increments the count of the number of occurrences of the
+ * encountered String value.
+ * @param {string} sStringValue The String value of the string
+ * literal encountered.
+ */
+ 'string': function(sStringValue) {
+ if (sStringValue.length > 0) {
+ fCountPrimaryExpression(
+ EPrimaryExpressionCategories.N_STRING_LITERALS,
+ EValuePrefixes.S_STRING + sStringValue);
+ }
+ },
+ /**
+ * Adds the identifier reserved for an exception to the list of
+ * identifier names found.
+ * @param {!TSyntacticCodeUnit} oTry A block of code in which an
+ * exception can occur.
+ * @param {Array} aCatch The identifier reserved for an exception
+ * and a block of code to handle the exception.
+ * @param {TSyntacticCodeUnit} oFinally An optional block of code
+ * to be evaluated regardless of whether an exception occurs.
+ */
+ 'try': function(oTry, aCatch, oFinally) {
+ if (Array.isArray(aCatch)) {
+ fAddIdentifier(aCatch[0]);
+ }
+ },
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name. Adds the identifier of each declared variable to the list
+ * of identifier names found.
+ * @param {!Array.} aVariableDeclarationList Variable
+ * declarations.
+ */
+ 'var': function(aVariableDeclarationList) {
+ fClassifyAsExcludable();
+ aVariableDeclarationList.forEach(fAddVariable);
+ },
+ /**
+ * Classifies a source element as containing the {@code with}
+ * statement.
+ * @param {!TSyntacticCodeUnit} oExpression An expression whose
+ * value is to be converted to a value of type Object and
+ * become the binding object of a new object environment
+ * record of a new lexical environment in which the statement
+ * is to be executed.
+ * @param {!TSyntacticCodeUnit} oStatement The statement to be
+ * executed in the augmented lexical environment.
+ * @return {!Array} An empty array to stop the traversal.
+ */
+ 'with': function(oExpression, oStatement) {
+ oSourceElementData.nCategory = ESourceElementCategories.N_WITH;
+ return [];
+ }
+ /**#nocode-*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ },
+ /**
+ * A collection of functions used while looking for nested functions.
+ * @namespace
+ * @type {!Object.}
+ */
+ oExamineFunctions: {
+ /**#nocode+*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ /**
+ * Orders an examination of a nested function declaration.
+ * @this {!TSyntacticCodeUnit} An array-like object representing
+ * the branch of an AST representing the syntactic code unit along with
+ * its scope.
+ * @return {!Array} An empty array to stop the traversal.
+ */
+ 'defun': function() {
+ fExamineSyntacticCodeUnit(this);
+ return [];
+ },
+ /**
+ * Orders an examination of a nested function expression.
+ * @this {!TSyntacticCodeUnit} An array-like object representing
+ * the branch of an AST representing the syntactic code unit along with
+ * its scope.
+ * @return {!Array} An empty array to stop the traversal.
+ */
+ 'function': function() {
+ fExamineSyntacticCodeUnit(this);
+ return [];
+ }
+ /**#nocode-*/ // JsDoc Toolkit 2.4.0 hides some of the keys.
+ }
+ },
+ /**
+ * Records containing data about source elements.
+ * @type {Array.}
+ */
+ aSourceElementsData = [],
+ /**
+ * The index (in the source text order) of the source element
+ * immediately following a Directive Prologue.
+ * @type {number}
+ */
+ nAfterDirectivePrologue = 0,
+ /**
+ * The index (in the source text order) of the source element that is
+ * currently being considered.
+ * @type {number}
+ */
+ nPosition,
+ /**
+ * The index (in the source text order) of the source element that is
+ * the last element of the range of source elements that is currently
+ * being considered.
+ * @type {(undefined|number)}
+ */
+ nTo,
+ /**
+ * Initiates the traversal of a source element.
+ * @param {!TWalker} oWalker An instance of an object that allows the
+ * traversal of an abstract syntax tree.
+ * @param {!TSyntacticCodeUnit} oSourceElement A source element from
+ * which the traversal should commence.
+ * @return {function(): !TSyntacticCodeUnit} A function that is able to
+ * initiate the traversal from a given source element.
+ */
+ cContext = function(oWalker, oSourceElement) {
+ /**
+ * @return {!TSyntacticCodeUnit} A function that is able to
+ * initiate the traversal from a given source element.
+ */
+ var fLambda = function() {
+ return oWalker.walk(oSourceElement);
+ };
+
+ return fLambda;
+ },
+ /**
+ * Classifies the source element as excludable if it does not
+ * contain a {@code with} statement or the {@code eval} identifier
+ * name.
+ */
+ fClassifyAsExcludable = function() {
+ if (oSourceElementData.nCategory ===
+ ESourceElementCategories.N_OTHER) {
+ oSourceElementData.nCategory =
+ ESourceElementCategories.N_EXCLUDABLE;
+ }
+ },
+ /**
+ * Adds an identifier to the list of identifier names found.
+ * @param {string} sIdentifier The identifier to be added.
+ */
+ fAddIdentifier = function(sIdentifier) {
+ if (-1 === oSourceElementData.aIdentifiers.indexOf(sIdentifier)) {
+ oSourceElementData.aIdentifiers.push(sIdentifier);
+ }
+ },
+ /**
+ * Adds the identifier of a variable to the list of identifier names
+ * found.
+ * @param {!Array} aVariableDeclaration A variable declaration.
+ */
+ fAddVariable = function(aVariableDeclaration) {
+ fAddIdentifier(/** @type {string} */ aVariableDeclaration[0]);
+ },
+ /**
+ * Increments the count of the number of occurrences of the prefixed
+ * String representation attributed to the primary expression.
+ * @param {number} nCategory The category of the primary expression.
+ * @param {string} sName The prefixed String representation attributed
+ * to the primary expression.
+ */
+ fCountPrimaryExpression = function(nCategory, sName) {
+ if (!oSourceElementData.aCount[nCategory].hasOwnProperty(sName)) {
+ oSourceElementData.aCount[nCategory][sName] = 0;
+ if (-1 === oSourceElementData.aPrimitiveValues.indexOf(sName)) {
+ oSourceElementData.aPrimitiveValues.push(sName);
+ }
+ }
+ oSourceElementData.aCount[nCategory][sName] += 1;
+ },
+ /**
+ * Consolidates all worthwhile primitive values in a range of source
+ * elements.
+ * @param {number} nFrom The index (in the source text order) of the
+ * source element that is the first element of the range.
+ * @param {number} nTo The index (in the source text order) of the
+ * source element that is the last element of the range.
+ * @param {boolean} bEnclose Indicates whether the range should be
+ * enclosed within a function call with no argument values to a
+ * function with an empty parameter list if any primitive values
+ * are consolidated.
+ * @see TPrimitiveValue#nSaving
+ */
+ fExamineSourceElements = function(nFrom, nTo, bEnclose) {
+ var _,
+ /**
+ * The index of the last mangled name.
+ * @type {number}
+ */
+ nIndex = oScope.cname,
+ /**
+ * The index of the source element that is currently being
+ * considered.
+ * @type {number}
+ */
+ nPosition,
+ /**
+ * A collection of functions used during the consolidation of
+ * primitive values and identifier names used as property
+ * accessors.
+ * @namespace
+ * @type {!Object.}
+ */
+ oWalkersTransformers = {
+ /**
+ * If the String value that is equivalent to the sequence of
+ * terminal symbols that constitute the encountered identifier
+ * name is worthwhile, a syntactic conversion from the dot
+ * notation to the bracket notation ensues with that sequence
+ * being substituted by an identifier name to which the value
+ * is assigned.
+ * Applies to property accessors that use the dot notation.
+ * @param {!TSyntacticCodeUnit} oExpression The nonterminal
+ * MemberExpression.
+ * @param {string} sIdentifierName The identifier name used as
+ * the property accessor.
+ * @return {!Array} A syntactic code unit that is equivalent to
+ * the one encountered.
+ * @see TPrimitiveValue#nSaving
+ */
+ 'dot': function(oExpression, sIdentifierName) {
+ /**
+ * The prefixed String value that is equivalent to the
+ * sequence of terminal symbols that constitute the
+ * encountered identifier name.
+ * @type {string}
+ */
+ var sPrefixed = EValuePrefixes.S_STRING + sIdentifierName;
+
+ return oSolutionBest.oPrimitiveValues.hasOwnProperty(
+ sPrefixed) &&
+ oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0 ?
+ ['sub',
+ oWalker.walk(oExpression),
+ ['name',
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName]] :
+ ['dot', oWalker.walk(oExpression), sIdentifierName];
+ },
+ /**
+ * If the encountered identifier is a null or Boolean literal
+ * and its value is worthwhile, the identifier is substituted
+ * by an identifier name to which that value is assigned.
+ * Applies to identifier names.
+ * @param {string} sIdentifier The identifier encountered.
+ * @return {!Array} A syntactic code unit that is equivalent to
+ * the one encountered.
+ * @see TPrimitiveValue#nSaving
+ */
+ 'name': function(sIdentifier) {
+ /**
+ * The prefixed representation String of the identifier.
+ * @type {string}
+ */
+ var sPrefixed = EValuePrefixes.S_SYMBOLIC + sIdentifier;
+
+ return [
+ 'name',
+ oSolutionBest.oPrimitiveValues.hasOwnProperty(sPrefixed) &&
+ oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0 ?
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName :
+ sIdentifier
+ ];
+ },
+ /**
+ * If the encountered String value is worthwhile, it is
+ * substituted by an identifier name to which that value is
+ * assigned.
+ * Applies to String values.
+ * @param {string} sStringValue The String value of the string
+ * literal encountered.
+ * @return {!Array} A syntactic code unit that is equivalent to
+ * the one encountered.
+ * @see TPrimitiveValue#nSaving
+ */
+ 'string': function(sStringValue) {
+ /**
+ * The prefixed representation String of the primitive value
+ * of the literal.
+ * @type {string}
+ */
+ var sPrefixed =
+ EValuePrefixes.S_STRING + sStringValue;
+
+ return oSolutionBest.oPrimitiveValues.hasOwnProperty(
+ sPrefixed) &&
+ oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0 ?
+ ['name',
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName] :
+ ['string', sStringValue];
+ }
+ },
+ /**
+ * Such data on what to consolidate within the range of source
+ * elements that is currently being considered that lead to the
+ * greatest known reduction of the number of the terminal symbols
+ * in comparison to the original source text.
+ * @type {!TSolution}
+ */
+ oSolutionBest = new TSolution(),
+ /**
+ * Data representing an ongoing attempt to find a better
+ * reduction of the number of the terminal symbols in comparison
+ * to the original source text than the best one that is
+ * currently known.
+ * @type {!TSolution}
+ * @see oSolutionBest
+ */
+ oSolutionCandidate = new TSolution(),
+ /**
+ * A record consisting of data about the range of source elements
+ * that is currently being examined.
+ * @type {!TSourceElementsData}
+ */
+ oSourceElementsData = new TSourceElementsData(),
+ /**
+ * Variable declarations for each primitive value that is to be
+ * consolidated within the elements.
+ * @type {!Array.}
+ */
+ aVariableDeclarations = [],
+ /**
+ * Augments a list with a prefixed representation String.
+ * @param {!Array.} aList A list that is to be augmented.
+ * @return {function(string)} A function that augments a list
+ * with a prefixed representation String.
+ */
+ cAugmentList = function(aList) {
+ /**
+ * @param {string} sPrefixed Prefixed representation String of
+ * a primitive value that could be consolidated within the
+ * elements.
+ */
+ var fLambda = function(sPrefixed) {
+ if (-1 === aList.indexOf(sPrefixed)) {
+ aList.push(sPrefixed);
+ }
+ };
+
+ return fLambda;
+ },
+ /**
+ * Adds the number of occurrences of a primitive value of a given
+ * category that could be consolidated in the source element with
+ * a given index to the count of occurrences of that primitive
+ * value within the range of source elements that is currently
+ * being considered.
+ * @param {number} nPosition The index (in the source text order)
+ * of a source element.
+ * @param {number} nCategory The category of the primary
+ * expression from which the primitive value is derived.
+ * @return {function(string)} A function that performs the
+ * addition.
+ * @see cAddOccurrencesInCategory
+ */
+ cAddOccurrences = function(nPosition, nCategory) {
+ /**
+ * @param {string} sPrefixed The prefixed representation String
+ * of a primitive value.
+ */
+ var fLambda = function(sPrefixed) {
+ if (!oSourceElementsData.aCount[nCategory].hasOwnProperty(
+ sPrefixed)) {
+ oSourceElementsData.aCount[nCategory][sPrefixed] = 0;
+ }
+ oSourceElementsData.aCount[nCategory][sPrefixed] +=
+ aSourceElementsData[nPosition].aCount[nCategory][
+ sPrefixed];
+ };
+
+ return fLambda;
+ },
+ /**
+ * Adds the number of occurrences of each primitive value of a
+ * given category that could be consolidated in the source
+ * element with a given index to the count of occurrences of that
+ * primitive values within the range of source elements that is
+ * currently being considered.
+ * @param {number} nPosition The index (in the source text order)
+ * of a source element.
+ * @return {function(number)} A function that performs the
+ * addition.
+ * @see fAddOccurrences
+ */
+ cAddOccurrencesInCategory = function(nPosition) {
+ /**
+ * @param {number} nCategory The category of the primary
+ * expression from which the primitive value is derived.
+ */
+ var fLambda = function(nCategory) {
+ Object.keys(
+ aSourceElementsData[nPosition].aCount[nCategory]
+ ).forEach(cAddOccurrences(nPosition, nCategory));
+ };
+
+ return fLambda;
+ },
+ /**
+ * Adds the number of occurrences of each primitive value that
+ * could be consolidated in the source element with a given index
+ * to the count of occurrences of that primitive values within
+ * the range of source elements that is currently being
+ * considered.
+ * @param {number} nPosition The index (in the source text order)
+ * of a source element.
+ */
+ fAddOccurrences = function(nPosition) {
+ Object.keys(aSourceElementsData[nPosition].aCount).forEach(
+ cAddOccurrencesInCategory(nPosition));
+ },
+ /**
+ * Creates a variable declaration for a primitive value if that
+ * primitive value is to be consolidated within the elements.
+ * @param {string} sPrefixed Prefixed representation String of a
+ * primitive value that could be consolidated within the
+ * elements.
+ * @see aVariableDeclarations
+ */
+ cAugmentVariableDeclarations = function(sPrefixed) {
+ if (oSolutionBest.oPrimitiveValues[sPrefixed].nSaving > 0) {
+ aVariableDeclarations.push([
+ oSolutionBest.oPrimitiveValues[sPrefixed].sName,
+ [0 === sPrefixed.indexOf(EValuePrefixes.S_SYMBOLIC) ?
+ 'name' : 'string',
+ sPrefixed.substring(EValuePrefixes.S_SYMBOLIC.length)]
+ ]);
+ }
+ },
+ /**
+ * Sorts primitive values with regard to the difference in the
+ * number of terminal symbols between the original source text
+ * and the one with those primitive values consolidated.
+ * @param {string} sPrefixed0 The prefixed representation String
+ * of the first of the two primitive values that are being
+ * compared.
+ * @param {string} sPrefixed1 The prefixed representation String
+ * of the second of the two primitive values that are being
+ * compared.
+ * @return {number}
+ *
+ *
-1
+ *
if the first primitive value must be placed before
+ * the other one,
+ *
0
+ *
if the first primitive value may be placed before
+ * the other one,
+ *
1
+ *
if the first primitive value must not be placed
+ * before the other one.
varslice = Array.prototype.slice
+ , net = require('net');
+
+
+
+
+
The server that does the Policy File severing
+
+
Options
+
+
log false or a function that can output log information, defaults to console.log?
+
+
+
+
param: Object options Options to customize the servers functionality.
param: Array origins The origins that are allowed on this server, defaults to *:*.
api: public
+
+
+
functionServer(options, origins){
+ varme = this;
+
+ this.origins = origins || ['*:*'];
+ this.port = 843;
+ this.log = console.log;
+
+ // merge `this` with the options
+ Object.keys(options).forEach(function(key){
+ me[key] && (me[key] = options[key])
+ });
+
+ // create the net server
+ this.socket = net.createServer(functioncreateServer(socket){
+ socket.on('error', functionsocketError(){ me.responder.call(me, socket) });
+ me.responder.call(me, socket);
+ });
+
+ // Listen for errors as the port might be blocked because we do not have root priv.
+ this.socket.on('error', functionserverError(err){
+ // Special and common case error handling
+ if (err.errno == 13){
+ me.log && me.log(
+ 'Unable to listen to port `' + me.port + '` as your Node.js instance does not have root privileges. ' +
+ (
+ me.server
+ ? 'The Flash Policy file will now be served inline over the supplied HTTP server, Flash Policy files request will suffer.'
+ : 'No fallback server supplied.'
+ )
+ );
+
+ me.socket.removeAllListeners();
+ deleteme.socket;
+
+ me.emit('connect_failed', err);
+ } else {
+ me.log && me.log('FlashPolicyFileServer received a error event:\n' + (err.message ? err.message : err));
+ }
+ });
+
+ this.socket.on('timeout', functionserverTimeout(){});
+ this.socket.on('close', functionserverClosed(err){
+ err && me.log && me.log('Server closing due to an error: \n' + (err.message ? err.message : err));
+
+ if (me.server){
+ // not online anymore
+ deleteme.server.online;
+
+ // Remove the inline policy listener if we close down
+ // but only when the server was `online` (see listen prototype)
+ if( me.server['@'] && me.server.online){
+ me.server.removeListener('connection', me.server['@']);
+ }
+ }
+ me.log && me.log('Shutting down FlashPolicyFileServer');
+ });
+
+ // Compile the initial `buffer`
+ this.compile();
+}
+
+
+
+
+
Start listening for requests
+
+
+
+
param: Number port The port number it should be listening to.
param: Server server A HTTP server instance, this will be used to listen for inline requests
param: Function cb The callback needs to be called once server is ready
api: public
+
+
+
Server.prototype.listen = functionlisten(port, server, cb){
+ varme = this
+ , args = slice.call(arguments, 0)
+ , callback;
+
+ // assign the correct vars, for flexible arguments
+ args.forEach(functionargs(arg){
+ vartype = typeofarg;
+
+ if (type === 'number') me.port = arg;
+ if (type === 'function') callback = arg;
+ if (type === 'object') me.server = arg;
+ });
+
+ if (this.server){
+
+ // no one in their right mind would ever create a `@` prototype, so Im just gonna store
+ // my function on the server, so I can remove it later again once the server(s) closes
+ this.server['@'] = functionconnection(socket){
+ socket.once('data', functionrequestData(data){
+ // if it's a Flash policy request, and we can write to the
+ if (
+ data
+ && data[0] === 60
+ && data.toString() === '<policy-file-request/>\0'
+ && socket
+ && (socket.readyState === 'open' || socket.readyState === 'writeOnly')
+ ){
+ // send the buffer
+ socket.end(me.buffer);
+ }
+ });
+ };
+ // attach it
+ this.server.on('connection', this.server['@']);
+ }
+
+ // We add a callback method, so we can set a flag for when the server is `enabled` or `online`.
+ // this flag is needed because if a error occurs and the we cannot boot up the server the
+ // fallback functionality should not be removed during the `close` event
+ this.socket.listen(this.port, functionserverListening(){
+ me.socket.online = true;
+
+ if (callback) callback(), callback = undefined;
+
+ });
+
+ returnthis;
+};
+
+
+
+
+
Adds a new origin to the Flash Policy File.
+
+
+
+
param: Arguments The origins that need to be added.
api: public
+
+
+
Server.prototype.add = functionadd(){
+ varargs = slice.call(arguments, 0)
+ , i = args.length;
+
+ // flag duplicates
+ while (i--){
+ if (this.origins.indexOf(args[i]) >= 0){
+ args[i] = null;
+ }
+ }
+
+ // Add all the arguments to the array
+ // but first we want to remove all `falsy` values from the args
+ Array.prototype.push.apply(
+ this.origins
+ , args.filter(function(value){ return !!value })
+ );
+
+ this.compile();
+ returnthis;
+};
+
+
+
+
+
Removes a origin from the Flash Policy File.
+
+
+
+
param: String origin The origin that needs to be removed from the server
api: public
+
+
+
Server.prototype.remove = functionremove(origin){
+ varposition = this.origins.indexOf(origin);
+
+ // only remove and recompile if we have a match
+ if (position > 0){
+ this.origins.splice(position,1);
+ this.compile();
+ }
+
+ returnthis;
+};
Provide a hook to the original server, so it can be extended if needed.
+
+
+
+
exports.Server = Server;
+
+
+
+
+
Module version
+
+
+
+
exports.version = '0.0.2';
+
+
+
+
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/policyfile/examples/basic.fallback.js b/node_modules/socket.io/node_modules/policyfile/examples/basic.fallback.js
new file mode 100644
index 0000000..b439449
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/examples/basic.fallback.js
@@ -0,0 +1,8 @@
+var http = require('http')
+ , fspfs = require('../');
+
+var server = http.createServer(function(q,r){ r.writeHead(200); r.end(':3') })
+ , flash = fspfs.createServer();
+
+server.listen(8080);
+flash.listen(8081,server);
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/policyfile/examples/basic.js b/node_modules/socket.io/node_modules/policyfile/examples/basic.js
new file mode 100644
index 0000000..5e2290f
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/examples/basic.js
@@ -0,0 +1,5 @@
+var http = require('http')
+ , fspfs = require('../');
+
+var flash = fspfs.createServer();
+flash.listen();
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/policyfile/index.js b/node_modules/socket.io/node_modules/policyfile/index.js
new file mode 100644
index 0000000..60cf298
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/index.js
@@ -0,0 +1 @@
+module.exports = require('./lib/server.js');
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/policyfile/lib/server.js b/node_modules/socket.io/node_modules/policyfile/lib/server.js
new file mode 100644
index 0000000..a525772
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/lib/server.js
@@ -0,0 +1,289 @@
+/**
+ * Module dependencies and cached references.
+ */
+
+var slice = Array.prototype.slice
+ , net = require('net');
+
+/**
+ * The server that does the Policy File severing
+ *
+ * Options:
+ * - `log` false or a function that can output log information, defaults to console.log?
+ *
+ * @param {Object} options Options to customize the servers functionality.
+ * @param {Array} origins The origins that are allowed on this server, defaults to `*:*`.
+ * @api public
+ */
+
+function Server (options, origins) {
+ var me = this;
+
+ this.origins = origins || ['*:*'];
+ this.port = 843;
+ this.log = console.log;
+
+ // merge `this` with the options
+ Object.keys(options).forEach(function (key) {
+ me[key] && (me[key] = options[key])
+ });
+
+ // create the net server
+ this.socket = net.createServer(function createServer (socket) {
+ socket.on('error', function socketError () {
+ me.responder.call(me, socket);
+ });
+
+ me.responder.call(me, socket);
+ });
+
+ // Listen for errors as the port might be blocked because we do not have root priv.
+ this.socket.on('error', function serverError (err) {
+ // Special and common case error handling
+ if (err.errno == 13) {
+ me.log && me.log(
+ 'Unable to listen to port `' + me.port + '` as your Node.js instance does not have root privileges. ' +
+ (
+ me.server
+ ? 'The Flash Policy File requests will only be served inline over the supplied HTTP server. Inline serving is slower than a dedicated server instance.'
+ : 'No fallback server supplied, we will be unable to answer Flash Policy File requests.'
+ )
+ );
+
+ me.emit('connect_failed', err);
+ me.socket.removeAllListeners();
+ delete me.socket;
+ } else {
+ me.log && me.log('FlashPolicyFileServer received an error event:\n' + (err.message ? err.message : err));
+ }
+ });
+
+ this.socket.on('timeout', function serverTimeout () {});
+ this.socket.on('close', function serverClosed (err) {
+ err && me.log && me.log('Server closing due to an error: \n' + (err.message ? err.message : err));
+
+ if (me.server) {
+ // Remove the inline policy listener if we close down
+ // but only when the server was `online` (see listen prototype)
+ if (me.server['@'] && me.server.online) {
+ me.server.removeListener('connection', me.server['@']);
+ }
+
+ // not online anymore
+ delete me.server.online;
+ }
+ });
+
+ // Compile the initial `buffer`
+ this.compile();
+}
+
+/**
+ * Start listening for requests
+ *
+ * @param {Number} port The port number it should be listening to.
+ * @param {Server} server A HTTP server instance, this will be used to listen for inline requests
+ * @param {Function} cb The callback needs to be called once server is ready
+ * @api public
+ */
+
+Server.prototype.listen = function listen (port, server, cb){
+ var me = this
+ , args = slice.call(arguments, 0)
+ , callback;
+
+ // assign the correct vars, for flexible arguments
+ args.forEach(function args (arg){
+ var type = typeof arg;
+
+ if (type === 'number') me.port = arg;
+ if (type === 'function') callback = arg;
+ if (type === 'object') me.server = arg;
+ });
+
+ if (this.server) {
+
+ // no one in their right mind would ever create a `@` prototype, so Im just gonna store
+ // my function on the server, so I can remove it later again once the server(s) closes
+ this.server['@'] = function connection (socket) {
+ socket.once('data', function requestData (data) {
+ // if it's a Flash policy request, and we can write to the
+ if (
+ data
+ && data[0] === 60
+ && data.toString() === '\0'
+ && socket
+ && (socket.readyState === 'open' || socket.readyState === 'writeOnly')
+ ){
+ // send the buffer
+ try {
+ socket.end(me.buffer);
+ } catch (e) {}
+ }
+ });
+ };
+
+ // attach it
+ this.server.on('connection', this.server['@']);
+ }
+
+ // We add a callback method, so we can set a flag for when the server is `enabled` or `online`.
+ // this flag is needed because if a error occurs and the we cannot boot up the server the
+ // fallback functionality should not be removed during the `close` event
+ this.port >= 0 && this.socket.listen(this.port, function serverListening () {
+ me.socket.online = true;
+ if (callback) {
+ callback.call(me);
+ callback = undefined;
+ }
+ });
+
+ return this;
+};
+
+/**
+ * Responds to socket connects and writes the compile policy file.
+ *
+ * @param {net.Socket} socket The socket that needs to receive the message
+ * @api private
+ */
+
+Server.prototype.responder = function responder (socket){
+ if (socket && socket.readyState == 'open' && socket.end) {
+ try {
+ socket.end(this.buffer);
+ } catch (e) {}
+ }
+};
+
+/**
+ * Compiles the supplied origins to a Flash Policy File format and stores it in a Node.js Buffer
+ * this way it can be send over the wire without any performance loss.
+ *
+ * @api private
+ */
+
+Server.prototype.compile = function compile (){
+ var xml = [
+ ''
+ , ''
+ , ''
+ ];
+
+ // add the allow access element
+ this.origins.forEach(function origin (origin){
+ var parts = origin.split(':');
+ xml.push('');
+ });
+
+ xml.push('');
+
+ // store the result in a buffer so we don't have to re-generate it all the time
+ this.buffer = new Buffer(xml.join(''), 'utf8');
+
+ return this;
+};
+
+/**
+ * Adds a new origin to the Flash Policy File.
+ *
+ * @param {Arguments} The origins that need to be added.
+ * @api public
+ */
+
+Server.prototype.add = function add(){
+ var args = slice.call(arguments, 0)
+ , i = args.length;
+
+ // flag duplicates
+ while (i--) {
+ if (this.origins.indexOf(args[i]) >= 0){
+ args[i] = null;
+ }
+ }
+
+ // Add all the arguments to the array
+ // but first we want to remove all `falsy` values from the args
+ Array.prototype.push.apply(
+ this.origins
+ , args.filter(function filter (value) {
+ return !!value;
+ })
+ );
+
+ this.compile();
+ return this;
+};
+
+/**
+ * Removes a origin from the Flash Policy File.
+ *
+ * @param {String} origin The origin that needs to be removed from the server
+ * @api public
+ */
+
+Server.prototype.remove = function remove (origin){
+ var position = this.origins.indexOf(origin);
+
+ // only remove and recompile if we have a match
+ if (position > 0) {
+ this.origins.splice(position,1);
+ this.compile();
+ }
+
+ return this;
+};
+
+/**
+ * Closes and cleans up the server
+ *
+ * @api public
+ */
+
+Server.prototype.close = function close () {
+ this.socket.removeAllListeners();
+ this.socket.close();
+
+ return this;
+};
+
+/**
+ * Proxy the event listener requests to the created Net server
+ */
+
+Object.keys(process.EventEmitter.prototype).forEach(function proxy (key){
+ Server.prototype[key] = Server.prototype[key] || function () {
+ if (this.socket) {
+ this.socket[key].apply(this.socket, arguments);
+ }
+
+ return this;
+ };
+});
+
+/**
+ * Creates a new server instance.
+ *
+ * @param {Object} options A options object to override the default config
+ * @param {Array} origins The origins that should be allowed by the server
+ * @api public
+ */
+
+exports.createServer = function createServer(options, origins){
+ origins = Array.isArray(origins) ? origins : (Array.isArray(options) ? options : false);
+ options = !Array.isArray(options) && options ? options : {};
+
+ return new Server(options, origins);
+};
+
+/**
+ * Provide a hook to the original server, so it can be extended if needed.
+ */
+
+exports.Server = Server;
+
+/**
+ * Module version
+ */
+
+exports.version = '0.0.4';
diff --git a/node_modules/socket.io/node_modules/policyfile/package.json b/node_modules/socket.io/node_modules/policyfile/package.json
new file mode 100644
index 0000000..b567146
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/package.json
@@ -0,0 +1,55 @@
+{
+ "name": "policyfile",
+ "version": "0.0.4",
+ "author": {
+ "name": "Arnout Kazemier"
+ },
+ "description": "Flash Socket Policy File Server. A server to respond to Flash Socket Policy requests, both inline and through a dedicated server instance.",
+ "main": "index",
+ "keywords": [
+ "flash",
+ "socket",
+ "policy",
+ "file",
+ "server",
+ "Flash Socket Policy File Server",
+ "cross domain"
+ ],
+ "directories": {
+ "lib": "./lib"
+ },
+ "maintainers": [
+ {
+ "name": "Arnout Kazemier",
+ "email": "info@3rd-Eden.com",
+ "url": "http://blog.3rd-Eden.com"
+ }
+ ],
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": "https://github.com/3rd-Eden/FlashPolicyFileServer/blob/master/LICENSE"
+ }
+ ],
+ "repositories": [
+ {
+ "type": "git",
+ "url": "https://github.com/3rd-Eden/FlashPolicyFileServer.git"
+ }
+ ],
+ "_id": "policyfile@0.0.4",
+ "dependencies": {},
+ "devDependencies": {},
+ "optionalDependencies": {},
+ "engines": {
+ "node": "*"
+ },
+ "_engineSupported": true,
+ "_npmVersion": "1.1.9",
+ "_nodeVersion": "v0.6.13",
+ "_defaultsLoaded": true,
+ "dist": {
+ "shasum": "5d68831f86284d31ba967d0211f70ffc12206879"
+ },
+ "_from": "policyfile@0.0.4"
+}
diff --git a/node_modules/socket.io/node_modules/policyfile/tests/ssl/ssl.crt b/node_modules/socket.io/node_modules/policyfile/tests/ssl/ssl.crt
new file mode 100644
index 0000000..5883cd4
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/tests/ssl/ssl.crt
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDXTCCAkWgAwIBAgIJAMUSOvlaeyQHMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQwHhcNMTAxMTE2MDkzMjQ5WhcNMTMxMTE1MDkzMjQ5WjBF
+MQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50
+ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+CgKCAQEAz+LXZOjcQCJq3+ZKUFabj71oo/ex/XsBcFqtBThjjTw9CVEVwfPQQp4X
+wtPiB204vnYXwQ1/R2NdTQqCZu47l79LssL/u2a5Y9+0NEU3nQA5qdt+1FAE0c5o
+exPimXOrR3GWfKz7PmZ2O0117IeCUUXPG5U8umhDe/4mDF4ZNJiKc404WthquTqg
+S7rLQZHhZ6D0EnGnOkzlmxJMYPNHSOY1/6ivdNUUcC87awNEA3lgfhy25IyBK3QJ
+c+aYKNTbt70Lery3bu2wWLFGtmNiGlQTS4JsxImRsECTI727ObS7/FWAQsqW+COL
+0Sa5BuMFrFIpjPrEe0ih7vRRbdmXRwIDAQABo1AwTjAdBgNVHQ4EFgQUDnV4d6mD
+tOnluLoCjkUHTX/n4agwHwYDVR0jBBgwFoAUDnV4d6mDtOnluLoCjkUHTX/n4agw
+DAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAFwV4MQfTo+qMv9JMiyno
+IEiqfOz4RgtmBqRnXUffcjS2dhc7/z+FPZnM79Kej8eLHoVfxCyWRHFlzm93vEdv
+wxOCrD13EDOi08OOZfxWyIlCa6Bg8cMAKqQzd2OvQOWqlRWBTThBJIhWflU33izX
+Qn5GdmYqhfpc+9ZHHGhvXNydtRQkdxVK2dZNzLBvBlLlRmtoClU7xm3A+/5dddeP
+AQHEPtyFlUw49VYtZ3ru6KqPms7MKvcRhYLsy9rwSfuuniMlx4d0bDR7TOkw0QQS
+A0N8MGQRQpzl4mw4jLzyM5d5QtuGBh2P6hPGa0YQxtI3RPT/p6ENzzBiAKXiSfzo
+xw==
+-----END CERTIFICATE-----
diff --git a/node_modules/socket.io/node_modules/policyfile/tests/ssl/ssl.private.key b/node_modules/socket.io/node_modules/policyfile/tests/ssl/ssl.private.key
new file mode 100644
index 0000000..f31ff3d
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/tests/ssl/ssl.private.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAz+LXZOjcQCJq3+ZKUFabj71oo/ex/XsBcFqtBThjjTw9CVEV
+wfPQQp4XwtPiB204vnYXwQ1/R2NdTQqCZu47l79LssL/u2a5Y9+0NEU3nQA5qdt+
+1FAE0c5oexPimXOrR3GWfKz7PmZ2O0117IeCUUXPG5U8umhDe/4mDF4ZNJiKc404
+WthquTqgS7rLQZHhZ6D0EnGnOkzlmxJMYPNHSOY1/6ivdNUUcC87awNEA3lgfhy2
+5IyBK3QJc+aYKNTbt70Lery3bu2wWLFGtmNiGlQTS4JsxImRsECTI727ObS7/FWA
+QsqW+COL0Sa5BuMFrFIpjPrEe0ih7vRRbdmXRwIDAQABAoIBAGe4+9VqZfJN+dsq
+8Osyuz01uQ8OmC0sAWTIqUlQgENIyf9rCJsUBlYmwR5BT6Z69XP6QhHdpSK+TiAR
+XUz0EqG9HYzcxHIBaACP7j6iRoQ8R4kbbiWKo0z3WqQGIOqFjvD/mKEuQdE5mEYw
+eOUCG6BnX1WY2Yr8WKd2AA/tp0/Y4d8z04u9eodMpSTbHTzYMJb5SbBN1vo6FY7q
+8zSuO0BMzXlAxUsCwHsk1GQHFr8Oh3zIR7bQGtMBouI+6Lhh7sjFYsfxJboqMTBV
+IKaA216M6ggHG7MU1/jeKcMGDmEfqQLQoyWp29rMK6TklUgipME2L3UD7vTyAVzz
+xbVOpZkCgYEA8CXW4sZBBrSSrLR5SB+Ubu9qNTggLowOsC/kVKB2WJ4+xooc5HQo
+mFhq1v/WxPQoWIxdYsfg2odlL+JclK5Qcy6vXmRSdAQ5lK9gBDKxZSYc3NwAw2HA
+zyHCTK+I0n8PBYQ+yGcrxu0WqTGnlLW+Otk4CejO34WlgHwbH9bbY5UCgYEA3ZvT
+C4+OoMHXlmICSt29zUrYiL33IWsR3/MaONxTEDuvgkOSXXQOl/8Ebd6Nu+3WbsSN
+bjiPC/JyL1YCVmijdvFpl4gjtgvfJifs4G+QHvO6YfsYoVANk4u6g6rUuBIOwNK4
+RwYxwDc0oysp+g7tPxoSgDHReEVKJNzGBe9NGGsCgYEA4O4QP4gCEA3B9BF2J5+s
+n9uPVxmiyvZUK6Iv8zP4pThTBBMIzNIf09G9AHPQ7djikU2nioY8jXKTzC3xGTHM
+GJZ5m6fLsu7iH+nDvSreDSeNkTBfZqGAvoGYQ8uGE+L+ZuRfCcXYsxIOT5s6o4c3
+Dle2rVFpsuKzCY00urW796ECgYBn3go75+xEwrYGQSer6WR1nTgCV29GVYXKPooy
+zmmMOT1Yw80NSkEw0pFD4cTyqVYREsTrPU0mn1sPfrOXxnGfZSVFpcR/Je9QVfQ7
+eW7GYxwfom335aqHVj10SxRqteP+UoWWnHujCPz94VRKZMakBddYCIGSan+G6YdS
+7sdmwwKBgBc2qj0wvGXDF2kCLwSGfWoMf8CS1+5fIiUIdT1e/+7MfDdbmLMIFVjF
+QKS3zVViXCbrG5SY6wS9hxoc57f6E2A8vcaX6zy2xkZlGHQCpWRtEM5R01OWJQaH
+HsHMmQZGUQVoDm1oRkDhrTFK4K3ukc3rAxzeTZ96utOQN8/KJsTv
+-----END RSA PRIVATE KEY-----
diff --git a/node_modules/socket.io/node_modules/policyfile/tests/unit.test.js b/node_modules/socket.io/node_modules/policyfile/tests/unit.test.js
new file mode 100644
index 0000000..932b3c1
--- /dev/null
+++ b/node_modules/socket.io/node_modules/policyfile/tests/unit.test.js
@@ -0,0 +1,231 @@
+var fspfs = require('../')
+ , fs = require('fs')
+ , http = require('http')
+ , https = require('https')
+ , net = require('net')
+ , should = require('should')
+ , assert = require('assert');
+
+module.exports = {
+ // Library version should be Semver compatible
+ 'Library version': function(){
+ fspfs.version.should.match(/^\d+\.\d+\.\d+$/);
+ }
+
+ // Creating a server instace should not cause any problems
+ // either using the new Server or createServer method.
+, 'Create Server instance': function(){
+ var server = fspfs.createServer()
+ , server2 = new fspfs.Server({log:false}, ['blog.3rd-Eden.com:1337']);
+
+ // server 2 options test
+ server2.log.should.be.false;
+ server2.origins.length.should.equal(1);
+ server2.origins[0].should.equal('blog.3rd-Eden.com:1337');
+
+ // server defaults
+ (typeof server.log).should.be.equal('function');
+ server.origins.length.should.equal(1);
+ server.origins[0].should.equal('*:*');
+
+ // instance checking, sanity check
+ assert.ok(server instanceof fspfs.Server);
+ assert.ok(!!server.buffer);
+
+ // more options testing
+ server = fspfs.createServer(['blog.3rd-Eden.com:80']);
+ server.origins.length.should.equal(1);
+ server.origins[0].should.equal('blog.3rd-Eden.com:80');
+
+ server = fspfs.createServer({log:false},['blog.3rd-Eden.com:80']);
+ server.log.should.be.false;
+ server.origins.length.should.equal(1);
+ server.origins[0].should.equal('blog.3rd-Eden.com:80');
+
+ }
+
+, 'Add origin': function(){
+ var server = fspfs.createServer();
+ server.add('google.com:80', 'blog.3rd-Eden.com:1337');
+
+ server.origins.length.should.equal(3);
+ server.origins.indexOf('google.com:80').should.be.above(0);
+
+ // don't allow duplicates
+ server.add('google.com:80', 'google.com:80');
+
+ var i = server.origins.length
+ , count = 0;
+
+ while(i--){
+ if (server.origins[i] === 'google.com:80'){
+ count++;
+ }
+ }
+
+ count.should.equal(1);
+ }
+
+, 'Remove origin': function(){
+ var server = fspfs.createServer();
+ server.add('google.com:80', 'blog.3rd-Eden.com:1337');
+ server.origins.length.should.equal(3);
+
+ server.remove('google.com:80');
+ server.origins.length.should.equal(2);
+ server.origins.indexOf('google.com:80').should.equal(-1);
+ }
+
+, 'Buffer': function(){
+ var server = fspfs.createServer();
+
+ Buffer.isBuffer(server.buffer).should.be.true;
+ server.buffer.toString().indexOf('to-ports="*"').should.be.above(0);
+ server.buffer.toString().indexOf('domain="*"').should.be.above(0);
+ server.buffer.toString().indexOf('domain="google.com"').should.equal(-1);
+
+ // The buffers should be rebuild when new origins are added
+ server.add('google.com:80');
+ server.buffer.toString().indexOf('to-ports="80"').should.be.above(0);
+ server.buffer.toString().indexOf('domain="google.com"').should.be.above(0);
+
+ server.remove('google.com:80');
+ server.buffer.toString().indexOf('to-ports="80"').should.equal(-1);
+ server.buffer.toString().indexOf('domain="google.com"').should.equal(-1);
+ }
+
+, 'Responder': function(){
+ var server = fspfs.createServer()
+ , calls = 0
+ // dummy socket to emulate a `real` socket
+ , dummySocket = {
+ readyState: 'open'
+ , end: function(buffer){
+ calls++;
+ Buffer.isBuffer(buffer).should.be.true;
+ buffer.toString().should.equal(server.buffer.toString());
+ }
+ };
+
+ server.responder(dummySocket);
+ calls.should.equal(1);
+ }
+
+, 'Event proxy': function(){
+ var server = fspfs.createServer()
+ , calls = 0;
+
+ Object.keys(process.EventEmitter.prototype).forEach(function proxy(key){
+ assert.ok(!!server[key] && typeof server[key] === 'function');
+ });
+
+ // test if it works by calling a none default event
+ server.on('pew', function(){
+ calls++;
+ });
+
+ server.emit('pew');
+ calls.should.equal(1);
+ }
+
+, 'inline response http': function(){
+ var port = 1335
+ , httpserver = http.createServer(function(q,r){r.writeHead(200);r.end(':3')})
+ , server = fspfs.createServer();
+
+ httpserver.listen(port, function(){
+ server.listen(port + 1, httpserver, function(){
+ var client = net.createConnection(port);
+ client.write('\0');
+ client.on('error', function(err){
+ assert.ok(!err, err)
+ });
+ client.on('data', function(data){
+
+ var response = data.toString();
+ console.log(response);
+
+ response.indexOf('to-ports="*"').should.be.above(0);
+ response.indexOf('domain="*"').should.be.above(0);
+ response.indexOf('domain="google.com"').should.equal(-1);
+
+ // clean up
+ client.destroy();
+ server.close();
+ httpserver.close();
+ });
+ });
+ });
+ }
+
+, 'server response': function(){
+ var port = 1340
+ , server = fspfs.createServer();
+
+ server.listen(port, function(){
+ var client = net.createConnection(port);
+ client.write('\0');
+ client.on('error', function(err){
+ assert.ok(!err, err)
+ });
+ client.on('data', function(data){
+
+ var response = data.toString();
+
+ response.indexOf('to-ports="*"').should.be.above(0);
+ response.indexOf('domain="*"').should.be.above(0);
+ response.indexOf('domain="google.com"').should.equal(-1);
+
+ // clean up
+ client.destroy();
+ server.close();
+ });
+ });
+ }
+
+, 'inline response https': function(){
+ var port = 1345
+ , ssl = {
+ key: fs.readFileSync(__dirname + '/ssl/ssl.private.key').toString()
+ , cert: fs.readFileSync(__dirname + '/ssl/ssl.crt').toString()
+ }
+ , httpserver = https.createServer(ssl, function(q,r){r.writeHead(200);r.end(':3')})
+ , server = fspfs.createServer();
+
+ httpserver.listen(port, function(){
+ server.listen(port + 1, httpserver, function(){
+ var client = net.createConnection(port);
+ client.write('\0');
+ client.on('error', function(err){
+ assert.ok(!err, err)
+ });
+ client.on('data', function(data){
+
+ var response = data.toString();
+
+ response.indexOf('to-ports="*"').should.be.above(0);
+ response.indexOf('domain="*"').should.be.above(0);
+ response.indexOf('domain="google.com"').should.equal(-1);
+
+ // clean up
+ client.destroy();
+ server.close();
+ httpserver.close();
+ });
+ });
+ });
+ }
+
+, 'connect_failed': function(){
+ var server = fspfs.createServer();
+
+ server.on('connect_failed', function(){
+ assert.ok(true);
+ });
+
+ server.listen(function(){
+ assert.ok(false, 'Run this test without root access');
+ server.close();
+ });
+ }
+};
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/redis/README.md b/node_modules/socket.io/node_modules/redis/README.md
new file mode 100644
index 0000000..02a873b
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/README.md
@@ -0,0 +1,567 @@
+redis - a node.js redis client
+===========================
+
+This is a complete Redis client for node.js. It supports all Redis commands, including many recently added commands like EVAL from
+experimental Redis server branches.
+
+
+Install with:
+
+ npm install redis
+
+Pieter Noordhuis has provided a binding to the official `hiredis` C library, which is non-blocking and fast. To use `hiredis`, do:
+
+ npm install hiredis redis
+
+If `hiredis` is installed, `node_redis` will use it by default. Otherwise, a pure JavaScript parser will be used.
+
+If you use `hiredis`, be sure to rebuild it whenever you upgrade your version of node. There are mysterious failures that can
+happen between node and native code modules after a node upgrade.
+
+
+## Usage
+
+Simple example, included as `examples/simple.js`:
+
+ var redis = require("redis"),
+ client = redis.createClient();
+
+ client.on("error", function (err) {
+ console.log("Error " + err);
+ });
+
+ client.set("string key", "string val", redis.print);
+ client.hset("hash key", "hashtest 1", "some value", redis.print);
+ client.hset(["hash key", "hashtest 2", "some other value"], redis.print);
+ client.hkeys("hash key", function (err, replies) {
+ console.log(replies.length + " replies:");
+ replies.forEach(function (reply, i) {
+ console.log(" " + i + ": " + reply);
+ });
+ client.quit();
+ });
+
+This will display:
+
+ mjr:~/work/node_redis (master)$ node example.js
+ Reply: OK
+ Reply: 0
+ Reply: 0
+ 2 replies:
+ 0: hashtest 1
+ 1: hashtest 2
+ mjr:~/work/node_redis (master)$
+
+
+## Performance
+
+Here are typical results of `multi_bench.js` which is similar to `redis-benchmark` from the Redis distribution.
+It uses 50 concurrent connections with no pipelining.
+
+JavaScript parser:
+
+ PING: 20000 ops 42283.30 ops/sec 0/5/1.182
+ SET: 20000 ops 32948.93 ops/sec 1/7/1.515
+ GET: 20000 ops 28694.40 ops/sec 0/9/1.740
+ INCR: 20000 ops 39370.08 ops/sec 0/8/1.269
+ LPUSH: 20000 ops 36429.87 ops/sec 0/8/1.370
+ LRANGE (10 elements): 20000 ops 9891.20 ops/sec 1/9/5.048
+ LRANGE (100 elements): 20000 ops 1384.56 ops/sec 10/91/36.072
+
+hiredis parser:
+
+ PING: 20000 ops 46189.38 ops/sec 1/4/1.082
+ SET: 20000 ops 41237.11 ops/sec 0/6/1.210
+ GET: 20000 ops 39682.54 ops/sec 1/7/1.257
+ INCR: 20000 ops 40080.16 ops/sec 0/8/1.242
+ LPUSH: 20000 ops 41152.26 ops/sec 0/3/1.212
+ LRANGE (10 elements): 20000 ops 36563.07 ops/sec 1/8/1.363
+ LRANGE (100 elements): 20000 ops 21834.06 ops/sec 0/9/2.287
+
+The performance of `node_redis` improves dramatically with pipelining, which happens automatically in most normal programs.
+
+
+### Sending Commands
+
+Each Redis command is exposed as a function on the `client` object.
+All functions take either take either an `args` Array plus optional `callback` Function or
+a variable number of individual arguments followed by an optional callback.
+Here is an example of passing an array of arguments and a callback:
+
+ client.mset(["test keys 1", "test val 1", "test keys 2", "test val 2"], function (err, res) {});
+
+Here is that same call in the second style:
+
+ client.mset("test keys 1", "test val 1", "test keys 2", "test val 2", function (err, res) {});
+
+Note that in either form the `callback` is optional:
+
+ client.set("some key", "some val");
+ client.set(["some other key", "some val"]);
+
+For a list of Redis commands, see [Redis Command Reference](http://redis.io/commands)
+
+The commands can be specified in uppercase or lowercase for convenience. `client.get()` is the same as `client.GET()`.
+
+Minimal parsing is done on the replies. Commands that return a single line reply return JavaScript Strings,
+integer replies return JavaScript Numbers, "bulk" replies return node Buffers, and "multi bulk" replies return a
+JavaScript Array of node Buffers. `HGETALL` returns an Object with Buffers keyed by the hash keys.
+
+# API
+
+## Connection Events
+
+`client` will emit some events about the state of the connection to the Redis server.
+
+### "ready"
+
+`client` will emit `ready` a connection is established to the Redis server and the server reports
+that it is ready to receive commands. Commands issued before the `ready` event are queued,
+then replayed just before this event is emitted.
+
+### "connect"
+
+`client` will emit `connect` at the same time as it emits `ready` unless `client.options.no_ready_check`
+is set. If this options is set, `connect` will be emitted when the stream is connected, and then
+you are free to try to send commands.
+
+### "error"
+
+`client` will emit `error` when encountering an error connecting to the Redis server.
+
+Note that "error" is a special event type in node. If there are no listeners for an
+"error" event, node will exit. This is usually what you want, but it can lead to some
+cryptic error messages like this:
+
+ mjr:~/work/node_redis (master)$ node example.js
+
+ node.js:50
+ throw e;
+ ^
+ Error: ECONNREFUSED, Connection refused
+ at IOWatcher.callback (net:870:22)
+ at node.js:607:9
+
+Not very useful in diagnosing the problem, but if your program isn't ready to handle this,
+it is probably the right thing to just exit.
+
+`client` will also emit `error` if an exception is thrown inside of `node_redis` for whatever reason.
+It would be nice to distinguish these two cases.
+
+### "end"
+
+`client` will emit `end` when an established Redis server connection has closed.
+
+### "drain"
+
+`client` will emit `drain` when the TCP connection to the Redis server has been buffering, but is now
+writable. This event can be used to stream commands in to Redis and adapt to backpressure. Right now,
+you need to check `client.command_queue.length` to decide when to reduce your send rate. Then you can
+resume sending when you get `drain`.
+
+### "idle"
+
+`client` will emit `idle` when there are no outstanding commands that are awaiting a response.
+
+## redis.createClient(port, host, options)
+
+Create a new client connection. `port` defaults to `6379` and `host` defaults
+to `127.0.0.1`. If you have `redis-server` running on the same computer as node, then the defaults for
+port and host are probably fine. `options` in an object with the following possible properties:
+
+* `parser`: which Redis protocol reply parser to use. Defaults to `hiredis` if that module is installed.
+This may also be set to `javascript`.
+* `return_buffers`: defaults to false. If set to `true`, then bulk data replies will be returned as node Buffer
+objects instead of JavaScript Strings.
+
+`createClient()` returns a `RedisClient` object that is named `client` in all of the examples here.
+
+## client.auth(password, callback)
+
+When connecting to Redis servers that require authentication, the `AUTH` command must be sent as the
+first command after connecting. This can be tricky to coordinate with reconnections, the ready check,
+etc. To make this easier, `client.auth()` stashes `password` and will send it after each connection,
+including reconnections. `callback` is invoked only once, after the response to the very first
+`AUTH` command sent.
+
+## client.end()
+
+Forcibly close the connection to the Redis server. Note that this does not wait until all replies have been parsed.
+If you want to exit cleanly, call `client.quit()` to send the `QUIT` command after you have handled all replies.
+
+This example closes the connection to the Redis server before the replies have been read. You probably don't
+want to do this:
+
+ var redis = require("redis"),
+ client = redis.createClient();
+
+ client.set("foo_rand000000000000", "some fantastic value");
+ client.get("foo_rand000000000000", function (err, reply) {
+ console.log(reply.toString());
+ });
+ client.end();
+
+`client.end()` is useful for timeout cases where something is stuck or taking too long and you want
+to start over.
+
+## Friendlier hash commands
+
+Most Redis commands take a single String or an Array of Strings as arguments, and replies are sent back as a single String or an Array of Strings. When dealing with hash values, there are a couple of useful exceptions to this.
+
+### client.hgetall(hash)
+
+The reply from an HGETALL command will be converted into a JavaScript Object by `node_redis`. That way you can interact
+with the responses using JavaScript syntax.
+
+Example:
+
+ client.hmset("hosts", "mjr", "1", "another", "23", "home", "1234");
+ client.hgetall("hosts", function (err, obj) {
+ console.dir(obj);
+ });
+
+Output:
+
+ { mjr: '1', another: '23', home: '1234' }
+
+### client.hmset(hash, obj, [callback])
+
+Multiple values in a hash can be set by supplying an object:
+
+ client.HMSET(key2, {
+ "0123456789": "abcdefghij",
+ "some manner of key": "a type of value"
+ });
+
+The properties and values of this Object will be set as keys and values in the Redis hash.
+
+### client.hmset(hash, key1, val1, ... keyn, valn, [callback])
+
+Multiple values may also be set by supplying a list:
+
+ client.HMSET(key1, "0123456789", "abcdefghij", "some manner of key", "a type of value");
+
+
+## Publish / Subscribe
+
+Here is a simple example of the API for publish / subscribe. This program opens two
+client connections, subscribes to a channel on one of them, and publishes to that
+channel on the other:
+
+ var redis = require("redis"),
+ client1 = redis.createClient(), client2 = redis.createClient(),
+ msg_count = 0;
+
+ client1.on("subscribe", function (channel, count) {
+ client2.publish("a nice channel", "I am sending a message.");
+ client2.publish("a nice channel", "I am sending a second message.");
+ client2.publish("a nice channel", "I am sending my last message.");
+ });
+
+ client1.on("message", function (channel, message) {
+ console.log("client1 channel " + channel + ": " + message);
+ msg_count += 1;
+ if (msg_count === 3) {
+ client1.unsubscribe();
+ client1.end();
+ client2.end();
+ }
+ });
+
+ client1.incr("did a thing");
+ client1.subscribe("a nice channel");
+
+When a client issues a `SUBSCRIBE` or `PSUBSCRIBE`, that connection is put into "pub/sub" mode.
+At that point, only commands that modify the subscription set are valid. When the subscription
+set is empty, the connection is put back into regular mode.
+
+If you need to send regular commands to Redis while in pub/sub mode, just open another connection.
+
+## Pub / Sub Events
+
+If a client has subscriptions active, it may emit these events:
+
+### "message" (channel, message)
+
+Client will emit `message` for every message received that matches an active subscription.
+Listeners are passed the channel name as `channel` and the message Buffer as `message`.
+
+### "pmessage" (pattern, channel, message)
+
+Client will emit `pmessage` for every message received that matches an active subscription pattern.
+Listeners are passed the original pattern used with `PSUBSCRIBE` as `pattern`, the sending channel
+name as `channel`, and the message Buffer as `message`.
+
+### "subscribe" (channel, count)
+
+Client will emit `subscribe` in response to a `SUBSCRIBE` command. Listeners are passed the
+channel name as `channel` and the new count of subscriptions for this client as `count`.
+
+### "psubscribe" (pattern, count)
+
+Client will emit `psubscribe` in response to a `PSUBSCRIBE` command. Listeners are passed the
+original pattern as `pattern`, and the new count of subscriptions for this client as `count`.
+
+### "unsubscribe" (channel, count)
+
+Client will emit `unsubscribe` in response to a `UNSUBSCRIBE` command. Listeners are passed the
+channel name as `channel` and the new count of subscriptions for this client as `count`. When
+`count` is 0, this client has left pub/sub mode and no more pub/sub events will be emitted.
+
+### "punsubscribe" (pattern, count)
+
+Client will emit `punsubscribe` in response to a `PUNSUBSCRIBE` command. Listeners are passed the
+channel name as `channel` and the new count of subscriptions for this client as `count`. When
+`count` is 0, this client has left pub/sub mode and no more pub/sub events will be emitted.
+
+## client.multi([commands])
+
+`MULTI` commands are queued up until an `EXEC` is issued, and then all commands are run atomically by
+Redis. The interface in `node_redis` is to return an individual `Multi` object by calling `client.multi()`.
+
+ var redis = require("./index"),
+ client = redis.createClient(), set_size = 20;
+
+ client.sadd("bigset", "a member");
+ client.sadd("bigset", "another member");
+
+ while (set_size > 0) {
+ client.sadd("bigset", "member " + set_size);
+ set_size -= 1;
+ }
+
+ // multi chain with an individual callback
+ client.multi()
+ .scard("bigset")
+ .smembers("bigset")
+ .keys("*", function (err, replies) {
+ client.mget(replies, redis.print);
+ })
+ .dbsize()
+ .exec(function (err, replies) {
+ console.log("MULTI got " + replies.length + " replies");
+ replies.forEach(function (reply, index) {
+ console.log("Reply " + index + ": " + reply.toString());
+ });
+ });
+
+`client.multi()` is a constructor that returns a `Multi` object. `Multi` objects share all of the
+same command methods as `client` objects do. Commands are queued up inside the `Multi` object
+until `Multi.exec()` is invoked.
+
+You can either chain together `MULTI` commands as in the above example, or you can queue individual
+commands while still sending regular client command as in this example:
+
+ var redis = require("redis"),
+ client = redis.createClient(), multi;
+
+ // start a separate multi command queue
+ multi = client.multi();
+ multi.incr("incr thing", redis.print);
+ multi.incr("incr other thing", redis.print);
+
+ // runs immediately
+ client.mset("incr thing", 100, "incr other thing", 1, redis.print);
+
+ // drains multi queue and runs atomically
+ multi.exec(function (err, replies) {
+ console.log(replies); // 101, 2
+ });
+
+ // you can re-run the same transaction if you like
+ multi.exec(function (err, replies) {
+ console.log(replies); // 102, 3
+ client.quit();
+ });
+
+In addition to adding commands to the `MULTI` queue individually, you can also pass an array
+of commands and arguments to the constructor:
+
+ var redis = require("redis"),
+ client = redis.createClient(), multi;
+
+ client.multi([
+ ["mget", "multifoo", "multibar", redis.print],
+ ["incr", "multifoo"],
+ ["incr", "multibar"]
+ ]).exec(function (err, replies) {
+ console.log(replies);
+ });
+
+
+## Monitor mode
+
+Redis supports the `MONITOR` command, which lets you see all commands received by the Redis server
+across all client connections, including from other client libraries and other computers.
+
+After you send the `MONITOR` command, no other commands are valid on that connection. `node_redis`
+will emit a `monitor` event for every new monitor message that comes across. The callback for the
+`monitor` event takes a timestamp from the Redis server and an array of command arguments.
+
+Here is a simple example:
+
+ var client = require("redis").createClient(),
+ util = require("util");
+
+ client.monitor(function (err, res) {
+ console.log("Entering monitoring mode.");
+ });
+
+ client.on("monitor", function (time, args) {
+ console.log(time + ": " + util.inspect(args));
+ });
+
+
+# Extras
+
+Some other things you might like to know about.
+
+## client.server_info
+
+After the ready probe completes, the results from the INFO command are saved in the `client.server_info`
+object.
+
+The `versions` key contains an array of the elements of the version string for easy comparison.
+
+ > client.server_info.redis_version
+ '2.3.0'
+ > client.server_info.versions
+ [ 2, 3, 0 ]
+
+## redis.print()
+
+A handy callback function for displaying return values when testing. Example:
+
+ var redis = require("redis"),
+ client = redis.createClient();
+
+ client.on("connect", function () {
+ client.set("foo_rand000000000000", "some fantastic value", redis.print);
+ client.get("foo_rand000000000000", redis.print);
+ });
+
+This will print:
+
+ Reply: OK
+ Reply: some fantastic value
+
+Note that this program will not exit cleanly because the client is still connected.
+
+## redis.debug_mode
+
+Boolean to enable debug mode and protocol tracing.
+
+ var redis = require("redis"),
+ client = redis.createClient();
+
+ redis.debug_mode = true;
+
+ client.on("connect", function () {
+ client.set("foo_rand000000000000", "some fantastic value");
+ });
+
+This will display:
+
+ mjr:~/work/node_redis (master)$ node ~/example.js
+ send command: *3
+ $3
+ SET
+ $20
+ foo_rand000000000000
+ $20
+ some fantastic value
+
+ on_data: +OK
+
+`send command` is data sent into Redis and `on_data` is data received from Redis.
+
+## client.send_command(command_name, args, callback)
+
+Used internally to send commands to Redis. For convenience, nearly all commands that are published on the Redis
+Wiki have been added to the `client` object. However, if I missed any, or if new commands are introduced before
+this library is updated, you can use `send_command()` to send arbitrary commands to Redis.
+
+All commands are sent as multi-bulk commands. `args` can either be an Array of arguments, or individual arguments,
+or omitted completely.
+
+## client.connected
+
+Boolean tracking the state of the connection to the Redis server.
+
+## client.command_queue.length
+
+The number of commands that have been sent to the Redis server but not yet replied to. You can use this to
+enforce some kind of maximum queue depth for commands while connected.
+
+Don't mess with `client.command_queue` though unless you really know what you are doing.
+
+## client.offline_queue.length
+
+The number of commands that have been queued up for a future connection. You can use this to enforce
+some kind of maximum queue depth for pre-connection commands.
+
+## client.retry_delay
+
+Current delay in milliseconds before a connection retry will be attempted. This starts at `250`.
+
+## client.retry_backoff
+
+Multiplier for future retry timeouts. This should be larger than 1 to add more time between retries.
+Defaults to 1.7. The default initial connection retry is 250, so the second retry will be 425, followed by 723.5, etc.
+
+
+## TODO
+
+Better tests for monitor mode, auth, disconnect/reconnect, and all combinations thereof.
+
+Stream large set/get values into and out of Redis. Otherwise the entire value must be in node's memory.
+
+Performance can be better for very large values.
+
+I think there are more performance improvements left in there for smaller values, especially for large lists of small values.
+
+## Contributors
+
+Some people have have added features and fixed bugs in `node_redis` other than me.
+
+In order of first contribution, they are:
+
+* [Tim Smart](https://github.com/Tim-Smart)
+* [TJ Holowaychuk](https://github.com/visionmedia)
+* [Rick Olson](https://github.com/technoweenie)
+* [Orion Henry](https://github.com/orionz)
+* [Hank Sims](https://github.com/hanksims)
+* [Aivo Paas](https://github.com/aivopaas)
+* [Paul Carey](https://github.com/paulcarey)
+* [Pieter Noordhuis](https://github.com/pietern)
+* [Vladimir Dronnikov](https://github.com/dvv)
+* [Dave Hoover](https://github.com/redsquirrel)
+
+Thanks.
+
+## LICENSE - "MIT License"
+
+Copyright (c) 2010 Matthew Ranney, http://ranney.com/
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+
diff --git a/node_modules/socket.io/node_modules/redis/changelog.md b/node_modules/socket.io/node_modules/redis/changelog.md
new file mode 100644
index 0000000..f9a0b20
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/changelog.md
@@ -0,0 +1,184 @@
+Changelog
+=========
+
+## v0.6.7 - July 30, 2011
+
+(accidentally skipped v0.6.6)
+
+Fix and test for [GH-123]
+
+Passing an Array as as the last argument should expand as users
+expect. The old behavior was to coerce the arguments into Strings,
+which did surprising things with Arrays.
+
+## v0.6.5 - July 6, 2011
+
+Contributed changes:
+
+* Support SlowBuffers (Umair Siddique)
+* Add Multi to exports (Louis-Philippe Perron)
+* Fix for drain event calculation (Vladimir Dronnikov)
+
+Thanks!
+
+## v0.6.4 - June 30, 2011
+
+Fix bug with optional callbacks for hmset.
+
+## v0.6.2 - June 30, 2011
+
+Bugs fixed:
+
+* authentication retry while server is loading db (danmaz74) [GH-101]
+* command arguments processing issue with arrays
+
+New features:
+
+* Auto update of new commands from redis.io (Dave Hoover)
+* Performance improvements and backpressure controls.
+* Commands now return the true/false value from the underlying socket write(s).
+* Implement command_queue high water and low water for more better control of queueing.
+
+See `examples/backpressure_drain.js` for more information.
+
+## v0.6.1 - June 29, 2011
+
+Add support and tests for Redis scripting through EXEC command.
+
+Bug fix for monitor mode. (forddg)
+
+Auto update of new commands from redis.io (Dave Hoover)
+
+## v0.6.0 - April 21, 2011
+
+Lots of bugs fixed.
+
+* connection error did not properly trigger reconnection logic [GH-85]
+* client.hmget(key, [val1, val2]) was not expanding properly [GH-66]
+* client.quit() while in pub/sub mode would throw an error [GH-87]
+* client.multi(['hmset', 'key', {foo: 'bar'}]) fails [GH-92]
+* unsubscribe before subscribe would make things very confused [GH-88]
+* Add BRPOPLPUSH [GH-79]
+
+## v0.5.11 - April 7, 2011
+
+Added DISCARD
+
+I originally didn't think DISCARD would do anything here because of the clever MULTI interface, but somebody
+pointed out to me that DISCARD can be used to flush the WATCH set.
+
+## v0.5.10 - April 6, 2011
+
+Added HVALS
+
+## v0.5.9 - March 14, 2011
+
+Fix bug with empty Array arguments - Andy Ray
+
+## v0.5.8 - March 14, 2011
+
+Add `MONITOR` command and special monitor command reply parsing.
+
+## v0.5.7 - February 27, 2011
+
+Add magical auth command.
+
+Authentication is now remembered by the client and will be automatically sent to the server
+on every connection, including any reconnections.
+
+## v0.5.6 - February 22, 2011
+
+Fix bug in ready check with `return_buffers` set to `true`.
+
+Thanks to Dean Mao and Austin Chau.
+
+## v0.5.5 - February 16, 2011
+
+Add probe for server readiness.
+
+When a Redis server starts up, it might take a while to load the dataset into memory.
+During this time, the server will accept connections, but will return errors for all non-INFO
+commands. Now node_redis will send an INFO command whenever it connects to a server.
+If the info command indicates that the server is not ready, the client will keep trying until
+the server is ready. Once it is ready, the client will emit a "ready" event as well as the
+"connect" event. The client will queue up all commands sent before the server is ready, just
+like it did before. When the server is ready, all offline/non-ready commands will be replayed.
+This should be backward compatible with previous versions.
+
+To disable this ready check behavior, set `options.no_ready_check` when creating the client.
+
+As a side effect of this change, the key/val params from the info command are available as
+`client.server_options`. Further, the version string is decomposed into individual elements
+in `client.server_options.versions`.
+
+## v0.5.4 - February 11, 2011
+
+Fix excess memory consumption from Queue backing store.
+
+Thanks to Gustaf Sjöberg.
+
+## v0.5.3 - February 5, 2011
+
+Fix multi/exec error reply callback logic.
+
+Thanks to Stella Laurenzo.
+
+## v0.5.2 - January 18, 2011
+
+Fix bug where unhandled error replies confuse the parser.
+
+## v0.5.1 - January 18, 2011
+
+Fix bug where subscribe commands would not handle redis-server startup error properly.
+
+## v0.5.0 - December 29, 2010
+
+Some bug fixes:
+
+* An important bug fix in reconnection logic. Previously, reply callbacks would be invoked twice after
+ a reconnect.
+* Changed error callback argument to be an actual Error object.
+
+New feature:
+
+* Add friendly syntax for HMSET using an object.
+
+## v0.4.1 - December 8, 2010
+
+Remove warning about missing hiredis. You probably do want it though.
+
+## v0.4.0 - December 5, 2010
+
+Support for multiple response parsers and hiredis C library from Pieter Noordhuis.
+Return Strings instead of Buffers by default.
+Empty nested mb reply bug fix.
+
+## v0.3.9 - November 30, 2010
+
+Fix parser bug on failed EXECs.
+
+## v0.3.8 - November 10, 2010
+
+Fix for null MULTI response when WATCH condition fails.
+
+## v0.3.7 - November 9, 2010
+
+Add "drain" and "idle" events.
+
+## v0.3.6 - November 3, 2010
+
+Add all known Redis commands from Redis master, even ones that are coming in 2.2 and beyond.
+
+Send a friendlier "error" event message on stream errors like connection refused / reset.
+
+## v0.3.5 - October 21, 2010
+
+A few bug fixes.
+
+* Fixed bug with `nil` multi-bulk reply lengths that showed up with `BLPOP` timeouts.
+* Only emit `end` once when connection goes away.
+* Fixed bug in `test.js` where driver finished before all tests completed.
+
+## unversioned wasteland
+
+See the git history for what happened before.
diff --git a/node_modules/socket.io/node_modules/redis/eval_test.js b/node_modules/socket.io/node_modules/redis/eval_test.js
new file mode 100644
index 0000000..c1fbf8a
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/eval_test.js
@@ -0,0 +1,9 @@
+var redis = require("./index"),
+ client = redis.createClient();
+
+redis.debug_mode = true;
+
+client.eval("return 100.5", 0, function (err, res) {
+ console.dir(err);
+ console.dir(res);
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/auth.js b/node_modules/socket.io/node_modules/redis/examples/auth.js
new file mode 100644
index 0000000..6c0a563
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/auth.js
@@ -0,0 +1,5 @@
+var redis = require("redis"),
+ client = redis.createClient();
+
+// This command is magical. Client stashes the password and will issue on every connect.
+client.auth("somepass");
diff --git a/node_modules/socket.io/node_modules/redis/examples/backpressure_drain.js b/node_modules/socket.io/node_modules/redis/examples/backpressure_drain.js
new file mode 100644
index 0000000..3488ef4
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/backpressure_drain.js
@@ -0,0 +1,33 @@
+var redis = require("../index"),
+ client = redis.createClient(null, null, {
+ command_queue_high_water: 5,
+ command_queue_low_water: 1
+ }),
+ remaining_ops = 100000, paused = false;
+
+function op() {
+ if (remaining_ops <= 0) {
+ console.error("Finished.");
+ process.exit(0);
+ }
+
+ remaining_ops--;
+ if (client.hset("test hash", "val " + remaining_ops, remaining_ops) === false) {
+ console.log("Pausing at " + remaining_ops);
+ paused = true;
+ } else {
+ process.nextTick(op);
+ }
+}
+
+client.on("drain", function () {
+ if (paused) {
+ console.log("Resuming at " + remaining_ops);
+ paused = false;
+ process.nextTick(op);
+ } else {
+ console.log("Got drain while not paused at " + remaining_ops);
+ }
+});
+
+op();
diff --git a/node_modules/socket.io/node_modules/redis/examples/extend.js b/node_modules/socket.io/node_modules/redis/examples/extend.js
new file mode 100644
index 0000000..488b8c2
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/extend.js
@@ -0,0 +1,24 @@
+var redis = require("redis"),
+ client = redis.createClient();
+
+// Extend the RedisClient prototype to add a custom method
+// This one converts the results from "INFO" into a JavaScript Object
+
+redis.RedisClient.prototype.parse_info = function (callback) {
+ this.info(function (err, res) {
+ var lines = res.toString().split("\r\n").sort();
+ var obj = {};
+ lines.forEach(function (line) {
+ var parts = line.split(':');
+ if (parts[1]) {
+ obj[parts[0]] = parts[1];
+ }
+ });
+ callback(obj)
+ });
+};
+
+client.parse_info(function (info) {
+ console.dir(info);
+ client.quit();
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/file.js b/node_modules/socket.io/node_modules/redis/examples/file.js
new file mode 100644
index 0000000..4d2b5d1
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/file.js
@@ -0,0 +1,32 @@
+// Read a file from disk, store it in Redis, then read it back from Redis.
+
+var redis = require("redis"),
+ client = redis.createClient(),
+ fs = require("fs"),
+ filename = "kids_in_cart.jpg";
+
+// Get the file I use for testing like this:
+// curl http://ranney.com/kids_in_cart.jpg -o kids_in_cart.jpg
+// or just use your own file.
+
+// Read a file from fs, store it in Redis, get it back from Redis, write it back to fs.
+fs.readFile(filename, function (err, data) {
+ if (err) throw err
+ console.log("Read " + data.length + " bytes from filesystem.");
+
+ client.set(filename, data, redis.print); // set entire file
+ client.get(filename, function (err, reply) { // get entire file
+ if (err) {
+ console.log("Get error: " + err);
+ } else {
+ fs.writeFile("duplicate_" + filename, reply, function (err) {
+ if (err) {
+ console.log("Error on write: " + err)
+ } else {
+ console.log("File written.");
+ }
+ client.end();
+ });
+ }
+ });
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/mget.js b/node_modules/socket.io/node_modules/redis/examples/mget.js
new file mode 100644
index 0000000..936740d
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/mget.js
@@ -0,0 +1,5 @@
+var client = require("redis").createClient();
+
+client.mget(["sessions started", "sessions started", "foo"], function (err, res) {
+ console.dir(res);
+});
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/redis/examples/monitor.js b/node_modules/socket.io/node_modules/redis/examples/monitor.js
new file mode 100644
index 0000000..2cb6a4e
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/monitor.js
@@ -0,0 +1,10 @@
+var client = require("../index").createClient(),
+ util = require("util");
+
+client.monitor(function (err, res) {
+ console.log("Entering monitoring mode.");
+});
+
+client.on("monitor", function (time, args) {
+ console.log(time + ": " + util.inspect(args));
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/multi.js b/node_modules/socket.io/node_modules/redis/examples/multi.js
new file mode 100644
index 0000000..35c08e1
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/multi.js
@@ -0,0 +1,46 @@
+var redis = require("redis"),
+ client = redis.createClient(), set_size = 20;
+
+client.sadd("bigset", "a member");
+client.sadd("bigset", "another member");
+
+while (set_size > 0) {
+ client.sadd("bigset", "member " + set_size);
+ set_size -= 1;
+}
+
+// multi chain with an individual callback
+client.multi()
+ .scard("bigset")
+ .smembers("bigset")
+ .keys("*", function (err, replies) {
+ client.mget(replies, redis.print);
+ })
+ .dbsize()
+ .exec(function (err, replies) {
+ console.log("MULTI got " + replies.length + " replies");
+ replies.forEach(function (reply, index) {
+ console.log("Reply " + index + ": " + reply.toString());
+ });
+ });
+
+client.mset("incr thing", 100, "incr other thing", 1, redis.print);
+
+// start a separate multi command queue
+var multi = client.multi();
+multi.incr("incr thing", redis.print);
+multi.incr("incr other thing", redis.print);
+
+// runs immediately
+client.get("incr thing", redis.print); // 100
+
+// drains multi queue and runs atomically
+multi.exec(function (err, replies) {
+ console.log(replies); // 101, 2
+});
+
+// you can re-run the same transaction if you like
+multi.exec(function (err, replies) {
+ console.log(replies); // 102, 3
+ client.quit();
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/multi2.js b/node_modules/socket.io/node_modules/redis/examples/multi2.js
new file mode 100644
index 0000000..8be4d73
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/multi2.js
@@ -0,0 +1,29 @@
+var redis = require("redis"),
+ client = redis.createClient(), multi;
+
+// start a separate command queue for multi
+multi = client.multi();
+multi.incr("incr thing", redis.print);
+multi.incr("incr other thing", redis.print);
+
+// runs immediately
+client.mset("incr thing", 100, "incr other thing", 1, redis.print);
+
+// drains multi queue and runs atomically
+multi.exec(function (err, replies) {
+ console.log(replies); // 101, 2
+});
+
+// you can re-run the same transaction if you like
+multi.exec(function (err, replies) {
+ console.log(replies); // 102, 3
+ client.quit();
+});
+
+client.multi([
+ ["mget", "multifoo", "multibar", redis.print],
+ ["incr", "multifoo"],
+ ["incr", "multibar"]
+]).exec(function (err, replies) {
+ console.log(replies.toString());
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/psubscribe.js b/node_modules/socket.io/node_modules/redis/examples/psubscribe.js
new file mode 100644
index 0000000..c57117b
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/psubscribe.js
@@ -0,0 +1,33 @@
+var redis = require("redis"),
+ client1 = redis.createClient(),
+ client2 = redis.createClient(),
+ client3 = redis.createClient(),
+ client4 = redis.createClient(),
+ msg_count = 0;
+
+redis.debug_mode = false;
+
+client1.on("psubscribe", function (pattern, count) {
+ console.log("client1 psubscribed to " + pattern + ", " + count + " total subscriptions");
+ client2.publish("channeltwo", "Me!");
+ client3.publish("channelthree", "Me too!");
+ client4.publish("channelfour", "And me too!");
+});
+
+client1.on("punsubscribe", function (pattern, count) {
+ console.log("client1 punsubscribed from " + pattern + ", " + count + " total subscriptions");
+ client4.end();
+ client3.end();
+ client2.end();
+ client1.end();
+});
+
+client1.on("pmessage", function (pattern, channel, message) {
+ console.log("("+ pattern +")" + " client1 received message on " + channel + ": " + message);
+ msg_count += 1;
+ if (msg_count === 3) {
+ client1.punsubscribe();
+ }
+});
+
+client1.psubscribe("channel*");
diff --git a/node_modules/socket.io/node_modules/redis/examples/pub_sub.js b/node_modules/socket.io/node_modules/redis/examples/pub_sub.js
new file mode 100644
index 0000000..aa508d6
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/pub_sub.js
@@ -0,0 +1,41 @@
+var redis = require("redis"),
+ client1 = redis.createClient(), msg_count = 0,
+ client2 = redis.createClient();
+
+redis.debug_mode = false;
+
+// Most clients probably don't do much on "subscribe". This example uses it to coordinate things within one program.
+client1.on("subscribe", function (channel, count) {
+ console.log("client1 subscribed to " + channel + ", " + count + " total subscriptions");
+ if (count === 2) {
+ client2.publish("a nice channel", "I am sending a message.");
+ client2.publish("another one", "I am sending a second message.");
+ client2.publish("a nice channel", "I am sending my last message.");
+ }
+});
+
+client1.on("unsubscribe", function (channel, count) {
+ console.log("client1 unsubscribed from " + channel + ", " + count + " total subscriptions");
+ if (count === 0) {
+ client2.end();
+ client1.end();
+ }
+});
+
+client1.on("message", function (channel, message) {
+ console.log("client1 channel " + channel + ": " + message);
+ msg_count += 1;
+ if (msg_count === 3) {
+ client1.unsubscribe();
+ }
+});
+
+client1.on("ready", function () {
+ // if you need auth, do it here
+ client1.incr("did a thing");
+ client1.subscribe("a nice channel", "another one");
+});
+
+client2.on("ready", function () {
+ // if you need auth, do it here
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/simple.js b/node_modules/socket.io/node_modules/redis/examples/simple.js
new file mode 100644
index 0000000..b93c557
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/simple.js
@@ -0,0 +1,17 @@
+var redis = require("redis"),
+ client = redis.createClient();
+
+client.on("error", function (err) {
+ console.log("Redis connection error to " + client.host + ":" + client.port + " - " + err);
+});
+
+client.set("string key", "string val", redis.print);
+client.hset("hash key", "hashtest 1", "some value", redis.print);
+client.hset(["hash key", "hashtest 2", "some other value"], redis.print);
+client.hkeys("hash key", function (err, replies) {
+ console.log(replies.length + " replies:");
+ replies.forEach(function (reply, i) {
+ console.log(" " + i + ": " + reply);
+ });
+ client.quit();
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/subqueries.js b/node_modules/socket.io/node_modules/redis/examples/subqueries.js
new file mode 100644
index 0000000..560db24
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/subqueries.js
@@ -0,0 +1,15 @@
+// Sending commands in response to other commands.
+// This example runs "type" against every key in the database
+//
+var client = require("redis").createClient();
+
+client.keys("*", function (err, keys) {
+ keys.forEach(function (key, pos) {
+ client.type(key, function (err, keytype) {
+ console.log(key + " is " + keytype);
+ if (pos === (keys.length - 1)) {
+ client.quit();
+ }
+ });
+ });
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/subquery.js b/node_modules/socket.io/node_modules/redis/examples/subquery.js
new file mode 100644
index 0000000..861657e
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/subquery.js
@@ -0,0 +1,19 @@
+var client = require("redis").createClient();
+
+function print_results(obj) {
+ console.dir(obj);
+}
+
+// build a map of all keys and their types
+client.keys("*", function (err, all_keys) {
+ var key_types = {};
+
+ all_keys.forEach(function (key, pos) { // use second arg of forEach to get pos
+ client.type(key, function (err, type) {
+ key_types[key] = type;
+ if (pos === all_keys.length - 1) { // callbacks all run in order
+ print_results(key_types);
+ }
+ });
+ });
+});
diff --git a/node_modules/socket.io/node_modules/redis/examples/unix_socket.js b/node_modules/socket.io/node_modules/redis/examples/unix_socket.js
new file mode 100644
index 0000000..4a5e0bb
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/unix_socket.js
@@ -0,0 +1,29 @@
+var redis = require("redis"),
+ client = redis.createClient("/tmp/redis.sock"),
+ profiler = require("v8-profiler");
+
+client.on("connect", function () {
+ console.log("Got Unix socket connection.")
+});
+
+client.on("error", function (err) {
+ console.log(err.message);
+});
+
+client.set("space chars", "space value");
+
+setInterval(function () {
+ client.get("space chars");
+}, 100);
+
+function done() {
+ client.info(function (err, reply) {
+ console.log(reply.toString());
+ client.quit();
+ });
+}
+
+setTimeout(function () {
+ console.log("Taking snapshot.");
+ var snap = profiler.takeSnapshot();
+}, 5000);
diff --git a/node_modules/socket.io/node_modules/redis/examples/web_server.js b/node_modules/socket.io/node_modules/redis/examples/web_server.js
new file mode 100644
index 0000000..9fd8592
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/examples/web_server.js
@@ -0,0 +1,31 @@
+// A simple web server that generates dyanmic content based on responses from Redis
+
+var http = require("http"), server,
+ redis_client = require("redis").createClient();
+
+server = http.createServer(function (request, response) {
+ response.writeHead(200, {
+ "Content-Type": "text/plain"
+ });
+
+ var redis_info, total_requests;
+
+ redis_client.info(function (err, reply) {
+ redis_info = reply; // stash response in outer scope
+ });
+ redis_client.incr("requests", function (err, reply) {
+ total_requests = reply; // stash response in outer scope
+ });
+ redis_client.hincrby("ip", request.connection.remoteAddress, 1);
+ redis_client.hgetall("ip", function (err, reply) {
+ // This is the last reply, so all of the previous replies must have completed already
+ response.write("This page was generated after talking to redis.\n\n" +
+ "Redis info:\n" + redis_info + "\n" +
+ "Total requests: " + total_requests + "\n\n" +
+ "IP count: \n");
+ Object.keys(reply).forEach(function (ip) {
+ response.write(" " + ip + ": " + reply[ip] + "\n");
+ });
+ response.end();
+ });
+}).listen(80);
diff --git a/node_modules/socket.io/node_modules/redis/generate_commands.js b/node_modules/socket.io/node_modules/redis/generate_commands.js
new file mode 100644
index 0000000..e94d74e
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/generate_commands.js
@@ -0,0 +1,40 @@
+var http = require("http"),
+ sys = require("sys"),
+ fs = require("fs");
+
+function prettyCurrentTime() {
+ var date = new Date();
+ return date.toLocaleString();
+}
+
+function write_file(commands, path) {
+ var file_contents, out_commands;
+
+ console.log("Writing " + Object.keys(commands).length + " commands to " + path);
+
+ file_contents = "// This file was generated by ./generate_commands.js on " + prettyCurrentTime() + "\n";
+
+ out_commands = Object.keys(commands).map(function (key) {
+ return key.toLowerCase();
+ });
+
+ file_contents += "module.exports = " + JSON.stringify(out_commands, null, " ") + ";\n";
+
+ fs.writeFile(path, file_contents);
+}
+
+http.get({host: "redis.io", path: "/commands.json"}, function (res) {
+ var body = "";
+
+ console.log("Response from redis.io/commands.json: " + res.statusCode);
+
+ res.on('data', function (chunk) {
+ body += chunk;
+ });
+
+ res.on('end', function () {
+ write_file(JSON.parse(body), "lib/commands.js");
+ });
+}).on('error', function (e) {
+ console.log("Error fetching command list from redis.io: " + e.message);
+});
diff --git a/node_modules/socket.io/node_modules/redis/index.js b/node_modules/socket.io/node_modules/redis/index.js
new file mode 100644
index 0000000..8728cea
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/index.js
@@ -0,0 +1,860 @@
+/*global Buffer require exports console setTimeout */
+
+var net = require("net"),
+ util = require("./lib/util").util,
+ Queue = require("./lib/queue").Queue,
+ to_array = require("./lib/to_array"),
+ events = require("events"),
+ parsers = [], commands,
+ default_port = 6379,
+ default_host = "127.0.0.1";
+
+// can set this to true to enable for all connections
+exports.debug_mode = false;
+
+// hiredis might not be installed
+try {
+ require("./lib/parser/hiredis");
+ parsers.push(require("./lib/parser/hiredis"));
+} catch (err) {
+ if (exports.debug_mode) {
+ console.log("hiredis parser not installed.");
+ }
+}
+
+parsers.push(require("./lib/parser/javascript"));
+
+function RedisClient(stream, options) {
+ this.stream = stream;
+ this.options = options || {};
+
+ this.connected = false;
+ this.ready = false;
+ this.connections = 0;
+ this.attempts = 1;
+ this.should_buffer = false;
+ this.command_queue_high_water = this.options.command_queue_high_water || 1000;
+ this.command_queue_low_water = this.options.command_queue_low_water || 0;
+ this.command_queue = new Queue(); // holds sent commands to de-pipeline them
+ this.offline_queue = new Queue(); // holds commands issued but not able to be sent
+ this.commands_sent = 0;
+ this.retry_delay = 250; // inital reconnection delay
+ this.current_retry_delay = this.retry_delay;
+ this.retry_backoff = 1.7; // each retry waits current delay * retry_backoff
+ this.subscriptions = false;
+ this.monitoring = false;
+ this.closing = false;
+ this.server_info = {};
+ this.auth_pass = null;
+
+ var parser_module, self = this;
+
+ if (self.options.parser) {
+ if (! parsers.some(function (parser) {
+ if (parser.name === self.options.parser) {
+ parser_module = parser;
+ if (exports.debug_mode) {
+ console.log("Using parser module: " + parser_module.name);
+ }
+ return true;
+ }
+ })) {
+ throw new Error("Couldn't find named parser " + self.options.parser + " on this system");
+ }
+ } else {
+ if (exports.debug_mode) {
+ console.log("Using default parser module: " + parsers[0].name);
+ }
+ parser_module = parsers[0];
+ }
+
+ parser_module.debug_mode = exports.debug_mode;
+ this.reply_parser = new parser_module.Parser({
+ return_buffers: self.options.return_buffers || false
+ });
+
+ // "reply error" is an error sent back by Redis
+ this.reply_parser.on("reply error", function (reply) {
+ self.return_error(new Error(reply));
+ });
+ this.reply_parser.on("reply", function (reply) {
+ self.return_reply(reply);
+ });
+ // "error" is bad. Somehow the parser got confused. It'll try to reset and continue.
+ this.reply_parser.on("error", function (err) {
+ self.emit("error", new Error("Redis reply parser error: " + err.stack));
+ });
+
+ this.stream.on("connect", function () {
+ self.on_connect();
+ });
+
+ this.stream.on("data", function (buffer_from_socket) {
+ self.on_data(buffer_from_socket);
+ });
+
+ this.stream.on("error", function (msg) {
+ if (this.closing) {
+ return;
+ }
+
+ var message = "Redis connection to " + self.host + ":" + self.port + " failed - " + msg.message;
+
+ if (exports.debug_mode) {
+ console.warn(message);
+ }
+ self.offline_queue.forEach(function (args) {
+ if (typeof args[2] === "function") {
+ args[2](message);
+ }
+ });
+ self.offline_queue = new Queue();
+
+ self.command_queue.forEach(function (args) {
+ if (typeof args[2] === "function") {
+ args[2](message);
+ }
+ });
+ self.command_queue = new Queue();
+
+ self.connected = false;
+ self.ready = false;
+
+ self.emit("error", new Error(message));
+ // "error" events get turned into exceptions if they aren't listened for. If the user handled this error
+ // then we should try to reconnect.
+ self.connection_gone("error");
+ });
+
+ this.stream.on("close", function () {
+ self.connection_gone("close");
+ });
+
+ this.stream.on("end", function () {
+ self.connection_gone("end");
+ });
+
+ this.stream.on("drain", function () {
+ self.should_buffer = false;
+ self.emit("drain");
+ });
+
+ events.EventEmitter.call(this);
+}
+util.inherits(RedisClient, events.EventEmitter);
+exports.RedisClient = RedisClient;
+
+RedisClient.prototype.do_auth = function () {
+ var self = this;
+
+ if (exports.debug_mode) {
+ console.log("Sending auth to " + self.host + ":" + self.port + " fd " + self.stream.fd);
+ }
+ self.send_anyway = true;
+ self.send_command("auth", [this.auth_pass], function (err, res) {
+ if (err) {
+ if (err.toString().match("LOADING")) {
+ // if redis is still loading the db, it will not authenticate and everything else will fail
+ console.log("Redis still loading, trying to authenticate later");
+ setTimeout(function () {
+ self.do_auth();
+ }, 2000); // TODO - magic number alert
+ return;
+ } else {
+ return self.emit("error", "Auth error: " + err);
+ }
+ }
+ if (res.toString() !== "OK") {
+ return self.emit("error", "Auth failed: " + res.toString());
+ }
+ if (exports.debug_mode) {
+ console.log("Auth succeeded " + self.host + ":" + self.port + " fd " + self.stream.fd);
+ }
+ if (self.auth_callback) {
+ self.auth_callback(err, res);
+ self.auth_callback = null;
+ }
+
+ // now we are really connected
+ self.emit("connect");
+ if (self.options.no_ready_check) {
+ self.ready = true;
+ self.send_offline_queue();
+ } else {
+ self.ready_check();
+ }
+ });
+ self.send_anyway = false;
+};
+
+RedisClient.prototype.on_connect = function () {
+ if (exports.debug_mode) {
+ console.log("Stream connected " + this.host + ":" + this.port + " fd " + this.stream.fd);
+ }
+ var self = this;
+
+ this.connected = true;
+ this.ready = false;
+ this.attempts = 0;
+ this.connections += 1;
+ this.command_queue = new Queue();
+ this.emitted_end = false;
+ this.retry_timer = null;
+ this.current_retry_delay = this.retry_time;
+ this.stream.setNoDelay();
+ this.stream.setTimeout(0);
+
+ if (this.auth_pass) {
+ this.do_auth();
+ } else {
+ this.emit("connect");
+
+ if (this.options.no_ready_check) {
+ this.ready = true;
+ this.send_offline_queue();
+ } else {
+ this.ready_check();
+ }
+ }
+};
+
+RedisClient.prototype.ready_check = function () {
+ var self = this;
+
+ function send_info_cmd() {
+ if (exports.debug_mode) {
+ console.log("checking server ready state...");
+ }
+
+ self.send_anyway = true; // secret flag to send_command to send something even if not "ready"
+ self.info(function (err, res) {
+ if (err) {
+ return self.emit("error", "Ready check failed: " + err);
+ }
+
+ var lines = res.toString().split("\r\n"), obj = {}, retry_time;
+
+ lines.forEach(function (line) {
+ var parts = line.split(':');
+ if (parts[1]) {
+ obj[parts[0]] = parts[1];
+ }
+ });
+
+ obj.versions = [];
+ obj.redis_version.split('.').forEach(function (num) {
+ obj.versions.push(+num);
+ });
+
+ // expose info key/vals to users
+ self.server_info = obj;
+
+ if (!obj.loading || (obj.loading && obj.loading === "0")) {
+ if (exports.debug_mode) {
+ console.log("Redis server ready.");
+ }
+ self.ready = true;
+
+ self.send_offline_queue();
+ self.emit("ready");
+ } else {
+ retry_time = obj.loading_eta_seconds * 1000;
+ if (retry_time > 1000) {
+ retry_time = 1000;
+ }
+ if (exports.debug_mode) {
+ console.log("Redis server still loading, trying again in " + retry_time);
+ }
+ setTimeout(send_info_cmd, retry_time);
+ }
+ });
+ self.send_anyway = false;
+ }
+
+ send_info_cmd();
+};
+
+RedisClient.prototype.send_offline_queue = function () {
+ var command_obj, buffered_writes = 0;
+ while (this.offline_queue.length > 0) {
+ command_obj = this.offline_queue.shift();
+ if (exports.debug_mode) {
+ console.log("Sending offline command: " + command_obj.command);
+ }
+ buffered_writes += !this.send_command(command_obj.command, command_obj.args, command_obj.callback);
+ }
+ this.offline_queue = new Queue();
+ // Even though items were shifted off, Queue backing store still uses memory until next add, so just get a new Queue
+
+ if (!buffered_writes) {
+ this.should_buffer = false;
+ this.emit("drain");
+ }
+};
+
+RedisClient.prototype.connection_gone = function (why) {
+ var self = this;
+
+ // If a retry is already in progress, just let that happen
+ if (this.retry_timer) {
+ return;
+ }
+
+ // Note that this may trigger another "close" or "end" event
+ this.stream.destroy();
+
+ if (exports.debug_mode) {
+ console.warn("Redis connection is gone from " + why + " event.");
+ }
+ this.connected = false;
+ this.ready = false;
+ this.subscriptions = false;
+ this.monitoring = false;
+
+ // since we are collapsing end and close, users don't expect to be called twice
+ if (! this.emitted_end) {
+ this.emit("end");
+ this.emitted_end = true;
+ }
+
+ this.command_queue.forEach(function (args) {
+ if (typeof args[2] === "function") {
+ args[2]("Server connection closed");
+ }
+ });
+ this.command_queue = new Queue();
+
+ // If this is a requested shutdown, then don't retry
+ if (this.closing) {
+ this.retry_timer = null;
+ return;
+ }
+
+ this.current_retry_delay = this.retry_delay * this.retry_backoff;
+
+ if (exports.debug_mode) {
+ console.log("Retry connection in " + this.current_retry_delay + " ms");
+ }
+ this.attempts += 1;
+ this.emit("reconnecting", {
+ delay: this.current_retry_delay,
+ attempt: this.attempts
+ });
+ this.retry_timer = setTimeout(function () {
+ if (exports.debug_mode) {
+ console.log("Retrying connection...");
+ }
+ self.stream.connect(self.port, self.host);
+ self.retry_timer = null;
+ }, this.current_retry_delay);
+};
+
+RedisClient.prototype.on_data = function (data) {
+ if (exports.debug_mode) {
+ console.log("net read " + this.host + ":" + this.port + " fd " + this.stream.fd + ": " + data.toString());
+ }
+
+ try {
+ this.reply_parser.execute(data);
+ } catch (err) {
+ // This is an unexpected parser problem, an exception that came from the parser code itself.
+ // Parser should emit "error" events if it notices things are out of whack.
+ // Callbacks that throw exceptions will land in return_reply(), below.
+ // TODO - it might be nice to have a different "error" event for different types of errors
+ this.emit("error", err);
+ }
+};
+
+RedisClient.prototype.return_error = function (err) {
+ var command_obj = this.command_queue.shift(), queue_len = this.command_queue.getLength();
+
+ if (this.subscriptions === false && queue_len === 0) {
+ this.emit("idle");
+ this.command_queue = new Queue();
+ }
+ if (this.should_buffer && queue_len <= this.command_queue_low_water) {
+ this.emit("drain");
+ this.should_buffer = false;
+ }
+
+ if (command_obj && typeof command_obj.callback === "function") {
+ try {
+ command_obj.callback(err);
+ } catch (callback_err) {
+ // if a callback throws an exception, re-throw it on a new stack so the parser can keep going
+ process.nextTick(function () {
+ throw callback_err;
+ });
+ }
+ } else {
+ console.log("node_redis: no callback to send error: " + err.message);
+ // this will probably not make it anywhere useful, but we might as well throw
+ process.nextTick(function () {
+ throw err;
+ });
+ }
+};
+
+RedisClient.prototype.return_reply = function (reply) {
+ var command_obj = this.command_queue.shift(),
+ obj, i, len, key, val, type, timestamp, args, queue_len = this.command_queue.getLength();
+
+ if (this.subscriptions === false && queue_len === 0) {
+ this.emit("idle");
+ this.command_queue = new Queue(); // explicitly reclaim storage from old Queue
+ }
+ if (this.should_buffer && queue_len <= this.command_queue_low_water) {
+ this.emit("drain");
+ this.should_buffer = false;
+ }
+
+ if (command_obj && !command_obj.sub_command) {
+ if (typeof command_obj.callback === "function") {
+ // HGETALL special case replies with keyed Buffers
+ if (reply && 'hgetall' === command_obj.command.toLowerCase()) {
+ obj = {};
+ for (i = 0, len = reply.length; i < len; i += 2) {
+ key = reply[i].toString();
+ val = reply[i + 1];
+ obj[key] = val;
+ }
+ reply = obj;
+ }
+
+ try {
+ command_obj.callback(null, reply);
+ } catch (err) {
+ // if a callback throws an exception, re-throw it on a new stack so the parser can keep going
+ process.nextTick(function () {
+ throw err;
+ });
+ }
+ } else if (exports.debug_mode) {
+ console.log("no callback for reply: " + (reply && reply.toString && reply.toString()));
+ }
+ } else if (this.subscriptions || (command_obj && command_obj.sub_command)) {
+ if (Array.isArray(reply)) {
+ type = reply[0].toString();
+
+ if (type === "message") {
+ this.emit("message", reply[1].toString(), reply[2]); // channel, message
+ } else if (type === "pmessage") {
+ this.emit("pmessage", reply[1].toString(), reply[2].toString(), reply[3]); // pattern, channel, message
+ } else if (type === "subscribe" || type === "unsubscribe" || type === "psubscribe" || type === "punsubscribe") {
+ if (reply[2] === 0) {
+ this.subscriptions = false;
+ if (this.debug_mode) {
+ console.log("All subscriptions removed, exiting pub/sub mode");
+ }
+ }
+ this.emit(type, reply[1].toString(), reply[2]); // channel, count
+ } else {
+ throw new Error("subscriptions are active but got unknown reply type " + type);
+ }
+ } else if (! this.closing) {
+ throw new Error("subscriptions are active but got an invalid reply: " + reply);
+ }
+ } else if (this.monitoring) {
+ len = reply.indexOf(" ");
+ timestamp = reply.slice(0, len);
+ // TODO - this de-quoting doesn't work correctly if you put JSON strings in your values.
+ args = reply.slice(len + 1).match(/"[^"]+"/g).map(function (elem) {
+ return elem.replace(/"/g, "");
+ });
+ this.emit("monitor", timestamp, args);
+ } else {
+ throw new Error("node_redis command queue state error. If you can reproduce this, please report it.");
+ }
+};
+
+// This Command constructor is ever so slightly faster than using an object literal
+function Command(command, args, sub_command, callback) {
+ this.command = command;
+ this.args = args;
+ this.sub_command = sub_command;
+ this.callback = callback;
+}
+
+RedisClient.prototype.send_command = function (command, args, callback) {
+ var arg, this_args, command_obj, i, il, elem_count, stream = this.stream, buffer_args, command_str = "", buffered_writes = 0;
+
+ if (typeof command !== "string") {
+ throw new Error("First argument to send_command must be the command name string, not " + typeof command);
+ }
+
+ if (Array.isArray(args)) {
+ if (typeof callback === "function") {
+ // probably the fastest way:
+ // client.command([arg1, arg2], cb); (straight passthrough)
+ // send_command(command, [arg1, arg2], cb);
+ } else if (! callback) {
+ // most people find this variable argument length form more convenient, but it uses arguments, which is slower
+ // client.command(arg1, arg2, cb); (wraps up arguments into an array)
+ // send_command(command, [arg1, arg2, cb]);
+ // client.command(arg1, arg2); (callback is optional)
+ // send_command(command, [arg1, arg2]);
+ if (typeof args[args.length - 1] === "function") {
+ callback = args[args.length - 1];
+ args.length -= 1;
+ }
+ } else {
+ throw new Error("send_command: last argument must be a callback or undefined");
+ }
+ } else {
+ throw new Error("send_command: second argument must be an array");
+ }
+
+ // if the last argument is an array, expand it out. This allows commands like this:
+ // client.command(arg1, [arg2, arg3, arg4], cb);
+ // and converts to:
+ // client.command(arg1, arg2, arg3, arg4, cb);
+ // which is convenient for some things like sadd
+ if (Array.isArray(args[args.length - 1])) {
+ args = args.slice(0, -1).concat(args[args.length - 1]);
+ }
+
+ command_obj = new Command(command, args, false, callback);
+
+ if ((!this.ready && !this.send_anyway) || !stream.writable) {
+ if (exports.debug_mode) {
+ if (!stream.writable) {
+ console.log("send command: stream is not writeable.");
+ }
+
+ console.log("Queueing " + command + " for next server connection.");
+ }
+ this.offline_queue.push(command_obj);
+ this.should_buffer = true;
+ return false;
+ }
+
+ if (command === "subscribe" || command === "psubscribe" || command === "unsubscribe" || command === "punsubscribe") {
+ if (this.subscriptions === false && exports.debug_mode) {
+ console.log("Entering pub/sub mode from " + command);
+ }
+ command_obj.sub_command = true;
+ this.subscriptions = true;
+ } else if (command === "monitor") {
+ this.monitoring = true;
+ } else if (command === "quit") {
+ this.closing = true;
+ } else if (this.subscriptions === true) {
+ throw new Error("Connection in pub/sub mode, only pub/sub commands may be used");
+ }
+ this.command_queue.push(command_obj);
+ this.commands_sent += 1;
+
+ elem_count = 1;
+ buffer_args = false;
+
+ elem_count += args.length;
+
+ // Always use "Multi bulk commands", but if passed any Buffer args, then do multiple writes, one for each arg
+ // This means that using Buffers in commands is going to be slower, so use Strings if you don't already have a Buffer.
+ // Also, why am I putting user documentation in the library source code?
+
+ command_str = "*" + elem_count + "\r\n$" + command.length + "\r\n" + command + "\r\n";
+
+ for (i = 0, il = args.length, arg; i < il; i += 1) {
+ if (Buffer.isBuffer(args[i])) {
+ buffer_args = true;
+ }
+ }
+
+ if (! buffer_args) { // Build up a string and send entire command in one write
+ for (i = 0, il = args.length, arg; i < il; i += 1) {
+ arg = args[i];
+ if (typeof arg !== "string") {
+ arg = String(arg);
+ }
+ command_str += "$" + Buffer.byteLength(arg) + "\r\n" + arg + "\r\n";
+ }
+ if (exports.debug_mode) {
+ console.log("send " + this.host + ":" + this.port + " fd " + this.stream.fd + ": " + command_str);
+ }
+ buffered_writes += !stream.write(command_str);
+ } else {
+ if (exports.debug_mode) {
+ console.log("send command (" + command_str + ") has Buffer arguments");
+ }
+ buffered_writes += !stream.write(command_str);
+
+ for (i = 0, il = args.length, arg; i < il; i += 1) {
+ arg = args[i];
+ if (!(Buffer.isBuffer(arg) || arg instanceof String)) {
+ arg = String(arg);
+ }
+
+ if (Buffer.isBuffer(arg)) {
+ if (arg.length === 0) {
+ if (exports.debug_mode) {
+ console.log("send_command: using empty string for 0 length buffer");
+ }
+ buffered_writes += !stream.write("$0\r\n\r\n");
+ } else {
+ buffered_writes += !stream.write("$" + arg.length + "\r\n");
+ buffered_writes += !stream.write(arg);
+ buffered_writes += !stream.write("\r\n");
+ if (exports.debug_mode) {
+ console.log("send_command: buffer send " + arg.length + " bytes");
+ }
+ }
+ } else {
+ if (exports.debug_mode) {
+ console.log("send_command: string send " + Buffer.byteLength(arg) + " bytes: " + arg);
+ }
+ buffered_writes += !stream.write("$" + Buffer.byteLength(arg) + "\r\n" + arg + "\r\n");
+ }
+ }
+ }
+ if (exports.debug_mode) {
+ console.log("send_command buffered_writes: " + buffered_writes, " should_buffer: " + this.should_buffer);
+ }
+ if (buffered_writes || this.command_queue.getLength() >= this.command_queue_high_water) {
+ this.should_buffer = true;
+ }
+ return !this.should_buffer;
+};
+
+RedisClient.prototype.end = function () {
+ this.stream._events = {};
+ this.connected = false;
+ this.ready = false;
+ return this.stream.end();
+};
+
+function Multi(client, args) {
+ this.client = client;
+ this.queue = [["MULTI"]];
+ if (Array.isArray(args)) {
+ this.queue = this.queue.concat(args);
+ }
+}
+
+exports.Multi = Multi;
+
+// take 2 arrays and return the union of their elements
+function set_union(seta, setb) {
+ var obj = {};
+
+ seta.forEach(function (val) {
+ obj[val] = true;
+ });
+ setb.forEach(function (val) {
+ obj[val] = true;
+ });
+ return Object.keys(obj);
+}
+
+// This static list of commands is updated from time to time. ./lib/commands.js can be updated with generate_commands.js
+commands = set_union(["get", "set", "setnx", "setex", "append", "strlen", "del", "exists", "setbit", "getbit", "setrange", "getrange", "substr",
+ "incr", "decr", "mget", "rpush", "lpush", "rpushx", "lpushx", "linsert", "rpop", "lpop", "brpop", "brpoplpush", "blpop", "llen", "lindex",
+ "lset", "lrange", "ltrim", "lrem", "rpoplpush", "sadd", "srem", "smove", "sismember", "scard", "spop", "srandmember", "sinter", "sinterstore",
+ "sunion", "sunionstore", "sdiff", "sdiffstore", "smembers", "zadd", "zincrby", "zrem", "zremrangebyscore", "zremrangebyrank", "zunionstore",
+ "zinterstore", "zrange", "zrangebyscore", "zrevrangebyscore", "zcount", "zrevrange", "zcard", "zscore", "zrank", "zrevrank", "hset", "hsetnx",
+ "hget", "hmset", "hmget", "hincrby", "hdel", "hlen", "hkeys", "hvals", "hgetall", "hexists", "incrby", "decrby", "getset", "mset", "msetnx",
+ "randomkey", "select", "move", "rename", "renamenx", "expire", "expireat", "keys", "dbsize", "auth", "ping", "echo", "save", "bgsave",
+ "bgrewriteaof", "shutdown", "lastsave", "type", "multi", "exec", "discard", "sync", "flushdb", "flushall", "sort", "info", "monitor", "ttl",
+ "persist", "slaveof", "debug", "config", "subscribe", "unsubscribe", "psubscribe", "punsubscribe", "publish", "watch", "unwatch", "cluster",
+ "restore", "migrate", "dump", "object", "client", "eval", "evalsha"], require("./lib/commands"));
+
+commands.forEach(function (command) {
+ RedisClient.prototype[command] = function (args, callback) {
+ if (Array.isArray(args) && typeof callback === "function") {
+ return this.send_command(command, args, callback);
+ } else {
+ return this.send_command(command, to_array(arguments));
+ }
+ };
+ RedisClient.prototype[command.toUpperCase()] = RedisClient.prototype[command];
+
+ Multi.prototype[command] = function () {
+ this.queue.push([command].concat(to_array(arguments)));
+ return this;
+ };
+ Multi.prototype[command.toUpperCase()] = Multi.prototype[command];
+});
+
+// Stash auth for connect and reconnect. Send immediately if already connected.
+RedisClient.prototype.auth = function () {
+ var args = to_array(arguments);
+ this.auth_pass = args[0];
+ this.auth_callback = args[1];
+ if (exports.debug_mode) {
+ console.log("Saving auth as " + this.auth_pass);
+ }
+
+ if (this.connected) {
+ this.send_command("auth", args);
+ }
+};
+RedisClient.prototype.AUTH = RedisClient.prototype.auth;
+
+RedisClient.prototype.hmget = function (arg1, arg2, arg3) {
+ if (Array.isArray(arg2) && typeof arg3 === "function") {
+ return this.send_command("hmget", [arg1].concat(arg2), arg3);
+ } else if (Array.isArray(arg1) && typeof arg2 === "function") {
+ return this.send_command("hmget", arg1, arg2);
+ } else {
+ return this.send_command("hmget", to_array(arguments));
+ }
+};
+RedisClient.prototype.HMGET = RedisClient.prototype.hmget;
+
+RedisClient.prototype.hmset = function (args, callback) {
+ var tmp_args, tmp_keys, i, il, key;
+
+ if (Array.isArray(args) && typeof callback === "function") {
+ return this.send_command("hmset", args, callback);
+ }
+
+ args = to_array(arguments);
+ if (typeof args[args.length - 1] === "function") {
+ callback = args[args.length - 1];
+ args.length -= 1;
+ } else {
+ callback = null;
+ }
+
+ if (args.length === 2 && typeof args[0] === "string" && typeof args[1] === "object") {
+ // User does: client.hmset(key, {key1: val1, key2: val2})
+ tmp_args = [ args[0] ];
+ tmp_keys = Object.keys(args[1]);
+ for (i = 0, il = tmp_keys.length; i < il ; i++) {
+ key = tmp_keys[i];
+ tmp_args.push(key);
+ tmp_args.push(args[1][key]);
+ }
+ args = tmp_args;
+ }
+
+ return this.send_command("hmset", args, callback);
+};
+RedisClient.prototype.HMSET = RedisClient.prototype.hmset;
+
+Multi.prototype.hmset = function () {
+ var args = to_array(arguments), tmp_args;
+ if (args.length >= 2 && typeof args[0] === "string" && typeof args[1] === "object") {
+ tmp_args = [ "hmset", args[0] ];
+ Object.keys(args[1]).map(function (key) {
+ tmp_args.push(key);
+ tmp_args.push(args[1][key]);
+ });
+ if (args[2]) {
+ tmp_args.push(args[2]);
+ }
+ args = tmp_args;
+ } else {
+ args.unshift("hmset");
+ }
+
+ this.queue.push(args);
+ return this;
+};
+Multi.prototype.HMSET = Multi.prototype.hmset;
+
+Multi.prototype.exec = function (callback) {
+ var self = this;
+
+ // drain queue, callback will catch "QUEUED" or error
+ // TODO - get rid of all of these anonymous functions which are elegant but slow
+ this.queue.forEach(function (args, index) {
+ var command = args[0], obj;
+ if (typeof args[args.length - 1] === "function") {
+ args = args.slice(1, -1);
+ } else {
+ args = args.slice(1);
+ }
+ if (args.length === 1 && Array.isArray(args[0])) {
+ args = args[0];
+ }
+ if (command === 'hmset' && typeof args[1] === 'object') {
+ obj = args.pop();
+ Object.keys(obj).forEach(function (key) {
+ args.push(key);
+ args.push(obj[key]);
+ });
+ }
+ this.client.send_command(command, args, function (err, reply) {
+ if (err) {
+ var cur = self.queue[index];
+ if (typeof cur[cur.length - 1] === "function") {
+ cur[cur.length - 1](err);
+ } else {
+ throw new Error(err);
+ }
+ self.queue.splice(index, 1);
+ }
+ });
+ }, this);
+
+ // TODO - make this callback part of Multi.prototype instead of creating it each time
+ return this.client.send_command("EXEC", [], function (err, replies) {
+ if (err) {
+ if (callback) {
+ callback(new Error(err));
+ return;
+ } else {
+ throw new Error(err);
+ }
+ }
+
+ var i, il, j, jl, reply, args, obj, key, val;
+
+ if (replies) {
+ for (i = 1, il = self.queue.length; i < il; i += 1) {
+ reply = replies[i - 1];
+ args = self.queue[i];
+
+ // Convert HGETALL reply to object
+ if (reply && args[0].toLowerCase() === "hgetall") {
+ obj = {};
+ for (j = 0, jl = reply.length; j < jl; j += 2) {
+ key = reply[j].toString();
+ val = reply[j + 1];
+ obj[key] = val;
+ }
+ replies[i - 1] = reply = obj;
+ }
+
+ if (typeof args[args.length - 1] === "function") {
+ args[args.length - 1](null, reply);
+ }
+ }
+ }
+
+ if (callback) {
+ callback(null, replies);
+ }
+ });
+};
+
+RedisClient.prototype.multi = function (args) {
+ return new Multi(this, args);
+};
+RedisClient.prototype.MULTI = function (args) {
+ return new Multi(this, args);
+};
+
+exports.createClient = function (port_arg, host_arg, options) {
+ var port = port_arg || default_port,
+ host = host_arg || default_host,
+ redis_client, net_client;
+
+ net_client = net.createConnection(port, host);
+
+ redis_client = new RedisClient(net_client, options);
+
+ redis_client.port = port;
+ redis_client.host = host;
+
+ return redis_client;
+};
+
+exports.print = function (err, reply) {
+ if (err) {
+ console.log("Error: " + err);
+ } else {
+ console.log("Reply: " + reply);
+ }
+};
diff --git a/node_modules/socket.io/node_modules/redis/lib/commands.js b/node_modules/socket.io/node_modules/redis/lib/commands.js
new file mode 100644
index 0000000..0293ae8
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/lib/commands.js
@@ -0,0 +1,126 @@
+// This file was generated by ./generate_commands.js on Tue Jun 28 2011 22:37:02 GMT-0700 (PDT)
+module.exports = [
+ "append",
+ "auth",
+ "bgrewriteaof",
+ "bgsave",
+ "blpop",
+ "brpop",
+ "brpoplpush",
+ "config get",
+ "config set",
+ "config resetstat",
+ "dbsize",
+ "debug object",
+ "debug segfault",
+ "decr",
+ "decrby",
+ "del",
+ "discard",
+ "echo",
+ "exec",
+ "exists",
+ "expire",
+ "expireat",
+ "flushall",
+ "flushdb",
+ "get",
+ "getbit",
+ "getrange",
+ "getset",
+ "hdel",
+ "hexists",
+ "hget",
+ "hgetall",
+ "hincrby",
+ "hkeys",
+ "hlen",
+ "hmget",
+ "hmset",
+ "hset",
+ "hsetnx",
+ "hvals",
+ "incr",
+ "incrby",
+ "info",
+ "keys",
+ "lastsave",
+ "lindex",
+ "linsert",
+ "llen",
+ "lpop",
+ "lpush",
+ "lpushx",
+ "lrange",
+ "lrem",
+ "lset",
+ "ltrim",
+ "mget",
+ "monitor",
+ "move",
+ "mset",
+ "msetnx",
+ "multi",
+ "object",
+ "persist",
+ "ping",
+ "psubscribe",
+ "publish",
+ "punsubscribe",
+ "quit",
+ "randomkey",
+ "rename",
+ "renamenx",
+ "rpop",
+ "rpoplpush",
+ "rpush",
+ "rpushx",
+ "sadd",
+ "save",
+ "scard",
+ "sdiff",
+ "sdiffstore",
+ "select",
+ "set",
+ "setbit",
+ "setex",
+ "setnx",
+ "setrange",
+ "shutdown",
+ "sinter",
+ "sinterstore",
+ "sismember",
+ "slaveof",
+ "smembers",
+ "smove",
+ "sort",
+ "spop",
+ "srandmember",
+ "srem",
+ "strlen",
+ "subscribe",
+ "sunion",
+ "sunionstore",
+ "sync",
+ "ttl",
+ "type",
+ "unsubscribe",
+ "unwatch",
+ "watch",
+ "zadd",
+ "zcard",
+ "zcount",
+ "zincrby",
+ "zinterstore",
+ "zrange",
+ "zrangebyscore",
+ "zrank",
+ "zrem",
+ "zremrangebyrank",
+ "zremrangebyscore",
+ "zrevrange",
+ "zrevrangebyscore",
+ "zrevrank",
+ "zscore",
+ "zunionstore"
+];
diff --git a/node_modules/socket.io/node_modules/redis/lib/parser/hiredis.js b/node_modules/socket.io/node_modules/redis/lib/parser/hiredis.js
new file mode 100644
index 0000000..9dba8c9
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/lib/parser/hiredis.js
@@ -0,0 +1,41 @@
+/*global Buffer require exports console setTimeout */
+
+var events = require("events"),
+ util = require("../util").util,
+ hiredis = require("hiredis");
+
+exports.debug_mode = false;
+exports.name = "hiredis";
+
+function HiredisReplyParser(options) {
+ this.name = exports.name;
+ this.options = options || {};
+ this.reset();
+ events.EventEmitter.call(this);
+}
+
+util.inherits(HiredisReplyParser, events.EventEmitter);
+
+exports.Parser = HiredisReplyParser;
+
+HiredisReplyParser.prototype.reset = function () {
+ this.reader = new hiredis.Reader({
+ return_buffers: this.options.return_buffers || false
+ });
+};
+
+HiredisReplyParser.prototype.execute = function (data) {
+ var reply;
+ this.reader.feed(data);
+ try {
+ while ((reply = this.reader.get()) !== undefined) {
+ if (reply && reply.constructor === Error) {
+ this.emit("reply error", reply);
+ } else {
+ this.emit("reply", reply);
+ }
+ }
+ } catch (err) {
+ this.emit("error", err);
+ }
+};
diff --git a/node_modules/socket.io/node_modules/redis/lib/parser/javascript.js b/node_modules/socket.io/node_modules/redis/lib/parser/javascript.js
new file mode 100644
index 0000000..6f250c9
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/lib/parser/javascript.js
@@ -0,0 +1,316 @@
+/*global Buffer require exports console setTimeout */
+
+// TODO - incorporate these V8 pro tips:
+// pre-allocate Arrays if length is known in advance
+// do not use delete
+// use numbers for parser state
+
+var events = require("events"),
+ util = require("../util").util;
+
+exports.debug_mode = false;
+exports.name = "javascript";
+
+function RedisReplyParser(options) {
+ this.name = exports.name;
+ this.options = options || {};
+ this.reset();
+ events.EventEmitter.call(this);
+}
+
+util.inherits(RedisReplyParser, events.EventEmitter);
+
+exports.Parser = RedisReplyParser;
+
+// Buffer.toString() is quite slow for small strings
+function small_toString(buf, len) {
+ var tmp = "", i;
+
+ for (i = 0; i < len; i += 1) {
+ tmp += String.fromCharCode(buf[i]);
+ }
+
+ return tmp;
+}
+
+// Reset parser to it's original state.
+RedisReplyParser.prototype.reset = function () {
+ this.return_buffer = new Buffer(16384); // for holding replies, might grow
+ this.return_string = "";
+ this.tmp_string = ""; // for holding size fields
+
+ this.multi_bulk_length = 0;
+ this.multi_bulk_replies = null;
+ this.multi_bulk_pos = 0;
+ this.multi_bulk_nested_length = 0;
+ this.multi_bulk_nested_replies = null;
+
+ this.states = {
+ TYPE: 1,
+ SINGLE_LINE: 2,
+ MULTI_BULK_COUNT: 3,
+ INTEGER_LINE: 4,
+ BULK_LENGTH: 5,
+ ERROR_LINE: 6,
+ BULK_DATA: 7,
+ UNKNOWN_TYPE: 8,
+ FINAL_CR: 9,
+ FINAL_LF: 10,
+ MULTI_BULK_COUNT_LF: 11
+ };
+
+ this.state = this.states.TYPE;
+};
+
+RedisReplyParser.prototype.parser_error = function (message) {
+ this.emit("error", message);
+ this.reset();
+};
+
+RedisReplyParser.prototype.execute = function (incoming_buf) {
+ var pos = 0, bd_tmp, bd_str, i, il, states = this.states;
+ //, state_times = {}, start_execute = new Date(), start_switch, end_switch, old_state;
+ //start_switch = new Date();
+
+ while (pos < incoming_buf.length) {
+ // old_state = this.state;
+ // console.log("execute: " + this.state + ", " + pos + "/" + incoming_buf.length + ", " + String.fromCharCode(incoming_buf[pos]));
+
+ switch (this.state) {
+ case states.TYPE:
+ this.type = incoming_buf[pos];
+ pos += 1;
+
+ switch (this.type) {
+ case 43: // +
+ this.state = states.SINGLE_LINE;
+ this.return_buffer.end = 0;
+ this.return_string = "";
+ break;
+ case 42: // *
+ this.state = states.MULTI_BULK_COUNT;
+ this.tmp_string = "";
+ break;
+ case 58: // :
+ this.state = states.INTEGER_LINE;
+ this.return_buffer.end = 0;
+ this.return_string = "";
+ break;
+ case 36: // $
+ this.state = states.BULK_LENGTH;
+ this.tmp_string = "";
+ break;
+ case 45: // -
+ this.state = states.ERROR_LINE;
+ this.return_buffer.end = 0;
+ this.return_string = "";
+ break;
+ default:
+ this.state = states.UNKNOWN_TYPE;
+ }
+ break;
+ case states.INTEGER_LINE:
+ if (incoming_buf[pos] === 13) {
+ this.send_reply(+small_toString(this.return_buffer, this.return_buffer.end));
+ this.state = states.FINAL_LF;
+ } else {
+ this.return_buffer[this.return_buffer.end] = incoming_buf[pos];
+ this.return_buffer.end += 1;
+ }
+ pos += 1;
+ break;
+ case states.ERROR_LINE:
+ if (incoming_buf[pos] === 13) {
+ this.send_error(this.return_buffer.toString("ascii", 0, this.return_buffer.end));
+ this.state = states.FINAL_LF;
+ } else {
+ this.return_buffer[this.return_buffer.end] = incoming_buf[pos];
+ this.return_buffer.end += 1;
+ }
+ pos += 1;
+ break;
+ case states.SINGLE_LINE:
+ if (incoming_buf[pos] === 13) {
+ this.send_reply(this.return_string);
+ this.state = states.FINAL_LF;
+ } else {
+ this.return_string += String.fromCharCode(incoming_buf[pos]);
+ }
+ pos += 1;
+ break;
+ case states.MULTI_BULK_COUNT:
+ if (incoming_buf[pos] === 13) { // \r
+ this.state = states.MULTI_BULK_COUNT_LF;
+ } else {
+ this.tmp_string += String.fromCharCode(incoming_buf[pos]);
+ }
+ pos += 1;
+ break;
+ case states.MULTI_BULK_COUNT_LF:
+ if (incoming_buf[pos] === 10) { // \n
+ if (this.multi_bulk_length) { // nested multi-bulk
+ this.multi_bulk_nested_length = this.multi_bulk_length;
+ this.multi_bulk_nested_replies = this.multi_bulk_replies;
+ this.multi_bulk_nested_pos = this.multi_bulk_pos;
+ }
+ this.multi_bulk_length = +this.tmp_string;
+ this.multi_bulk_pos = 0;
+ this.state = states.TYPE;
+ if (this.multi_bulk_length < 0) {
+ this.send_reply(null);
+ this.multi_bulk_length = 0;
+ } else if (this.multi_bulk_length === 0) {
+ this.multi_bulk_pos = 0;
+ this.multi_bulk_replies = null;
+ this.send_reply([]);
+ } else {
+ this.multi_bulk_replies = new Array(this.multi_bulk_length);
+ }
+ } else {
+ this.parser_error(new Error("didn't see LF after NL reading multi bulk count"));
+ return;
+ }
+ pos += 1;
+ break;
+ case states.BULK_LENGTH:
+ if (incoming_buf[pos] === 13) { // \r
+ this.state = states.BULK_LF;
+ } else {
+ this.tmp_string += String.fromCharCode(incoming_buf[pos]);
+ }
+ pos += 1;
+ break;
+ case states.BULK_LF:
+ if (incoming_buf[pos] === 10) { // \n
+ this.bulk_length = +this.tmp_string;
+ if (this.bulk_length === -1) {
+ this.send_reply(null);
+ this.state = states.TYPE;
+ } else if (this.bulk_length === 0) {
+ this.send_reply(new Buffer(""));
+ this.state = states.FINAL_CR;
+ } else {
+ this.state = states.BULK_DATA;
+ if (this.bulk_length > this.return_buffer.length) {
+ if (exports.debug_mode) {
+ console.log("Growing return_buffer from " + this.return_buffer.length + " to " + this.bulk_length);
+ }
+ this.return_buffer = new Buffer(this.bulk_length);
+ }
+ this.return_buffer.end = 0;
+ }
+ } else {
+ this.parser_error(new Error("didn't see LF after NL while reading bulk length"));
+ return;
+ }
+ pos += 1;
+ break;
+ case states.BULK_DATA:
+ this.return_buffer[this.return_buffer.end] = incoming_buf[pos];
+ this.return_buffer.end += 1;
+ pos += 1;
+ if (this.return_buffer.end === this.bulk_length) {
+ bd_tmp = new Buffer(this.bulk_length);
+ // When the response is small, Buffer.copy() is a lot slower.
+ if (this.bulk_length > 10) {
+ this.return_buffer.copy(bd_tmp, 0, 0, this.bulk_length);
+ } else {
+ for (i = 0, il = this.bulk_length; i < il; i += 1) {
+ bd_tmp[i] = this.return_buffer[i];
+ }
+ }
+ this.send_reply(bd_tmp);
+ this.state = states.FINAL_CR;
+ }
+ break;
+ case states.FINAL_CR:
+ if (incoming_buf[pos] === 13) { // \r
+ this.state = states.FINAL_LF;
+ pos += 1;
+ } else {
+ this.parser_error(new Error("saw " + incoming_buf[pos] + " when expecting final CR"));
+ return;
+ }
+ break;
+ case states.FINAL_LF:
+ if (incoming_buf[pos] === 10) { // \n
+ this.state = states.TYPE;
+ pos += 1;
+ } else {
+ this.parser_error(new Error("saw " + incoming_buf[pos] + " when expecting final LF"));
+ return;
+ }
+ break;
+ default:
+ this.parser_error(new Error("invalid state " + this.state));
+ }
+ // end_switch = new Date();
+ // if (state_times[old_state] === undefined) {
+ // state_times[old_state] = 0;
+ // }
+ // state_times[old_state] += (end_switch - start_switch);
+ // start_switch = end_switch;
+ }
+ // console.log("execute ran for " + (Date.now() - start_execute) + " ms, on " + incoming_buf.length + " Bytes. ");
+ // Object.keys(state_times).forEach(function (state) {
+ // console.log(" " + state + ": " + state_times[state]);
+ // });
+};
+
+RedisReplyParser.prototype.send_error = function (reply) {
+ if (this.multi_bulk_length > 0 || this.multi_bulk_nested_length > 0) {
+ // TODO - can this happen? Seems like maybe not.
+ this.add_multi_bulk_reply(reply);
+ } else {
+ this.emit("reply error", reply);
+ }
+};
+
+RedisReplyParser.prototype.send_reply = function (reply) {
+ if (this.multi_bulk_length > 0 || this.multi_bulk_nested_length > 0) {
+ if (!this.options.return_buffers && Buffer.isBuffer(reply)) {
+ this.add_multi_bulk_reply(reply.toString("utf8"));
+ } else {
+ this.add_multi_bulk_reply(reply);
+ }
+ } else {
+ if (!this.options.return_buffers && Buffer.isBuffer(reply)) {
+ this.emit("reply", reply.toString("utf8"));
+ } else {
+ this.emit("reply", reply);
+ }
+ }
+};
+
+RedisReplyParser.prototype.add_multi_bulk_reply = function (reply) {
+ if (this.multi_bulk_replies) {
+ this.multi_bulk_replies[this.multi_bulk_pos] = reply;
+ this.multi_bulk_pos += 1;
+ if (this.multi_bulk_pos < this.multi_bulk_length) {
+ return;
+ }
+ } else {
+ this.multi_bulk_replies = reply;
+ }
+
+ if (this.multi_bulk_nested_length > 0) {
+ this.multi_bulk_nested_replies[this.multi_bulk_nested_pos] = this.multi_bulk_replies;
+ this.multi_bulk_nested_pos += 1;
+
+ this.multi_bulk_length = 0;
+ this.multi_bulk_replies = null;
+ this.multi_bulk_pos = 0;
+
+ if (this.multi_bulk_nested_length === this.multi_bulk_nested_pos) {
+ this.emit("reply", this.multi_bulk_nested_replies);
+ this.multi_bulk_nested_length = 0;
+ this.multi_bulk_nested_pos = 0;
+ this.multi_bulk_nested_replies = null;
+ }
+ } else {
+ this.emit("reply", this.multi_bulk_replies);
+ this.multi_bulk_length = 0;
+ this.multi_bulk_replies = null;
+ this.multi_bulk_pos = 0;
+ }
+};
diff --git a/node_modules/socket.io/node_modules/redis/lib/queue.js b/node_modules/socket.io/node_modules/redis/lib/queue.js
new file mode 100644
index 0000000..5cc3c42
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/lib/queue.js
@@ -0,0 +1,58 @@
+var to_array = require("./to_array");
+
+// Queue class adapted from Tim Caswell's pattern library
+// http://github.com/creationix/pattern/blob/master/lib/pattern/queue.js
+
+function Queue() {
+ this.tail = [];
+ this.head = to_array(arguments);
+ this.offset = 0;
+}
+
+Queue.prototype.shift = function () {
+ if (this.offset === this.head.length) {
+ var tmp = this.head;
+ tmp.length = 0;
+ this.head = this.tail;
+ this.tail = tmp;
+ this.offset = 0;
+ if (this.head.length === 0) {
+ return;
+ }
+ }
+ return this.head[this.offset++]; // sorry, JSLint
+};
+
+Queue.prototype.push = function (item) {
+ return this.tail.push(item);
+};
+
+Queue.prototype.forEach = function (fn, thisv) {
+ var array = this.head.slice(this.offset), i, il;
+
+ array.push.apply(array, this.tail);
+
+ if (thisv) {
+ for (i = 0, il = array.length; i < il; i += 1) {
+ fn.call(thisv, array[i], i, array);
+ }
+ } else {
+ for (i = 0, il = array.length; i < il; i += 1) {
+ fn(array[i], i, array);
+ }
+ }
+
+ return array;
+};
+
+Queue.prototype.getLength = function () {
+ return this.head.length - this.offset + this.tail.length;
+};
+
+Object.defineProperty(Queue.prototype, 'length', {
+ get: function () {
+ return this.getLength();
+ }
+});
+
+exports.Queue = Queue;
diff --git a/node_modules/socket.io/node_modules/redis/lib/to_array.js b/node_modules/socket.io/node_modules/redis/lib/to_array.js
new file mode 100644
index 0000000..88a57e1
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/lib/to_array.js
@@ -0,0 +1,12 @@
+function to_array(args) {
+ var len = args.length,
+ arr = new Array(len), i;
+
+ for (i = 0; i < len; i += 1) {
+ arr[i] = args[i];
+ }
+
+ return arr;
+}
+
+module.exports = to_array;
diff --git a/node_modules/socket.io/node_modules/redis/lib/util.js b/node_modules/socket.io/node_modules/redis/lib/util.js
new file mode 100644
index 0000000..3dc41a5
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/lib/util.js
@@ -0,0 +1,6 @@
+if (process.versions.node.match(/^0.3/)) {
+ exports.util = require("util");
+} else {
+ // This module is called "sys" in 0.2.x
+ exports.util = require("sys");
+}
diff --git a/node_modules/socket.io/node_modules/redis/multi_bench.js b/node_modules/socket.io/node_modules/redis/multi_bench.js
new file mode 100644
index 0000000..b78c126
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/multi_bench.js
@@ -0,0 +1,135 @@
+var redis = require("./index"),
+ num_clients = parseInt(process.argv[2], 10) || 50,
+ active_clients = 0,
+ clients = new Array(num_clients),
+ num_requests = 20000,
+ issued_requests = 0,
+ latency = new Array(num_requests),
+ tests = [],
+ test_start, parser_logged = false,
+ client_options = {
+ return_buffers: false
+ };
+
+redis.debug_mode = false;
+
+tests.push({
+ descr: "PING",
+ command: ["ping"]
+});
+
+tests.push({
+ descr: "SET",
+ command: ["set", "foo_rand000000000000", "bar"]
+});
+
+tests.push({
+ descr: "GET",
+ command: ["get", "foo_rand000000000000"]
+});
+
+tests.push({
+ descr: "INCR",
+ command: ["incr", "counter_rand000000000000"]
+});
+
+tests.push({
+ descr: "LPUSH",
+ command: ["lpush", "mylist", new Array(8).join("-")]
+});
+
+tests.push({
+ descr: "LRANGE (10 elements)",
+ command: ["lrange", "mylist", "0", "9"]
+});
+
+tests.push({
+ descr: "LRANGE (100 elements)",
+ command: ["lrange", "mylist", "0", "99"]
+});
+
+function create_clients(callback) {
+ if (active_clients === num_clients) {
+ // common case is all clients are already created
+ console.log("create_clients: all clients already created " + num_clients);
+ callback();
+ } else {
+ var client, connected = active_clients;
+
+ while (active_clients < num_clients) {
+ client = clients[active_clients++] = redis.createClient(6379, "127.0.0.1", client_options);
+ if (! parser_logged) {
+ console.log("Using reply parser " + client.reply_parser.name);
+ parser_logged = true;
+ }
+ client.on("connect", function () {
+ // Fire callback when all clients are connected
+ connected += 1;
+ if (connected === num_clients) {
+ callback();
+ }
+ });
+ // TODO - need to check for client disconnect
+ client.on("error", function (msg) {
+ console.log("Connect problem:" + msg.stack);
+ });
+ }
+ }
+}
+
+function issue_request(client, test, cmd, args) {
+ var i = issued_requests++;
+ latency[i] = Date.now();
+
+ client[cmd](args, function() {
+ latency[i] = Date.now() - latency[i];
+ if (issued_requests < num_requests) {
+ issue_request(client, test, cmd, args);
+ } else {
+ client.end();
+ if (--active_clients == 0)
+ test_complete(test);
+ }
+ });
+}
+
+function test_run(test) {
+ create_clients(function() {
+ var i = num_clients,
+ cmd = test.command[0],
+ args = test.command.slice(1);
+
+ test_start = Date.now();
+ issued_requests = 0;
+ while(i-- && issued_requests < num_requests) {
+ issue_request(clients[i], test, cmd, args);
+ }
+ });
+}
+
+function test_complete(test) {
+ var min, max, sum, avg;
+ var total_time = Date.now() - test_start;
+ var op_rate = (issued_requests / (total_time / 1000.0)).toFixed(2);
+ var i;
+
+ latency.sort();
+ min = latency[0];
+ max = latency[issued_requests-1];
+ for (sum = 0, i = 0; i < issued_requests; i++)
+ sum += latency[i];
+ avg = (sum / issued_requests).toFixed(3);
+
+ console.log(test.descr + ": " + issued_requests + " ops " + op_rate + " ops/sec " + min + "/" + max + "/" + avg);
+
+ next();
+}
+
+function next() {
+ var test = tests.shift();
+ if (test) {
+ test_run(test);
+ }
+}
+
+next();
diff --git a/node_modules/socket.io/node_modules/redis/package.json b/node_modules/socket.io/node_modules/redis/package.json
new file mode 100644
index 0000000..1fb9f27
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "redis",
+ "version": "0.6.7",
+ "description": "Redis client library",
+ "author": {
+ "name": "Matt Ranney",
+ "email": "mjr@ranney.com"
+ },
+ "contributors": [
+ {
+ "name": "Rick Olson"
+ },
+ {
+ "name": "Tim-Smart"
+ },
+ {
+ "name": "TJ Holowaychuk"
+ },
+ {
+ "name": "Orion Henry"
+ },
+ {
+ "name": "Hank Sims"
+ },
+ {
+ "name": "Aivo Paas"
+ },
+ {
+ "name": "Paul Carey"
+ },
+ {
+ "name": "Pieter Noordhuis"
+ },
+ {
+ "name": "Andy Ray"
+ },
+ {
+ "name": "Vladimir Dronnikov"
+ },
+ {
+ "name": "Dave Hoover"
+ }
+ ],
+ "main": "./index.js",
+ "scripts": {
+ "test": "node ./test.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/mranney/node_redis.git"
+ },
+ "_id": "redis@0.6.7",
+ "dependencies": {},
+ "devDependencies": {},
+ "optionalDependencies": {},
+ "engines": {
+ "node": "*"
+ },
+ "_engineSupported": true,
+ "_npmVersion": "1.1.9",
+ "_nodeVersion": "v0.6.13",
+ "_defaultsLoaded": true,
+ "dist": {
+ "shasum": "641b2ae42d11301a04d76f26150f9dad08885e17"
+ },
+ "_from": "redis@0.6.7"
+}
diff --git a/node_modules/socket.io/node_modules/redis/simple_test.js b/node_modules/socket.io/node_modules/redis/simple_test.js
new file mode 100644
index 0000000..f32ab9d
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/simple_test.js
@@ -0,0 +1,3 @@
+var client = require("./index").createClient();
+
+client.hmset("test hash", "key 1", "val 1", "key 2", "val 2");
diff --git a/node_modules/socket.io/node_modules/redis/test.js b/node_modules/socket.io/node_modules/redis/test.js
new file mode 100644
index 0000000..7489e0c
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/test.js
@@ -0,0 +1,1248 @@
+/*global require console setTimeout process Buffer */
+var redis = require("./index"),
+ client = redis.createClient(),
+ client2 = redis.createClient(),
+ client3 = redis.createClient(),
+ client4 = redis.createClient(9006, "filefish.redistogo.com"),
+ assert = require("assert"),
+ util = require("./lib/util").util,
+ test_db_num = 15, // this DB will be flushed and used for testing
+ tests = {},
+ connected = false,
+ ended = false,
+ next, cur_start, run_next_test, all_tests, all_start, test_count;
+
+// Set this to truthy to see the wire protocol and other debugging info
+redis.debug_mode = process.argv[2];
+
+function buffers_to_strings(arr) {
+ return arr.map(function (val) {
+ return val.toString();
+ });
+}
+
+function require_number(expected, label) {
+ return function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(expected, results, label + " " + expected + " !== " + results);
+ assert.strictEqual(typeof results, "number", label);
+ return true;
+ };
+}
+
+function require_number_any(label) {
+ return function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(typeof results, "number", label + " " + results + " is not a number");
+ return true;
+ };
+}
+
+function require_number_pos(label) {
+ return function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(true, (results > 0), label + " " + results + " is not a positive number");
+ return true;
+ };
+}
+
+function require_string(str, label) {
+ return function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.equal(str, results, label + " " + str + " does not match " + results);
+ return true;
+ };
+}
+
+function require_null(label) {
+ return function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(null, results, label + ": " + results + " is not null");
+ return true;
+ };
+}
+
+function require_error(label) {
+ return function (err, results) {
+ assert.notEqual(err, null, label + " err is null, but an error is expected here.");
+ return true;
+ };
+}
+
+function is_empty_array(obj) {
+ return Array.isArray(obj) && obj.length === 0;
+}
+
+function last(name, fn) {
+ return function (err, results) {
+ fn(err, results);
+ next(name);
+ };
+}
+
+next = function next(name) {
+ console.log(" \x1b[33m" + (Date.now() - cur_start) + "\x1b[0m ms");
+ run_next_test();
+};
+
+// Tests are run in the order they are defined. So FLUSHDB should be stay first.
+
+tests.FLUSHDB = function () {
+ var name = "FLUSHDB";
+ client.select(test_db_num, require_string("OK", name));
+ client2.select(test_db_num, require_string("OK", name));
+ client3.select(test_db_num, require_string("OK", name));
+ client.mset("flush keys 1", "flush val 1", "flush keys 2", "flush val 2", require_string("OK", name));
+ client.FLUSHDB(require_string("OK", name));
+ client.dbsize(last(name, require_number(0, name)));
+};
+
+tests.MULTI_1 = function () {
+ var name = "MULTI_1", multi1, multi2;
+
+ // Provoke an error at queue time
+ multi1 = client.multi();
+ multi1.mset("multifoo", "10", "multibar", "20", require_string("OK", name));
+ multi1.set("foo2", require_error(name));
+ multi1.incr("multifoo", require_number(11, name));
+ multi1.incr("multibar", require_number(21, name));
+ multi1.exec();
+
+ // Confirm that the previous command, while containing an error, still worked.
+ multi2 = client.multi();
+ multi2.incr("multibar", require_number(22, name));
+ multi2.incr("multifoo", require_number(12, name));
+ multi2.exec(function (err, replies) {
+ assert.strictEqual(22, replies[0]);
+ assert.strictEqual(12, replies[1]);
+ next(name);
+ });
+};
+
+tests.MULTI_2 = function () {
+ var name = "MULTI_2";
+
+ // test nested multi-bulk replies
+ client.multi([
+ ["mget", "multifoo", "multibar", function (err, res) {
+ assert.strictEqual(2, res.length, name);
+ assert.strictEqual("12", res[0].toString(), name);
+ assert.strictEqual("22", res[1].toString(), name);
+ }],
+ ["set", "foo2", require_error(name)],
+ ["incr", "multifoo", require_number(13, name)],
+ ["incr", "multibar", require_number(23, name)]
+ ]).exec(function (err, replies) {
+ assert.strictEqual(2, replies[0].length, name);
+ assert.strictEqual("12", replies[0][0].toString(), name);
+ assert.strictEqual("22", replies[0][1].toString(), name);
+
+ assert.strictEqual("13", replies[1].toString());
+ assert.strictEqual("23", replies[2].toString());
+ next(name);
+ });
+};
+
+tests.MULTI_3 = function () {
+ var name = "MULTI_3";
+
+ client.sadd("some set", "mem 1");
+ client.sadd("some set", "mem 2");
+ client.sadd("some set", "mem 3");
+ client.sadd("some set", "mem 4");
+
+ // make sure empty mb reply works
+ client.del("some missing set");
+ client.smembers("some missing set", function (err, reply) {
+ // make sure empty mb reply works
+ assert.strictEqual(true, is_empty_array(reply), name);
+ });
+
+ // test nested multi-bulk replies with empty mb elements.
+ client.multi([
+ ["smembers", "some set"],
+ ["del", "some set"],
+ ["smembers", "some set"]
+ ])
+ .scard("some set")
+ .exec(function (err, replies) {
+ assert.strictEqual(true, is_empty_array(replies[2]), name);
+ next(name);
+ });
+};
+
+tests.MULTI_4 = function () {
+ var name = "MULTI_4";
+
+ client.multi()
+ .mset('some', '10', 'keys', '20')
+ .incr('some')
+ .incr('keys')
+ .mget('some', 'keys')
+ .exec(function (err, replies) {
+ assert.strictEqual(null, err);
+ assert.equal('OK', replies[0]);
+ assert.equal(11, replies[1]);
+ assert.equal(21, replies[2]);
+ assert.equal(11, replies[3][0].toString());
+ assert.equal(21, replies[3][1].toString());
+ next(name);
+ });
+};
+
+tests.MULTI_5 = function () {
+ var name = "MULTI_5";
+
+ // test nested multi-bulk replies with nulls.
+ client.multi([
+ ["mget", ["multifoo", "some", "random value", "keys"]],
+ ["incr", "multifoo"]
+ ])
+ .exec(function (err, replies) {
+ assert.strictEqual(replies.length, 2, name);
+ assert.strictEqual(replies[0].length, 4, name);
+ next(name);
+ });
+};
+
+tests.MULTI_6 = function () {
+ var name = "MULTI_6";
+
+ client.multi()
+ .hmset("multihash", "a", "foo", "b", 1)
+ .hmset("multihash", {
+ extra: "fancy",
+ things: "here"
+ })
+ .hgetall("multihash")
+ .exec(function (err, replies) {
+ assert.strictEqual(null, err);
+ assert.equal("OK", replies[0]);
+ assert.equal(Object.keys(replies[2]).length, 4);
+ assert.equal("foo", replies[2].a);
+ assert.equal("1", replies[2].b);
+ assert.equal("fancy", replies[2].extra);
+ assert.equal("here", replies[2].things);
+ next(name);
+ });
+};
+
+tests.EVAL_1 = function () {
+ var name = "EVAL_1";
+
+ if (client.server_info.versions[0] >= 2 && client.server_info.versions[1] >= 9) {
+ // test {EVAL - Lua integer -> Redis protocol type conversion}
+ client.eval("return 100.5", 0, require_number(100, name));
+ // test {EVAL - Lua string -> Redis protocol type conversion}
+ client.eval("return 'hello world'", 0, require_string("hello world", name));
+ // test {EVAL - Lua true boolean -> Redis protocol type conversion}
+ client.eval("return true", 0, require_number(1, name));
+ // test {EVAL - Lua false boolean -> Redis protocol type conversion}
+ client.eval("return false", 0, require_null(name));
+ // test {EVAL - Lua status code reply -> Redis protocol type conversion}
+ client.eval("return {ok='fine'}", 0, require_string("fine", name));
+ // test {EVAL - Lua error reply -> Redis protocol type conversion}
+ client.eval("return {err='this is an error'}", 0, require_error(name));
+ // test {EVAL - Lua table -> Redis protocol type conversion}
+ client.eval("return {1,2,3,'ciao',{1,2}}", 0, function (err, res) {
+ assert.strictEqual(5, res.length, name);
+ assert.strictEqual(1, res[0], name);
+ assert.strictEqual(2, res[1], name);
+ assert.strictEqual(3, res[2], name);
+ assert.strictEqual("ciao", res[3], name);
+ assert.strictEqual(2, res[4].length, name);
+ assert.strictEqual(1, res[4][0], name);
+ assert.strictEqual(2, res[4][1], name);
+ });
+ // test {EVAL - Are the KEYS and ARGS arrays populated correctly?}
+ client.eval("return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}", 2, "a", "b", "c", "d", function (err, res) {
+ assert.strictEqual(4, res.length, name);
+ assert.strictEqual("a", res[0], name);
+ assert.strictEqual("b", res[1], name);
+ assert.strictEqual("c", res[2], name);
+ assert.strictEqual("d", res[3], name);
+ });
+ // test {EVAL - is Lua able to call Redis API?}
+ client.set("mykey", "myval");
+ client.eval("return redis.call('get','mykey')", 0, require_string("myval", name));
+ // test {EVALSHA - Can we call a SHA1 if already defined?}
+ client.evalsha("9bd632c7d33e571e9f24556ebed26c3479a87129", 0, require_string("myval", name));
+ // test {EVALSHA - Do we get an error on non defined SHA1?}
+ client.evalsha("ffffffffffffffffffffffffffffffffffffffff", 0, require_error(name));
+ // test {EVAL - Redis integer -> Lua type conversion}
+ client.set("x", 0);
+ client.eval("local foo = redis.call('incr','x')\n" + "return {type(foo),foo}", 0, function (err, res) {
+ assert.strictEqual(2, res.length, name);
+ assert.strictEqual("number", res[0], name);
+ assert.strictEqual(1, res[1], name);
+ });
+ // test {EVAL - Redis bulk -> Lua type conversion}
+ client.eval("local foo = redis.call('get','mykey'); return {type(foo),foo}", 0, function (err, res) {
+ assert.strictEqual(2, res.length, name);
+ assert.strictEqual("string", res[0], name);
+ assert.strictEqual("myval", res[1], name);
+ });
+ // test {EVAL - Redis multi bulk -> Lua type conversion}
+ client.del("mylist");
+ client.rpush("mylist", "a");
+ client.rpush("mylist", "b");
+ client.rpush("mylist", "c");
+ client.eval("local foo = redis.call('lrange','mylist',0,-1)\n" + "return {type(foo),foo[1],foo[2],foo[3],# foo}", 0, function (err, res) {
+ assert.strictEqual(5, res.length, name);
+ assert.strictEqual("table", res[0], name);
+ assert.strictEqual("a", res[1], name);
+ assert.strictEqual("b", res[2], name);
+ assert.strictEqual("c", res[3], name);
+ assert.strictEqual(3, res[4], name);
+ });
+ // test {EVAL - Redis status reply -> Lua type conversion}
+ client.eval("local foo = redis.call('set','mykey','myval'); return {type(foo),foo['ok']}", 0, function (err, res) {
+ assert.strictEqual(2, res.length, name);
+ assert.strictEqual("table", res[0], name);
+ assert.strictEqual("OK", res[1], name);
+ });
+ // test {EVAL - Redis error reply -> Lua type conversion}
+ client.set("mykey", "myval");
+ client.eval("local foo = redis.call('incr','mykey'); return {type(foo),foo['err']}", 0, function (err, res) {
+ assert.strictEqual(2, res.length, name);
+ assert.strictEqual("table", res[0], name);
+ assert.strictEqual("ERR value is not an integer or out of range", res[1], name);
+ });
+ // test {EVAL - Redis nil bulk reply -> Lua type conversion}
+ client.del("mykey");
+ client.eval("local foo = redis.call('get','mykey'); return {type(foo),foo == false}", 0, function (err, res) {
+ assert.strictEqual(2, res.length, name);
+ assert.strictEqual("boolean", res[0], name);
+ assert.strictEqual(1, res[1], name);
+ });
+ // test {EVAL - Script can't run more than configured time limit} {
+ client.config("set", "lua-time-limit", 1);
+ client.eval("local i = 0; while true do i=i+1 end", 0, last("name", require_error(name)));
+ } else {
+ console.log("Skipping " + name + " because server version isn't new enough.");
+ next(name);
+ }
+};
+
+tests.WATCH_MULTI = function () {
+ var name = 'WATCH_MULTI', multi;
+
+ if (client.server_info.versions[0] >= 2 && client.server_info.versions[1] >= 1) {
+ client.watch(name);
+ client.incr(name);
+ multi = client.multi();
+ multi.incr(name);
+ multi.exec(last(name, require_null(name)));
+ } else {
+ console.log("Skipping " + name + " because server version isn't new enough.");
+ next(name);
+ }
+};
+
+tests.reconnect = function () {
+ var name = "reconnect";
+
+ client.set("recon 1", "one");
+ client.set("recon 2", "two", function (err, res) {
+ // Do not do this in normal programs. This is to simulate the server closing on us.
+ // For orderly shutdown in normal programs, do client.quit()
+ client.stream.destroy();
+ });
+
+ client.on("reconnecting", function on_recon(params) {
+ client.on("connect", function on_connect() {
+ client.select(test_db_num, require_string("OK", name));
+ client.get("recon 1", require_string("one", name));
+ client.get("recon 1", require_string("one", name));
+ client.get("recon 2", require_string("two", name));
+ client.get("recon 2", require_string("two", name));
+ client.removeListener("connect", on_connect);
+ client.removeListener("reconnecting", on_recon);
+ next(name);
+ });
+ });
+};
+
+tests.HSET = function () {
+ var key = "test hash",
+ field1 = new Buffer("0123456789"),
+ value1 = new Buffer("abcdefghij"),
+ field2 = new Buffer(0),
+ value2 = new Buffer(0),
+ name = "HSET";
+
+ client.HSET(key, field1, value1, require_number(1, name));
+ client.HGET(key, field1, require_string(value1.toString(), name));
+
+ // Empty value
+ client.HSET(key, field1, value2, require_number(0, name));
+ client.HGET([key, field1], require_string("", name));
+
+ // Empty key, empty value
+ client.HSET([key, field2, value1], require_number(1, name));
+ client.HSET(key, field2, value2, last(name, require_number(0, name)));
+};
+
+tests.HMSET_BUFFER_AND_ARRAY = function () {
+ // Saving a buffer and an array to the same key should not error
+ var key = "test hash",
+ field1 = "buffer",
+ value1 = new Buffer("abcdefghij"),
+ field2 = "array",
+ value2 = ["array contents"],
+ name = "HSET";
+
+ client.HMSET(key, field1, value1, field2, value2, last(name, require_string("OK", name)));
+};
+
+// TODO - add test for HMSET. It is special. Test for all forms as well as optional callbacks
+
+tests.HMGET = function () {
+ var key1 = "test hash 1", key2 = "test hash 2", name = "HMGET";
+
+ // redis-like hmset syntax
+ client.HMSET(key1, "0123456789", "abcdefghij", "some manner of key", "a type of value", require_string("OK", name));
+
+ // fancy hmset syntax
+ client.HMSET(key2, {
+ "0123456789": "abcdefghij",
+ "some manner of key": "a type of value"
+ }, require_string("OK", name));
+
+ client.HMGET(key1, "0123456789", "some manner of key", function (err, reply) {
+ assert.strictEqual("abcdefghij", reply[0].toString(), name);
+ assert.strictEqual("a type of value", reply[1].toString(), name);
+ });
+
+ client.HMGET(key2, "0123456789", "some manner of key", function (err, reply) {
+ assert.strictEqual("abcdefghij", reply[0].toString(), name);
+ assert.strictEqual("a type of value", reply[1].toString(), name);
+ });
+
+ client.HMGET(key1, ["0123456789"], function (err, reply) {
+ assert.strictEqual("abcdefghij", reply[0], name);
+ });
+
+ client.HMGET(key1, ["0123456789", "some manner of key"], function (err, reply) {
+ assert.strictEqual("abcdefghij", reply[0], name);
+ assert.strictEqual("a type of value", reply[1], name);
+ });
+
+ client.HMGET(key1, "missing thing", "another missing thing", function (err, reply) {
+ assert.strictEqual(null, reply[0], name);
+ assert.strictEqual(null, reply[1], name);
+ next(name);
+ });
+};
+
+tests.HINCRBY = function () {
+ var name = "HINCRBY";
+ client.hset("hash incr", "value", 10, require_number(1, name));
+ client.HINCRBY("hash incr", "value", 1, require_number(11, name));
+ client.HINCRBY("hash incr", "value 2", 1, last(name, require_number(1, name)));
+};
+
+tests.SUBSCRIBE = function () {
+ var client1 = client, msg_count = 0, name = "SUBSCRIBE";
+
+ client1.on("subscribe", function (channel, count) {
+ if (channel === "chan1") {
+ client2.publish("chan1", "message 1", require_number(1, name));
+ client2.publish("chan2", "message 2", require_number(1, name));
+ client2.publish("chan1", "message 3", require_number(1, name));
+ }
+ });
+
+ client1.on("unsubscribe", function (channel, count) {
+ if (count === 0) {
+ // make sure this connection can go into and out of pub/sub mode
+ client1.incr("did a thing", last(name, require_number(2, name)));
+ }
+ });
+
+ client1.on("message", function (channel, message) {
+ msg_count += 1;
+ assert.strictEqual("message " + msg_count, message.toString());
+ if (msg_count === 3) {
+ client1.unsubscribe("chan1", "chan2");
+ }
+ });
+
+ client1.set("did a thing", 1, require_string("OK", name));
+ client1.subscribe("chan1", "chan2");
+};
+
+tests.SUBSCRIBE_QUIT = function () {
+ var name = "SUBSCRIBE_QUIT";
+ client3.on("end", function () {
+ next(name);
+ });
+ client3.on("subscribe", function (channel, count) {
+ client3.quit();
+ });
+ client3.subscribe("chan3");
+};
+
+tests.EXISTS = function () {
+ var name = "EXISTS";
+ client.del("foo", "foo2", require_number_any(name));
+ client.set("foo", "bar", require_string("OK", name));
+ client.EXISTS("foo", require_number(1, name));
+ client.EXISTS("foo2", last(name, require_number(0, name)));
+};
+
+tests.DEL = function () {
+ var name = "DEL";
+ client.DEL("delkey", require_number_any(name));
+ client.set("delkey", "delvalue", require_string("OK", name));
+ client.DEL("delkey", require_number(1, name));
+ client.exists("delkey", require_number(0, name));
+ client.DEL("delkey", require_number(0, name));
+ client.mset("delkey", "delvalue", "delkey2", "delvalue2", require_string("OK", name));
+ client.DEL("delkey", "delkey2", last(name, require_number(2, name)));
+};
+
+tests.TYPE = function () {
+ var name = "TYPE";
+ client.set(["string key", "should be a string"], require_string("OK", name));
+ client.rpush(["list key", "should be a list"], require_number_pos(name));
+ client.sadd(["set key", "should be a set"], require_number_any(name));
+ client.zadd(["zset key", "10.0", "should be a zset"], require_number_any(name));
+ client.hset(["hash key", "hashtest", "should be a hash"], require_number_any(0, name));
+
+ client.TYPE(["string key"], require_string("string", name));
+ client.TYPE(["list key"], require_string("list", name));
+ client.TYPE(["set key"], require_string("set", name));
+ client.TYPE(["zset key"], require_string("zset", name));
+ client.TYPE("not here yet", require_string("none", name));
+ client.TYPE(["hash key"], last(name, require_string("hash", name)));
+};
+
+tests.KEYS = function () {
+ var name = "KEYS";
+ client.mset(["test keys 1", "test val 1", "test keys 2", "test val 2"], require_string("OK", name));
+ client.KEYS(["test keys*"], function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(2, results.length, name);
+ assert.strictEqual("test keys 1", results[0].toString(), name);
+ assert.strictEqual("test keys 2", results[1].toString(), name);
+ next(name);
+ });
+};
+
+tests.MULTIBULK_ZERO_LENGTH = function () {
+ var name = "MULTIBULK_ZERO_LENGTH";
+ client.KEYS(['users:*'], function (err, results) {
+ assert.strictEqual(null, err, 'error on empty multibulk reply');
+ assert.strictEqual(true, is_empty_array(results), "not an empty array");
+ next(name);
+ });
+};
+
+tests.RANDOMKEY = function () {
+ var name = "RANDOMKEY";
+ client.mset(["test keys 1", "test val 1", "test keys 2", "test val 2"], require_string("OK", name));
+ client.RANDOMKEY([], function (err, results) {
+ assert.strictEqual(null, err, name + " result sent back unexpected error: " + err);
+ assert.strictEqual(true, /\w+/.test(results), name);
+ next(name);
+ });
+};
+
+tests.RENAME = function () {
+ var name = "RENAME";
+ client.set(['foo', 'bar'], require_string("OK", name));
+ client.RENAME(["foo", "new foo"], require_string("OK", name));
+ client.exists(["foo"], require_number(0, name));
+ client.exists(["new foo"], last(name, require_number(1, name)));
+};
+
+tests.RENAMENX = function () {
+ var name = "RENAMENX";
+ client.set(['foo', 'bar'], require_string("OK", name));
+ client.set(['foo2', 'bar2'], require_string("OK", name));
+ client.RENAMENX(["foo", "foo2"], require_number(0, name));
+ client.exists(["foo"], require_number(1, name));
+ client.exists(["foo2"], require_number(1, name));
+ client.del(["foo2"], require_number(1, name));
+ client.RENAMENX(["foo", "foo2"], require_number(1, name));
+ client.exists(["foo"], require_number(0, name));
+ client.exists(["foo2"], last(name, require_number(1, name)));
+};
+
+tests.DBSIZE = function () {
+ var name = "DBSIZE";
+ client.set(['foo', 'bar'], require_string("OK", name));
+ client.DBSIZE([], last(name, require_number_pos("DBSIZE")));
+};
+
+tests.GET = function () {
+ var name = "GET";
+ client.set(["get key", "get val"], require_string("OK", name));
+ client.GET(["get key"], last(name, require_string("get val", name)));
+};
+
+tests.SET = function () {
+ var name = "SET";
+ client.SET(["set key", "set val"], require_string("OK", name));
+ client.get(["set key"], last(name, require_string("set val", name)));
+};
+
+tests.GETSET = function () {
+ var name = "GETSET";
+ client.set(["getset key", "getset val"], require_string("OK", name));
+ client.GETSET(["getset key", "new getset val"], require_string("getset val", name));
+ client.get(["getset key"], last(name, require_string("new getset val", name)));
+};
+
+tests.MGET = function () {
+ var name = "MGET";
+ client.mset(["mget keys 1", "mget val 1", "mget keys 2", "mget val 2", "mget keys 3", "mget val 3"], require_string("OK", name));
+ client.MGET("mget keys 1", "mget keys 2", "mget keys 3", function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(3, results.length, name);
+ assert.strictEqual("mget val 1", results[0].toString(), name);
+ assert.strictEqual("mget val 2", results[1].toString(), name);
+ assert.strictEqual("mget val 3", results[2].toString(), name);
+ });
+ client.MGET(["mget keys 1", "mget keys 2", "mget keys 3"], function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(3, results.length, name);
+ assert.strictEqual("mget val 1", results[0].toString(), name);
+ assert.strictEqual("mget val 2", results[1].toString(), name);
+ assert.strictEqual("mget val 3", results[2].toString(), name);
+ });
+ client.MGET(["mget keys 1", "some random shit", "mget keys 2", "mget keys 3"], function (err, results) {
+ assert.strictEqual(null, err, "result sent back unexpected error: " + err);
+ assert.strictEqual(4, results.length, name);
+ assert.strictEqual("mget val 1", results[0].toString(), name);
+ assert.strictEqual(null, results[1], name);
+ assert.strictEqual("mget val 2", results[2].toString(), name);
+ assert.strictEqual("mget val 3", results[3].toString(), name);
+ next(name);
+ });
+};
+
+tests.SETNX = function () {
+ var name = "SETNX";
+ client.set(["setnx key", "setnx value"], require_string("OK", name));
+ client.SETNX(["setnx key", "new setnx value"], require_number(0, name));
+ client.del(["setnx key"], require_number(1, name));
+ client.exists(["setnx key"], require_number(0, name));
+ client.SETNX(["setnx key", "new setnx value"], require_number(1, name));
+ client.exists(["setnx key"], last(name, require_number(1, name)));
+};
+
+tests.SETEX = function () {
+ var name = "SETEX";
+ client.SETEX(["setex key", "100", "setex val"], require_string("OK", name));
+ client.exists(["setex key"], require_number(1, name));
+ client.ttl(["setex key"], last(name, require_number_pos(name)));
+};
+
+tests.MSETNX = function () {
+ var name = "MSETNX";
+ client.mset(["mset1", "val1", "mset2", "val2", "mset3", "val3"], require_string("OK", name));
+ client.MSETNX(["mset3", "val3", "mset4", "val4"], require_number(0, name));
+ client.del(["mset3"], require_number(1, name));
+ client.MSETNX(["mset3", "val3", "mset4", "val4"], require_number(1, name));
+ client.exists(["mset3"], require_number(1, name));
+ client.exists(["mset4"], last(name, require_number(1, name)));
+};
+
+tests.HGETALL = function () {
+ var name = "HGETALL";
+ client.hmset(["hosts", "mjr", "1", "another", "23", "home", "1234"], require_string("OK", name));
+ client.HGETALL(["hosts"], function (err, obj) {
+ assert.strictEqual(null, err, name + " result sent back unexpected error: " + err);
+ assert.strictEqual(3, Object.keys(obj).length, name);
+ assert.strictEqual("1", obj.mjr.toString(), name);
+ assert.strictEqual("23", obj.another.toString(), name);
+ assert.strictEqual("1234", obj.home.toString(), name);
+ next(name);
+ });
+};
+
+tests.HGETALL_NULL = function () {
+ var name = "HGETALL_NULL";
+
+ client.hgetall('missing', function (err, obj) {
+ assert.strictEqual(null, err);
+ assert.deepEqual([], obj);
+ next(name);
+ });
+};
+
+tests.UTF8 = function () {
+ var name = "UTF8",
+ utf8_sample = "ಠ_ಠ";
+
+ client.set(["utf8test", utf8_sample], require_string("OK", name));
+ client.get(["utf8test"], function (err, obj) {
+ assert.strictEqual(null, err);
+ assert.strictEqual(utf8_sample, obj);
+ next(name);
+ });
+};
+
+// Set tests were adapted from Brian Hammond's redis-node-client.js, which has a comprehensive test suite
+
+tests.SADD = function () {
+ var name = "SADD";
+
+ client.del('set0');
+ client.sadd('set0', 'member0', require_number(1, name));
+ client.sadd('set0', 'member0', last(name, require_number(0, name)));
+};
+
+tests.SADD2 = function () {
+ var name = "SADD2";
+
+ client.del("set0");
+ client.sadd("set0", ["member0", "member1", "member2"], require_number(3, name));
+ client.smembers("set0", function (err, res) {
+ assert.strictEqual(res.length, 3);
+ assert.strictEqual(res[0], "member0");
+ assert.strictEqual(res[1], "member1");
+ assert.strictEqual(res[2], "member2");
+ next(name);
+ });
+};
+
+tests.SISMEMBER = function () {
+ var name = "SISMEMBER";
+
+ client.del('set0');
+ client.sadd('set0', 'member0', require_number(1, name));
+ client.sismember('set0', 'member0', require_number(1, name));
+ client.sismember('set0', 'member1', last(name, require_number(0, name)));
+};
+
+tests.SCARD = function () {
+ var name = "SCARD";
+
+ client.del('set0');
+ client.sadd('set0', 'member0', require_number(1, name));
+ client.scard('set0', require_number(1, name));
+ client.sadd('set0', 'member1', require_number(1, name));
+ client.scard('set0', last(name, require_number(2, name)));
+};
+
+tests.SREM = function () {
+ var name = "SREM";
+
+ client.del('set0');
+ client.sadd('set0', 'member0', require_number(1, name));
+ client.srem('set0', 'foobar', require_number(0, name));
+ client.srem('set0', 'member0', require_number(1, name));
+ client.scard('set0', last(name, require_number(0, name)));
+};
+
+tests.SPOP = function () {
+ var name = "SPOP";
+
+ client.del('zzz');
+ client.sadd('zzz', 'member0', require_number(1, name));
+ client.scard('zzz', require_number(1, name));
+
+ client.spop('zzz', function (err, value) {
+ if (err) {
+ assert.fail(err);
+ }
+ assert.equal(value, 'member0', name);
+ });
+
+ client.scard('zzz', last(name, require_number(0, name)));
+};
+
+tests.SDIFF = function () {
+ var name = "SDIFF";
+
+ client.del('foo');
+ client.sadd('foo', 'x', require_number(1, name));
+ client.sadd('foo', 'a', require_number(1, name));
+ client.sadd('foo', 'b', require_number(1, name));
+ client.sadd('foo', 'c', require_number(1, name));
+
+ client.sadd('bar', 'c', require_number(1, name));
+
+ client.sadd('baz', 'a', require_number(1, name));
+ client.sadd('baz', 'd', require_number(1, name));
+
+ client.sdiff('foo', 'bar', 'baz', function (err, values) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ values.sort();
+ assert.equal(values.length, 2, name);
+ assert.equal(values[0], 'b', name);
+ assert.equal(values[1], 'x', name);
+ next(name);
+ });
+};
+
+tests.SDIFFSTORE = function () {
+ var name = "SDIFFSTORE";
+
+ client.del('foo');
+ client.del('bar');
+ client.del('baz');
+ client.del('quux');
+
+ client.sadd('foo', 'x', require_number(1, name));
+ client.sadd('foo', 'a', require_number(1, name));
+ client.sadd('foo', 'b', require_number(1, name));
+ client.sadd('foo', 'c', require_number(1, name));
+
+ client.sadd('bar', 'c', require_number(1, name));
+
+ client.sadd('baz', 'a', require_number(1, name));
+ client.sadd('baz', 'd', require_number(1, name));
+
+ // NB: SDIFFSTORE returns the number of elements in the dstkey
+
+ client.sdiffstore('quux', 'foo', 'bar', 'baz', require_number(2, name));
+
+ client.smembers('quux', function (err, values) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ var members = buffers_to_strings(values).sort();
+
+ assert.deepEqual(members, [ 'b', 'x' ], name);
+ next(name);
+ });
+};
+
+tests.SMEMBERS = function () {
+ var name = "SMEMBERS";
+
+ client.del('foo');
+ client.sadd('foo', 'x', require_number(1, name));
+
+ client.smembers('foo', function (err, members) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(members), [ 'x' ], name);
+ });
+
+ client.sadd('foo', 'y', require_number(1, name));
+
+ client.smembers('foo', function (err, values) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(values.length, 2, name);
+ var members = buffers_to_strings(values).sort();
+
+ assert.deepEqual(members, [ 'x', 'y' ], name);
+ next(name);
+ });
+};
+
+tests.SMOVE = function () {
+ var name = "SMOVE";
+
+ client.del('foo');
+ client.del('bar');
+
+ client.sadd('foo', 'x', require_number(1, name));
+ client.smove('foo', 'bar', 'x', require_number(1, name));
+ client.sismember('foo', 'x', require_number(0, name));
+ client.sismember('bar', 'x', require_number(1, name));
+ client.smove('foo', 'bar', 'x', last(name, require_number(0, name)));
+};
+
+tests.SINTER = function () {
+ var name = "SINTER";
+
+ client.del('sa');
+ client.del('sb');
+ client.del('sc');
+
+ client.sadd('sa', 'a', require_number(1, name));
+ client.sadd('sa', 'b', require_number(1, name));
+ client.sadd('sa', 'c', require_number(1, name));
+
+ client.sadd('sb', 'b', require_number(1, name));
+ client.sadd('sb', 'c', require_number(1, name));
+ client.sadd('sb', 'd', require_number(1, name));
+
+ client.sadd('sc', 'c', require_number(1, name));
+ client.sadd('sc', 'd', require_number(1, name));
+ client.sadd('sc', 'e', require_number(1, name));
+
+ client.sinter('sa', 'sb', function (err, intersection) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(intersection.length, 2, name);
+ assert.deepEqual(buffers_to_strings(intersection).sort(), [ 'b', 'c' ], name);
+ });
+
+ client.sinter('sb', 'sc', function (err, intersection) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(intersection.length, 2, name);
+ assert.deepEqual(buffers_to_strings(intersection).sort(), [ 'c', 'd' ], name);
+ });
+
+ client.sinter('sa', 'sc', function (err, intersection) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(intersection.length, 1, name);
+ assert.equal(intersection[0], 'c', name);
+ });
+
+ // 3-way
+
+ client.sinter('sa', 'sb', 'sc', function (err, intersection) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(intersection.length, 1, name);
+ assert.equal(intersection[0], 'c', name);
+ next(name);
+ });
+};
+
+tests.SINTERSTORE = function () {
+ var name = "SINTERSTORE";
+
+ client.del('sa');
+ client.del('sb');
+ client.del('sc');
+ client.del('foo');
+
+ client.sadd('sa', 'a', require_number(1, name));
+ client.sadd('sa', 'b', require_number(1, name));
+ client.sadd('sa', 'c', require_number(1, name));
+
+ client.sadd('sb', 'b', require_number(1, name));
+ client.sadd('sb', 'c', require_number(1, name));
+ client.sadd('sb', 'd', require_number(1, name));
+
+ client.sadd('sc', 'c', require_number(1, name));
+ client.sadd('sc', 'd', require_number(1, name));
+ client.sadd('sc', 'e', require_number(1, name));
+
+ client.sinterstore('foo', 'sa', 'sb', 'sc', require_number(1, name));
+
+ client.smembers('foo', function (err, members) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(members), [ 'c' ], name);
+ next(name);
+ });
+};
+
+tests.SUNION = function () {
+ var name = "SUNION";
+
+ client.del('sa');
+ client.del('sb');
+ client.del('sc');
+
+ client.sadd('sa', 'a', require_number(1, name));
+ client.sadd('sa', 'b', require_number(1, name));
+ client.sadd('sa', 'c', require_number(1, name));
+
+ client.sadd('sb', 'b', require_number(1, name));
+ client.sadd('sb', 'c', require_number(1, name));
+ client.sadd('sb', 'd', require_number(1, name));
+
+ client.sadd('sc', 'c', require_number(1, name));
+ client.sadd('sc', 'd', require_number(1, name));
+ client.sadd('sc', 'e', require_number(1, name));
+
+ client.sunion('sa', 'sb', 'sc', function (err, union) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(union).sort(), ['a', 'b', 'c', 'd', 'e'], name);
+ next(name);
+ });
+};
+
+tests.SUNIONSTORE = function () {
+ var name = "SUNIONSTORE";
+
+ client.del('sa');
+ client.del('sb');
+ client.del('sc');
+ client.del('foo');
+
+ client.sadd('sa', 'a', require_number(1, name));
+ client.sadd('sa', 'b', require_number(1, name));
+ client.sadd('sa', 'c', require_number(1, name));
+
+ client.sadd('sb', 'b', require_number(1, name));
+ client.sadd('sb', 'c', require_number(1, name));
+ client.sadd('sb', 'd', require_number(1, name));
+
+ client.sadd('sc', 'c', require_number(1, name));
+ client.sadd('sc', 'd', require_number(1, name));
+ client.sadd('sc', 'e', require_number(1, name));
+
+ client.sunionstore('foo', 'sa', 'sb', 'sc', function (err, cardinality) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(cardinality, 5, name);
+ });
+
+ client.smembers('foo', function (err, members) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.equal(members.length, 5, name);
+ assert.deepEqual(buffers_to_strings(members).sort(), ['a', 'b', 'c', 'd', 'e'], name);
+ next(name);
+ });
+};
+
+// SORT test adapted from Brian Hammond's redis-node-client.js, which has a comprehensive test suite
+
+tests.SORT = function () {
+ var name = "SORT";
+
+ client.del('y');
+ client.del('x');
+
+ client.rpush('y', 'd', require_number(1, name));
+ client.rpush('y', 'b', require_number(2, name));
+ client.rpush('y', 'a', require_number(3, name));
+ client.rpush('y', 'c', require_number(4, name));
+
+ client.rpush('x', '3', require_number(1, name));
+ client.rpush('x', '9', require_number(2, name));
+ client.rpush('x', '2', require_number(3, name));
+ client.rpush('x', '4', require_number(4, name));
+
+ client.set('w3', '4', require_string("OK", name));
+ client.set('w9', '5', require_string("OK", name));
+ client.set('w2', '12', require_string("OK", name));
+ client.set('w4', '6', require_string("OK", name));
+
+ client.set('o2', 'buz', require_string("OK", name));
+ client.set('o3', 'foo', require_string("OK", name));
+ client.set('o4', 'baz', require_string("OK", name));
+ client.set('o9', 'bar', require_string("OK", name));
+
+ client.set('p2', 'qux', require_string("OK", name));
+ client.set('p3', 'bux', require_string("OK", name));
+ client.set('p4', 'lux', require_string("OK", name));
+ client.set('p9', 'tux', require_string("OK", name));
+
+ // Now the data has been setup, we can test.
+
+ // But first, test basic sorting.
+
+ // y = [ d b a c ]
+ // sort y ascending = [ a b c d ]
+ // sort y descending = [ d c b a ]
+
+ client.sort('y', 'asc', 'alpha', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), ['a', 'b', 'c', 'd'], name);
+ });
+
+ client.sort('y', 'desc', 'alpha', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), ['d', 'c', 'b', 'a'], name);
+ });
+
+ // Now try sorting numbers in a list.
+ // x = [ 3, 9, 2, 4 ]
+
+ client.sort('x', 'asc', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), [2, 3, 4, 9], name);
+ });
+
+ client.sort('x', 'desc', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), [9, 4, 3, 2], name);
+ });
+
+ // Try sorting with a 'by' pattern.
+
+ client.sort('x', 'by', 'w*', 'asc', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), [3, 9, 4, 2], name);
+ });
+
+ // Try sorting with a 'by' pattern and 1 'get' pattern.
+
+ client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), ['foo', 'bar', 'baz', 'buz'], name);
+ });
+
+ // Try sorting with a 'by' pattern and 2 'get' patterns.
+
+ client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', function (err, sorted) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(sorted), ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux'], name);
+ });
+
+ // Try sorting with a 'by' pattern and 2 'get' patterns.
+ // Instead of getting back the sorted set/list, store the values to a list.
+ // Then check that the values are there in the expected order.
+
+ client.sort('x', 'by', 'w*', 'asc', 'get', 'o*', 'get', 'p*', 'store', 'bacon', function (err) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ });
+
+ client.lrange('bacon', 0, -1, function (err, values) {
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.deepEqual(buffers_to_strings(values), ['foo', 'bux', 'bar', 'tux', 'baz', 'lux', 'buz', 'qux'], name);
+ next(name);
+ });
+
+ // TODO - sort by hash value
+};
+
+tests.BLPOP = function () {
+ var name = "BLPOP";
+
+ client.rpush("blocking list", "initial value", function (err, res) {
+ client2.BLPOP("blocking list", 0, function (err, res) {
+ assert.strictEqual("blocking list", res[0].toString());
+ assert.strictEqual("initial value", res[1].toString());
+
+ client.rpush("blocking list", "wait for this value");
+ });
+ client2.BLPOP("blocking list", 0, function (err, res) {
+ assert.strictEqual("blocking list", res[0].toString());
+ assert.strictEqual("wait for this value", res[1].toString());
+ next(name);
+ });
+ });
+};
+
+tests.BLPOP_TIMEOUT = function () {
+ var name = "BLPOP_TIMEOUT";
+
+ // try to BLPOP the list again, which should be empty. This should timeout and return null.
+ client2.BLPOP("blocking list", 1, function (err, res) {
+ if (err) {
+ throw err;
+ }
+
+ assert.strictEqual(res, null);
+ next(name);
+ });
+};
+
+tests.EXPIRE = function () {
+ var name = "EXPIRE";
+ client.set(['expiry key', 'bar'], require_string("OK", name));
+ client.EXPIRE(["expiry key", "1"], require_number_pos(name));
+ setTimeout(function () {
+ client.exists(["expiry key"], last(name, require_number(0, name)));
+ }, 2000);
+};
+
+tests.TTL = function () {
+ var name = "TTL";
+ client.set(["ttl key", "ttl val"], require_string("OK", name));
+ client.expire(["ttl key", "100"], require_number_pos(name));
+ setTimeout(function () {
+ client.TTL(["ttl key"], last(name, require_number_pos(0, name)));
+ }, 500);
+};
+
+all_tests = Object.keys(tests);
+all_start = new Date();
+test_count = 0;
+
+run_next_test = function run_next_test() {
+ var test_name = all_tests.shift();
+ if (typeof tests[test_name] === "function") {
+ util.print('- \x1b[1m' + test_name.toLowerCase() + '\x1b[0m:');
+ cur_start = new Date();
+ test_count += 1;
+ tests[test_name]();
+ } else {
+ console.log('\n completed \x1b[32m%d\x1b[0m tests in \x1b[33m%d\x1b[0m ms\n', test_count, new Date() - all_start);
+ client.quit();
+ client2.quit();
+ client4.quit();
+ }
+};
+
+console.log("Using reply parser " + client.reply_parser.name);
+
+client.once("ready", function start_tests() {
+ console.log("Connected to " + client.host + ":" + client.port + ", Redis server version " + client.server_info.redis_version + "\n");
+
+ run_next_test();
+
+ connected = true;
+});
+
+client.on('end', function () {
+ ended = true;
+});
+
+// TODO - need a better way to test auth, maybe auto-config a local Redis server? Sounds hard.
+// Yes, this is the real password. Please be nice, thanks.
+client4.auth("664b1b6aaf134e1ec281945a8de702a9", function (err, res) {
+ var name = "AUTH_4";
+
+ if (err) {
+ assert.fail(err, name);
+ }
+ assert.strictEqual("OK", res.toString(), "auth");
+});
+
+// Exit immediately on connection failure, which triggers "exit", below, which fails the test
+client.on("error", function (err) {
+ console.error("client: " + err.stack);
+ process.exit();
+});
+client2.on("error", function (err) {
+ console.error("client2: " + err.stack);
+ process.exit();
+});
+client3.on("error", function (err) {
+ console.error("client3: " + err.stack);
+ process.exit();
+});
+
+client.on("reconnecting", function (params) {
+// console.log("reconnecting: " + util.inspect(params));
+});
+
+process.on('uncaughtException', function (err) {
+ console.error("Uncaught exception: " + err.stack);
+ process.exit(1);
+});
+
+process.on('exit', function (code) {
+ assert.equal(true, connected);
+ assert.equal(true, ended);
+});
diff --git a/node_modules/socket.io/node_modules/redis/tests/buffer_bench.js b/node_modules/socket.io/node_modules/redis/tests/buffer_bench.js
new file mode 100644
index 0000000..a504fbc
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/buffer_bench.js
@@ -0,0 +1,89 @@
+var source = new Buffer(100),
+ dest = new Buffer(100), i, j, k, tmp, count = 1000000, bytes = 100;
+
+for (i = 99 ; i >= 0 ; i--) {
+ source[i] = 120;
+}
+
+var str = "This is a nice String.",
+ buf = new Buffer("This is a lovely Buffer.");
+
+var start = new Date();
+for (i = count * 100; i > 0 ; i--) {
+ if (Buffer.isBuffer(str)) {}
+}
+var end = new Date();
+console.log("Buffer.isBuffer(str) " + (end - start) + " ms");
+
+var start = new Date();
+for (i = count * 100; i > 0 ; i--) {
+ if (Buffer.isBuffer(buf)) {}
+}
+var end = new Date();
+console.log("Buffer.isBuffer(buf) " + (end - start) + " ms");
+
+var start = new Date();
+for (i = count * 100; i > 0 ; i--) {
+ if (str instanceof Buffer) {}
+}
+var end = new Date();
+console.log("str instanceof Buffer " + (end - start) + " ms");
+
+var start = new Date();
+for (i = count * 100; i > 0 ; i--) {
+ if (buf instanceof Buffer) {}
+}
+var end = new Date();
+console.log("buf instanceof Buffer " + (end - start) + " ms");
+
+for (i = bytes ; i > 0 ; i --) {
+ var start = new Date();
+ for (j = count ; j > 0; j--) {
+ tmp = source.toString("ascii", 0, bytes);
+ }
+ var end = new Date();
+ console.log("toString() " + i + " bytes " + (end - start) + " ms");
+}
+
+for (i = bytes ; i > 0 ; i --) {
+ var start = new Date();
+ for (j = count ; j > 0; j--) {
+ tmp = "";
+ for (k = 0; k <= i ; k++) {
+ tmp += String.fromCharCode(source[k]);
+ }
+ }
+ var end = new Date();
+ console.log("manual string " + i + " bytes " + (end - start) + " ms");
+}
+
+for (i = bytes ; i > 0 ; i--) {
+ var start = new Date();
+ for (j = count ; j > 0 ; j--) {
+ for (k = i ; k > 0 ; k--) {
+ dest[k] = source[k];
+ }
+ }
+ var end = new Date();
+ console.log("Manual copy " + i + " bytes " + (end - start) + " ms");
+}
+
+for (i = bytes ; i > 0 ; i--) {
+ var start = new Date();
+ for (j = count ; j > 0 ; j--) {
+ for (k = i ; k > 0 ; k--) {
+ dest[k] = 120;
+ }
+ }
+ var end = new Date();
+ console.log("Direct assignment " + i + " bytes " + (end - start) + " ms");
+}
+
+for (i = bytes ; i > 0 ; i--) {
+ var start = new Date();
+ for (j = count ; j > 0 ; j--) {
+ source.copy(dest, 0, 0, i);
+ }
+ var end = new Date();
+ console.log("Buffer.copy() " + i + " bytes " + (end - start) + " ms");
+}
diff --git a/node_modules/socket.io/node_modules/redis/tests/reconnect_test.js b/node_modules/socket.io/node_modules/redis/tests/reconnect_test.js
new file mode 100644
index 0000000..08a6ca6
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/reconnect_test.js
@@ -0,0 +1,27 @@
+var redis = require("redis").createClient();
+
+redis.on("error", function (err) {
+ console.log("Redis says: " + err);
+});
+
+redis.on("ready", function () {
+ console.log("Redis ready.");
+});
+
+redis.on("reconnecting", function (arg) {
+ console.log("Redis reconnecting: " + JSON.stringify(arg));
+});
+redis.on("connect", function () {
+ console.log("Redis connected.");
+});
+
+setInterval(function () {
+ var now = Date.now();
+ redis.set("now", now, function (err, res) {
+ if (err) {
+ console.log(now + " Redis reply error: " + err);
+ } else {
+ console.log(now + " Redis reply: " + res);
+ }
+ });
+}, 200);
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/codec.js b/node_modules/socket.io/node_modules/redis/tests/stress/codec.js
new file mode 100644
index 0000000..7d764f6
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/codec.js
@@ -0,0 +1,16 @@
+var json = {
+ encode: JSON.stringify,
+ decode: JSON.parse
+};
+
+var MsgPack = require('node-msgpack');
+msgpack = {
+ encode: MsgPack.pack,
+ decode: function(str) { return MsgPack.unpack(new Buffer(str)); }
+};
+
+bison = require('bison');
+
+module.exports = json;
+//module.exports = msgpack;
+//module.exports = bison;
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/pub.js b/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/pub.js
new file mode 100644
index 0000000..0acde7a
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/pub.js
@@ -0,0 +1,38 @@
+'use strict';
+
+var freemem = require('os').freemem;
+var profiler = require('v8-profiler');
+var codec = require('../codec');
+
+var sent = 0;
+
+var pub = require('redis').createClient(null, null, {
+ //command_queue_high_water: 5,
+ //command_queue_low_water: 1
+})
+.on('ready', function() {
+ this.emit('drain');
+})
+.on('drain', function() {
+ process.nextTick(exec);
+});
+
+var payload = '1'; for (var i = 0; i < 12; ++i) payload += payload;
+console.log('Message payload length', payload.length);
+
+function exec() {
+ pub.publish('timeline', codec.encode({ foo: payload }));
+ ++sent;
+ if (!pub.should_buffer) {
+ process.nextTick(exec);
+ }
+}
+
+profiler.takeSnapshot('s_0');
+
+exec();
+
+setInterval(function() {
+ profiler.takeSnapshot('s_' + sent);
+ console.error('sent', sent, 'free', freemem(), 'cmdqlen', pub.command_queue.length, 'offqlen', pub.offline_queue.length);
+}, 2000);
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/run b/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/run
new file mode 100755
index 0000000..bd9ac39
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/run
@@ -0,0 +1,10 @@
+#!/bin/sh
+node server.js &
+node server.js &
+node server.js &
+node server.js &
+node server.js &
+node server.js &
+node server.js &
+node server.js &
+node --debug pub.js
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/server.js b/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/server.js
new file mode 100644
index 0000000..035e6b7
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/pubsub/server.js
@@ -0,0 +1,23 @@
+'use strict';
+
+var freemem = require('os').freemem;
+var codec = require('../codec');
+
+var id = Math.random();
+var recv = 0;
+
+var sub = require('redis').createClient()
+ .on('ready', function() {
+ this.subscribe('timeline');
+ })
+ .on('message', function(channel, message) {
+ var self = this;
+ if (message) {
+ message = codec.decode(message);
+ ++recv;
+ }
+ });
+
+setInterval(function() {
+ console.error('id', id, 'received', recv, 'free', freemem());
+}, 2000);
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/pub.js b/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/pub.js
new file mode 100644
index 0000000..9caf1d0
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/pub.js
@@ -0,0 +1,49 @@
+'use strict';
+
+var freemem = require('os').freemem;
+//var profiler = require('v8-profiler');
+var codec = require('../codec');
+
+var sent = 0;
+
+var pub = require('redis').createClient(null, null, {
+ //command_queue_high_water: 5,
+ //command_queue_low_water: 1
+})
+.on('ready', function() {
+ this.del('timeline');
+ this.emit('drain');
+})
+.on('drain', function() {
+ process.nextTick(exec);
+});
+
+var payload = '1'; for (var i = 0; i < 12; ++i) payload += payload;
+console.log('Message payload length', payload.length);
+
+function exec() {
+ pub.rpush('timeline', codec.encode({ foo: payload }));
+ ++sent;
+ if (!pub.should_buffer) {
+ process.nextTick(exec);
+ }
+}
+
+//profiler.takeSnapshot('s_0');
+
+exec();
+
+setInterval(function() {
+ //var ss = profiler.takeSnapshot('s_' + sent);
+ //console.error(ss.stringify());
+ pub.llen('timeline', function(err, result) {
+ console.error('sent', sent, 'free', freemem(),
+ 'cmdqlen', pub.command_queue.length, 'offqlen', pub.offline_queue.length,
+ 'llen', result
+ );
+ });
+}, 2000);
+
+/*setTimeout(function() {
+ process.exit();
+}, 30000);*/
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/run b/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/run
new file mode 100755
index 0000000..8045ae8
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/run
@@ -0,0 +1,6 @@
+#!/bin/sh
+node server.js &
+#node server.js &
+#node server.js &
+#node server.js &
+node --debug pub.js
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/server.js b/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/server.js
new file mode 100644
index 0000000..9cbcdd9
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/rpushblpop/server.js
@@ -0,0 +1,30 @@
+'use strict';
+
+var freemem = require('os').freemem;
+var codec = require('../codec');
+
+var id = Math.random();
+var recv = 0;
+
+var cmd = require('redis').createClient();
+var sub = require('redis').createClient()
+ .on('ready', function() {
+ this.emit('timeline');
+ })
+ .on('timeline', function() {
+ var self = this;
+ this.blpop('timeline', 0, function(err, result) {
+ var message = result[1];
+ if (message) {
+ message = codec.decode(message);
+ ++recv;
+ }
+ self.emit('timeline');
+ });
+ });
+
+setInterval(function() {
+ cmd.llen('timeline', function(err, result) {
+ console.error('id', id, 'received', recv, 'free', freemem(), 'llen', result);
+ });
+}, 2000);
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/speed/00 b/node_modules/socket.io/node_modules/redis/tests/stress/speed/00
new file mode 100644
index 0000000..29d7bf7
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/speed/00
@@ -0,0 +1,13 @@
+# size JSON msgpack bison
+26602 2151.0170848180414
+25542 ? 2842.589272665782
+24835 ? ? 7280.4538397469805
+6104 6985.234528557929
+5045 ? 7217.461392841478
+4341 ? ? 14261.406335354604
+4180 15864.633685636572
+4143 ? 12954.806235781925
+4141 ? ? 44650.70733912719
+75 114227.07313350472
+40 ? 30162.440062810834
+39 ? ? 119815.66013519121
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/speed/plot b/node_modules/socket.io/node_modules/redis/tests/stress/speed/plot
new file mode 100755
index 0000000..2563797
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/speed/plot
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+gnuplot >size-rate.jpg << _EOF_
+
+set terminal png nocrop enhanced font verdana 12 size 640,480
+set logscale x
+set logscale y
+set grid
+set xlabel 'Serialized object size, octets'
+set ylabel 'decode(encode(obj)) rate, 1/sec'
+plot '00' using 1:2 title 'json' smooth bezier, '00' using 1:3 title 'msgpack' smooth bezier, '00' using 1:4 title 'bison' smooth bezier
+
+_EOF_
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/speed/size-rate.png b/node_modules/socket.io/node_modules/redis/tests/stress/speed/size-rate.png
new file mode 100644
index 0000000..c9c2bee
Binary files /dev/null and b/node_modules/socket.io/node_modules/redis/tests/stress/speed/size-rate.png differ
diff --git a/node_modules/socket.io/node_modules/redis/tests/stress/speed/speed.js b/node_modules/socket.io/node_modules/redis/tests/stress/speed/speed.js
new file mode 100644
index 0000000..8e43cbc
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/stress/speed/speed.js
@@ -0,0 +1,84 @@
+var msgpack = require('node-msgpack');
+var bison = require('bison');
+var codec = {
+ JSON: {
+ encode: JSON.stringify,
+ decode: JSON.parse
+ },
+ msgpack: {
+ encode: msgpack.pack,
+ decode: msgpack.unpack
+ },
+ bison: bison
+};
+
+var obj, l;
+
+var s = '0';
+for (var i = 0; i < 12; ++i) s += s;
+
+obj = {
+ foo: s,
+ arrrrrr: [{a:1,b:false,c:null,d:1.0}, 1111, 2222, 33333333],
+ rand: [],
+ a: s,
+ ccc: s,
+ b: s + s + s
+};
+for (i = 0; i < 100; ++i) obj.rand.push(Math.random());
+forObj(obj);
+
+obj = {
+ foo: s,
+ arrrrrr: [{a:1,b:false,c:null,d:1.0}, 1111, 2222, 33333333],
+ rand: []
+};
+for (i = 0; i < 100; ++i) obj.rand.push(Math.random());
+forObj(obj);
+
+obj = {
+ foo: s,
+ arrrrrr: [{a:1,b:false,c:null,d:1.0}, 1111, 2222, 33333333],
+ rand: []
+};
+forObj(obj);
+
+obj = {
+ arrrrrr: [{a:1,b:false,c:null,d:1.0}, 1111, 2222, 33333333],
+ rand: []
+};
+forObj(obj);
+
+function run(obj, codec) {
+ var t1 = Date.now();
+ var n = 10000;
+ for (var i = 0; i < n; ++i) {
+ codec.decode(l = codec.encode(obj));
+ }
+ var t2 = Date.now();
+ //console.log('DONE', n*1000/(t2-t1), 'codecs/sec, length=', l.length);
+ return [n*1000/(t2-t1), l.length];
+}
+
+function series(obj, cname, n) {
+ var rate = 0;
+ var len = 0;
+ for (var i = 0; i < n; ++i) {
+ var r = run(obj, codec[cname]);
+ rate += r[0];
+ len += r[1];
+ }
+ rate /= n;
+ len /= n;
+ console.log(cname + ' ' + rate + ' ' + len);
+ return [rate, len];
+}
+
+function forObj(obj) {
+ var r = {
+ JSON: series(obj, 'JSON', 20),
+ msgpack: series(obj, 'msgpack', 20),
+ bison: series(obj, 'bison', 20)
+ };
+ return r;
+}
diff --git a/node_modules/socket.io/node_modules/redis/tests/sub_quit_test.js b/node_modules/socket.io/node_modules/redis/tests/sub_quit_test.js
new file mode 100644
index 0000000..ad1f413
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/sub_quit_test.js
@@ -0,0 +1,18 @@
+var client = require("redis").createClient(),
+ client2 = require("redis").createClient();
+
+client.subscribe("something");
+client.on("subscribe", function (channel, count) {
+ console.log("Got sub: " + channel);
+ client.unsubscribe("something");
+});
+
+client.on("unsubscribe", function (channel, count) {
+ console.log("Got unsub: " + channel + ", quitting");
+ client.quit();
+});
+
+// exercise unsub before sub
+client2.unsubscribe("something");
+client2.subscribe("another thing");
+client2.quit();
diff --git a/node_modules/socket.io/node_modules/redis/tests/test_start_stop.js b/node_modules/socket.io/node_modules/redis/tests/test_start_stop.js
new file mode 100644
index 0000000..0770893
--- /dev/null
+++ b/node_modules/socket.io/node_modules/redis/tests/test_start_stop.js
@@ -0,0 +1,17 @@
+var redis = require("./index"),
+ client = redis.createClient();
+
+// This currently doesn't work, due to what I beleive to be a bug in redis 2.0.1.
+// INFO and QUIT are pipelined together, and the socket closes before the INFO
+// command gets a reply.
+
+redis.debug_mode = true;
+client.info(redis.print);
+client.quit();
+
+// A workaround is:
+// client.info(function (err, res) {
+// console.log(res.toString());
+// client.quit();
+// });
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/.npmignore b/node_modules/socket.io/node_modules/socket.io-client/.npmignore
new file mode 100644
index 0000000..c27cb50
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/.npmignore
@@ -0,0 +1,2 @@
+test/node_modules
+support
diff --git a/node_modules/socket.io/node_modules/socket.io-client/History.md b/node_modules/socket.io/node_modules/socket.io-client/History.md
new file mode 100644
index 0000000..7315604
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/History.md
@@ -0,0 +1,192 @@
+
+0.9.6 / 2012-04-17
+==================
+
+ * Don't position the jsonp form off the screen (android fix).
+
+0.9.5 / 2012-04-05
+==================
+
+ * Bumped version.
+
+0.9.4 / 2012-04-01
+==================
+
+ * Fixes polling loop upon reconnect advice (fixes #438).
+
+0.9.3 / 2012-03-28
+==================
+
+ * Fix XHR.check, which was throwing an error transparently and causing non-IE browsers to fall back to JSONP [mikito]
+ * Fixed forced disconnect on window close [zzzaaa]
+
+0.9.2 / 2012-03-13
+==================
+
+ * Transport order set by "options" [zzzaaa]
+
+0.9.1-1 / 2012-03-02
+====================
+
+ * Fixed active-x-obfuscator NPM dependency.
+
+0.9.1 / 2012-03-02
+==================
+
+ * Misc corrections.
+ * Added warning within Firefox about webworker test in test runner.
+ * Update ws dependency [einaros]
+ * Implemented client side heartbeat checks. [felixge]
+ * Improved Firewall support with ActiveX obfuscation. [felixge]
+ * Fixed error handling during connection process. [Outsideris]
+
+0.9.0 / 2012-02-26
+==================
+
+ * Added DS_Store to gitignore.
+ * Updated depedencies.
+ * Bumped uglify
+ * Tweaking code so it doesn't throw an exception when used inside a WebWorker in Firefox
+ * Do not rely on Array.prototype.indexOf as it breaks with pages that use the Prototype.js library.
+ * Windows support landed
+ * Use @einaros ws module instead of the old crap one
+ * Fix for broken closeTimeout and 'IE + xhr' goes into infinite loop on disconnection
+ * Disabled reconnection on error if reconnect option is set to false
+ * Set withCredentials to true before xhr to fix authentication
+ * Clears the timeout from reconnection attempt when there is a successful or failed reconnection.
+ This fixes the issue of setTimeout's carrying over from previous reconnection
+ and changing (skipping) values of self.reconnectionDelay in the newer reconnection.
+ * Removed decoding of parameters when chunking the query string.
+ This was used later on to construct the url to post to the socket.io server
+ for connection and if we're adding custom parameters of our own to this url
+ (for example for OAuth authentication) they were being sent decoded, which is wrong.
+
+0.8.7 / 2011-11-05
+==================
+
+ * Bumped client
+
+0.8.6 / 2011-10-27
+==================
+
+ * Added WebWorker support.
+ * Fixed swfobject and web_socket.js to not assume window.
+ * Fixed CORS detection for webworker.
+ * Fix `defer` for webkit in a webworker.
+ * Fixed io.util.request to not rely on window.
+ * FIxed; use global instead of window and dont rely on document.
+ * Fixed; JSON-P handshake if CORS is not available.
+ * Made underlying Transport disconnection trigger immediate socket.io disconnect.
+ * Fixed warning when compressing with Google Closure Compiler.
+ * Fixed builder's uglify utf-8 support.
+ * Added workaround for loading indicator in FF jsonp-polling. [3rd-Eden]
+ * Fixed host discovery lookup. [holic]
+ * Fixed close timeout when disconnected/reconnecting. [jscharlach]
+ * Fixed jsonp-polling feature detection.
+ * Fixed jsonp-polling client POSTing of \n.
+ * Fixed test runner on IE6/7
+
+0.8.5 / 2011-10-07
+==================
+
+ * Bumped client
+
+0.8.4 / 2011-09-06
+==================
+
+ * Corrected build
+
+0.8.3 / 2011-09-03
+==================
+
+ * Fixed `\n` parsing for non-JSON packets.
+ * Fixed; make Socket.IO XHTML doctype compatible (fixes #460 from server)
+ * Fixed support for Node.JS running `socket.io-client`.
+ * Updated repository name in `package.json`.
+ * Added support for different policy file ports without having to port
+ forward 843 on the server side [3rd-Eden]
+
+0.8.2 / 2011-08-29
+==================
+
+ * Fixed flashsocket detection.
+
+0.8.1 / 2011-08-29
+==================
+
+ * Bump version.
+
+0.8.0 / 2011-08-28
+==================
+
+ * Added MozWebSocket support (hybi-10 doesn't require API changes) [einaros].
+
+0.7.11 / 2011-08-27
+===================
+
+ * Corrected previous release (missing build).
+
+0.7.10 / 2011-08-27
+===================
+
+ * Fix for failing fallback in websockets
+
+0.7.9 / 2011-08-12
+==================
+
+ * Added check on `Socket#onConnect` to prevent double `connect` events on the main manager.
+ * Fixed socket namespace connect test. Remove broken alternative namespace connect test.
+ * Removed test handler for removed test.
+ * Bumped version to match `socket.io` server.
+
+0.7.5 / 2011-08-08
+==================
+
+ * Added querystring support for `connect` [3rd-Eden]
+ * Added partial Node.JS transports support [3rd-Eden, josephg]
+ * Fixed builder test.
+ * Changed `util.inherit` to replicate Object.create / __proto__.
+ * Changed and cleaned up some acceptance tests.
+ * Fixed race condition with a test that could not be run multiple times.
+ * Added test for encoding a payload.
+ * Added the ability to override the transport to use in acceptance test [3rd-Eden]
+ * Fixed multiple connect packets [DanielBaulig]
+ * Fixed jsonp-polling over-buffering [3rd-Eden]
+ * Fixed ascii preservation in minified socket.io client [3rd-Eden]
+ * Fixed socket.io in situations where the page is not served through utf8.
+ * Fixed namespaces not reconnecting after disconnect [3rd-Eden]
+ * Fixed default port for secure connections.
+
+0.7.4 / 2011-07-12
+==================
+
+ * Added `SocketNamespace#of` shortcut. [3rd-Eden]
+ * Fixed a IE payload decoding bug. [3rd-Eden]
+ * Honor document protocol, unless overriden. [dvv]
+ * Fixed new builder dependencies. [3rd-Eden]
+
+0.7.3 / 2011-06-30
+==================
+
+ * Fixed; acks don't depend on arity. They're automatic for `.send` and
+ callback based for `.emit`. [dvv]
+ * Added support for sub-sockets authorization. [3rd-Eden]
+ * Added BC support for `new io.connect`. [fat]
+ * Fixed double `connect` events. [3rd-Eden]
+ * Fixed reconnection with jsonp-polling maintaining old sessionid. [franck34]
+
+0.7.2 / 2011-06-22
+==================
+
+ * Added `noop` message type.
+
+0.7.1 / 2011-06-21
+==================
+
+ * Bumped socket.io dependency version for acceptance tests.
+
+0.7.0 / 2011-06-21
+==================
+
+ * http://socket.io/announcement.html
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/Makefile b/node_modules/socket.io/node_modules/socket.io-client/Makefile
new file mode 100644
index 0000000..f2d2f41
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/Makefile
@@ -0,0 +1,20 @@
+
+ALL_TESTS = $(shell find test/ -name '*.test.js')
+
+run-tests:
+ @./node_modules/.bin/expresso \
+ -I lib \
+ -I support \
+ --serial \
+ $(TESTS)
+
+test:
+ @$(MAKE) TESTS="$(ALL_TESTS)" run-tests
+
+test-acceptance:
+ @node support/test-runner/app $(TRANSPORT)
+
+build:
+ @node ./bin/builder.js
+
+.PHONY: test
diff --git a/node_modules/socket.io/node_modules/socket.io-client/README.md b/node_modules/socket.io/node_modules/socket.io-client/README.md
new file mode 100644
index 0000000..cdb7715
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/README.md
@@ -0,0 +1,246 @@
+socket.io
+=========
+
+#### Sockets for the rest of us
+
+The `socket.io` client is basically a simple HTTP Socket interface implementation.
+It looks similar to WebSocket while providing additional features and
+leveraging other transports when WebSocket is not supported by the user's
+browser.
+
+```js
+var socket = io.connect('http://domain.com');
+socket.on('connect', function () {
+ // socket connected
+});
+socket.on('custom event', function () {
+ // server emitted a custom event
+});
+socket.on('disconnect', function () {
+ // socket disconnected
+});
+socket.send('hi there');
+```
+
+### Recipes
+
+#### Utilizing namespaces (ie: multiple sockets)
+
+If you want to namespace all the messages and events emitted to a particular
+endpoint, simply specify it as part of the `connect` uri:
+
+```js
+var chat = io.connect('http://localhost/chat');
+chat.on('connect', function () {
+ // chat socket connected
+});
+
+var news = io.connect('/news'); // io.connect auto-detects host
+news.on('connect', function () {
+ // news socket connected
+});
+```
+
+#### Emitting custom events
+
+To ease with the creation of applications, you can emit custom events outside
+of the global `message` event.
+
+```js
+var socket = io.connect();
+socket.emit('server custom event', { my: 'data' });
+```
+
+#### Forcing disconnection
+
+```js
+var socket = io.connect();
+socket.on('connect', function () {
+ socket.disconnect();
+});
+```
+
+### Documentation
+
+#### io#connect
+
+```js
+io.connect(uri, [options]);
+```
+
+##### Options:
+
+- *resource*
+
+ socket.io
+
+ The resource is what allows the `socket.io` server to identify incoming connections by `socket.io` clients. In other words, any HTTP server can implement socket.io and still serve other normal, non-realtime HTTP requests.
+
+- *transports*
+
+```js
+['websocket', 'flashsocket', 'htmlfile', 'xhr-multipart', 'xhr-polling', 'jsonp-polling']
+```
+
+ A list of the transports to attempt to utilize (in order of preference).
+
+- *'connect timeout'*
+
+```js
+5000
+```
+
+ The amount of milliseconds a transport has to create a connection before we consider it timed out.
+
+- *'try multiple transports'*
+
+```js
+true
+```
+
+ A boolean indicating if we should try other transports when the connectTimeout occurs.
+
+- *reconnect*
+
+```js
+true
+```
+
+ A boolean indicating if we should automatically reconnect if a connection is disconnected.
+
+- *'reconnection delay'*
+
+```js
+500
+```
+
+ The amount of milliseconds before we try to connect to the server again. We are using a exponential back off algorithm for the following reconnections, on each reconnect attempt this value will get multiplied (500 > 1000 > 2000 > 4000 > 8000).
+
+
+- *'max reconnection attempts'*
+
+```js
+10
+```
+
+ The amount of attempts should we make using the current transport to connect to the server? After this we will do one final attempt, and re-try with all enabled transport methods before we give up.
+
+##### Properties:
+
+- *options*
+
+ The passed in options combined with the defaults.
+
+- *connected*
+
+ Whether the socket is connected or not.
+
+- *connecting*
+
+ Whether the socket is connecting or not.
+
+- *reconnecting*
+
+ Whether we are reconnecting or not.
+
+- *transport*
+
+ The transport instance.
+
+##### Methods:
+
+- *connect(λ)*
+
+ Establishes a connection. If λ is supplied as argument, it will be called once the connection is established.
+
+- *send(message)*
+
+ A string of data to send.
+
+- *disconnect*
+
+ Closes the connection.
+
+- *on(event, λ)*
+
+ Adds a listener for the event *event*.
+
+- *once(event, λ)*
+
+ Adds a one time listener for the event *event*. The listener is removed after the first time the event is fired.
+
+- *removeListener(event, λ)*
+
+ Removes the listener λ for the event *event*.
+
+##### Events:
+
+- *connect*
+
+ Fired when the connection is established and the handshake successful.
+
+- *connecting(transport_type)*
+
+ Fired when a connection is attempted, passing the transport name.
+
+- *connect_failed*
+
+ Fired when the connection timeout occurs after the last connection attempt.
+ This only fires if the `connectTimeout` option is set.
+ If the `tryTransportsOnConnectTimeout` option is set, this only fires once all
+ possible transports have been tried.
+
+- *message(message)*
+
+ Fired when a message arrives from the server
+
+- *close*
+
+ Fired when the connection is closed. Be careful with using this event, as some transports will fire it even under temporary, expected disconnections (such as XHR-Polling).
+
+- *disconnect*
+
+ Fired when the connection is considered disconnected.
+
+- *reconnect(transport_type,reconnectionAttempts)*
+
+ Fired when the connection has been re-established. This only fires if the `reconnect` option is set.
+
+- *reconnecting(reconnectionDelay,reconnectionAttempts)*
+
+ Fired when a reconnection is attempted, passing the next delay for the next reconnection.
+
+- *reconnect_failed*
+
+ Fired when all reconnection attempts have failed and we where unsuccessful in reconnecting to the server.
+
+### Contributors
+
+Guillermo Rauch <guillermo@learnboost.com>
+
+Arnout Kazemier <info@3rd-eden.com>
+
+### License
+
+(The MIT License)
+
+Copyright (c) 2010 LearnBoost <dev@learnboost.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/socket.io/node_modules/socket.io-client/bin/builder.js b/node_modules/socket.io/node_modules/socket.io-client/bin/builder.js
new file mode 100755
index 0000000..8870e51
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/bin/builder.js
@@ -0,0 +1,281 @@
+/*!
+ * socket.io-node
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var fs = require('fs')
+ , socket = require('../lib/io')
+ , uglify = require('uglify-js')
+ , activeXObfuscator = require('active-x-obfuscator');
+
+/**
+ * License headers.
+ *
+ * @api private
+ */
+
+var template = '/*! Socket.IO.%ext% build:' + socket.version + ', %type%. Copyright(c) 2011 LearnBoost MIT Licensed */\n'
+ , development = template.replace('%type%', 'development').replace('%ext%', 'js')
+ , production = template.replace('%type%', 'production').replace('%ext%', 'min.js');
+
+/**
+ * If statements, these allows you to create serveride & client side compatible
+ * code using specially designed `if` statements that remove serverside
+ * designed code from the source files
+ *
+ * @api private
+ */
+
+var starttagIF = '// if node'
+ , endtagIF = '// end node';
+
+/**
+ * The modules that are required to create a base build of Socket.IO.
+ *
+ * @const
+ * @type {Array}
+ * @api private
+ */
+
+var base = [
+ 'io.js'
+ , 'util.js'
+ , 'events.js'
+ , 'json.js'
+ , 'parser.js'
+ , 'transport.js'
+ , 'socket.js'
+ , 'namespace.js'
+ ];
+
+/**
+ * The available transports for Socket.IO. These are mapped as:
+ *
+ * - `key` the name of the transport
+ * - `value` the dependencies for the transport
+ *
+ * @const
+ * @type {Object}
+ * @api public
+ */
+
+var baseTransports = {
+ 'websocket': ['transports/websocket.js']
+ , 'flashsocket': [
+ 'transports/websocket.js'
+ , 'transports/flashsocket.js'
+ , 'vendor/web-socket-js/swfobject.js'
+ , 'vendor/web-socket-js/web_socket.js'
+ ]
+ , 'htmlfile': ['transports/xhr.js', 'transports/htmlfile.js']
+ /* FIXME: re-enable me once we have multi-part support
+ , 'xhr-multipart': ['transports/xhr.js', 'transports/xhr-multipart.js'] */
+ , 'xhr-polling': ['transports/xhr.js', 'transports/xhr-polling.js']
+ , 'jsonp-polling': [
+ 'transports/xhr.js'
+ , 'transports/xhr-polling.js'
+ , 'transports/jsonp-polling.js'
+ ]
+};
+
+/**
+ * Builds a custom Socket.IO distribution based on the transports that you
+ * need. You can configure the build to create development build or production
+ * build (minified).
+ *
+ * @param {Array} transports The transports that needs to be bundled.
+ * @param {Object} [options] Options to configure the building process.
+ * @param {Function} callback Last argument should always be the callback
+ * @callback {String|Boolean} err An optional argument, if it exists than an error
+ * occurred during the build process.
+ * @callback {String} result The result of the build process.
+ * @api public
+ */
+
+var builder = module.exports = function () {
+ var transports, options, callback, error = null
+ , args = Array.prototype.slice.call(arguments, 0)
+ , settings = {
+ minify: true
+ , node: false
+ , custom: []
+ };
+
+ // Fancy pancy argument support this makes any pattern possible mainly
+ // because we require only one of each type
+ args.forEach(function (arg) {
+ var type = Object.prototype.toString.call(arg)
+ .replace(/\[object\s(\w+)\]/gi , '$1' ).toLowerCase();
+
+ switch (type) {
+ case 'array':
+ return transports = arg;
+ case 'object':
+ return options = arg;
+ case 'function':
+ return callback = arg;
+ }
+ });
+
+ // Add defaults
+ options = options || {};
+ transports = transports || Object.keys(baseTransports);
+
+ // Merge the data
+ for(var option in options) {
+ settings[option] = options[option];
+ }
+
+ // Start creating a dependencies chain with all the required files for the
+ // custom Socket.IO bundle.
+ var files = [];
+ base.forEach(function (file) {
+ files.push(__dirname + '/../lib/' + file);
+ });
+
+ transports.forEach(function (transport) {
+ var dependencies = baseTransports[transport];
+ if (!dependencies) {
+ error = 'Unsupported transport `' + transport + '` supplied as argument.';
+ return;
+ }
+
+ // Add the files to the files list, but only if they are not added before
+ dependencies.forEach(function (file) {
+ var path = __dirname + '/../lib/' + file;
+ if (!~files.indexOf(path)) files.push(path);
+ })
+ });
+
+ // check to see if the files tree compilation generated any errors.
+ if (error) return callback(error);
+
+ var results = {};
+ files.forEach(function (file) {
+ fs.readFile(file, function (err, content) {
+ if (err) error = err;
+ results[file] = content;
+
+ // check if we are done yet, or not.. Just by checking the size of the result
+ // object.
+ if (Object.keys(results).length !== files.length) return;
+
+ // we are done, did we error?
+ if (error) return callback(error);
+
+ // concatinate the file contents in order
+ var code = development
+ , ignore = 0;
+
+ files.forEach(function (file) {
+ code += results[file];
+ });
+
+ // check if we need to add custom code
+ if (settings.custom.length) {
+ settings.custom.forEach(function (content) {
+ code += content;
+ });
+ }
+
+ code = activeXObfuscator(code);
+
+ // Search for conditional code blocks that need to be removed as they
+ // where designed for a server side env. but only if we don't want to
+ // make this build node compatible.
+ if (!settings.node) {
+ code = code.split('\n').filter(function (line) {
+ // check if there are tags in here
+ var start = line.indexOf(starttagIF) >= 0
+ , end = line.indexOf(endtagIF) >= 0
+ , ret = ignore;
+
+ // ignore the current line
+ if (start) {
+ ignore++;
+ ret = ignore;
+ }
+
+ // stop ignoring the next line
+ if (end) {
+ ignore--;
+ }
+
+ return ret == 0;
+ }).join('\n');
+ }
+
+ // check if we need to process it any further
+ if (settings.minify) {
+ var ast = uglify.parser.parse(code);
+ ast = uglify.uglify.ast_mangle(ast);
+ ast = uglify.uglify.ast_squeeze(ast);
+
+ code = production + uglify.uglify.gen_code(ast, { ascii_only: true });
+ }
+
+ callback(error, code);
+ })
+ })
+};
+
+/**
+ * Builder version is also the current client version
+ * this way we don't have to do another include for the
+ * clients version number and we can just include the builder.
+ *
+ * @type {String}
+ * @api public
+ */
+
+builder.version = socket.version;
+
+/**
+ * A list of all build in transport types.
+ *
+ * @type {Object}
+ * @api public
+ */
+
+builder.transports = baseTransports;
+
+/**
+ * Command line support, this allows us to generate builds without having
+ * to load it as module.
+ */
+
+if (!module.parent){
+ // the first 2 are `node` and the path to this file, we don't need them
+ var args = process.argv.slice(2);
+
+ // build a development build
+ builder(args.length ? args : false, { minify:false }, function (err, content) {
+ if (err) return console.error(err);
+
+ fs.write(
+ fs.openSync(__dirname + '/../dist/socket.io.js', 'w')
+ , content
+ , 0
+ , 'utf8'
+ );
+ console.log('Successfully generated the development build: socket.io.js');
+ });
+
+ // and build a production build
+ builder(args.length ? args : false, function (err, content) {
+ if (err) return console.error(err);
+
+ fs.write(
+ fs.openSync(__dirname + '/../dist/socket.io.min.js', 'w')
+ , content
+ , 0
+ , 'utf8'
+ );
+ console.log('Successfully generated the production build: socket.io.min.js');
+ });
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/dist/WebSocketMain.swf b/node_modules/socket.io/node_modules/socket.io-client/dist/WebSocketMain.swf
new file mode 100644
index 0000000..20a451f
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/dist/WebSocketMain.swf differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/dist/WebSocketMainInsecure.swf b/node_modules/socket.io/node_modules/socket.io-client/dist/WebSocketMainInsecure.swf
new file mode 100644
index 0000000..5949ff3
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/dist/WebSocketMainInsecure.swf differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/dist/socket.io.js b/node_modules/socket.io/node_modules/socket.io-client/dist/socket.io.js
new file mode 100644
index 0000000..f2c6a38
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/dist/socket.io.js
@@ -0,0 +1,3788 @@
+/*! Socket.IO.js build:0.9.6, development. Copyright(c) 2011 LearnBoost MIT Licensed */
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, global) {
+
+ /**
+ * IO namespace.
+ *
+ * @namespace
+ */
+
+ var io = exports;
+
+ /**
+ * Socket.IO version
+ *
+ * @api public
+ */
+
+ io.version = '0.9.6';
+
+ /**
+ * Protocol implemented.
+ *
+ * @api public
+ */
+
+ io.protocol = 1;
+
+ /**
+ * Available transports, these will be populated with the available transports
+ *
+ * @api public
+ */
+
+ io.transports = [];
+
+ /**
+ * Keep track of jsonp callbacks.
+ *
+ * @api private
+ */
+
+ io.j = [];
+
+ /**
+ * Keep track of our io.Sockets
+ *
+ * @api private
+ */
+ io.sockets = {};
+
+
+ /**
+ * Manages connections to hosts.
+ *
+ * @param {String} uri
+ * @Param {Boolean} force creation of new socket (defaults to false)
+ * @api public
+ */
+
+ io.connect = function (host, details) {
+ var uri = io.util.parseUri(host)
+ , uuri
+ , socket;
+
+ if (global && global.location) {
+ uri.protocol = uri.protocol || global.location.protocol.slice(0, -1);
+ uri.host = uri.host || (global.document
+ ? global.document.domain : global.location.hostname);
+ uri.port = uri.port || global.location.port;
+ }
+
+ uuri = io.util.uniqueUri(uri);
+
+ var options = {
+ host: uri.host
+ , secure: 'https' == uri.protocol
+ , port: uri.port || ('https' == uri.protocol ? 443 : 80)
+ , query: uri.query || ''
+ };
+
+ io.util.merge(options, details);
+
+ if (options['force new connection'] || !io.sockets[uuri]) {
+ socket = new io.Socket(options);
+ }
+
+ if (!options['force new connection'] && socket) {
+ io.sockets[uuri] = socket;
+ }
+
+ socket = socket || io.sockets[uuri];
+
+ // if path is different from '' or /
+ return socket.of(uri.path.length > 1 ? uri.path : '');
+ };
+
+})('object' === typeof module ? module.exports : (this.io = {}), this);
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, global) {
+
+ /**
+ * Utilities namespace.
+ *
+ * @namespace
+ */
+
+ var util = exports.util = {};
+
+ /**
+ * Parses an URI
+ *
+ * @author Steven Levithan (MIT license)
+ * @api public
+ */
+
+ var re = /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+
+ var parts = ['source', 'protocol', 'authority', 'userInfo', 'user', 'password',
+ 'host', 'port', 'relative', 'path', 'directory', 'file', 'query',
+ 'anchor'];
+
+ util.parseUri = function (str) {
+ var m = re.exec(str || '')
+ , uri = {}
+ , i = 14;
+
+ while (i--) {
+ uri[parts[i]] = m[i] || '';
+ }
+
+ return uri;
+ };
+
+ /**
+ * Produces a unique url that identifies a Socket.IO connection.
+ *
+ * @param {Object} uri
+ * @api public
+ */
+
+ util.uniqueUri = function (uri) {
+ var protocol = uri.protocol
+ , host = uri.host
+ , port = uri.port;
+
+ if ('document' in global) {
+ host = host || document.domain;
+ port = port || (protocol == 'https'
+ && document.location.protocol !== 'https:' ? 443 : document.location.port);
+ } else {
+ host = host || 'localhost';
+
+ if (!port && protocol == 'https') {
+ port = 443;
+ }
+ }
+
+ return (protocol || 'http') + '://' + host + ':' + (port || 80);
+ };
+
+ /**
+ * Mergest 2 query strings in to once unique query string
+ *
+ * @param {String} base
+ * @param {String} addition
+ * @api public
+ */
+
+ util.query = function (base, addition) {
+ var query = util.chunkQuery(base || '')
+ , components = [];
+
+ util.merge(query, util.chunkQuery(addition || ''));
+ for (var part in query) {
+ if (query.hasOwnProperty(part)) {
+ components.push(part + '=' + query[part]);
+ }
+ }
+
+ return components.length ? '?' + components.join('&') : '';
+ };
+
+ /**
+ * Transforms a querystring in to an object
+ *
+ * @param {String} qs
+ * @api public
+ */
+
+ util.chunkQuery = function (qs) {
+ var query = {}
+ , params = qs.split('&')
+ , i = 0
+ , l = params.length
+ , kv;
+
+ for (; i < l; ++i) {
+ kv = params[i].split('=');
+ if (kv[0]) {
+ query[kv[0]] = kv[1];
+ }
+ }
+
+ return query;
+ };
+
+ /**
+ * Executes the given function when the page is loaded.
+ *
+ * io.util.load(function () { console.log('page loaded'); });
+ *
+ * @param {Function} fn
+ * @api public
+ */
+
+ var pageLoaded = false;
+
+ util.load = function (fn) {
+ if ('document' in global && document.readyState === 'complete' || pageLoaded) {
+ return fn();
+ }
+
+ util.on(global, 'load', fn, false);
+ };
+
+ /**
+ * Adds an event.
+ *
+ * @api private
+ */
+
+ util.on = function (element, event, fn, capture) {
+ if (element.attachEvent) {
+ element.attachEvent('on' + event, fn);
+ } else if (element.addEventListener) {
+ element.addEventListener(event, fn, capture);
+ }
+ };
+
+ /**
+ * Generates the correct `XMLHttpRequest` for regular and cross domain requests.
+ *
+ * @param {Boolean} [xdomain] Create a request that can be used cross domain.
+ * @returns {XMLHttpRequest|false} If we can create a XMLHttpRequest.
+ * @api private
+ */
+
+ util.request = function (xdomain) {
+
+ if (xdomain && 'undefined' != typeof XDomainRequest) {
+ return new XDomainRequest();
+ }
+
+ if ('undefined' != typeof XMLHttpRequest && (!xdomain || util.ua.hasCORS)) {
+ return new XMLHttpRequest();
+ }
+
+ if (!xdomain) {
+ try {
+ return new window[(['Active'].concat('Object').join('X'))]('Microsoft.XMLHTTP');
+ } catch(e) { }
+ }
+
+ return null;
+ };
+
+ /**
+ * XHR based transport constructor.
+ *
+ * @constructor
+ * @api public
+ */
+
+ /**
+ * Change the internal pageLoaded value.
+ */
+
+ if ('undefined' != typeof window) {
+ util.load(function () {
+ pageLoaded = true;
+ });
+ }
+
+ /**
+ * Defers a function to ensure a spinner is not displayed by the browser
+ *
+ * @param {Function} fn
+ * @api public
+ */
+
+ util.defer = function (fn) {
+ if (!util.ua.webkit || 'undefined' != typeof importScripts) {
+ return fn();
+ }
+
+ util.load(function () {
+ setTimeout(fn, 100);
+ });
+ };
+
+ /**
+ * Merges two objects.
+ *
+ * @api public
+ */
+
+ util.merge = function merge (target, additional, deep, lastseen) {
+ var seen = lastseen || []
+ , depth = typeof deep == 'undefined' ? 2 : deep
+ , prop;
+
+ for (prop in additional) {
+ if (additional.hasOwnProperty(prop) && util.indexOf(seen, prop) < 0) {
+ if (typeof target[prop] !== 'object' || !depth) {
+ target[prop] = additional[prop];
+ seen.push(additional[prop]);
+ } else {
+ util.merge(target[prop], additional[prop], depth - 1, seen);
+ }
+ }
+ }
+
+ return target;
+ };
+
+ /**
+ * Merges prototypes from objects
+ *
+ * @api public
+ */
+
+ util.mixin = function (ctor, ctor2) {
+ util.merge(ctor.prototype, ctor2.prototype);
+ };
+
+ /**
+ * Shortcut for prototypical and static inheritance.
+ *
+ * @api private
+ */
+
+ util.inherit = function (ctor, ctor2) {
+ function f() {};
+ f.prototype = ctor2.prototype;
+ ctor.prototype = new f;
+ };
+
+ /**
+ * Checks if the given object is an Array.
+ *
+ * io.util.isArray([]); // true
+ * io.util.isArray({}); // false
+ *
+ * @param Object obj
+ * @api public
+ */
+
+ util.isArray = Array.isArray || function (obj) {
+ return Object.prototype.toString.call(obj) === '[object Array]';
+ };
+
+ /**
+ * Intersects values of two arrays into a third
+ *
+ * @api public
+ */
+
+ util.intersect = function (arr, arr2) {
+ var ret = []
+ , longest = arr.length > arr2.length ? arr : arr2
+ , shortest = arr.length > arr2.length ? arr2 : arr;
+
+ for (var i = 0, l = shortest.length; i < l; i++) {
+ if (~util.indexOf(longest, shortest[i]))
+ ret.push(shortest[i]);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Array indexOf compatibility.
+ *
+ * @see bit.ly/a5Dxa2
+ * @api public
+ */
+
+ util.indexOf = function (arr, o, i) {
+
+ for (var j = arr.length, i = i < 0 ? i + j < 0 ? 0 : i + j : i || 0;
+ i < j && arr[i] !== o; i++) {}
+
+ return j <= i ? -1 : i;
+ };
+
+ /**
+ * Converts enumerables to array.
+ *
+ * @api public
+ */
+
+ util.toArray = function (enu) {
+ var arr = [];
+
+ for (var i = 0, l = enu.length; i < l; i++)
+ arr.push(enu[i]);
+
+ return arr;
+ };
+
+ /**
+ * UA / engines detection namespace.
+ *
+ * @namespace
+ */
+
+ util.ua = {};
+
+ /**
+ * Whether the UA supports CORS for XHR.
+ *
+ * @api public
+ */
+
+ util.ua.hasCORS = 'undefined' != typeof XMLHttpRequest && (function () {
+ try {
+ var a = new XMLHttpRequest();
+ } catch (e) {
+ return false;
+ }
+
+ return a.withCredentials != undefined;
+ })();
+
+ /**
+ * Detect webkit.
+ *
+ * @api public
+ */
+
+ util.ua.webkit = 'undefined' != typeof navigator
+ && /webkit/i.test(navigator.userAgent);
+
+})('undefined' != typeof io ? io : module.exports, this);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.EventEmitter = EventEmitter;
+
+ /**
+ * Event emitter constructor.
+ *
+ * @api public.
+ */
+
+ function EventEmitter () {};
+
+ /**
+ * Adds a listener
+ *
+ * @api public
+ */
+
+ EventEmitter.prototype.on = function (name, fn) {
+ if (!this.$events) {
+ this.$events = {};
+ }
+
+ if (!this.$events[name]) {
+ this.$events[name] = fn;
+ } else if (io.util.isArray(this.$events[name])) {
+ this.$events[name].push(fn);
+ } else {
+ this.$events[name] = [this.$events[name], fn];
+ }
+
+ return this;
+ };
+
+ EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+ /**
+ * Adds a volatile listener.
+ *
+ * @api public
+ */
+
+ EventEmitter.prototype.once = function (name, fn) {
+ var self = this;
+
+ function on () {
+ self.removeListener(name, on);
+ fn.apply(this, arguments);
+ };
+
+ on.listener = fn;
+ this.on(name, on);
+
+ return this;
+ };
+
+ /**
+ * Removes a listener.
+ *
+ * @api public
+ */
+
+ EventEmitter.prototype.removeListener = function (name, fn) {
+ if (this.$events && this.$events[name]) {
+ var list = this.$events[name];
+
+ if (io.util.isArray(list)) {
+ var pos = -1;
+
+ for (var i = 0, l = list.length; i < l; i++) {
+ if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {
+ pos = i;
+ break;
+ }
+ }
+
+ if (pos < 0) {
+ return this;
+ }
+
+ list.splice(pos, 1);
+
+ if (!list.length) {
+ delete this.$events[name];
+ }
+ } else if (list === fn || (list.listener && list.listener === fn)) {
+ delete this.$events[name];
+ }
+ }
+
+ return this;
+ };
+
+ /**
+ * Removes all listeners for an event.
+ *
+ * @api public
+ */
+
+ EventEmitter.prototype.removeAllListeners = function (name) {
+ // TODO: enable this when node 0.5 is stable
+ //if (name === undefined) {
+ //this.$events = {};
+ //return this;
+ //}
+
+ if (this.$events && this.$events[name]) {
+ this.$events[name] = null;
+ }
+
+ return this;
+ };
+
+ /**
+ * Gets all listeners for a certain event.
+ *
+ * @api publci
+ */
+
+ EventEmitter.prototype.listeners = function (name) {
+ if (!this.$events) {
+ this.$events = {};
+ }
+
+ if (!this.$events[name]) {
+ this.$events[name] = [];
+ }
+
+ if (!io.util.isArray(this.$events[name])) {
+ this.$events[name] = [this.$events[name]];
+ }
+
+ return this.$events[name];
+ };
+
+ /**
+ * Emits an event.
+ *
+ * @api public
+ */
+
+ EventEmitter.prototype.emit = function (name) {
+ if (!this.$events) {
+ return false;
+ }
+
+ var handler = this.$events[name];
+
+ if (!handler) {
+ return false;
+ }
+
+ var args = Array.prototype.slice.call(arguments, 1);
+
+ if ('function' == typeof handler) {
+ handler.apply(this, args);
+ } else if (io.util.isArray(handler)) {
+ var listeners = handler.slice();
+
+ for (var i = 0, l = listeners.length; i < l; i++) {
+ listeners[i].apply(this, args);
+ }
+ } else {
+ return false;
+ }
+
+ return true;
+ };
+
+})(
+ 'undefined' != typeof io ? io : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+/**
+ * Based on JSON2 (http://www.JSON.org/js.html).
+ */
+
+(function (exports, nativeJSON) {
+ "use strict";
+
+ // use native JSON if it's available
+ if (nativeJSON && nativeJSON.parse){
+ return exports.JSON = {
+ parse: nativeJSON.parse
+ , stringify: nativeJSON.stringify
+ }
+ }
+
+ var JSON = exports.JSON = {};
+
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ function date(d, key) {
+ return isFinite(d.valueOf()) ?
+ d.getUTCFullYear() + '-' +
+ f(d.getUTCMonth() + 1) + '-' +
+ f(d.getUTCDate()) + 'T' +
+ f(d.getUTCHours()) + ':' +
+ f(d.getUTCMinutes()) + ':' +
+ f(d.getUTCSeconds()) + 'Z' : null;
+ };
+
+ var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ gap,
+ indent,
+ meta = { // table of character substitutions
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '"' : '\\"',
+ '\\': '\\\\'
+ },
+ rep;
+
+
+ function quote(string) {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can safely slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe escape
+// sequences.
+
+ escapable.lastIndex = 0;
+ return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+ var c = meta[a];
+ return typeof c === 'string' ? c :
+ '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"' : '"' + string + '"';
+ }
+
+
+ function str(key, holder) {
+
+// Produce a string from holder[key].
+
+ var i, // The loop counter.
+ k, // The member key.
+ v, // The member value.
+ length,
+ mind = gap,
+ partial,
+ value = holder[key];
+
+// If the value has a toJSON method, call it to obtain a replacement value.
+
+ if (value instanceof Date) {
+ value = date(key);
+ }
+
+// If we were called with a replacer function, then call the replacer to
+// obtain a replacement value.
+
+ if (typeof rep === 'function') {
+ value = rep.call(holder, key, value);
+ }
+
+// What happens next depends on the value's type.
+
+ switch (typeof value) {
+ case 'string':
+ return quote(value);
+
+ case 'number':
+
+// JSON numbers must be finite. Encode non-finite numbers as null.
+
+ return isFinite(value) ? String(value) : 'null';
+
+ case 'boolean':
+ case 'null':
+
+// If the value is a boolean or null, convert it to a string. Note:
+// typeof null does not produce 'null'. The case is included here in
+// the remote chance that this gets fixed someday.
+
+ return String(value);
+
+// If the type is 'object', we might be dealing with an object or an array or
+// null.
+
+ case 'object':
+
+// Due to a specification blunder in ECMAScript, typeof null is 'object',
+// so watch out for that case.
+
+ if (!value) {
+ return 'null';
+ }
+
+// Make an array to hold the partial results of stringifying this object value.
+
+ gap += indent;
+ partial = [];
+
+// Is the value an array?
+
+ if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+// The value is an array. Stringify every element. Use null as a placeholder
+// for non-JSON values.
+
+ length = value.length;
+ for (i = 0; i < length; i += 1) {
+ partial[i] = str(i, value) || 'null';
+ }
+
+// Join all of the elements together, separated with commas, and wrap them in
+// brackets.
+
+ v = partial.length === 0 ? '[]' : gap ?
+ '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
+ '[' + partial.join(',') + ']';
+ gap = mind;
+ return v;
+ }
+
+// If the replacer is an array, use it to select the members to be stringified.
+
+ if (rep && typeof rep === 'object') {
+ length = rep.length;
+ for (i = 0; i < length; i += 1) {
+ if (typeof rep[i] === 'string') {
+ k = rep[i];
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ } else {
+
+// Otherwise, iterate through all of the keys in the object.
+
+ for (k in value) {
+ if (Object.prototype.hasOwnProperty.call(value, k)) {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+
+// Join all of the member texts together, separated with commas,
+// and wrap them in braces.
+
+ v = partial.length === 0 ? '{}' : gap ?
+ '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
+ '{' + partial.join(',') + '}';
+ gap = mind;
+ return v;
+ }
+ }
+
+// If the JSON object does not yet have a stringify method, give it one.
+
+ JSON.stringify = function (value, replacer, space) {
+
+// The stringify method takes a value and an optional replacer, and an optional
+// space parameter, and returns a JSON text. The replacer can be a function
+// that can replace values, or an array of strings that will select the keys.
+// A default replacer method can be provided. Use of the space parameter can
+// produce text that is more easily readable.
+
+ var i;
+ gap = '';
+ indent = '';
+
+// If the space parameter is a number, make an indent string containing that
+// many spaces.
+
+ if (typeof space === 'number') {
+ for (i = 0; i < space; i += 1) {
+ indent += ' ';
+ }
+
+// If the space parameter is a string, it will be used as the indent string.
+
+ } else if (typeof space === 'string') {
+ indent = space;
+ }
+
+// If there is a replacer, it must be a function or an array.
+// Otherwise, throw an error.
+
+ rep = replacer;
+ if (replacer && typeof replacer !== 'function' &&
+ (typeof replacer !== 'object' ||
+ typeof replacer.length !== 'number')) {
+ throw new Error('JSON.stringify');
+ }
+
+// Make a fake root object containing our value under the key of ''.
+// Return the result of stringifying the value.
+
+ return str('', {'': value});
+ };
+
+// If the JSON object does not yet have a parse method, give it one.
+
+ JSON.parse = function (text, reviver) {
+ // The parse method takes a text and an optional reviver function, and returns
+ // a JavaScript value if the text is a valid JSON text.
+
+ var j;
+
+ function walk(holder, key) {
+
+ // The walk method is used to recursively walk the resulting structure so
+ // that modifications can be made.
+
+ var k, v, value = holder[key];
+ if (value && typeof value === 'object') {
+ for (k in value) {
+ if (Object.prototype.hasOwnProperty.call(value, k)) {
+ v = walk(value, k);
+ if (v !== undefined) {
+ value[k] = v;
+ } else {
+ delete value[k];
+ }
+ }
+ }
+ }
+ return reviver.call(holder, key, value);
+ }
+
+
+ // Parsing happens in four stages. In the first stage, we replace certain
+ // Unicode characters with escape sequences. JavaScript handles many characters
+ // incorrectly, either silently deleting them, or treating them as line endings.
+
+ text = String(text);
+ cx.lastIndex = 0;
+ if (cx.test(text)) {
+ text = text.replace(cx, function (a) {
+ return '\\u' +
+ ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ });
+ }
+
+ // In the second stage, we run the text against regular expressions that look
+ // for non-JSON patterns. We are especially concerned with '()' and 'new'
+ // because they can cause invocation, and '=' because it can cause mutation.
+ // But just to be safe, we want to reject all unexpected forms.
+
+ // We split the second stage into 4 regexp operations in order to work around
+ // crippling inefficiencies in IE's and Safari's regexp engines. First we
+ // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
+ // replace all simple value tokens with ']' characters. Third, we delete all
+ // open brackets that follow a colon or comma or that begin the text. Finally,
+ // we look to see that the remaining characters are only whitespace or ']' or
+ // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+ if (/^[\],:{}\s]*$/
+ .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+ .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+ .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+ // In the third stage we use the eval function to compile the text into a
+ // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+ // in JavaScript: it can begin a block or an object literal. We wrap the text
+ // in parens to eliminate the ambiguity.
+
+ j = eval('(' + text + ')');
+
+ // In the optional fourth stage, we recursively walk the new structure, passing
+ // each name/value pair to a reviver function for possible transformation.
+
+ return typeof reviver === 'function' ?
+ walk({'': j}, '') : j;
+ }
+
+ // If the text is not JSON parseable, then a SyntaxError is thrown.
+
+ throw new SyntaxError('JSON.parse');
+ };
+
+})(
+ 'undefined' != typeof io ? io : module.exports
+ , typeof JSON !== 'undefined' ? JSON : undefined
+);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io) {
+
+ /**
+ * Parser namespace.
+ *
+ * @namespace
+ */
+
+ var parser = exports.parser = {};
+
+ /**
+ * Packet types.
+ */
+
+ var packets = parser.packets = [
+ 'disconnect'
+ , 'connect'
+ , 'heartbeat'
+ , 'message'
+ , 'json'
+ , 'event'
+ , 'ack'
+ , 'error'
+ , 'noop'
+ ];
+
+ /**
+ * Errors reasons.
+ */
+
+ var reasons = parser.reasons = [
+ 'transport not supported'
+ , 'client not handshaken'
+ , 'unauthorized'
+ ];
+
+ /**
+ * Errors advice.
+ */
+
+ var advice = parser.advice = [
+ 'reconnect'
+ ];
+
+ /**
+ * Shortcuts.
+ */
+
+ var JSON = io.JSON
+ , indexOf = io.util.indexOf;
+
+ /**
+ * Encodes a packet.
+ *
+ * @api private
+ */
+
+ parser.encodePacket = function (packet) {
+ var type = indexOf(packets, packet.type)
+ , id = packet.id || ''
+ , endpoint = packet.endpoint || ''
+ , ack = packet.ack
+ , data = null;
+
+ switch (packet.type) {
+ case 'error':
+ var reason = packet.reason ? indexOf(reasons, packet.reason) : ''
+ , adv = packet.advice ? indexOf(advice, packet.advice) : '';
+
+ if (reason !== '' || adv !== '')
+ data = reason + (adv !== '' ? ('+' + adv) : '');
+
+ break;
+
+ case 'message':
+ if (packet.data !== '')
+ data = packet.data;
+ break;
+
+ case 'event':
+ var ev = { name: packet.name };
+
+ if (packet.args && packet.args.length) {
+ ev.args = packet.args;
+ }
+
+ data = JSON.stringify(ev);
+ break;
+
+ case 'json':
+ data = JSON.stringify(packet.data);
+ break;
+
+ case 'connect':
+ if (packet.qs)
+ data = packet.qs;
+ break;
+
+ case 'ack':
+ data = packet.ackId
+ + (packet.args && packet.args.length
+ ? '+' + JSON.stringify(packet.args) : '');
+ break;
+ }
+
+ // construct packet with required fragments
+ var encoded = [
+ type
+ , id + (ack == 'data' ? '+' : '')
+ , endpoint
+ ];
+
+ // data fragment is optional
+ if (data !== null && data !== undefined)
+ encoded.push(data);
+
+ return encoded.join(':');
+ };
+
+ /**
+ * Encodes multiple messages (payload).
+ *
+ * @param {Array} messages
+ * @api private
+ */
+
+ parser.encodePayload = function (packets) {
+ var decoded = '';
+
+ if (packets.length == 1)
+ return packets[0];
+
+ for (var i = 0, l = packets.length; i < l; i++) {
+ var packet = packets[i];
+ decoded += '\ufffd' + packet.length + '\ufffd' + packets[i];
+ }
+
+ return decoded;
+ };
+
+ /**
+ * Decodes a packet
+ *
+ * @api private
+ */
+
+ var regexp = /([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/;
+
+ parser.decodePacket = function (data) {
+ var pieces = data.match(regexp);
+
+ if (!pieces) return {};
+
+ var id = pieces[2] || ''
+ , data = pieces[5] || ''
+ , packet = {
+ type: packets[pieces[1]]
+ , endpoint: pieces[4] || ''
+ };
+
+ // whether we need to acknowledge the packet
+ if (id) {
+ packet.id = id;
+ if (pieces[3])
+ packet.ack = 'data';
+ else
+ packet.ack = true;
+ }
+
+ // handle different packet types
+ switch (packet.type) {
+ case 'error':
+ var pieces = data.split('+');
+ packet.reason = reasons[pieces[0]] || '';
+ packet.advice = advice[pieces[1]] || '';
+ break;
+
+ case 'message':
+ packet.data = data || '';
+ break;
+
+ case 'event':
+ try {
+ var opts = JSON.parse(data);
+ packet.name = opts.name;
+ packet.args = opts.args;
+ } catch (e) { }
+
+ packet.args = packet.args || [];
+ break;
+
+ case 'json':
+ try {
+ packet.data = JSON.parse(data);
+ } catch (e) { }
+ break;
+
+ case 'connect':
+ packet.qs = data || '';
+ break;
+
+ case 'ack':
+ var pieces = data.match(/^([0-9]+)(\+)?(.*)/);
+ if (pieces) {
+ packet.ackId = pieces[1];
+ packet.args = [];
+
+ if (pieces[3]) {
+ try {
+ packet.args = pieces[3] ? JSON.parse(pieces[3]) : [];
+ } catch (e) { }
+ }
+ }
+ break;
+
+ case 'disconnect':
+ case 'heartbeat':
+ break;
+ };
+
+ return packet;
+ };
+
+ /**
+ * Decodes data payload. Detects multiple messages
+ *
+ * @return {Array} messages
+ * @api public
+ */
+
+ parser.decodePayload = function (data) {
+ // IE doesn't like data[i] for unicode chars, charAt works fine
+ if (data.charAt(0) == '\ufffd') {
+ var ret = [];
+
+ for (var i = 1, length = ''; i < data.length; i++) {
+ if (data.charAt(i) == '\ufffd') {
+ ret.push(parser.decodePacket(data.substr(i + 1).substr(0, length)));
+ i += Number(length) + 1;
+ length = '';
+ } else {
+ length += data.charAt(i);
+ }
+ }
+
+ return ret;
+ } else {
+ return [parser.decodePacket(data)];
+ }
+ };
+
+})(
+ 'undefined' != typeof io ? io : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+);
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.Transport = Transport;
+
+ /**
+ * This is the transport template for all supported transport methods.
+ *
+ * @constructor
+ * @api public
+ */
+
+ function Transport (socket, sessid) {
+ this.socket = socket;
+ this.sessid = sessid;
+ };
+
+ /**
+ * Apply EventEmitter mixin.
+ */
+
+ io.util.mixin(Transport, io.EventEmitter);
+
+ /**
+ * Handles the response from the server. When a new response is received
+ * it will automatically update the timeout, decode the message and
+ * forwards the response to the onMessage function for further processing.
+ *
+ * @param {String} data Response from the server.
+ * @api private
+ */
+
+ Transport.prototype.onData = function (data) {
+ this.clearCloseTimeout();
+
+ // If the connection in currently open (or in a reopening state) reset the close
+ // timeout since we have just received data. This check is necessary so
+ // that we don't reset the timeout on an explicitly disconnected connection.
+ if (this.socket.connected || this.socket.connecting || this.socket.reconnecting) {
+ this.setCloseTimeout();
+ }
+
+ if (data !== '') {
+ // todo: we should only do decodePayload for xhr transports
+ var msgs = io.parser.decodePayload(data);
+
+ if (msgs && msgs.length) {
+ for (var i = 0, l = msgs.length; i < l; i++) {
+ this.onPacket(msgs[i]);
+ }
+ }
+ }
+
+ return this;
+ };
+
+ /**
+ * Handles packets.
+ *
+ * @api private
+ */
+
+ Transport.prototype.onPacket = function (packet) {
+ this.socket.setHeartbeatTimeout();
+
+ if (packet.type == 'heartbeat') {
+ return this.onHeartbeat();
+ }
+
+ if (packet.type == 'connect' && packet.endpoint == '') {
+ this.onConnect();
+ }
+
+ if (packet.type == 'error' && packet.advice == 'reconnect') {
+ this.open = false;
+ }
+
+ this.socket.onPacket(packet);
+
+ return this;
+ };
+
+ /**
+ * Sets close timeout
+ *
+ * @api private
+ */
+
+ Transport.prototype.setCloseTimeout = function () {
+ if (!this.closeTimeout) {
+ var self = this;
+
+ this.closeTimeout = setTimeout(function () {
+ self.onDisconnect();
+ }, this.socket.closeTimeout);
+ }
+ };
+
+ /**
+ * Called when transport disconnects.
+ *
+ * @api private
+ */
+
+ Transport.prototype.onDisconnect = function () {
+ if (this.close && this.open) this.close();
+ this.clearTimeouts();
+ this.socket.onDisconnect();
+ return this;
+ };
+
+ /**
+ * Called when transport connects
+ *
+ * @api private
+ */
+
+ Transport.prototype.onConnect = function () {
+ this.socket.onConnect();
+ return this;
+ }
+
+ /**
+ * Clears close timeout
+ *
+ * @api private
+ */
+
+ Transport.prototype.clearCloseTimeout = function () {
+ if (this.closeTimeout) {
+ clearTimeout(this.closeTimeout);
+ this.closeTimeout = null;
+ }
+ };
+
+ /**
+ * Clear timeouts
+ *
+ * @api private
+ */
+
+ Transport.prototype.clearTimeouts = function () {
+ this.clearCloseTimeout();
+
+ if (this.reopenTimeout) {
+ clearTimeout(this.reopenTimeout);
+ }
+ };
+
+ /**
+ * Sends a packet
+ *
+ * @param {Object} packet object.
+ * @api private
+ */
+
+ Transport.prototype.packet = function (packet) {
+ this.send(io.parser.encodePacket(packet));
+ };
+
+ /**
+ * Send the received heartbeat message back to server. So the server
+ * knows we are still connected.
+ *
+ * @param {String} heartbeat Heartbeat response from the server.
+ * @api private
+ */
+
+ Transport.prototype.onHeartbeat = function (heartbeat) {
+ this.packet({ type: 'heartbeat' });
+ };
+
+ /**
+ * Called when the transport opens.
+ *
+ * @api private
+ */
+
+ Transport.prototype.onOpen = function () {
+ this.open = true;
+ this.clearCloseTimeout();
+ this.socket.onOpen();
+ };
+
+ /**
+ * Notifies the base when the connection with the Socket.IO server
+ * has been disconnected.
+ *
+ * @api private
+ */
+
+ Transport.prototype.onClose = function () {
+ var self = this;
+
+ /* FIXME: reopen delay causing a infinit loop
+ this.reopenTimeout = setTimeout(function () {
+ self.open();
+ }, this.socket.options['reopen delay']);*/
+
+ this.open = false;
+ this.socket.onClose();
+ this.onDisconnect();
+ };
+
+ /**
+ * Generates a connection url based on the Socket.IO URL Protocol.
+ * See for more details.
+ *
+ * @returns {String} Connection url
+ * @api private
+ */
+
+ Transport.prototype.prepareUrl = function () {
+ var options = this.socket.options;
+
+ return this.scheme() + '://'
+ + options.host + ':' + options.port + '/'
+ + options.resource + '/' + io.protocol
+ + '/' + this.name + '/' + this.sessid;
+ };
+
+ /**
+ * Checks if the transport is ready to start a connection.
+ *
+ * @param {Socket} socket The socket instance that needs a transport
+ * @param {Function} fn The callback
+ * @api private
+ */
+
+ Transport.prototype.ready = function (socket, fn) {
+ fn.call(this);
+ };
+})(
+ 'undefined' != typeof io ? io : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+);
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io, global) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.Socket = Socket;
+
+ /**
+ * Create a new `Socket.IO client` which can establish a persistent
+ * connection with a Socket.IO enabled server.
+ *
+ * @api public
+ */
+
+ function Socket (options) {
+ this.options = {
+ port: 80
+ , secure: false
+ , document: 'document' in global ? document : false
+ , resource: 'socket.io'
+ , transports: io.transports
+ , 'connect timeout': 10000
+ , 'try multiple transports': true
+ , 'reconnect': true
+ , 'reconnection delay': 500
+ , 'reconnection limit': Infinity
+ , 'reopen delay': 3000
+ , 'max reconnection attempts': 10
+ , 'sync disconnect on unload': true
+ , 'auto connect': true
+ , 'flash policy port': 10843
+ };
+
+ io.util.merge(this.options, options);
+
+ this.connected = false;
+ this.open = false;
+ this.connecting = false;
+ this.reconnecting = false;
+ this.namespaces = {};
+ this.buffer = [];
+ this.doBuffer = false;
+
+ if (this.options['sync disconnect on unload'] &&
+ (!this.isXDomain() || io.util.ua.hasCORS)) {
+ var self = this;
+
+ io.util.on(global, 'unload', function () {
+ self.disconnectSync();
+ }, false);
+ }
+
+ if (this.options['auto connect']) {
+ this.connect();
+ }
+};
+
+ /**
+ * Apply EventEmitter mixin.
+ */
+
+ io.util.mixin(Socket, io.EventEmitter);
+
+ /**
+ * Returns a namespace listener/emitter for this socket
+ *
+ * @api public
+ */
+
+ Socket.prototype.of = function (name) {
+ if (!this.namespaces[name]) {
+ this.namespaces[name] = new io.SocketNamespace(this, name);
+
+ if (name !== '') {
+ this.namespaces[name].packet({ type: 'connect' });
+ }
+ }
+
+ return this.namespaces[name];
+ };
+
+ /**
+ * Emits the given event to the Socket and all namespaces
+ *
+ * @api private
+ */
+
+ Socket.prototype.publish = function () {
+ this.emit.apply(this, arguments);
+
+ var nsp;
+
+ for (var i in this.namespaces) {
+ if (this.namespaces.hasOwnProperty(i)) {
+ nsp = this.of(i);
+ nsp.$emit.apply(nsp, arguments);
+ }
+ }
+ };
+
+ /**
+ * Performs the handshake
+ *
+ * @api private
+ */
+
+ function empty () { };
+
+ Socket.prototype.handshake = function (fn) {
+ var self = this
+ , options = this.options;
+
+ function complete (data) {
+ if (data instanceof Error) {
+ self.onError(data.message);
+ } else {
+ fn.apply(null, data.split(':'));
+ }
+ };
+
+ var url = [
+ 'http' + (options.secure ? 's' : '') + ':/'
+ , options.host + ':' + options.port
+ , options.resource
+ , io.protocol
+ , io.util.query(this.options.query, 't=' + +new Date)
+ ].join('/');
+
+ if (this.isXDomain() && !io.util.ua.hasCORS) {
+ var insertAt = document.getElementsByTagName('script')[0]
+ , script = document.createElement('script');
+
+ script.src = url + '&jsonp=' + io.j.length;
+ insertAt.parentNode.insertBefore(script, insertAt);
+
+ io.j.push(function (data) {
+ complete(data);
+ script.parentNode.removeChild(script);
+ });
+ } else {
+ var xhr = io.util.request();
+
+ xhr.open('GET', url, true);
+ xhr.withCredentials = true;
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState == 4) {
+ xhr.onreadystatechange = empty;
+
+ if (xhr.status == 200) {
+ complete(xhr.responseText);
+ } else {
+ !self.reconnecting && self.onError(xhr.responseText);
+ }
+ }
+ };
+ xhr.send(null);
+ }
+ };
+
+ /**
+ * Find an available transport based on the options supplied in the constructor.
+ *
+ * @api private
+ */
+
+ Socket.prototype.getTransport = function (override) {
+ var transports = override || this.transports, match;
+
+ for (var i = 0, transport; transport = transports[i]; i++) {
+ if (io.Transport[transport]
+ && io.Transport[transport].check(this)
+ && (!this.isXDomain() || io.Transport[transport].xdomainCheck())) {
+ return new io.Transport[transport](this, this.sessionid);
+ }
+ }
+
+ return null;
+ };
+
+ /**
+ * Connects to the server.
+ *
+ * @param {Function} [fn] Callback.
+ * @returns {io.Socket}
+ * @api public
+ */
+
+ Socket.prototype.connect = function (fn) {
+ if (this.connecting) {
+ return this;
+ }
+
+ var self = this;
+
+ this.handshake(function (sid, heartbeat, close, transports) {
+ self.sessionid = sid;
+ self.closeTimeout = close * 1000;
+ self.heartbeatTimeout = heartbeat * 1000;
+ self.transports = transports ? io.util.intersect(
+ transports.split(',')
+ , self.options.transports
+ ) : self.options.transports;
+
+ self.setHeartbeatTimeout();
+
+ function connect (transports){
+ if (self.transport) self.transport.clearTimeouts();
+
+ self.transport = self.getTransport(transports);
+ if (!self.transport) return self.publish('connect_failed');
+
+ // once the transport is ready
+ self.transport.ready(self, function () {
+ self.connecting = true;
+ self.publish('connecting', self.transport.name);
+ self.transport.open();
+
+ if (self.options['connect timeout']) {
+ self.connectTimeoutTimer = setTimeout(function () {
+ if (!self.connected) {
+ self.connecting = false;
+
+ if (self.options['try multiple transports']) {
+ if (!self.remainingTransports) {
+ self.remainingTransports = self.transports.slice(0);
+ }
+
+ var remaining = self.remainingTransports;
+
+ while (remaining.length > 0 && remaining.splice(0,1)[0] !=
+ self.transport.name) {}
+
+ if (remaining.length){
+ connect(remaining);
+ } else {
+ self.publish('connect_failed');
+ }
+ }
+ }
+ }, self.options['connect timeout']);
+ }
+ });
+ }
+
+ connect(self.transports);
+
+ self.once('connect', function (){
+ clearTimeout(self.connectTimeoutTimer);
+
+ fn && typeof fn == 'function' && fn();
+ });
+ });
+
+ return this;
+ };
+
+ /**
+ * Clears and sets a new heartbeat timeout using the value given by the
+ * server during the handshake.
+ *
+ * @api private
+ */
+
+ Socket.prototype.setHeartbeatTimeout = function () {
+ clearTimeout(this.heartbeatTimeoutTimer);
+
+ var self = this;
+ this.heartbeatTimeoutTimer = setTimeout(function () {
+ self.transport.onClose();
+ }, this.heartbeatTimeout);
+ };
+
+ /**
+ * Sends a message.
+ *
+ * @param {Object} data packet.
+ * @returns {io.Socket}
+ * @api public
+ */
+
+ Socket.prototype.packet = function (data) {
+ if (this.connected && !this.doBuffer) {
+ this.transport.packet(data);
+ } else {
+ this.buffer.push(data);
+ }
+
+ return this;
+ };
+
+ /**
+ * Sets buffer state
+ *
+ * @api private
+ */
+
+ Socket.prototype.setBuffer = function (v) {
+ this.doBuffer = v;
+
+ if (!v && this.connected && this.buffer.length) {
+ this.transport.payload(this.buffer);
+ this.buffer = [];
+ }
+ };
+
+ /**
+ * Disconnect the established connect.
+ *
+ * @returns {io.Socket}
+ * @api public
+ */
+
+ Socket.prototype.disconnect = function () {
+ if (this.connected || this.connecting) {
+ if (this.open) {
+ this.of('').packet({ type: 'disconnect' });
+ }
+
+ // handle disconnection immediately
+ this.onDisconnect('booted');
+ }
+
+ return this;
+ };
+
+ /**
+ * Disconnects the socket with a sync XHR.
+ *
+ * @api private
+ */
+
+ Socket.prototype.disconnectSync = function () {
+ // ensure disconnection
+ var xhr = io.util.request()
+ , uri = this.resource + '/' + io.protocol + '/' + this.sessionid;
+
+ xhr.open('GET', uri, true);
+
+ // handle disconnection immediately
+ this.onDisconnect('booted');
+ };
+
+ /**
+ * Check if we need to use cross domain enabled transports. Cross domain would
+ * be a different port or different domain name.
+ *
+ * @returns {Boolean}
+ * @api private
+ */
+
+ Socket.prototype.isXDomain = function () {
+
+ var port = global.location.port ||
+ ('https:' == global.location.protocol ? 443 : 80);
+
+ return this.options.host !== global.location.hostname
+ || this.options.port != port;
+ };
+
+ /**
+ * Called upon handshake.
+ *
+ * @api private
+ */
+
+ Socket.prototype.onConnect = function () {
+ if (!this.connected) {
+ this.connected = true;
+ this.connecting = false;
+ if (!this.doBuffer) {
+ // make sure to flush the buffer
+ this.setBuffer(false);
+ }
+ this.emit('connect');
+ }
+ };
+
+ /**
+ * Called when the transport opens
+ *
+ * @api private
+ */
+
+ Socket.prototype.onOpen = function () {
+ this.open = true;
+ };
+
+ /**
+ * Called when the transport closes.
+ *
+ * @api private
+ */
+
+ Socket.prototype.onClose = function () {
+ this.open = false;
+ clearTimeout(this.heartbeatTimeoutTimer);
+ };
+
+ /**
+ * Called when the transport first opens a connection
+ *
+ * @param text
+ */
+
+ Socket.prototype.onPacket = function (packet) {
+ this.of(packet.endpoint).onPacket(packet);
+ };
+
+ /**
+ * Handles an error.
+ *
+ * @api private
+ */
+
+ Socket.prototype.onError = function (err) {
+ if (err && err.advice) {
+ if (err.advice === 'reconnect' && (this.connected || this.connecting)) {
+ this.disconnect();
+ if (this.options.reconnect) {
+ this.reconnect();
+ }
+ }
+ }
+
+ this.publish('error', err && err.reason ? err.reason : err);
+ };
+
+ /**
+ * Called when the transport disconnects.
+ *
+ * @api private
+ */
+
+ Socket.prototype.onDisconnect = function (reason) {
+ var wasConnected = this.connected
+ , wasConnecting = this.connecting;
+
+ this.connected = false;
+ this.connecting = false;
+ this.open = false;
+
+ if (wasConnected || wasConnecting) {
+ this.transport.close();
+ this.transport.clearTimeouts();
+ if (wasConnected) {
+ this.publish('disconnect', reason);
+
+ if ('booted' != reason && this.options.reconnect && !this.reconnecting) {
+ this.reconnect();
+ }
+ }
+ }
+ };
+
+ /**
+ * Called upon reconnection.
+ *
+ * @api private
+ */
+
+ Socket.prototype.reconnect = function () {
+ this.reconnecting = true;
+ this.reconnectionAttempts = 0;
+ this.reconnectionDelay = this.options['reconnection delay'];
+
+ var self = this
+ , maxAttempts = this.options['max reconnection attempts']
+ , tryMultiple = this.options['try multiple transports']
+ , limit = this.options['reconnection limit'];
+
+ function reset () {
+ if (self.connected) {
+ for (var i in self.namespaces) {
+ if (self.namespaces.hasOwnProperty(i) && '' !== i) {
+ self.namespaces[i].packet({ type: 'connect' });
+ }
+ }
+ self.publish('reconnect', self.transport.name, self.reconnectionAttempts);
+ }
+
+ clearTimeout(self.reconnectionTimer);
+
+ self.removeListener('connect_failed', maybeReconnect);
+ self.removeListener('connect', maybeReconnect);
+
+ self.reconnecting = false;
+
+ delete self.reconnectionAttempts;
+ delete self.reconnectionDelay;
+ delete self.reconnectionTimer;
+ delete self.redoTransports;
+
+ self.options['try multiple transports'] = tryMultiple;
+ };
+
+ function maybeReconnect () {
+ if (!self.reconnecting) {
+ return;
+ }
+
+ if (self.connected) {
+ return reset();
+ };
+
+ if (self.connecting && self.reconnecting) {
+ return self.reconnectionTimer = setTimeout(maybeReconnect, 1000);
+ }
+
+ if (self.reconnectionAttempts++ >= maxAttempts) {
+ if (!self.redoTransports) {
+ self.on('connect_failed', maybeReconnect);
+ self.options['try multiple transports'] = true;
+ self.transport = self.getTransport();
+ self.redoTransports = true;
+ self.connect();
+ } else {
+ self.publish('reconnect_failed');
+ reset();
+ }
+ } else {
+ if (self.reconnectionDelay < limit) {
+ self.reconnectionDelay *= 2; // exponential back off
+ }
+
+ self.connect();
+ self.publish('reconnecting', self.reconnectionDelay, self.reconnectionAttempts);
+ self.reconnectionTimer = setTimeout(maybeReconnect, self.reconnectionDelay);
+ }
+ };
+
+ this.options['try multiple transports'] = false;
+ this.reconnectionTimer = setTimeout(maybeReconnect, this.reconnectionDelay);
+
+ this.on('connect', maybeReconnect);
+ };
+
+})(
+ 'undefined' != typeof io ? io : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+ , this
+);
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.SocketNamespace = SocketNamespace;
+
+ /**
+ * Socket namespace constructor.
+ *
+ * @constructor
+ * @api public
+ */
+
+ function SocketNamespace (socket, name) {
+ this.socket = socket;
+ this.name = name || '';
+ this.flags = {};
+ this.json = new Flag(this, 'json');
+ this.ackPackets = 0;
+ this.acks = {};
+ };
+
+ /**
+ * Apply EventEmitter mixin.
+ */
+
+ io.util.mixin(SocketNamespace, io.EventEmitter);
+
+ /**
+ * Copies emit since we override it
+ *
+ * @api private
+ */
+
+ SocketNamespace.prototype.$emit = io.EventEmitter.prototype.emit;
+
+ /**
+ * Creates a new namespace, by proxying the request to the socket. This
+ * allows us to use the synax as we do on the server.
+ *
+ * @api public
+ */
+
+ SocketNamespace.prototype.of = function () {
+ return this.socket.of.apply(this.socket, arguments);
+ };
+
+ /**
+ * Sends a packet.
+ *
+ * @api private
+ */
+
+ SocketNamespace.prototype.packet = function (packet) {
+ packet.endpoint = this.name;
+ this.socket.packet(packet);
+ this.flags = {};
+ return this;
+ };
+
+ /**
+ * Sends a message
+ *
+ * @api public
+ */
+
+ SocketNamespace.prototype.send = function (data, fn) {
+ var packet = {
+ type: this.flags.json ? 'json' : 'message'
+ , data: data
+ };
+
+ if ('function' == typeof fn) {
+ packet.id = ++this.ackPackets;
+ packet.ack = true;
+ this.acks[packet.id] = fn;
+ }
+
+ return this.packet(packet);
+ };
+
+ /**
+ * Emits an event
+ *
+ * @api public
+ */
+
+ SocketNamespace.prototype.emit = function (name) {
+ var args = Array.prototype.slice.call(arguments, 1)
+ , lastArg = args[args.length - 1]
+ , packet = {
+ type: 'event'
+ , name: name
+ };
+
+ if ('function' == typeof lastArg) {
+ packet.id = ++this.ackPackets;
+ packet.ack = 'data';
+ this.acks[packet.id] = lastArg;
+ args = args.slice(0, args.length - 1);
+ }
+
+ packet.args = args;
+
+ return this.packet(packet);
+ };
+
+ /**
+ * Disconnects the namespace
+ *
+ * @api private
+ */
+
+ SocketNamespace.prototype.disconnect = function () {
+ if (this.name === '') {
+ this.socket.disconnect();
+ } else {
+ this.packet({ type: 'disconnect' });
+ this.$emit('disconnect');
+ }
+
+ return this;
+ };
+
+ /**
+ * Handles a packet
+ *
+ * @api private
+ */
+
+ SocketNamespace.prototype.onPacket = function (packet) {
+ var self = this;
+
+ function ack () {
+ self.packet({
+ type: 'ack'
+ , args: io.util.toArray(arguments)
+ , ackId: packet.id
+ });
+ };
+
+ switch (packet.type) {
+ case 'connect':
+ this.$emit('connect');
+ break;
+
+ case 'disconnect':
+ if (this.name === '') {
+ this.socket.onDisconnect(packet.reason || 'booted');
+ } else {
+ this.$emit('disconnect', packet.reason);
+ }
+ break;
+
+ case 'message':
+ case 'json':
+ var params = ['message', packet.data];
+
+ if (packet.ack == 'data') {
+ params.push(ack);
+ } else if (packet.ack) {
+ this.packet({ type: 'ack', ackId: packet.id });
+ }
+
+ this.$emit.apply(this, params);
+ break;
+
+ case 'event':
+ var params = [packet.name].concat(packet.args);
+
+ if (packet.ack == 'data')
+ params.push(ack);
+
+ this.$emit.apply(this, params);
+ break;
+
+ case 'ack':
+ if (this.acks[packet.ackId]) {
+ this.acks[packet.ackId].apply(this, packet.args);
+ delete this.acks[packet.ackId];
+ }
+ break;
+
+ case 'error':
+ if (packet.advice){
+ this.socket.onError(packet);
+ } else {
+ if (packet.reason == 'unauthorized') {
+ this.$emit('connect_failed', packet.reason);
+ } else {
+ this.$emit('error', packet.reason);
+ }
+ }
+ break;
+ }
+ };
+
+ /**
+ * Flag interface.
+ *
+ * @api private
+ */
+
+ function Flag (nsp, name) {
+ this.namespace = nsp;
+ this.name = name;
+ };
+
+ /**
+ * Send a message
+ *
+ * @api public
+ */
+
+ Flag.prototype.send = function () {
+ this.namespace.flags[this.name] = true;
+ this.namespace.send.apply(this.namespace, arguments);
+ };
+
+ /**
+ * Emit an event
+ *
+ * @api public
+ */
+
+ Flag.prototype.emit = function () {
+ this.namespace.flags[this.name] = true;
+ this.namespace.emit.apply(this.namespace, arguments);
+ };
+
+})(
+ 'undefined' != typeof io ? io : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io, global) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.websocket = WS;
+
+ /**
+ * The WebSocket transport uses the HTML5 WebSocket API to establish an
+ * persistent connection with the Socket.IO server. This transport will also
+ * be inherited by the FlashSocket fallback as it provides a API compatible
+ * polyfill for the WebSockets.
+ *
+ * @constructor
+ * @extends {io.Transport}
+ * @api public
+ */
+
+ function WS (socket) {
+ io.Transport.apply(this, arguments);
+ };
+
+ /**
+ * Inherits from Transport.
+ */
+
+ io.util.inherit(WS, io.Transport);
+
+ /**
+ * Transport name
+ *
+ * @api public
+ */
+
+ WS.prototype.name = 'websocket';
+
+ /**
+ * Initializes a new `WebSocket` connection with the Socket.IO server. We attach
+ * all the appropriate listeners to handle the responses from the server.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ WS.prototype.open = function () {
+ var query = io.util.query(this.socket.options.query)
+ , self = this
+ , Socket
+
+
+ if (!Socket) {
+ Socket = global.MozWebSocket || global.WebSocket;
+ }
+
+ this.websocket = new Socket(this.prepareUrl() + query);
+
+ this.websocket.onopen = function () {
+ self.onOpen();
+ self.socket.setBuffer(false);
+ };
+ this.websocket.onmessage = function (ev) {
+ self.onData(ev.data);
+ };
+ this.websocket.onclose = function () {
+ self.onClose();
+ self.socket.setBuffer(true);
+ };
+ this.websocket.onerror = function (e) {
+ self.onError(e);
+ };
+
+ return this;
+ };
+
+ /**
+ * Send a message to the Socket.IO server. The message will automatically be
+ * encoded in the correct message format.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ WS.prototype.send = function (data) {
+ this.websocket.send(data);
+ return this;
+ };
+
+ /**
+ * Payload
+ *
+ * @api private
+ */
+
+ WS.prototype.payload = function (arr) {
+ for (var i = 0, l = arr.length; i < l; i++) {
+ this.packet(arr[i]);
+ }
+ return this;
+ };
+
+ /**
+ * Disconnect the established `WebSocket` connection.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ WS.prototype.close = function () {
+ this.websocket.close();
+ return this;
+ };
+
+ /**
+ * Handle the errors that `WebSocket` might be giving when we
+ * are attempting to connect or send messages.
+ *
+ * @param {Error} e The error.
+ * @api private
+ */
+
+ WS.prototype.onError = function (e) {
+ this.socket.onError(e);
+ };
+
+ /**
+ * Returns the appropriate scheme for the URI generation.
+ *
+ * @api private
+ */
+ WS.prototype.scheme = function () {
+ return this.socket.options.secure ? 'wss' : 'ws';
+ };
+
+ /**
+ * Checks if the browser has support for native `WebSockets` and that
+ * it's not the polyfill created for the FlashSocket transport.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+ WS.check = function () {
+ return ('WebSocket' in global && !('__addTask' in WebSocket))
+ || 'MozWebSocket' in global;
+ };
+
+ /**
+ * Check if the `WebSocket` transport support cross domain communications.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+ WS.xdomainCheck = function () {
+ return true;
+ };
+
+ /**
+ * Add the transport to your public io.transports array.
+ *
+ * @api private
+ */
+
+ io.transports.push('websocket');
+
+})(
+ 'undefined' != typeof io ? io.Transport : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+ , this
+);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.flashsocket = Flashsocket;
+
+ /**
+ * The FlashSocket transport. This is a API wrapper for the HTML5 WebSocket
+ * specification. It uses a .swf file to communicate with the server. If you want
+ * to serve the .swf file from a other server than where the Socket.IO script is
+ * coming from you need to use the insecure version of the .swf. More information
+ * about this can be found on the github page.
+ *
+ * @constructor
+ * @extends {io.Transport.websocket}
+ * @api public
+ */
+
+ function Flashsocket () {
+ io.Transport.websocket.apply(this, arguments);
+ };
+
+ /**
+ * Inherits from Transport.
+ */
+
+ io.util.inherit(Flashsocket, io.Transport.websocket);
+
+ /**
+ * Transport name
+ *
+ * @api public
+ */
+
+ Flashsocket.prototype.name = 'flashsocket';
+
+ /**
+ * Disconnect the established `FlashSocket` connection. This is done by adding a
+ * new task to the FlashSocket. The rest will be handled off by the `WebSocket`
+ * transport.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ Flashsocket.prototype.open = function () {
+ var self = this
+ , args = arguments;
+
+ WebSocket.__addTask(function () {
+ io.Transport.websocket.prototype.open.apply(self, args);
+ });
+ return this;
+ };
+
+ /**
+ * Sends a message to the Socket.IO server. This is done by adding a new
+ * task to the FlashSocket. The rest will be handled off by the `WebSocket`
+ * transport.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ Flashsocket.prototype.send = function () {
+ var self = this, args = arguments;
+ WebSocket.__addTask(function () {
+ io.Transport.websocket.prototype.send.apply(self, args);
+ });
+ return this;
+ };
+
+ /**
+ * Disconnects the established `FlashSocket` connection.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ Flashsocket.prototype.close = function () {
+ WebSocket.__tasks.length = 0;
+ io.Transport.websocket.prototype.close.call(this);
+ return this;
+ };
+
+ /**
+ * The WebSocket fall back needs to append the flash container to the body
+ * element, so we need to make sure we have access to it. Or defer the call
+ * until we are sure there is a body element.
+ *
+ * @param {Socket} socket The socket instance that needs a transport
+ * @param {Function} fn The callback
+ * @api private
+ */
+
+ Flashsocket.prototype.ready = function (socket, fn) {
+ function init () {
+ var options = socket.options
+ , port = options['flash policy port']
+ , path = [
+ 'http' + (options.secure ? 's' : '') + ':/'
+ , options.host + ':' + options.port
+ , options.resource
+ , 'static/flashsocket'
+ , 'WebSocketMain' + (socket.isXDomain() ? 'Insecure' : '') + '.swf'
+ ];
+
+ // Only start downloading the swf file when the checked that this browser
+ // actually supports it
+ if (!Flashsocket.loaded) {
+ if (typeof WEB_SOCKET_SWF_LOCATION === 'undefined') {
+ // Set the correct file based on the XDomain settings
+ WEB_SOCKET_SWF_LOCATION = path.join('/');
+ }
+
+ if (port !== 843) {
+ WebSocket.loadFlashPolicyFile('xmlsocket://' + options.host + ':' + port);
+ }
+
+ WebSocket.__initialize();
+ Flashsocket.loaded = true;
+ }
+
+ fn.call(self);
+ }
+
+ var self = this;
+ if (document.body) return init();
+
+ io.util.load(init);
+ };
+
+ /**
+ * Check if the FlashSocket transport is supported as it requires that the Adobe
+ * Flash Player plug-in version `10.0.0` or greater is installed. And also check if
+ * the polyfill is correctly loaded.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+ Flashsocket.check = function () {
+ if (
+ typeof WebSocket == 'undefined'
+ || !('__initialize' in WebSocket) || !swfobject
+ ) return false;
+
+ return swfobject.getFlashPlayerVersion().major >= 10;
+ };
+
+ /**
+ * Check if the FlashSocket transport can be used as cross domain / cross origin
+ * transport. Because we can't see which type (secure or insecure) of .swf is used
+ * we will just return true.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+ Flashsocket.xdomainCheck = function () {
+ return true;
+ };
+
+ /**
+ * Disable AUTO_INITIALIZATION
+ */
+
+ if (typeof window != 'undefined') {
+ WEB_SOCKET_DISABLE_AUTO_INITIALIZATION = true;
+ }
+
+ /**
+ * Add the transport to your public io.transports array.
+ *
+ * @api private
+ */
+
+ io.transports.push('flashsocket');
+})(
+ 'undefined' != typeof io ? io.Transport : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+);
+/* SWFObject v2.2
+ is released under the MIT License
+*/
+if ('undefined' != typeof window) {
+var swfobject=function(){var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,Q,E,B,J=false,a=false,n,G,m=true,M=function(){var aa=typeof j.getElementById!=D&&typeof j.getElementsByTagName!=D&&typeof j.createElement!=D,ah=t.userAgent.toLowerCase(),Y=t.platform.toLowerCase(),ae=Y?/win/.test(Y):/win/.test(ah),ac=Y?/mac/.test(Y):/mac/.test(ah),af=/webkit/.test(ah)?parseFloat(ah.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,X=!+"\v1",ag=[0,0,0],ab=null;if(typeof t.plugins!=D&&typeof t.plugins[S]==r){ab=t.plugins[S].description;if(ab&&!(typeof t.mimeTypes!=D&&t.mimeTypes[q]&&!t.mimeTypes[q].enabledPlugin)){T=true;X=false;ab=ab.replace(/^.*\s+(\S+\s+\S+$)/,"$1");ag[0]=parseInt(ab.replace(/^(.*)\..*$/,"$1"),10);ag[1]=parseInt(ab.replace(/^.*\.(.*)\s.*$/,"$1"),10);ag[2]=/[a-zA-Z]/.test(ab)?parseInt(ab.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0}}else{if(typeof O[(['Active'].concat('Object').join('X'))]!=D){try{var ad=new window[(['Active'].concat('Object').join('X'))](W);if(ad){ab=ad.GetVariable("$version");if(ab){X=true;ab=ab.split(" ")[1].split(",");ag=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}}catch(Z){}}}return{w3:aa,pv:ag,wk:af,ie:X,win:ae,mac:ac}}(),k=function(){if(!M.w3){return}if((typeof j.readyState!=D&&j.readyState=="complete")||(typeof j.readyState==D&&(j.getElementsByTagName("body")[0]||j.body))){f()}if(!J){if(typeof j.addEventListener!=D){j.addEventListener("DOMContentLoaded",f,false)}if(M.ie&&M.win){j.attachEvent(x,function(){if(j.readyState=="complete"){j.detachEvent(x,arguments.callee);f()}});if(O==top){(function(){if(J){return}try{j.documentElement.doScroll("left")}catch(X){setTimeout(arguments.callee,0);return}f()})()}}if(M.wk){(function(){if(J){return}if(!/loaded|complete/.test(j.readyState)){setTimeout(arguments.callee,0);return}f()})()}s(f)}}();function f(){if(J){return}try{var Z=j.getElementsByTagName("body")[0].appendChild(C("span"));Z.parentNode.removeChild(Z)}catch(aa){return}J=true;var X=U.length;for(var Y=0;Y0){for(var af=0;af0){var ae=c(Y);if(ae){if(F(o[af].swfVersion)&&!(M.wk&&M.wk<312)){w(Y,true);if(ab){aa.success=true;aa.ref=z(Y);ab(aa)}}else{if(o[af].expressInstall&&A()){var ai={};ai.data=o[af].expressInstall;ai.width=ae.getAttribute("width")||"0";ai.height=ae.getAttribute("height")||"0";if(ae.getAttribute("class")){ai.styleclass=ae.getAttribute("class")}if(ae.getAttribute("align")){ai.align=ae.getAttribute("align")}var ah={};var X=ae.getElementsByTagName("param");var ac=X.length;for(var ad=0;ad'}}aa.outerHTML='";N[N.length]=ai.id;X=c(ai.id)}else{var Z=C(r);Z.setAttribute("type",q);for(var ac in ai){if(ai[ac]!=Object.prototype[ac]){if(ac.toLowerCase()=="styleclass"){Z.setAttribute("class",ai[ac])}else{if(ac.toLowerCase()!="classid"){Z.setAttribute(ac,ai[ac])}}}}for(var ab in ag){if(ag[ab]!=Object.prototype[ab]&&ab.toLowerCase()!="movie"){e(Z,ab,ag[ab])}}aa.parentNode.replaceChild(Z,aa);X=Z}}return X}function e(Z,X,Y){var aa=C("param");aa.setAttribute("name",X);aa.setAttribute("value",Y);Z.appendChild(aa)}function y(Y){var X=c(Y);if(X&&X.nodeName=="OBJECT"){if(M.ie&&M.win){X.style.display="none";(function(){if(X.readyState==4){b(Y)}else{setTimeout(arguments.callee,10)}})()}else{X.parentNode.removeChild(X)}}}function b(Z){var Y=c(Z);if(Y){for(var X in Y){if(typeof Y[X]=="function"){Y[X]=null}}Y.parentNode.removeChild(Y)}}function c(Z){var X=null;try{X=j.getElementById(Z)}catch(Y){}return X}function C(X){return j.createElement(X)}function i(Z,X,Y){Z.attachEvent(X,Y);I[I.length]=[Z,X,Y]}function F(Z){var Y=M.pv,X=Z.split(".");X[0]=parseInt(X[0],10);X[1]=parseInt(X[1],10)||0;X[2]=parseInt(X[2],10)||0;return(Y[0]>X[0]||(Y[0]==X[0]&&Y[1]>X[1])||(Y[0]==X[0]&&Y[1]==X[1]&&Y[2]>=X[2]))?true:false}function v(ac,Y,ad,ab){if(M.ie&&M.mac){return}var aa=j.getElementsByTagName("head")[0];if(!aa){return}var X=(ad&&typeof ad=="string")?ad:"screen";if(ab){n=null;G=null}if(!n||G!=X){var Z=C("style");Z.setAttribute("type","text/css");Z.setAttribute("media",X);n=aa.appendChild(Z);if(M.ie&&M.win&&typeof j.styleSheets!=D&&j.styleSheets.length>0){n=j.styleSheets[j.styleSheets.length-1]}G=X}if(M.ie&&M.win){if(n&&typeof n.addRule==r){n.addRule(ac,Y)}}else{if(n&&typeof j.createTextNode!=D){n.appendChild(j.createTextNode(ac+" {"+Y+"}"))}}}function w(Z,X){if(!m){return}var Y=X?"visible":"hidden";if(J&&c(Z)){c(Z).style.visibility=Y}else{v("#"+Z,"visibility:"+Y)}}function L(Y){var Z=/[\\\"<>\.;]/;var X=Z.exec(Y)!=null;return X&&typeof encodeURIComponent!=D?encodeURIComponent(Y):Y}var d=function(){if(M.ie&&M.win){window.attachEvent("onunload",function(){var ac=I.length;for(var ab=0;ab
+// License: New BSD License
+// Reference: http://dev.w3.org/html5/websockets/
+// Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
+
+(function() {
+
+ if ('undefined' == typeof window || window.WebSocket) return;
+
+ var console = window.console;
+ if (!console || !console.log || !console.error) {
+ console = {log: function(){ }, error: function(){ }};
+ }
+
+ if (!swfobject.hasFlashPlayerVersion("10.0.0")) {
+ console.error("Flash Player >= 10.0.0 is required.");
+ return;
+ }
+ if (location.protocol == "file:") {
+ console.error(
+ "WARNING: web-socket-js doesn't work in file:///... URL " +
+ "unless you set Flash Security Settings properly. " +
+ "Open the page via Web server i.e. http://...");
+ }
+
+ /**
+ * This class represents a faux web socket.
+ * @param {string} url
+ * @param {array or string} protocols
+ * @param {string} proxyHost
+ * @param {int} proxyPort
+ * @param {string} headers
+ */
+ WebSocket = function(url, protocols, proxyHost, proxyPort, headers) {
+ var self = this;
+ self.__id = WebSocket.__nextId++;
+ WebSocket.__instances[self.__id] = self;
+ self.readyState = WebSocket.CONNECTING;
+ self.bufferedAmount = 0;
+ self.__events = {};
+ if (!protocols) {
+ protocols = [];
+ } else if (typeof protocols == "string") {
+ protocols = [protocols];
+ }
+ // Uses setTimeout() to make sure __createFlash() runs after the caller sets ws.onopen etc.
+ // Otherwise, when onopen fires immediately, onopen is called before it is set.
+ setTimeout(function() {
+ WebSocket.__addTask(function() {
+ WebSocket.__flash.create(
+ self.__id, url, protocols, proxyHost || null, proxyPort || 0, headers || null);
+ });
+ }, 0);
+ };
+
+ /**
+ * Send data to the web socket.
+ * @param {string} data The data to send to the socket.
+ * @return {boolean} True for success, false for failure.
+ */
+ WebSocket.prototype.send = function(data) {
+ if (this.readyState == WebSocket.CONNECTING) {
+ throw "INVALID_STATE_ERR: Web Socket connection has not been established";
+ }
+ // We use encodeURIComponent() here, because FABridge doesn't work if
+ // the argument includes some characters. We don't use escape() here
+ // because of this:
+ // https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Functions#escape_and_unescape_Functions
+ // But it looks decodeURIComponent(encodeURIComponent(s)) doesn't
+ // preserve all Unicode characters either e.g. "\uffff" in Firefox.
+ // Note by wtritch: Hopefully this will not be necessary using ExternalInterface. Will require
+ // additional testing.
+ var result = WebSocket.__flash.send(this.__id, encodeURIComponent(data));
+ if (result < 0) { // success
+ return true;
+ } else {
+ this.bufferedAmount += result;
+ return false;
+ }
+ };
+
+ /**
+ * Close this web socket gracefully.
+ */
+ WebSocket.prototype.close = function() {
+ if (this.readyState == WebSocket.CLOSED || this.readyState == WebSocket.CLOSING) {
+ return;
+ }
+ this.readyState = WebSocket.CLOSING;
+ WebSocket.__flash.close(this.__id);
+ };
+
+ /**
+ * Implementation of {@link DOM 2 EventTarget Interface}
+ *
+ * @param {string} type
+ * @param {function} listener
+ * @param {boolean} useCapture
+ * @return void
+ */
+ WebSocket.prototype.addEventListener = function(type, listener, useCapture) {
+ if (!(type in this.__events)) {
+ this.__events[type] = [];
+ }
+ this.__events[type].push(listener);
+ };
+
+ /**
+ * Implementation of {@link DOM 2 EventTarget Interface}
+ *
+ * @param {string} type
+ * @param {function} listener
+ * @param {boolean} useCapture
+ * @return void
+ */
+ WebSocket.prototype.removeEventListener = function(type, listener, useCapture) {
+ if (!(type in this.__events)) return;
+ var events = this.__events[type];
+ for (var i = events.length - 1; i >= 0; --i) {
+ if (events[i] === listener) {
+ events.splice(i, 1);
+ break;
+ }
+ }
+ };
+
+ /**
+ * Implementation of {@link DOM 2 EventTarget Interface}
+ *
+ * @param {Event} event
+ * @return void
+ */
+ WebSocket.prototype.dispatchEvent = function(event) {
+ var events = this.__events[event.type] || [];
+ for (var i = 0; i < events.length; ++i) {
+ events[i](event);
+ }
+ var handler = this["on" + event.type];
+ if (handler) handler(event);
+ };
+
+ /**
+ * Handles an event from Flash.
+ * @param {Object} flashEvent
+ */
+ WebSocket.prototype.__handleEvent = function(flashEvent) {
+ if ("readyState" in flashEvent) {
+ this.readyState = flashEvent.readyState;
+ }
+ if ("protocol" in flashEvent) {
+ this.protocol = flashEvent.protocol;
+ }
+
+ var jsEvent;
+ if (flashEvent.type == "open" || flashEvent.type == "error") {
+ jsEvent = this.__createSimpleEvent(flashEvent.type);
+ } else if (flashEvent.type == "close") {
+ // TODO implement jsEvent.wasClean
+ jsEvent = this.__createSimpleEvent("close");
+ } else if (flashEvent.type == "message") {
+ var data = decodeURIComponent(flashEvent.message);
+ jsEvent = this.__createMessageEvent("message", data);
+ } else {
+ throw "unknown event type: " + flashEvent.type;
+ }
+
+ this.dispatchEvent(jsEvent);
+ };
+
+ WebSocket.prototype.__createSimpleEvent = function(type) {
+ if (document.createEvent && window.Event) {
+ var event = document.createEvent("Event");
+ event.initEvent(type, false, false);
+ return event;
+ } else {
+ return {type: type, bubbles: false, cancelable: false};
+ }
+ };
+
+ WebSocket.prototype.__createMessageEvent = function(type, data) {
+ if (document.createEvent && window.MessageEvent && !window.opera) {
+ var event = document.createEvent("MessageEvent");
+ event.initMessageEvent("message", false, false, data, null, null, window, null);
+ return event;
+ } else {
+ // IE and Opera, the latter one truncates the data parameter after any 0x00 bytes.
+ return {type: type, data: data, bubbles: false, cancelable: false};
+ }
+ };
+
+ /**
+ * Define the WebSocket readyState enumeration.
+ */
+ WebSocket.CONNECTING = 0;
+ WebSocket.OPEN = 1;
+ WebSocket.CLOSING = 2;
+ WebSocket.CLOSED = 3;
+
+ WebSocket.__flash = null;
+ WebSocket.__instances = {};
+ WebSocket.__tasks = [];
+ WebSocket.__nextId = 0;
+
+ /**
+ * Load a new flash security policy file.
+ * @param {string} url
+ */
+ WebSocket.loadFlashPolicyFile = function(url){
+ WebSocket.__addTask(function() {
+ WebSocket.__flash.loadManualPolicyFile(url);
+ });
+ };
+
+ /**
+ * Loads WebSocketMain.swf and creates WebSocketMain object in Flash.
+ */
+ WebSocket.__initialize = function() {
+ if (WebSocket.__flash) return;
+
+ if (WebSocket.__swfLocation) {
+ // For backword compatibility.
+ window.WEB_SOCKET_SWF_LOCATION = WebSocket.__swfLocation;
+ }
+ if (!window.WEB_SOCKET_SWF_LOCATION) {
+ console.error("[WebSocket] set WEB_SOCKET_SWF_LOCATION to location of WebSocketMain.swf");
+ return;
+ }
+ var container = document.createElement("div");
+ container.id = "webSocketContainer";
+ // Hides Flash box. We cannot use display: none or visibility: hidden because it prevents
+ // Flash from loading at least in IE. So we move it out of the screen at (-100, -100).
+ // But this even doesn't work with Flash Lite (e.g. in Droid Incredible). So with Flash
+ // Lite, we put it at (0, 0). This shows 1x1 box visible at left-top corner but this is
+ // the best we can do as far as we know now.
+ container.style.position = "absolute";
+ if (WebSocket.__isFlashLite()) {
+ container.style.left = "0px";
+ container.style.top = "0px";
+ } else {
+ container.style.left = "-100px";
+ container.style.top = "-100px";
+ }
+ var holder = document.createElement("div");
+ holder.id = "webSocketFlash";
+ container.appendChild(holder);
+ document.body.appendChild(container);
+ // See this article for hasPriority:
+ // http://help.adobe.com/en_US/as3/mobile/WS4bebcd66a74275c36cfb8137124318eebc6-7ffd.html
+ swfobject.embedSWF(
+ WEB_SOCKET_SWF_LOCATION,
+ "webSocketFlash",
+ "1" /* width */,
+ "1" /* height */,
+ "10.0.0" /* SWF version */,
+ null,
+ null,
+ {hasPriority: true, swliveconnect : true, allowScriptAccess: "always"},
+ null,
+ function(e) {
+ if (!e.success) {
+ console.error("[WebSocket] swfobject.embedSWF failed");
+ }
+ });
+ };
+
+ /**
+ * Called by Flash to notify JS that it's fully loaded and ready
+ * for communication.
+ */
+ WebSocket.__onFlashInitialized = function() {
+ // We need to set a timeout here to avoid round-trip calls
+ // to flash during the initialization process.
+ setTimeout(function() {
+ WebSocket.__flash = document.getElementById("webSocketFlash");
+ WebSocket.__flash.setCallerUrl(location.href);
+ WebSocket.__flash.setDebug(!!window.WEB_SOCKET_DEBUG);
+ for (var i = 0; i < WebSocket.__tasks.length; ++i) {
+ WebSocket.__tasks[i]();
+ }
+ WebSocket.__tasks = [];
+ }, 0);
+ };
+
+ /**
+ * Called by Flash to notify WebSockets events are fired.
+ */
+ WebSocket.__onFlashEvent = function() {
+ setTimeout(function() {
+ try {
+ // Gets events using receiveEvents() instead of getting it from event object
+ // of Flash event. This is to make sure to keep message order.
+ // It seems sometimes Flash events don't arrive in the same order as they are sent.
+ var events = WebSocket.__flash.receiveEvents();
+ for (var i = 0; i < events.length; ++i) {
+ WebSocket.__instances[events[i].webSocketId].__handleEvent(events[i]);
+ }
+ } catch (e) {
+ console.error(e);
+ }
+ }, 0);
+ return true;
+ };
+
+ // Called by Flash.
+ WebSocket.__log = function(message) {
+ console.log(decodeURIComponent(message));
+ };
+
+ // Called by Flash.
+ WebSocket.__error = function(message) {
+ console.error(decodeURIComponent(message));
+ };
+
+ WebSocket.__addTask = function(task) {
+ if (WebSocket.__flash) {
+ task();
+ } else {
+ WebSocket.__tasks.push(task);
+ }
+ };
+
+ /**
+ * Test if the browser is running flash lite.
+ * @return {boolean} True if flash lite is running, false otherwise.
+ */
+ WebSocket.__isFlashLite = function() {
+ if (!window.navigator || !window.navigator.mimeTypes) {
+ return false;
+ }
+ var mimeType = window.navigator.mimeTypes["application/x-shockwave-flash"];
+ if (!mimeType || !mimeType.enabledPlugin || !mimeType.enabledPlugin.filename) {
+ return false;
+ }
+ return mimeType.enabledPlugin.filename.match(/flashlite/i) ? true : false;
+ };
+
+ if (!window.WEB_SOCKET_DISABLE_AUTO_INITIALIZATION) {
+ if (window.addEventListener) {
+ window.addEventListener("load", function(){
+ WebSocket.__initialize();
+ }, false);
+ } else {
+ window.attachEvent("onload", function(){
+ WebSocket.__initialize();
+ });
+ }
+ }
+
+})();
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io, global) {
+
+ /**
+ * Expose constructor.
+ *
+ * @api public
+ */
+
+ exports.XHR = XHR;
+
+ /**
+ * XHR constructor
+ *
+ * @costructor
+ * @api public
+ */
+
+ function XHR (socket) {
+ if (!socket) return;
+
+ io.Transport.apply(this, arguments);
+ this.sendBuffer = [];
+ };
+
+ /**
+ * Inherits from Transport.
+ */
+
+ io.util.inherit(XHR, io.Transport);
+
+ /**
+ * Establish a connection
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ XHR.prototype.open = function () {
+ this.socket.setBuffer(false);
+ this.onOpen();
+ this.get();
+
+ // we need to make sure the request succeeds since we have no indication
+ // whether the request opened or not until it succeeded.
+ this.setCloseTimeout();
+
+ return this;
+ };
+
+ /**
+ * Check if we need to send data to the Socket.IO server, if we have data in our
+ * buffer we encode it and forward it to the `post` method.
+ *
+ * @api private
+ */
+
+ XHR.prototype.payload = function (payload) {
+ var msgs = [];
+
+ for (var i = 0, l = payload.length; i < l; i++) {
+ msgs.push(io.parser.encodePacket(payload[i]));
+ }
+
+ this.send(io.parser.encodePayload(msgs));
+ };
+
+ /**
+ * Send data to the Socket.IO server.
+ *
+ * @param data The message
+ * @returns {Transport}
+ * @api public
+ */
+
+ XHR.prototype.send = function (data) {
+ this.post(data);
+ return this;
+ };
+
+ /**
+ * Posts a encoded message to the Socket.IO server.
+ *
+ * @param {String} data A encoded message.
+ * @api private
+ */
+
+ function empty () { };
+
+ XHR.prototype.post = function (data) {
+ var self = this;
+ this.socket.setBuffer(true);
+
+ function stateChange () {
+ if (this.readyState == 4) {
+ this.onreadystatechange = empty;
+ self.posting = false;
+
+ if (this.status == 200){
+ self.socket.setBuffer(false);
+ } else {
+ self.onClose();
+ }
+ }
+ }
+
+ function onload () {
+ this.onload = empty;
+ self.socket.setBuffer(false);
+ };
+
+ this.sendXHR = this.request('POST');
+
+ if (global.XDomainRequest && this.sendXHR instanceof XDomainRequest) {
+ this.sendXHR.onload = this.sendXHR.onerror = onload;
+ } else {
+ this.sendXHR.onreadystatechange = stateChange;
+ }
+
+ this.sendXHR.send(data);
+ };
+
+ /**
+ * Disconnects the established `XHR` connection.
+ *
+ * @returns {Transport}
+ * @api public
+ */
+
+ XHR.prototype.close = function () {
+ this.onClose();
+ return this;
+ };
+
+ /**
+ * Generates a configured XHR request
+ *
+ * @param {String} url The url that needs to be requested.
+ * @param {String} method The method the request should use.
+ * @returns {XMLHttpRequest}
+ * @api private
+ */
+
+ XHR.prototype.request = function (method) {
+ var req = io.util.request(this.socket.isXDomain())
+ , query = io.util.query(this.socket.options.query, 't=' + +new Date);
+
+ req.open(method || 'GET', this.prepareUrl() + query, true);
+
+ if (method == 'POST') {
+ try {
+ if (req.setRequestHeader) {
+ req.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');
+ } else {
+ // XDomainRequest
+ req.contentType = 'text/plain';
+ }
+ } catch (e) {}
+ }
+
+ return req;
+ };
+
+ /**
+ * Returns the scheme to use for the transport URLs.
+ *
+ * @api private
+ */
+
+ XHR.prototype.scheme = function () {
+ return this.socket.options.secure ? 'https' : 'http';
+ };
+
+ /**
+ * Check if the XHR transports are supported
+ *
+ * @param {Boolean} xdomain Check if we support cross domain requests.
+ * @returns {Boolean}
+ * @api public
+ */
+
+ XHR.check = function (socket, xdomain) {
+ try {
+ var request = io.util.request(xdomain),
+ usesXDomReq = (global.XDomainRequest && request instanceof XDomainRequest),
+ socketProtocol = (socket && socket.options && socket.options.secure ? 'https:' : 'http:'),
+ isXProtocol = (socketProtocol != global.location.protocol);
+ if (request && !(usesXDomReq && isXProtocol)) {
+ return true;
+ }
+ } catch(e) {}
+
+ return false;
+ };
+
+ /**
+ * Check if the XHR transport supports cross domain requests.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+ XHR.xdomainCheck = function () {
+ return XHR.check(null, true);
+ };
+
+})(
+ 'undefined' != typeof io ? io.Transport : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+ , this
+);
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports.htmlfile = HTMLFile;
+
+ /**
+ * The HTMLFile transport creates a `forever iframe` based transport
+ * for Internet Explorer. Regular forever iframe implementations will
+ * continuously trigger the browsers buzy indicators. If the forever iframe
+ * is created inside a `htmlfile` these indicators will not be trigged.
+ *
+ * @constructor
+ * @extends {io.Transport.XHR}
+ * @api public
+ */
+
+ function HTMLFile (socket) {
+ io.Transport.XHR.apply(this, arguments);
+ };
+
+ /**
+ * Inherits from XHR transport.
+ */
+
+ io.util.inherit(HTMLFile, io.Transport.XHR);
+
+ /**
+ * Transport name
+ *
+ * @api public
+ */
+
+ HTMLFile.prototype.name = 'htmlfile';
+
+ /**
+ * Creates a new Ac...eX `htmlfile` with a forever loading iframe
+ * that can be used to listen to messages. Inside the generated
+ * `htmlfile` a reference will be made to the HTMLFile transport.
+ *
+ * @api private
+ */
+
+ HTMLFile.prototype.get = function () {
+ this.doc = new window[(['Active'].concat('Object').join('X'))]('htmlfile');
+ this.doc.open();
+ this.doc.write('');
+ this.doc.close();
+ this.doc.parentWindow.s = this;
+
+ var iframeC = this.doc.createElement('div');
+ iframeC.className = 'socketio';
+
+ this.doc.body.appendChild(iframeC);
+ this.iframe = this.doc.createElement('iframe');
+
+ iframeC.appendChild(this.iframe);
+
+ var self = this
+ , query = io.util.query(this.socket.options.query, 't='+ +new Date);
+
+ this.iframe.src = this.prepareUrl() + query;
+
+ io.util.on(window, 'unload', function () {
+ self.destroy();
+ });
+ };
+
+ /**
+ * The Socket.IO server will write script tags inside the forever
+ * iframe, this function will be used as callback for the incoming
+ * information.
+ *
+ * @param {String} data The message
+ * @param {document} doc Reference to the context
+ * @api private
+ */
+
+ HTMLFile.prototype._ = function (data, doc) {
+ this.onData(data);
+ try {
+ var script = doc.getElementsByTagName('script')[0];
+ script.parentNode.removeChild(script);
+ } catch (e) { }
+ };
+
+ /**
+ * Destroy the established connection, iframe and `htmlfile`.
+ * And calls the `CollectGarbage` function of Internet Explorer
+ * to release the memory.
+ *
+ * @api private
+ */
+
+ HTMLFile.prototype.destroy = function () {
+ if (this.iframe){
+ try {
+ this.iframe.src = 'about:blank';
+ } catch(e){}
+
+ this.doc = null;
+ this.iframe.parentNode.removeChild(this.iframe);
+ this.iframe = null;
+
+ CollectGarbage();
+ }
+ };
+
+ /**
+ * Disconnects the established connection.
+ *
+ * @returns {Transport} Chaining.
+ * @api public
+ */
+
+ HTMLFile.prototype.close = function () {
+ this.destroy();
+ return io.Transport.XHR.prototype.close.call(this);
+ };
+
+ /**
+ * Checks if the browser supports this transport. The browser
+ * must have an `Ac...eXObject` implementation.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+ HTMLFile.check = function () {
+ if (typeof window != "undefined" && (['Active'].concat('Object').join('X')) in window){
+ try {
+ var a = new window[(['Active'].concat('Object').join('X'))]('htmlfile');
+ return a && io.Transport.XHR.check();
+ } catch(e){}
+ }
+ return false;
+ };
+
+ /**
+ * Check if cross domain requests are supported.
+ *
+ * @returns {Boolean}
+ * @api public
+ */
+
+ HTMLFile.xdomainCheck = function () {
+ // we can probably do handling for sub-domains, we should
+ // test that it's cross domain but a subdomain here
+ return false;
+ };
+
+ /**
+ * Add the transport to your public io.transports array.
+ *
+ * @api private
+ */
+
+ io.transports.push('htmlfile');
+
+})(
+ 'undefined' != typeof io ? io.Transport : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io, global) {
+
+ /**
+ * Expose constructor.
+ */
+
+ exports['xhr-polling'] = XHRPolling;
+
+ /**
+ * The XHR-polling transport uses long polling XHR requests to create a
+ * "persistent" connection with the server.
+ *
+ * @constructor
+ * @api public
+ */
+
+ function XHRPolling () {
+ io.Transport.XHR.apply(this, arguments);
+ };
+
+ /**
+ * Inherits from XHR transport.
+ */
+
+ io.util.inherit(XHRPolling, io.Transport.XHR);
+
+ /**
+ * Merge the properties from XHR transport
+ */
+
+ io.util.merge(XHRPolling, io.Transport.XHR);
+
+ /**
+ * Transport name
+ *
+ * @api public
+ */
+
+ XHRPolling.prototype.name = 'xhr-polling';
+
+ /**
+ * Establish a connection, for iPhone and Android this will be done once the page
+ * is loaded.
+ *
+ * @returns {Transport} Chaining.
+ * @api public
+ */
+
+ XHRPolling.prototype.open = function () {
+ var self = this;
+
+ io.Transport.XHR.prototype.open.call(self);
+ return false;
+ };
+
+ /**
+ * Starts a XHR request to wait for incoming messages.
+ *
+ * @api private
+ */
+
+ function empty () {};
+
+ XHRPolling.prototype.get = function () {
+ if (!this.open) return;
+
+ var self = this;
+
+ function stateChange () {
+ if (this.readyState == 4) {
+ this.onreadystatechange = empty;
+
+ if (this.status == 200) {
+ self.onData(this.responseText);
+ self.get();
+ } else {
+ self.onClose();
+ }
+ }
+ };
+
+ function onload () {
+ this.onload = empty;
+ this.onerror = empty;
+ self.onData(this.responseText);
+ self.get();
+ };
+
+ function onerror () {
+ self.onClose();
+ };
+
+ this.xhr = this.request();
+
+ if (global.XDomainRequest && this.xhr instanceof XDomainRequest) {
+ this.xhr.onload = onload;
+ this.xhr.onerror = onerror;
+ } else {
+ this.xhr.onreadystatechange = stateChange;
+ }
+
+ this.xhr.send(null);
+ };
+
+ /**
+ * Handle the unclean close behavior.
+ *
+ * @api private
+ */
+
+ XHRPolling.prototype.onClose = function () {
+ io.Transport.XHR.prototype.onClose.call(this);
+
+ if (this.xhr) {
+ this.xhr.onreadystatechange = this.xhr.onload = this.xhr.onerror = empty;
+ try {
+ this.xhr.abort();
+ } catch(e){}
+ this.xhr = null;
+ }
+ };
+
+ /**
+ * Webkit based browsers show a infinit spinner when you start a XHR request
+ * before the browsers onload event is called so we need to defer opening of
+ * the transport until the onload event is called. Wrapping the cb in our
+ * defer method solve this.
+ *
+ * @param {Socket} socket The socket instance that needs a transport
+ * @param {Function} fn The callback
+ * @api private
+ */
+
+ XHRPolling.prototype.ready = function (socket, fn) {
+ var self = this;
+
+ io.util.defer(function () {
+ fn.call(self);
+ });
+ };
+
+ /**
+ * Add the transport to your public io.transports array.
+ *
+ * @api private
+ */
+
+ io.transports.push('xhr-polling');
+
+})(
+ 'undefined' != typeof io ? io.Transport : module.exports
+ , 'undefined' != typeof io ? io : module.parent.exports
+ , this
+);
+
+/**
+ * socket.io
+ * Copyright(c) 2011 LearnBoost
+ * MIT Licensed
+ */
+
+(function (exports, io, global) {
+ /**
+ * There is a way to hide the loading indicator in Firefox. If you create and
+ * remove a iframe it will stop showing the current loading indicator.
+ * Unfortunately we can't feature detect that and UA sniffing is evil.
+ *
+ * @api private
+ */
+
+ var indicator = global.document && "MozAppearance" in
+ global.document.documentElement.style;
+
+ /**
+ * Expose constructor.
+ */
+
+ exports['jsonp-polling'] = JSONPPolling;
+
+ /**
+ * The JSONP transport creates an persistent connection by dynamically
+ * inserting a script tag in the page. This script tag will receive the
+ * information of the Socket.IO server. When new information is received
+ * it creates a new script tag for the new data stream.
+ *
+ * @constructor
+ * @extends {io.Transport.xhr-polling}
+ * @api public
+ */
+
+ function JSONPPolling (socket) {
+ io.Transport['xhr-polling'].apply(this, arguments);
+
+ this.index = io.j.length;
+
+ var self = this;
+
+ io.j.push(function (msg) {
+ self._(msg);
+ });
+ };
+
+ /**
+ * Inherits from XHR polling transport.
+ */
+
+ io.util.inherit(JSONPPolling, io.Transport['xhr-polling']);
+
+ /**
+ * Transport name
+ *
+ * @api public
+ */
+
+ JSONPPolling.prototype.name = 'jsonp-polling';
+
+ /**
+ * Posts a encoded message to the Socket.IO server using an iframe.
+ * The iframe is used because script tags can create POST based requests.
+ * The iframe is positioned outside of the view so the user does not
+ * notice it's existence.
+ *
+ * @param {String} data A encoded message.
+ * @api private
+ */
+
+ JSONPPolling.prototype.post = function (data) {
+ var self = this
+ , query = io.util.query(
+ this.socket.options.query
+ , 't='+ (+new Date) + '&i=' + this.index
+ );
+
+ if (!this.form) {
+ var form = document.createElement('form')
+ , area = document.createElement('textarea')
+ , id = this.iframeId = 'socketio_iframe_' + this.index
+ , iframe;
+
+ form.className = 'socketio';
+ form.style.position = 'absolute';
+ form.style.top = '0px';
+ form.style.left = '0px';
+ form.style.display = 'none';
+ form.target = id;
+ form.method = 'POST';
+ form.setAttribute('accept-charset', 'utf-8');
+ area.name = 'd';
+ form.appendChild(area);
+ document.body.appendChild(form);
+
+ this.form = form;
+ this.area = area;
+ }
+
+ this.form.action = this.prepareUrl() + query;
+
+ function complete () {
+ initIframe();
+ self.socket.setBuffer(false);
+ };
+
+ function initIframe () {
+ if (self.iframe) {
+ self.form.removeChild(self.iframe);
+ }
+
+ try {
+ // ie6 dynamic iframes with target="" support (thanks Chris Lambacher)
+ iframe = document.createElement('';
+html += '
';
+html += '
';
+html += '
Upload File
';
+html += '
Want to upload multiple files at once? Please upgrade to the latest Flash Player, then reload this page. For some reason our Flash based uploader did not load, so you are currently using our single file uploader.
This is the complete list of public games currently being built by our users, presented in alphabetical order. Maybe they could use some help! Check out the game project pages and see (requires user account).
1 UglifyJS — a JavaScript parser/compressor/beautifier
+
+
+
+
+This package implements a general-purpose JavaScript
+parser/compressor/beautifier toolkit. It is developed on NodeJS, but it
+should work on any JavaScript platform supporting the CommonJS module system
+(and if your platform of choice doesn't support CommonJS, you can easily
+implement it, or discard the exports.* lines from UglifyJS sources).
+
+
+The tokenizer/parser generates an abstract syntax tree from JS code. You
+can then traverse the AST to learn more about the code, or do various
+manipulations on it. This part is implemented in parse-js.js and it's a
+port to JavaScript of the excellent parse-js Common Lisp library from Marijn Haverbeke.
+
+
+( See cl-uglify-js if you're looking for the Common Lisp version of
+UglifyJS. )
+
+
+The second part of this package, implemented in process.js, inspects and
+manipulates the AST generated by the parser to provide the following:
+
+
+
ability to re-generate JavaScript code from the AST. Optionally
+ indented—you can use this if you want to “beautify” a program that has
+ been compressed, so that you can inspect the source. But you can also run
+ our code generator to print out an AST without any whitespace, so you
+ achieve compression as well.
+
+
+
shorten variable names (usually to single characters). Our mangler will
+ analyze the code and generate proper variable names, depending on scope
+ and usage, and is smart enough to deal with globals defined elsewhere, or
+ with eval() calls or with{} statements. In short, if eval() or
+ with{} are used in some scope, then all variables in that scope and any
+ variables in the parent scopes will remain unmangled, and any references
+ to such variables remain unmangled as well.
+
+
+
various small optimizations that may lead to faster code but certainly
+ lead to smaller code. Where possible, we do the following:
+
+
+
foo["bar"] ==> foo.bar
+
+
+
remove block brackets {}
+
+
+
join consecutive var declarations:
+ var a = 10; var b = 20; ==> var a=10,b=20;
+
+
+
resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the
+ replacement if the result occupies less bytes; for example 1/3 would
+ translate to 0.333333333333, so in this case we don't replace it.
+
+
+
consecutive statements in blocks are merged into a sequence; in many
+ cases, this leaves blocks with a single statement, so then we can remove
+ the block brackets.
+
+
+
various optimizations for IF statements:
+
+
+
if (foo) bar(); else baz(); ==> foo?bar():baz();
+
+
if (!foo) bar(); else baz(); ==> foo?baz():bar();
+
remove some unreachable code and warn about it (code that follows a
+ return, throw, break or continue statement, except
+ function/variable declarations).
+
+
+
act a limited version of a pre-processor (c.f. the pre-processor of
+ C/C++) to allow you to safely replace selected global symbols with
+ specified values. When combined with the optimisations above this can
+ make UglifyJS operate slightly more like a compilation process, in
+ that when certain symbols are replaced by constant values, entire code
+ blocks may be optimised away as unreachable.
+
+
+
+
+
+
+
+
+
+
+
+
1.1Unsafe transformations
+
+
+
+
+The following transformations can in theory break code, although they're
+probably safe in most practical cases. To enable them you need to pass the
+--unsafe flag.
+
+
+
+
+
+
1.1.1 Calls involving the global Array constructor
+These are all safe if the Array name isn't redefined. JavaScript does allow
+one to globally redefine Array (and pretty much everything, in fact) but I
+personally don't see why would anyone do that.
+
+
+UglifyJS does handle the case where Array is redefined locally, or even
+globally but with a function or var declaration. Therefore, in the
+following cases UglifyJS doesn't touch calls or instantiations of Array:
+
+
+
+
+
// case 1. globally declared variable
+ varArray;
+ newArray(1, 2, 3);
+ Array(a, b);
+
+ // or (can be declared later)
+ newArray(1, 2, 3);
+ varArray;
+
+ // or (can be a function)
+ newArray(1, 2, 3);
+ functionArray() { ... }
+
+// case 2. declared in a function
+ (function(){
+ a = newArray(1, 2, 3);
+ b = Array(5, 6);
+ varArray;
+ })();
+
+ // or
+ (function(Array){
+ return Array(5, 6, 7);
+ })();
+
+ // or
+ (function(){
+ returnnewArray(1, 2, 3, 4);
+ functionArray() { ... }
+ })();
+
+ // etc.
+
+
+
+
+
+
+
+
+
1.1.2obj.toString() ==> obj+“”
+
+
+
+
+
+
+
+
+
+
1.2 Install (NPM)
+
+
+
+
+UglifyJS is now available through NPM — npm install uglify-js should do
+the job.
+
+
+
+
+
+
+
1.3 Install latest code from GitHub
+
+
+
+
+
+
+
## clone the repository
+mkdir -p /where/you/wanna/put/it
+cd /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+## make the module available to Node
+mkdir -p ~/.node_libraries/
+cd ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+## and if you want the CLI script too:
+mkdir -p ~/bin
+cd ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ # (then add ~/bin to your $PATH if it's not there already)
+
+
+
+
+
+
+
+
+
1.4 Usage
+
+
+
+
+There is a command-line tool that exposes the functionality of this library
+for your shell-scripting needs:
+
+
+
+
+
uglifyjs [ options... ] [ filename ]
+
+
+
+
+filename should be the last argument and should name the file from which
+to read the JavaScript code. If you don't specify it, it will read code
+from STDIN.
+
+
+Supported options:
+
+
+
-b or --beautify — output indented code; when passed, additional
+ options control the beautifier:
+
+
+
-i N or --indent N — indentation level (number of spaces)
+
+
+
-q or --quote-keys — quote keys in literal objects (by default,
+ only keys that cannot be identifier names will be quotes).
+
+
+
+
+
+
--ascii — pass this argument to encode non-ASCII characters as
+ \uXXXX sequences. By default UglifyJS won't bother to do it and will
+ output Unicode characters instead. (the output is always encoded in UTF8,
+ but if you pass this option you'll only get ASCII).
+
+
+
-nm or --no-mangle — don't mangle names.
+
+
+
-nmf or --no-mangle-functions – in case you want to mangle variable
+ names, but not touch function names.
+
+
+
-ns or --no-squeeze — don't call ast_squeeze() (which does various
+ optimizations that result in smaller, less readable code).
+
+
+
-mt or --mangle-toplevel — mangle names in the toplevel scope too
+ (by default we don't do this).
+
+
+
--no-seqs — when ast_squeeze() is called (thus, unless you pass
+ --no-squeeze) it will reduce consecutive statements in blocks into a
+ sequence. For example, "a = 10; b = 20; foo();" will be written as
+ "a=10,b=20,foo();". In various occasions, this allows us to discard the
+ block brackets (since the block becomes a single statement). This is ON
+ by default because it seems safe and saves a few hundred bytes on some
+ libs that I tested it on, but pass --no-seqs to disable it.
+
+
+
--no-dead-code — by default, UglifyJS will remove code that is
+ obviously unreachable (code that follows a return, throw, break or
+ continue statement and is not a function/variable declaration). Pass
+ this option to disable this optimization.
+
+
+
-nc or --no-copyright — by default, uglifyjs will keep the initial
+ comment tokens in the generated code (assumed to be copyright information
+ etc.). If you pass this it will discard it.
+
+
+
-o filename or --output filename — put the result in filename. If
+ this isn't given, the result goes to standard output (or see next one).
+
+
+
--overwrite — if the code is read from a file (not from STDIN) and you
+ pass --overwrite then the output will be written in the same file.
+
+
+
--ast — pass this if you want to get the Abstract Syntax Tree instead
+ of JavaScript as output. Useful for debugging or learning more about the
+ internals.
+
+
+
-v or --verbose — output some notes on STDERR (for now just how long
+ each operation takes).
+
+
+
-d SYMBOL[=VALUE] or --define SYMBOL[=VALUE] — will replace
+ all instances of the specified symbol where used as an identifier
+ (except where symbol has properly declared by a var declaration or
+ use as function parameter or similar) with the specified value. This
+ argument may be specified multiple times to define multiple
+ symbols - if no value is specified the symbol will be replaced with
+ the value true, or you can specify a numeric value (such as
+ 1024), a quoted string value (such as ="object"= or
+ ='https://github.com'), or the name of another symbol or keyword (such as =null or document).
+ This allows you, for example, to assign meaningful names to key
+ constant values but discard the symbolic names in the uglified
+ version for brevity/efficiency, or when used wth care, allows
+ UglifyJS to operate as a form of conditional compilation
+ whereby defining appropriate values may, by dint of the constant
+ folding and dead code removal features above, remove entire
+ superfluous code blocks (e.g. completely remove instrumentation or
+ trace code for production use).
+ Where string values are being defined, the handling of quotes are
+ likely to be subject to the specifics of your command shell
+ environment, so you may need to experiment with quoting styles
+ depending on your platform, or you may find the option
+ --define-from-module more suitable for use.
+
+
+
-define-from-module SOMEMODULE — will load the named module (as
+ per the NodeJS require() function) and iterate all the exported
+ properties of the module defining them as symbol names to be defined
+ (as if by the --define option) per the name of each property
+ (i.e. without the module name prefix) and given the value of the
+ property. This is a much easier way to handle and document groups of
+ symbols to be defined rather than a large number of --define
+ options.
+
+
+
--unsafe — enable other additional optimizations that are known to be
+ unsafe in some contrived situations, but could still be generally useful.
+ For now only these:
+
+
+
foo.toString() ==> foo+""
+
+
new Array(x,…) ==> [x,…]
+
+
new Array(x) ==> Array(x)
+
+
+
+
+
+
--max-line-len (default 32K characters) — add a newline after around
+ 32K characters. I've seen both FF and Chrome croak when all the code was
+ on a single line of around 670K. Pass –max-line-len 0 to disable this
+ safety feature.
+
+
+
--reserved-names — some libraries rely on certain names to be used, as
+ pointed out in issue #92 and #81, so this option allow you to exclude such
+ names from the mangler. For example, to keep names require and $super
+ intact you'd specify –reserved-names "require,$super".
+
+
+
--inline-script – when you want to include the output literally in an
+ HTML <script> tag you can use this option to prevent </script from
+ showing up in the output.
+
+
+
--lift-vars – when you pass this, UglifyJS will apply the following
+ transformations (see the notes in API, ast_lift_variables):
+
+
+
put all var declarations at the start of the scope
+
+
make sure a variable is declared only once
+
+
discard unused function arguments
+
+
discard unused inner (named) functions
+
+
finally, try to merge assignments into that one var declaration, if
+ possible.
+
+
+
+
+
+
+
+
+
+
+
+
1.4.1 API
+
+
+
+
+To use the library from JavaScript, you'd do the following (example for
+NodeJS):
+
+
+
+
+
varjsp = require("uglify-js").parser;
+varpro = require("uglify-js").uglify;
+
+varorig_code = "... JS code here";
+varast = jsp.parse(orig_code); // parse code and get the initial AST
+ast = pro.ast_mangle(ast); // get a new AST with mangled names
+ast = pro.ast_squeeze(ast); // get an AST with compression optimizations
+varfinal_code = pro.gen_code(ast); // compressed code here
+
+
+
+
+The above performs the full compression that is possible right now. As you
+can see, there are a sequence of steps which you can apply. For example if
+you want compressed output but for some reason you don't want to mangle
+variable names, you would simply skip the line that calls
+pro.ast_mangle(ast).
+
+
+Some of these functions take optional arguments. Here's a description:
+
+
+
jsp.parse(code, strict_semicolons) – parses JS code and returns an AST.
+ strict_semicolons is optional and defaults to false. If you pass
+ true then the parser will throw an error when it expects a semicolon and
+ it doesn't find it. For most JS code you don't want that, but it's useful
+ if you want to strictly sanitize your code.
+
+
+
pro.ast_lift_variables(ast) – merge and move var declarations to the
+ scop of the scope; discard unused function arguments or variables; discard
+ unused (named) inner functions. It also tries to merge assignments
+ following the var declaration into it.
+
+
+ If your code is very hand-optimized concerning var declarations, this
+ lifting variable declarations might actually increase size. For me it
+ helps out. On jQuery it adds 865 bytes (243 after gzip). YMMV. Also
+ note that (since it's not enabled by default) this operation isn't yet
+ heavily tested (please report if you find issues!).
+
+
+ Note that although it might increase the image size (on jQuery it gains
+ 865 bytes, 243 after gzip) it's technically more correct: in certain
+ situations, dead code removal might drop variable declarations, which
+ would not happen if the variables are lifted in advance.
+
+
+ Here's an example of what it does:
+
+
+
+
+
+
+
+
functionf(a, b, c, d, e) {
+ varq;
+ varw;
+ w = 10;
+ q = 20;
+ for (vari = 1; i < 10; ++i) {
+ varboo = foo(a);
+ }
+ for (vari = 0; i < 1; ++i) {
+ varboo = bar(c);
+ }
+ functionfoo(){ ... }
+ functionbar(){ ... }
+ functionbaz(){ ... }
+}
+
+// transforms into ==>
+
+functionf(a, b, c) {
+ vari, boo, w = 10, q = 20;
+ for (i = 1; i < 10; ++i) {
+ boo = foo(a);
+ }
+ for (i = 0; i < 1; ++i) {
+ boo = bar(c);
+ }
+ functionfoo() { ... }
+ functionbar() { ... }
+}
+
+
+
+
+
pro.ast_mangle(ast, options) – generates a new AST containing mangled
+ (compressed) variable and function names. It supports the following
+ options:
+
+
except – an array of names to exclude from compression.
+
+
defines – an object with properties named after symbols to
+ replace (see the --define option for the script) and the values
+ representing the AST replacement value.
+
+
+
+
+
+
pro.ast_squeeze(ast, options) – employs further optimizations designed
+ to reduce the size of the code that gen_code would generate from the
+ AST. Returns a new AST. options can be a hash; the supported options
+ are:
+
+
+
make_seqs (default true) which will cause consecutive statements in a
+ block to be merged using the "sequence" (comma) operator
+
+
+
dead_code (default true) which will remove unreachable code.
+
+
+
+
+
+
pro.gen_code(ast, options) – generates JS code from the AST. By
+ default it's minified, but using the options argument you can get nicely
+ formatted output. options is, well, optional :-) and if you pass it it
+ must be an object and supports the following properties (below you can see
+ the default values):
+
+
+
beautify: false – pass true if you want indented output
+
+
indent_start: 0 (only applies when beautify is true) – initial
+ indentation in spaces
+
+
indent_level: 4 (only applies when beautify is true) --
+ indentation level, in spaces (pass an even number)
+
+
quote_keys: false – if you pass true it will quote all keys in
+ literal objects
+
+
space_colon: false (only applies when beautify is true) – wether
+ to put a space before the colon in object literals
+
+
ascii_only: false – pass true if you want to encode non-ASCII
+ characters as \uXXXX.
+
+
inline_script: false – pass true to escape occurrences of
+ </script in strings
+
+
+
+
+
+
+
+
+
+
+
+
+
1.4.2 Beautifier shortcoming – no more comments
+
+
+
+
+The beautifier can be used as a general purpose indentation tool. It's
+useful when you want to make a minified file readable. One limitation,
+though, is that it discards all comments, so you don't really want to use it
+to reformat your code, unless you don't have, or don't care about, comments.
+
+
+In fact it's not the beautifier who discards comments — they are dumped at
+the parsing stage, when we build the initial AST. Comments don't really
+make sense in the AST, and while we could add nodes for them, it would be
+inconvenient because we'd have to add special rules to ignore them at all
+the processing stages.
+
+
+
+
+
+
+
1.4.3 Use as a code pre-processor
+
+
+
+
+The --define option can be used, particularly when combined with the
+constant folding logic, as a form of pre-processor to enable or remove
+particular constructions, such as might be used for instrumenting
+development code, or to produce variations aimed at a specific
+platform.
+
+
+The code below illustrates the way this can be done, and how the
+symbol replacement is performed.
+
+When the above code is normally executed, the undeclared global
+variable DEVMODE will be assigned the value true (see CLAUSE1)
+and so the init() function (CLAUSE2) will write messages to the
+console log when executed, but in CLAUSE3 a locally declared
+variable will mask access to the DEVMODE global symbol.
+
+
+If the above code is processed by UglifyJS with an argument of
+--define DEVMODE=false then UglifyJS will replace DEVMODE with the
+boolean constant value false within CLAUSE1 and CLAUSE2, but it
+will leave CLAUSE3 as it stands because there DEVMODE resolves to
+a validly declared variable.
+
+
+And more so, the constant-folding features of UglifyJS will recognise
+that the if condition of CLAUSE1 is thus always false, and so will
+remove the test and body of CLAUSE1 altogether (including the
+otherwise slightly problematical statement false = true; which it
+will have formed by replacing DEVMODE in the body). Similarly,
+within CLAUSE2 both calls to console.log() will be removed
+altogether.
+
+
+In this way you can mimic, to a limited degree, the functionality of
+the C/C++ pre-processor to enable or completely remove blocks
+depending on how certain symbols are defined - perhaps using UglifyJS
+to generate different versions of source aimed at different
+environments
+
+
+It is recommmended (but not made mandatory) that symbols designed for
+this purpose are given names consisting of UPPER_CASE_LETTERS to
+distinguish them from other (normal) symbols and avoid the sort of
+clash that CLAUSE3 above illustrates.
+
+
+
+
+
+
+
+
1.5 Compression – how good is it?
+
+
+
+
+Here are updated statistics. (I also updated my Google Closure and YUI
+installations).
+
+
+We're still a lot better than YUI in terms of compression, though slightly
+slower. We're still a lot faster than Closure, and compression after gzip
+is comparable.
+
+
+
+
+
+
+
File
UglifyJS
UglifyJS+gzip
Closure
Closure+gzip
YUI
YUI+gzip
+
+
+
jquery-1.6.2.js
91001 (0:01.59)
31896
90678 (0:07.40)
31979
101527 (0:01.82)
34646
+
paper.js
142023 (0:01.65)
43334
134301 (0:07.42)
42495
173383 (0:01.58)
48785
+
prototype.js
88544 (0:01.09)
26680
86955 (0:06.97)
26326
92130 (0:00.79)
28624
+
thelib-full.js (DynarchLIB)
251939 (0:02.55)
72535
249911 (0:09.05)
72696
258869 (0:01.94)
76584
+
+
+
+
+
+
+
+
+
+
1.6 Bugs?
+
+
+
+
+Unfortunately, for the time being there is no automated test suite. But I
+ran the compressor manually on non-trivial code, and then I tested that the
+generated code works as expected. A few hundred times.
+
+
+DynarchLIB was started in times when there was no good JS minifier.
+Therefore I was quite religious about trying to write short code manually,
+and as such DL contains a lot of syntactic hacks1 such as “foo == bar ? a
+= 10 : b = 20”, though the more readable version would clearly be to use
+“if/else”.
+
+
+Since the parser/compressor runs fine on DL and jQuery, I'm quite confident
+that it's solid enough for production use. If you can identify any bugs,
+I'd love to hear about them (use the Google Group or email me directly).
+
Copyright 2010 (c) Mihai Bazon <mihai.bazon@gmail.com>
+Based on parse-js (http://marijn.haverbeke.nl/parse-js/).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the following
+ disclaimer.
+
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials
+ provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
+
+
+
+
Footnotes:
+
+
1 I even reported a few bugs and suggested some fixes in the original
+ parse-js library, and Marijn pushed fixes literally in minutes.
+
+
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org b/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org
new file mode 100644
index 0000000..4d01fdf
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/README.org
@@ -0,0 +1,574 @@
+#+TITLE: UglifyJS -- a JavaScript parser/compressor/beautifier
+#+KEYWORDS: javascript, js, parser, compiler, compressor, mangle, minify, minifier
+#+DESCRIPTION: a JavaScript parser/compressor/beautifier in JavaScript
+#+STYLE:
+#+AUTHOR: Mihai Bazon
+#+EMAIL: mihai.bazon@gmail.com
+
+* UglifyJS --- a JavaScript parser/compressor/beautifier
+
+This package implements a general-purpose JavaScript
+parser/compressor/beautifier toolkit. It is developed on [[http://nodejs.org/][NodeJS]], but it
+should work on any JavaScript platform supporting the CommonJS module system
+(and if your platform of choice doesn't support CommonJS, you can easily
+implement it, or discard the =exports.*= lines from UglifyJS sources).
+
+The tokenizer/parser generates an abstract syntax tree from JS code. You
+can then traverse the AST to learn more about the code, or do various
+manipulations on it. This part is implemented in [[../lib/parse-js.js][parse-js.js]] and it's a
+port to JavaScript of the excellent [[http://marijn.haverbeke.nl/parse-js/][parse-js]] Common Lisp library from [[http://marijn.haverbeke.nl/][Marijn
+Haverbeke]].
+
+( See [[http://github.com/mishoo/cl-uglify-js][cl-uglify-js]] if you're looking for the Common Lisp version of
+UglifyJS. )
+
+The second part of this package, implemented in [[../lib/process.js][process.js]], inspects and
+manipulates the AST generated by the parser to provide the following:
+
+- ability to re-generate JavaScript code from the AST. Optionally
+ indented---you can use this if you want to “beautify” a program that has
+ been compressed, so that you can inspect the source. But you can also run
+ our code generator to print out an AST without any whitespace, so you
+ achieve compression as well.
+
+- shorten variable names (usually to single characters). Our mangler will
+ analyze the code and generate proper variable names, depending on scope
+ and usage, and is smart enough to deal with globals defined elsewhere, or
+ with =eval()= calls or =with{}= statements. In short, if =eval()= or
+ =with{}= are used in some scope, then all variables in that scope and any
+ variables in the parent scopes will remain unmangled, and any references
+ to such variables remain unmangled as well.
+
+- various small optimizations that may lead to faster code but certainly
+ lead to smaller code. Where possible, we do the following:
+
+ - foo["bar"] ==> foo.bar
+
+ - remove block brackets ={}=
+
+ - join consecutive var declarations:
+ var a = 10; var b = 20; ==> var a=10,b=20;
+
+ - resolve simple constant expressions: 1 +2 * 3 ==> 7. We only do the
+ replacement if the result occupies less bytes; for example 1/3 would
+ translate to 0.333333333333, so in this case we don't replace it.
+
+ - consecutive statements in blocks are merged into a sequence; in many
+ cases, this leaves blocks with a single statement, so then we can remove
+ the block brackets.
+
+ - various optimizations for IF statements:
+
+ - if (foo) bar(); else baz(); ==> foo?bar():baz();
+ - if (!foo) bar(); else baz(); ==> foo?baz():bar();
+ - if (foo) bar(); ==> foo&&bar();
+ - if (!foo) bar(); ==> foo||bar();
+ - if (foo) return bar(); else return baz(); ==> return foo?bar():baz();
+ - if (foo) return bar(); else something(); ==> {if(foo)return bar();something()}
+
+ - remove some unreachable code and warn about it (code that follows a
+ =return=, =throw=, =break= or =continue= statement, except
+ function/variable declarations).
+
+ - act a limited version of a pre-processor (c.f. the pre-processor of
+ C/C++) to allow you to safely replace selected global symbols with
+ specified values. When combined with the optimisations above this can
+ make UglifyJS operate slightly more like a compilation process, in
+ that when certain symbols are replaced by constant values, entire code
+ blocks may be optimised away as unreachable.
+
+** <>
+
+The following transformations can in theory break code, although they're
+probably safe in most practical cases. To enable them you need to pass the
+=--unsafe= flag.
+
+*** Calls involving the global Array constructor
+
+The following transformations occur:
+
+#+BEGIN_SRC js
+new Array(1, 2, 3, 4) => [1,2,3,4]
+Array(a, b, c) => [a,b,c]
+new Array(5) => Array(5)
+new Array(a) => Array(a)
+#+END_SRC
+
+These are all safe if the Array name isn't redefined. JavaScript does allow
+one to globally redefine Array (and pretty much everything, in fact) but I
+personally don't see why would anyone do that.
+
+UglifyJS does handle the case where Array is redefined locally, or even
+globally but with a =function= or =var= declaration. Therefore, in the
+following cases UglifyJS *doesn't touch* calls or instantiations of Array:
+
+#+BEGIN_SRC js
+// case 1. globally declared variable
+ var Array;
+ new Array(1, 2, 3);
+ Array(a, b);
+
+ // or (can be declared later)
+ new Array(1, 2, 3);
+ var Array;
+
+ // or (can be a function)
+ new Array(1, 2, 3);
+ function Array() { ... }
+
+// case 2. declared in a function
+ (function(){
+ a = new Array(1, 2, 3);
+ b = Array(5, 6);
+ var Array;
+ })();
+
+ // or
+ (function(Array){
+ return Array(5, 6, 7);
+ })();
+
+ // or
+ (function(){
+ return new Array(1, 2, 3, 4);
+ function Array() { ... }
+ })();
+
+ // etc.
+#+END_SRC
+
+*** =obj.toString()= ==> =obj+“”=
+
+** Install (NPM)
+
+UglifyJS is now available through NPM --- =npm install uglify-js= should do
+the job.
+
+** Install latest code from GitHub
+
+#+BEGIN_SRC sh
+## clone the repository
+mkdir -p /where/you/wanna/put/it
+cd /where/you/wanna/put/it
+git clone git://github.com/mishoo/UglifyJS.git
+
+## make the module available to Node
+mkdir -p ~/.node_libraries/
+cd ~/.node_libraries/
+ln -s /where/you/wanna/put/it/UglifyJS/uglify-js.js
+
+## and if you want the CLI script too:
+mkdir -p ~/bin
+cd ~/bin
+ln -s /where/you/wanna/put/it/UglifyJS/bin/uglifyjs
+ # (then add ~/bin to your $PATH if it's not there already)
+#+END_SRC
+
+** Usage
+
+There is a command-line tool that exposes the functionality of this library
+for your shell-scripting needs:
+
+#+BEGIN_SRC sh
+uglifyjs [ options... ] [ filename ]
+#+END_SRC
+
+=filename= should be the last argument and should name the file from which
+to read the JavaScript code. If you don't specify it, it will read code
+from STDIN.
+
+Supported options:
+
+- =-b= or =--beautify= --- output indented code; when passed, additional
+ options control the beautifier:
+
+ - =-i N= or =--indent N= --- indentation level (number of spaces)
+
+ - =-q= or =--quote-keys= --- quote keys in literal objects (by default,
+ only keys that cannot be identifier names will be quotes).
+
+- =--ascii= --- pass this argument to encode non-ASCII characters as
+ =\uXXXX= sequences. By default UglifyJS won't bother to do it and will
+ output Unicode characters instead. (the output is always encoded in UTF8,
+ but if you pass this option you'll only get ASCII).
+
+- =-nm= or =--no-mangle= --- don't mangle names.
+
+- =-nmf= or =--no-mangle-functions= -- in case you want to mangle variable
+ names, but not touch function names.
+
+- =-ns= or =--no-squeeze= --- don't call =ast_squeeze()= (which does various
+ optimizations that result in smaller, less readable code).
+
+- =-mt= or =--mangle-toplevel= --- mangle names in the toplevel scope too
+ (by default we don't do this).
+
+- =--no-seqs= --- when =ast_squeeze()= is called (thus, unless you pass
+ =--no-squeeze=) it will reduce consecutive statements in blocks into a
+ sequence. For example, "a = 10; b = 20; foo();" will be written as
+ "a=10,b=20,foo();". In various occasions, this allows us to discard the
+ block brackets (since the block becomes a single statement). This is ON
+ by default because it seems safe and saves a few hundred bytes on some
+ libs that I tested it on, but pass =--no-seqs= to disable it.
+
+- =--no-dead-code= --- by default, UglifyJS will remove code that is
+ obviously unreachable (code that follows a =return=, =throw=, =break= or
+ =continue= statement and is not a function/variable declaration). Pass
+ this option to disable this optimization.
+
+- =-nc= or =--no-copyright= --- by default, =uglifyjs= will keep the initial
+ comment tokens in the generated code (assumed to be copyright information
+ etc.). If you pass this it will discard it.
+
+- =-o filename= or =--output filename= --- put the result in =filename=. If
+ this isn't given, the result goes to standard output (or see next one).
+
+- =--overwrite= --- if the code is read from a file (not from STDIN) and you
+ pass =--overwrite= then the output will be written in the same file.
+
+- =--ast= --- pass this if you want to get the Abstract Syntax Tree instead
+ of JavaScript as output. Useful for debugging or learning more about the
+ internals.
+
+- =-v= or =--verbose= --- output some notes on STDERR (for now just how long
+ each operation takes).
+
+- =-d SYMBOL[=VALUE]= or =--define SYMBOL[=VALUE]= --- will replace
+ all instances of the specified symbol where used as an identifier
+ (except where symbol has properly declared by a var declaration or
+ use as function parameter or similar) with the specified value. This
+ argument may be specified multiple times to define multiple
+ symbols - if no value is specified the symbol will be replaced with
+ the value =true=, or you can specify a numeric value (such as
+ =1024=), a quoted string value (such as ="object"= or
+ ='https://github.com'=), or the name of another symbol or keyword
+ (such as =null= or =document=).
+ This allows you, for example, to assign meaningful names to key
+ constant values but discard the symbolic names in the uglified
+ version for brevity/efficiency, or when used wth care, allows
+ UglifyJS to operate as a form of *conditional compilation*
+ whereby defining appropriate values may, by dint of the constant
+ folding and dead code removal features above, remove entire
+ superfluous code blocks (e.g. completely remove instrumentation or
+ trace code for production use).
+ Where string values are being defined, the handling of quotes are
+ likely to be subject to the specifics of your command shell
+ environment, so you may need to experiment with quoting styles
+ depending on your platform, or you may find the option
+ =--define-from-module= more suitable for use.
+
+- =-define-from-module SOMEMODULE= --- will load the named module (as
+ per the NodeJS =require()= function) and iterate all the exported
+ properties of the module defining them as symbol names to be defined
+ (as if by the =--define= option) per the name of each property
+ (i.e. without the module name prefix) and given the value of the
+ property. This is a much easier way to handle and document groups of
+ symbols to be defined rather than a large number of =--define=
+ options.
+
+- =--unsafe= --- enable other additional optimizations that are known to be
+ unsafe in some contrived situations, but could still be generally useful.
+ For now only these:
+
+ - foo.toString() ==> foo+""
+ - new Array(x,...) ==> [x,...]
+ - new Array(x) ==> Array(x)
+
+- =--max-line-len= (default 32K characters) --- add a newline after around
+ 32K characters. I've seen both FF and Chrome croak when all the code was
+ on a single line of around 670K. Pass --max-line-len 0 to disable this
+ safety feature.
+
+- =--reserved-names= --- some libraries rely on certain names to be used, as
+ pointed out in issue #92 and #81, so this option allow you to exclude such
+ names from the mangler. For example, to keep names =require= and =$super=
+ intact you'd specify --reserved-names "require,$super".
+
+- =--inline-script= -- when you want to include the output literally in an
+ HTML =
+
+
+ */
+
+(function() {
+ this.loggly = function(opts) {
+ this.user_agent = get_agent();
+ this.browser_size = get_size();
+ log_methods = {'error': 5, 'warn': 4, 'info': 3, 'debug': 2, 'log': 1};
+ if (!opts.url) throw new Error("Please include a Loggly HTTP URL.");
+ if (!opts.level) {
+ this.level = log_methods['info'];
+ } else {
+ this.level = log_methods[opts.level];
+ }
+ this.log = function(data) {
+ if (log_methods['log'] == this.level) {
+ opts.data = data;
+ janky(opts);
+ }
+ };
+ this.debug = function(data) {
+ if (log_methods['debug'] >= this.level) {
+ opts.data = data;
+ janky(opts);
+ }
+ };
+ this.info = function(data) {
+ if (log_methods['info'] >= this.level) {
+ opts.data = data;
+ janky(opts);
+ }
+ };
+ this.warn = function(data) {
+ if (log_methods['warn'] >= this.level) {
+ opts.data = data;
+ janky(opts);
+ }
+ };
+ this.error = function(data) {
+ if (log_methods['error'] >= this.level) {
+ opts.data = data;
+ janky(opts);
+ }
+ };
+ };
+ this.janky = function(opts) {
+ janky._form(function(iframe, form) {
+ form.setAttribute("action", opts.url);
+ form.setAttribute("method", "post");
+ janky._input(iframe, form, opts.data);
+ form.submit();
+ setTimeout(function(){
+ document.body.removeChild(iframe);
+ }, 2000);
+ });
+ };
+ this.janky._form = function(cb) {
+ var iframe = document.createElement("iframe");
+ document.body.appendChild(iframe);
+ iframe.style.display = "none";
+ setTimeout(function() {
+ var form = iframe.contentWindow.document.createElement("form");
+ iframe.contentWindow.document.body.appendChild(form);
+ cb(iframe, form);
+ }, 0);
+ };
+ this.janky._input = function(iframe, form, data) {
+ var inp = iframe.contentWindow.document.createElement("input");
+ inp.setAttribute("type", "hidden");
+ inp.setAttribute("name", "source");
+ inp.value = "castor " + data;
+ form.appendChild(inp);
+ };
+ this.get_agent = function () {
+ return navigator.appCodeName + navigator.appName + navigator.appVersion;
+ };
+ this.get_size = function () {
+ var width = 0; var height = 0;
+ if( typeof( window.innerWidth ) == 'number' ) {
+ width = window.innerWidth; height = window.innerHeight;
+ } else if( document.documentElement && ( document.documentElement.clientWidth || document.documentElement.clientHeight ) ) {
+ width = document.documentElement.clientWidth; height = document.documentElement.clientHeight;
+ } else if( document.body && ( document.body.clientWidth || document.body.clientHeight ) ) {
+ width = document.body.clientWidth; height = document.body.clientHeight;
+ }
+ return {'height': height, 'width': width};
+ };
+})();
+
+
+jsworld={};jsworld.formatIsoDateTime=function(a,b){if(typeof a==="undefined")a=new Date;if(typeof b==="undefined")b=false;var c=jsworld.formatIsoDate(a)+" "+jsworld.formatIsoTime(a);if(b){var d=a.getHours()-a.getUTCHours();var e=Math.abs(d);var f=a.getUTCMinutes();var g=a.getMinutes();if(g!=f&&f<30&&d<0)e--;if(g!=f&&f>30&&d>0)e--;var h;if(g!=f)h=":30";else h=":00";var i;if(e<10)i="0"+e+h;else i=""+e+h;if(d<0)i="-"+i;else i="+"+i;c=c+i}return c};jsworld.formatIsoDate=function(a){if(typeof a==="undefined")a=new Date;var b=a.getFullYear();var c=a.getMonth()+1;var d=a.getDate();return b+"-"+jsworld._zeroPad(c,2)+"-"+jsworld._zeroPad(d,2)};jsworld.formatIsoTime=function(a){if(typeof a==="undefined")a=new Date;var b=a.getHours();var c=a.getMinutes();var d=a.getSeconds();return jsworld._zeroPad(b,2)+":"+jsworld._zeroPad(c,2)+":"+jsworld._zeroPad(d,2)};jsworld.parseIsoDateTime=function(a){if(typeof a!="string")throw"Error: The parameter must be a string";var b=a.match(/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d):(\d\d)/);if(b===null)b=a.match(/^(\d\d\d\d)(\d\d)(\d\d)[T ](\d\d)(\d\d)(\d\d)/);if(b===null)b=a.match(/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d)(\d\d)(\d\d)/);if(b===null)b=a.match(/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d):(\d\d)/);if(b===null)throw"Error: Invalid ISO-8601 date/time string";var c=parseInt(b[1],10);var d=parseInt(b[2],10);var e=parseInt(b[3],10);var f=parseInt(b[4],10);var g=parseInt(b[5],10);var h=parseInt(b[6],10);if(d<1||d>12||e<1||e>31||f<0||f>23||g<0||g>59||h<0||h>59)throw"Error: Invalid ISO-8601 date/time value";var i=new Date(c,d-1,e,f,g,h);if(i.getDate()!=e||i.getMonth()+1!=d)throw"Error: Invalid date";return i};jsworld.parseIsoDate=function(a){if(typeof a!="string")throw"Error: The parameter must be a string";var b=a.match(/^(\d\d\d\d)-(\d\d)-(\d\d)/);if(b===null)b=a.match(/^(\d\d\d\d)(\d\d)(\d\d)/);if(b===null)throw"Error: Invalid ISO-8601 date string";var c=parseInt(b[1],10);var d=parseInt(b[2],10);var e=parseInt(b[3],10);if(d<1||d>12||e<1||e>31)throw"Error: Invalid ISO-8601 date value";var f=new Date(c,d-1,e);if(f.getDate()!=e||f.getMonth()+1!=d)throw"Error: Invalid date";return f};jsworld.parseIsoTime=function(a){if(typeof a!="string")throw"Error: The parameter must be a string";var b=a.match(/^(\d\d):(\d\d):(\d\d)/);if(b===null)b=a.match(/^(\d\d)(\d\d)(\d\d)/);if(b===null)throw"Error: Invalid ISO-8601 date/time string";var c=parseInt(b[1],10);var d=parseInt(b[2],10);var e=parseInt(b[3],10);if(c<0||c>23||d<0||d>59||e<0||e>59)throw"Error: Invalid ISO-8601 time value";return new Date(0,0,0,c,d,e)};jsworld._trim=function(a){var b=" \n\r\t\f \u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000";for(var c=0;c=0;c--){if(b.indexOf(a.charAt(c))===-1){a=a.substring(0,c+1);break}}return b.indexOf(a.charAt(0))===-1?a:""};jsworld._isNumber=function(a){if(typeof a=="number")return true;if(typeof a!="string")return false;var b=a+"";return/^-?(\d+|\d*\.\d+)$/.test(b)};jsworld._isInteger=function(a){if(typeof a!="number"&&typeof a!="string")return false;var b=a+"";return/^-?\d+$/.test(b)};jsworld._isFloat=function(a){if(typeof a!="number"&&typeof a!="string")return false;var b=a+"";return/^-?\.\d+?$/.test(b)};jsworld._hasOption=function(a,b){if(typeof a!="string"||typeof b!="string")return false;if(b.indexOf(a)!=-1)return true;else return false};jsworld._stringReplaceAll=function(a,b,c){var d;if(b.length==1&&c.length==1){d="";for(var e=0;e0){if(d.length>0)g=parseInt(d.shift(),10);if(isNaN(g))throw"Error: Invalid grouping";if(g==-1){e=a.substring(0,f)+e;break}f-=g;if(f<1){e=a.substring(0,f+g)+e;break}e=c+a.substring(f,f+g)+e}return e};jsworld._formatFractionPart=function(a,b){for(var c=0;a.length0)return a;else throw"Empty or no string"};if(a==null||typeof a!="object")throw"Error: Invalid/missing locale properties";if(typeof a.decimal_point!="string")throw"Error: Invalid/missing decimal_point property";this.decimal_point=a.decimal_point;if(typeof a.thousands_sep!="string")throw"Error: Invalid/missing thousands_sep property";this.thousands_sep=a.thousands_sep;if(typeof a.grouping!="string")throw"Error: Invalid/missing grouping property";this.grouping=a.grouping;if(typeof a.int_curr_symbol!="string")throw"Error: Invalid/missing int_curr_symbol property";if(!/[A-Za-z]{3}.?/.test(a.int_curr_symbol))throw"Error: Invalid int_curr_symbol property";this.int_curr_symbol=a.int_curr_symbol;if(typeof a.currency_symbol!="string")throw"Error: Invalid/missing currency_symbol property";this.currency_symbol=a.currency_symbol;if(typeof a.frac_digits!="number"&&a.frac_digits<0)throw"Error: Invalid/missing frac_digits property";this.frac_digits=a.frac_digits;if(a.mon_decimal_point===null||a.mon_decimal_point==""){if(this.frac_digits>0)throw"Error: Undefined mon_decimal_point property";else a.mon_decimal_point=""}if(typeof a.mon_decimal_point!="string")throw"Error: Invalid/missing mon_decimal_point property";this.mon_decimal_point=a.mon_decimal_point;if(typeof a.mon_thousands_sep!="string")throw"Error: Invalid/missing mon_thousands_sep property";this.mon_thousands_sep=a.mon_thousands_sep;if(typeof a.mon_grouping!="string")throw"Error: Invalid/missing mon_grouping property";this.mon_grouping=a.mon_grouping;if(typeof a.positive_sign!="string")throw"Error: Invalid/missing positive_sign property";this.positive_sign=a.positive_sign;if(typeof a.negative_sign!="string")throw"Error: Invalid/missing negative_sign property";this.negative_sign=a.negative_sign;if(a.p_cs_precedes!==0&&a.p_cs_precedes!==1)throw"Error: Invalid/missing p_cs_precedes property, must be 0 or 1";this.p_cs_precedes=a.p_cs_precedes;if(a.n_cs_precedes!==0&&a.n_cs_precedes!==1)throw"Error: Invalid/missing n_cs_precedes, must be 0 or 1";this.n_cs_precedes=a.n_cs_precedes;if(a.p_sep_by_space!==0&&a.p_sep_by_space!==1&&a.p_sep_by_space!==2)throw"Error: Invalid/missing p_sep_by_space property, must be 0, 1 or 2";this.p_sep_by_space=a.p_sep_by_space;if(a.n_sep_by_space!==0&&a.n_sep_by_space!==1&&a.n_sep_by_space!==2)throw"Error: Invalid/missing n_sep_by_space property, must be 0, 1, or 2";this.n_sep_by_space=a.n_sep_by_space;if(a.p_sign_posn!==0&&a.p_sign_posn!==1&&a.p_sign_posn!==2&&a.p_sign_posn!==3&&a.p_sign_posn!==4)throw"Error: Invalid/missing p_sign_posn property, must be 0, 1, 2, 3 or 4";this.p_sign_posn=a.p_sign_posn;if(a.n_sign_posn!==0&&a.n_sign_posn!==1&&a.n_sign_posn!==2&&a.n_sign_posn!==3&&a.n_sign_posn!==4)throw"Error: Invalid/missing n_sign_posn property, must be 0, 1, 2, 3 or 4";this.n_sign_posn=a.n_sign_posn;if(typeof a.int_frac_digits!="number"&&a.int_frac_digits<0)throw"Error: Invalid/missing int_frac_digits property";this.int_frac_digits=a.int_frac_digits;if(a.int_p_cs_precedes!==0&&a.int_p_cs_precedes!==1)throw"Error: Invalid/missing int_p_cs_precedes property, must be 0 or 1";this.int_p_cs_precedes=a.int_p_cs_precedes;if(a.int_n_cs_precedes!==0&&a.int_n_cs_precedes!==1)throw"Error: Invalid/missing int_n_cs_precedes property, must be 0 or 1";this.int_n_cs_precedes=a.int_n_cs_precedes;if(a.int_p_sep_by_space!==0&&a.int_p_sep_by_space!==1&&a.int_p_sep_by_space!==2)throw"Error: Invalid/missing int_p_sep_by_spacev, must be 0, 1 or 2";this.int_p_sep_by_space=a.int_p_sep_by_space;if(a.int_n_sep_by_space!==0&&a.int_n_sep_by_space!==1&&a.int_n_sep_by_space!==2)throw"Error: Invalid/missing int_n_sep_by_space property, must be 0, 1, or 2";this.int_n_sep_by_space=a.int_n_sep_by_space;if(a.int_p_sign_posn!==0&&a.int_p_sign_posn!==1&&a.int_p_sign_posn!==2&&a.int_p_sign_posn!==3&&a.int_p_sign_posn!==4)throw"Error: Invalid/missing int_p_sign_posn property, must be 0, 1, 2, 3 or 4";this.int_p_sign_posn=a.int_p_sign_posn;if(a.int_n_sign_posn!==0&&a.int_n_sign_posn!==1&&a.int_n_sign_posn!==2&&a.int_n_sign_posn!==3&&a.int_n_sign_posn!==4)throw"Error: Invalid/missing int_n_sign_posn property, must be 0, 1, 2, 3 or 4";this.int_n_sign_posn=a.int_n_sign_posn;if(a==null||typeof a!="object")throw"Error: Invalid/missing time locale properties";try{this.abday=this._parseList(a.abday,7)}catch(b){throw"Error: Invalid abday property: "+b}try{this.day=this._parseList(a.day,7)}catch(b){throw"Error: Invalid day property: "+b}try{this.abmon=this._parseList(a.abmon,12)}catch(b){throw"Error: Invalid abmon property: "+b}try{this.mon=this._parseList(a.mon,12)}catch(b){throw"Error: Invalid mon property: "+b}try{this.d_fmt=this._validateFormatString(a.d_fmt)}catch(b){throw"Error: Invalid d_fmt property: "+b}try{this.t_fmt=this._validateFormatString(a.t_fmt)}catch(b){throw"Error: Invalid t_fmt property: "+b}try{this.d_t_fmt=this._validateFormatString(a.d_t_fmt)}catch(b){throw"Error: Invalid d_t_fmt property: "+b}try{var c=this._parseList(a.am_pm,2);this.am=c[0];this.pm=c[1]}catch(b){this.am="";this.pm=""}this.getAbbreviatedWeekdayName=function(a){if(typeof a=="undefined"||a===null)return this.abday;if(!jsworld._isInteger(a)||a<0||a>6)throw"Error: Invalid weekday argument, must be an integer [0..6]";return this.abday[a]};this.getWeekdayName=function(a){if(typeof a=="undefined"||a===null)return this.day;if(!jsworld._isInteger(a)||a<0||a>6)throw"Error: Invalid weekday argument, must be an integer [0..6]";return this.day[a]};this.getAbbreviatedMonthName=function(a){if(typeof a=="undefined"||a===null)return this.abmon;if(!jsworld._isInteger(a)||a<0||a>11)throw"Error: Invalid month argument, must be an integer [0..11]";return this.abmon[a]};this.getMonthName=function(a){if(typeof a=="undefined"||a===null)return this.mon;if(!jsworld._isInteger(a)||a<0||a>11)throw"Error: Invalid month argument, must be an integer [0..11]";return this.mon[a]};this.getDecimalPoint=function(){return this.decimal_point};this.getCurrencySymbol=function(){return this.currency_symbol};this.getIntCurrencySymbol=function(){return this.int_curr_symbol.substring(0,3)};this.currencySymbolPrecedes=function(){if(this.p_cs_precedes==1)return true;else return false};this.intCurrencySymbolPrecedes=function(){if(this.int_p_cs_precedes==1)return true;else return false};this.getMonetaryDecimalPoint=function(){return this.mon_decimal_point};this.getFractionalDigits=function(){return this.frac_digits};this.getIntFractionalDigits=function(){return this.int_frac_digits}};jsworld.NumericFormatter=function(a){if(typeof a!="object"||a._className!="jsworld.Locale")throw"Constructor error: You must provide a valid jsworld.Locale instance";this.lc=a;this.format=function(a,b){if(typeof a=="string")a=jsworld._trim(a);if(!jsworld._isNumber(a))throw"Error: The input is not a number";var c=parseFloat(a,10);var d=jsworld._getPrecision(b);if(d!=-1)c=Math.round(c*Math.pow(10,d))/Math.pow(10,d);var e=jsworld._splitNumber(String(c));var f;if(c===0)f="0";else f=jsworld._hasOption("^",b)?e.integer:jsworld._formatIntegerPart(e.integer,this.lc.grouping,this.lc.thousands_sep);var g=d!=-1?jsworld._formatFractionPart(e.fraction,d):e.fraction;var h=g.length?f+this.lc.decimal_point+g:f;if(jsworld._hasOption("~",b)||c===0){return h}else{if(jsworld._hasOption("+",b)||c<0){if(c>0)return"+"+h;else if(c<0)return"-"+h;else return h}else{return h}}}};jsworld.DateTimeFormatter=function(a){if(typeof a!="object"||a._className!="jsworld.Locale")throw"Constructor error: You must provide a valid jsworld.Locale instance.";this.lc=a;this.formatDate=function(a){var b=null;if(typeof a=="string"){try{b=jsworld.parseIsoDate(a)}catch(c){b=jsworld.parseIsoDateTime(a)}}else if(a!==null&&typeof a=="object"){b=a}else{throw"Error: Invalid date argument, must be a Date object or an ISO-8601 date/time string"}return this._applyFormatting(b,this.lc.d_fmt)};this.formatTime=function(a){var b=null;if(typeof a=="string"){try{b=jsworld.parseIsoTime(a)}catch(c){b=jsworld.parseIsoDateTime(a)}}else if(a!==null&&typeof a=="object"){b=a}else{throw"Error: Invalid date argument, must be a Date object or an ISO-8601 date/time string"}return this._applyFormatting(b,this.lc.t_fmt)};this.formatDateTime=function(a){var b=null;if(typeof a=="string"){b=jsworld.parseIsoDateTime(a)}else if(a!==null&&typeof a=="object"){b=a}else{throw"Error: Invalid date argument, must be a Date object or an ISO-8601 date/time string"}return this._applyFormatting(b,this.lc.d_t_fmt)};this._applyFormatting=function(a,b){b=b.replace(/%%/g,"%");b=b.replace(/%a/g,this.lc.abday[a.getDay()]);b=b.replace(/%A/g,this.lc.day[a.getDay()]);b=b.replace(/%b/g,this.lc.abmon[a.getMonth()]);b=b.replace(/%B/g,this.lc.mon[a.getMonth()]);b=b.replace(/%d/g,jsworld._zeroPad(a.getDate(),2));b=b.replace(/%e/g,jsworld._spacePad(a.getDate(),2));b=b.replace(/%F/g,a.getFullYear()+"-"+jsworld._zeroPad(a.getMonth()+1,2)+"-"+jsworld._zeroPad(a.getDate(),2));b=b.replace(/%h/g,this.lc.abmon[a.getMonth()]);b=b.replace(/%H/g,jsworld._zeroPad(a.getHours(),2));b=b.replace(/%I/g,jsworld._zeroPad(this._hours12(a.getHours()),2));b=b.replace(/%k/g,a.getHours());b=b.replace(/%l/g,this._hours12(a.getHours()));b=b.replace(/%m/g,jsworld._zeroPad(a.getMonth()+1,2));b=b.replace(/%n/g,"\n");b=b.replace(/%M/g,jsworld._zeroPad(a.getMinutes(),2));b=b.replace(/%p/g,this._getAmPm(a.getHours()));b=b.replace(/%P/g,this._getAmPm(a.getHours()).toLocaleLowerCase());b=b.replace(/%R/g,jsworld._zeroPad(a.getHours(),2)+":"+jsworld._zeroPad(a.getMinutes(),2));b=b.replace(/%S/g,jsworld._zeroPad(a.getSeconds(),2));b=b.replace(/%T/g,jsworld._zeroPad(a.getHours(),2)+":"+jsworld._zeroPad(a.getMinutes(),2)+":"+jsworld._zeroPad(a.getSeconds(),2));b=b.replace(/%w/g,this.lc.day[a.getDay()]);b=b.replace(/%y/g,(new String(a.getFullYear())).substring(2));b=b.replace(/%Y/g,a.getFullYear());b=b.replace(/%Z/g,"");b=b.replace(/%[a-zA-Z]/g,"");return b};this._hours12=function(a){if(a===0)return 12;else if(a>12)return a-12;else return a};this._getAmPm=function(a){if(a===0||a>12)return this.lc.pm;else return this.lc.am}};jsworld.MonetaryFormatter=function(a,b,c){if(typeof a!="object"||a._className!="jsworld.Locale")throw"Constructor error: You must provide a valid jsworld.Locale instance";this.lc=a;this.currencyFractionDigits={AFN:0,ALL:0,AMD:0,BHD:3,BIF:0,BYR:0,CLF:0,CLP:0,COP:0,CRC:0,DJF:0,GNF:0,GYD:0,HUF:0,IDR:0,IQD:0,IRR:0,ISK:0,JOD:3,JPY:0,KMF:0,KRW:0,KWD:3,LAK:0,LBP:0,LYD:3,MGA:0,MMK:0,MNT:0,MRO:0,MUR:0,OMR:3,PKR:0,PYG:0,RSD:0,RWF:0,SLL:0,SOS:0,STD:0,SYP:0,TND:3,TWD:0,TZS:0,UGX:0,UZS:0,VND:0,VUV:0,XAF:0,XOF:0,XPF:0,YER:0,ZMK:0};if(typeof b=="string"){this.currencyCode=b.toUpperCase();var d=this.currencyFractionDigits[this.currencyCode];if(typeof d!="number")d=2;this.lc.frac_digits=d;this.lc.int_frac_digits=d}else{this.currencyCode=this.lc.int_curr_symbol.substring(0,3).toUpperCase()}this.intSep=this.lc.int_curr_symbol.charAt(3);if(this.currencyCode==this.lc.int_curr_symbol.substring(0,3)){this.internationalFormatting=false;this.curSym=this.lc.currency_symbol}else{if(typeof c=="string"){this.curSym=c;this.internationalFormatting=false}else{this.internationalFormatting=true}}this.getCurrencySymbol=function(){return this.curSym};this.currencySymbolPrecedes=function(a){if(typeof a=="string"&&a=="i"){if(this.lc.int_p_cs_precedes==1)return true;else return false}else{if(this.internationalFormatting){if(this.lc.int_p_cs_precedes==1)return true;else return false}else{if(this.lc.p_cs_precedes==1)return true;else return false}}};this.getDecimalPoint=function(){return this.lc.mon_decimal_point};this.getFractionalDigits=function(a){if(typeof a=="string"&&a=="i"){return this.lc.int_frac_digits}else{if(this.internationalFormatting)return this.lc.int_frac_digits;else return this.lc.frac_digits}};this.format=function(a,b){var c;if(typeof a=="string"){a=jsworld._trim(a);c=parseFloat(a);if(typeof c!="number"||isNaN(c))throw"Error: Amount string not a number"}else if(typeof a=="number"){c=a}else{throw"Error: Amount not a number"}var d=jsworld._getPrecision(b);if(d==-1){if(this.internationalFormatting||jsworld._hasOption("i",b))d=this.lc.int_frac_digits;else d=this.lc.frac_digits}c=Math.round(c*Math.pow(10,d))/Math.pow(10,d);var e=jsworld._splitNumber(String(c));var f;if(c===0)f="0";else f=jsworld._hasOption("^",b)?e.integer:jsworld._formatIntegerPart(e.integer,this.lc.mon_grouping,this.lc.mon_thousands_sep);var g;if(d==-1){if(this.internationalFormatting||jsworld._hasOption("i",b))g=jsworld._formatFractionPart(e.fraction,this.lc.int_frac_digits);else g=jsworld._formatFractionPart(e.fraction,this.lc.frac_digits)}else{g=jsworld._formatFractionPart(e.fraction,d)}var h;if(this.lc.frac_digits>0||g.length)h=f+this.lc.mon_decimal_point+g;else h=f;if(jsworld._hasOption("~",b)){return h}else{var i=jsworld._hasOption("!",b)?true:false;var j=c<0?"-":"+";if(this.internationalFormatting||jsworld._hasOption("i",b)){if(i)return this._formatAsInternationalCurrencyWithNoSym(j,h);else return this._formatAsInternationalCurrency(j,h)}else{if(i)return this._formatAsLocalCurrencyWithNoSym(j,h);else return this._formatAsLocalCurrency(j,h)}}};this._formatAsLocalCurrency=function(a,b){if(a=="+"){if(this.lc.p_sign_posn===0&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return"("+b+this.curSym+")"}else if(this.lc.p_sign_posn===0&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return"("+this.curSym+b+")"}else if(this.lc.p_sign_posn===0&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return"("+b+" "+this.curSym+")"}else if(this.lc.p_sign_posn===0&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return"("+this.curSym+" "+b+")"}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return this.lc.positive_sign+b+this.curSym}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+this.curSym+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return this.lc.positive_sign+b+" "+this.curSym}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+this.curSym+" "+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return this.lc.positive_sign+" "+b+this.curSym}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+" "+this.curSym+b}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return b+this.curSym+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.curSym+b+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return b+" "+this.curSym+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.curSym+" "+b+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return b+this.curSym+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.curSym+b+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign+this.curSym}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+this.curSym+b}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return b+" "+this.lc.positive_sign+this.curSym}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+this.curSym+" "+b}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign+" "+this.curSym}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+" "+this.curSym+b}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return b+this.curSym+this.lc.positive_sign}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.curSym+this.lc.positive_sign+b}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return b+" "+this.curSym+this.lc.positive_sign}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.curSym+this.lc.positive_sign+" "+b}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return b+this.curSym+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.curSym+" "+this.lc.positive_sign+b}}else if(a=="-"){if(this.lc.n_sign_posn===0&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return"("+b+this.curSym+")"}else if(this.lc.n_sign_posn===0&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return"("+this.curSym+b+")"}else if(this.lc.n_sign_posn===0&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return"("+b+" "+this.curSym+")"}else if(this.lc.n_sign_posn===0&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return"("+this.curSym+" "+b+")"}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return this.lc.negative_sign+b+this.curSym}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+this.curSym+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return this.lc.negative_sign+b+" "+this.curSym}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+this.curSym+" "+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return this.lc.negative_sign+" "+b+this.curSym}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+this.curSym+b}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return b+this.curSym+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.curSym+b+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return b+" "+this.curSym+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.curSym+" "+b+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return b+this.curSym+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.curSym+b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return b+this.lc.negative_sign+this.curSym}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+this.curSym+b}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return b+" "+this.lc.negative_sign+this.curSym}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+this.curSym+" "+b}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return b+this.lc.negative_sign+" "+this.curSym}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+this.curSym+b}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return b+this.curSym+this.lc.negative_sign}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.curSym+this.lc.negative_sign+b}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return b+" "+this.curSym+this.lc.negative_sign}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.curSym+this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return b+this.curSym+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.curSym+" "+this.lc.negative_sign+b}}throw"Error: Invalid POSIX LC MONETARY definition"};this._formatAsInternationalCurrency=function(a,b){if(a=="+"){if(this.lc.int_p_sign_posn===0&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return"("+b+this.currencyCode+")"}else if(this.lc.int_p_sign_posn===0&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return"("+this.currencyCode+b+")"}else if(this.lc.int_p_sign_posn===0&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return"("+b+this.intSep+this.currencyCode+")"}else if(this.lc.int_p_sign_posn===0&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return"("+this.currencyCode+this.intSep+b+")"}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return this.lc.positive_sign+b+this.currencyCode}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.currencyCode+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return this.lc.positive_sign+b+this.intSep+this.currencyCode}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.currencyCode+this.intSep+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return this.lc.positive_sign+this.intSep+b+this.currencyCode}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+this.currencyCode+b}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return b+this.currencyCode+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.currencyCode+b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.currencyCode+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.currencyCode+this.intSep+b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return b+this.currencyCode+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.currencyCode+b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return b+this.lc.positive_sign+this.currencyCode}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.currencyCode+b}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.lc.positive_sign+this.currencyCode}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.currencyCode+this.intSep+b}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return b+this.lc.positive_sign+this.intSep+this.currencyCode}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+this.currencyCode+b}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return b+this.currencyCode+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.currencyCode+this.lc.positive_sign+b}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.currencyCode+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.currencyCode+this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return b+this.currencyCode+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.currencyCode+this.intSep+this.lc.positive_sign+b}}else if(a=="-"){if(this.lc.int_n_sign_posn===0&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return"("+b+this.currencyCode+")"}else if(this.lc.int_n_sign_posn===0&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return"("+this.currencyCode+b+")"}else if(this.lc.int_n_sign_posn===0&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return"("+b+this.intSep+this.currencyCode+")"}else if(this.lc.int_n_sign_posn===0&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return"("+this.currencyCode+this.intSep+b+")"}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return this.lc.negative_sign+b+this.currencyCode}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.currencyCode+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return this.lc.negative_sign+b+this.intSep+this.currencyCode}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.currencyCode+this.intSep+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return this.lc.negative_sign+this.intSep+b+this.currencyCode}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+this.currencyCode+b}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return b+this.currencyCode+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.currencyCode+b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.currencyCode+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.currencyCode+this.intSep+b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return b+this.currencyCode+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.currencyCode+b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return b+this.lc.negative_sign+this.currencyCode}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.currencyCode+b}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.lc.negative_sign+this.currencyCode}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.currencyCode+this.intSep+b}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return b+this.lc.negative_sign+this.intSep+this.currencyCode}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+this.currencyCode+b}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return b+this.currencyCode+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.currencyCode+this.lc.negative_sign+b}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.currencyCode+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.currencyCode+this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return b+this.currencyCode+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.currencyCode+this.intSep+this.lc.negative_sign+b}}throw"Error: Invalid POSIX LC MONETARY definition"};this._formatAsLocalCurrencyWithNoSym=function(a,b){if(a=="+"){if(this.lc.p_sign_posn===0){return"("+b+")"}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return this.lc.positive_sign+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return this.lc.positive_sign+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return this.lc.positive_sign+" "+b}else if(this.lc.p_sign_posn===1&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+" "+b}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return b+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===2&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return b+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return b+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+" "+b}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===3&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+" "+b}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===0&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===0){return b+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===1&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+" "+b}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===0){return b+" "+this.lc.positive_sign}else if(this.lc.p_sign_posn===4&&this.lc.p_sep_by_space===2&&this.lc.p_cs_precedes===1){return this.lc.positive_sign+b}}else if(a=="-"){if(this.lc.n_sign_posn===0){return"("+b+")"}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return this.lc.negative_sign+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return this.lc.negative_sign+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===1&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return b+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return b+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===2&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+b}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.n_sign_posn===3&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===0&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+b}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===0){return b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===1&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+" "+b}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===0){return b+" "+this.lc.negative_sign}else if(this.lc.n_sign_posn===4&&this.lc.n_sep_by_space===2&&this.lc.n_cs_precedes===1){return this.lc.negative_sign+b}}throw"Error: Invalid POSIX LC MONETARY definition"};this._formatAsInternationalCurrencyWithNoSym=function(a,b){if(a=="+"){if(this.lc.int_p_sign_posn===0){return"("+b+")"}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return this.lc.positive_sign+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return this.lc.positive_sign+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===1&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===2&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===3&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===0){return b+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===0&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+b}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===1&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+this.intSep+b}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===0){return b+this.intSep+this.lc.positive_sign}else if(this.lc.int_p_sign_posn===4&&this.lc.int_p_sep_by_space===2&&this.lc.int_p_cs_precedes===1){return this.lc.positive_sign+b}}else if(a=="-"){if(this.lc.int_n_sign_posn===0){return"("+b+")"}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return this.lc.negative_sign+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return this.lc.negative_sign+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===1&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===2&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+b}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===3&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===0){return b+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===0&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+b}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===1&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+this.intSep+b}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===0){return b+this.intSep+this.lc.negative_sign}else if(this.lc.int_n_sign_posn===4&&this.lc.int_n_sep_by_space===2&&this.lc.int_n_cs_precedes===1){return this.lc.negative_sign+b}}throw"Error: Invalid POSIX LC_MONETARY definition"}};jsworld.NumericParser=function(a){if(typeof a!="object"||a._className!="jsworld.Locale")throw"Constructor error: You must provide a valid jsworld.Locale instance";this.lc=a;this.parse=function(a){if(typeof a!="string")throw"Parse error: Argument must be a string";var b=jsworld._trim(a);b=jsworld._stringReplaceAll(a,this.lc.thousands_sep,"");b=jsworld._stringReplaceAll(b,this.lc.decimal_point,".");if(jsworld._isNumber(b))return parseFloat(b,10);else throw"Parse error: Invalid number string"}};jsworld.DateTimeParser=function(a){if(typeof a!="object"||a._className!="jsworld.Locale")throw"Constructor error: You must provide a valid jsworld.Locale instance.";this.lc=a;this.parseTime=function(a){if(typeof a!="string")throw"Parse error: Argument must be a string";var b=this._extractTokens(this.lc.t_fmt,a);var c=false;if(b.hour!==null&&b.minute!==null&&b.second!==null){c=true}else if(b.hourAmPm!==null&&b.am!==null&&b.minute!==null&&b.second!==null){if(b.am){b.hour=parseInt(b.hourAmPm,10)}else{if(b.hourAmPm==12)b.hour=0;else b.hour=parseInt(b.hourAmPm,10)+12}c=true}if(c)return jsworld._zeroPad(b.hour,2)+":"+jsworld._zeroPad(b.minute,2)+":"+jsworld._zeroPad(b.second,2);else throw"Parse error: Invalid/ambiguous time string"};this.parseDate=function(a){if(typeof a!="string")throw"Parse error: Argument must be a string";var b=this._extractTokens(this.lc.d_fmt,a);var c=false;if(b.year!==null&&b.month!==null&&b.day!==null){c=true}if(c)return jsworld._zeroPad(b.year,4)+"-"+jsworld._zeroPad(b.month,2)+"-"+jsworld._zeroPad(b.day,2);else throw"Parse error: Invalid date string"};this.parseDateTime=function(a){if(typeof a!="string")throw"Parse error: Argument must be a string";var b=this._extractTokens(this.lc.d_t_fmt,a);var c=false;var d=false;if(b.hour!==null&&b.minute!==null&&b.second!==null){c=true}else if(b.hourAmPm!==null&&b.am!==null&&b.minute!==null&&b.second!==null){if(b.am){b.hour=parseInt(b.hourAmPm,10)}else{if(b.hourAmPm==12)b.hour=0;else b.hour=parseInt(b.hourAmPm,10)+12}c=true}if(b.year!==null&&b.month!==null&&b.day!==null){d=true}if(d&&c)return jsworld._zeroPad(b.year,4)+"-"+jsworld._zeroPad(b.month,2)+"-"+jsworld._zeroPad(b.day,2)+" "+jsworld._zeroPad(b.hour,2)+":"+jsworld._zeroPad(b.minute,2)+":"+jsworld._zeroPad(b.second,2);else throw"Parse error: Invalid/ambiguous date/time string"};this._extractTokens=function(a,b){var c={year:null,month:null,day:null,hour:null,hourAmPm:null,am:null,minute:null,second:null,weekday:null};while(a.length>0){if(a.charAt(0)=="%"&&a.charAt(1)!=""){var d=a.substring(0,2);if(d=="%%"){b=b.substring(1)}else if(d=="%a"){for(var e=0;e31)throw"Parse error: Unrecognised day of the month (%e)";b=b.substring(f.length)}else if(d=="%F"){if(/^\d\d\d\d/.test(b)){c.year=parseInt(b.substring(0,4),10);b=b.substring(4)}else{throw"Parse error: Unrecognised date (%F)"}if(jsworld._stringStartsWith(b,"-"))b=b.substring(1);else throw"Parse error: Unrecognised date (%F)";if(/^0[1-9]|1[0-2]/.test(b)){c.month=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised date (%F)";if(jsworld._stringStartsWith(b,"-"))b=b.substring(1);else throw"Parse error: Unrecognised date (%F)";if(/^0[1-9]|[1-2][0-9]|3[0-1]/.test(b)){c.day=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised date (%F)"}else if(d=="%H"){if(/^[0-1][0-9]|2[0-3]/.test(b)){c.hour=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised hour (%H)"}else if(d=="%I"){if(/^0[1-9]|1[0-2]/.test(b)){c.hourAmPm=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised hour (%I)"}else if(d=="%k"){var g=b.match(/^(\d{1,2})/);c.hour=parseInt(g,10);if(isNaN(c.hour)||c.hour<0||c.hour>23)throw"Parse error: Unrecognised hour (%k)";b=b.substring(g.length)}else if(d=="%l"){var g=b.match(/^(\d{1,2})/);c.hourAmPm=parseInt(g,10);if(isNaN(c.hourAmPm)||c.hourAmPm<1||c.hourAmPm>12)throw"Parse error: Unrecognised hour (%l)";b=b.substring(g.length)}else if(d=="%m"){if(/^0[1-9]|1[0-2]/.test(b)){c.month=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised month (%m)"}else if(d=="%M"){if(/^[0-5][0-9]/.test(b)){c.minute=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised minute (%M)"}else if(d=="%n"){if(b.charAt(0)=="\n")b=b.substring(1);else throw"Parse error: Unrecognised new line (%n)"}else if(d=="%p"){if(jsworld._stringStartsWith(b,this.lc.am)){c.am=true;b=b.substring(this.lc.am.length)}else if(jsworld._stringStartsWith(b,this.lc.pm)){c.am=false;b=b.substring(this.lc.pm.length)}else throw"Parse error: Unrecognised AM/PM value (%p)"}else if(d=="%P"){if(jsworld._stringStartsWith(b,this.lc.am.toLowerCase())){c.am=true;b=b.substring(this.lc.am.length)}else if(jsworld._stringStartsWith(b,this.lc.pm.toLowerCase())){c.am=false;b=b.substring(this.lc.pm.length)}else throw"Parse error: Unrecognised AM/PM value (%P)"}else if(d=="%R"){if(/^[0-1][0-9]|2[0-3]/.test(b)){c.hour=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised time (%R)";if(jsworld._stringStartsWith(b,":"))b=b.substring(1);else throw"Parse error: Unrecognised time (%R)";if(/^[0-5][0-9]/.test(b)){c.minute=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised time (%R)"}else if(d=="%S"){if(/^[0-5][0-9]/.test(b)){c.second=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised second (%S)"}else if(d=="%T"){if(/^[0-1][0-9]|2[0-3]/.test(b)){c.hour=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised time (%T)";if(jsworld._stringStartsWith(b,":"))b=b.substring(1);else throw"Parse error: Unrecognised time (%T)";if(/^[0-5][0-9]/.test(b)){c.minute=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised time (%T)";if(jsworld._stringStartsWith(b,":"))b=b.substring(1);else throw"Parse error: Unrecognised time (%T)";if(/^[0-5][0-9]/.test(b)){c.second=parseInt(b.substring(0,2),10);b=b.substring(2)}else throw"Parse error: Unrecognised time (%T)"}else if(d=="%w"){if(/^\d/.test(b)){c.weekday=parseInt(b.substring(0,1),10);b=b.substring(1)}else throw"Parse error: Unrecognised weekday number (%w)"}else if(d=="%y"){if(/^\d\d/.test(b)){var h=parseInt(b.substring(0,2),10);if(h>50)c.year=1900+h;else c.year=2e3+h;b=b.substring(2)}else throw"Parse error: Unrecognised year (%y)"}else if(d=="%Y"){if(/^\d\d\d\d/.test(b)){c.year=parseInt(b.substring(0,4),10);b=b.substring(4)}else throw"Parse error: Unrecognised year (%Y)"}else if(d=="%Z"){if(a.length===0)break}a=a.substring(2)}else{if(a.charAt(0)!=b.charAt(0))throw'Parse error: Unexpected symbol "'+b.charAt(0)+'" in date/time string';a=a.substring(1);b=b.substring(1)}}return c}};jsworld.MonetaryParser=function(a){if(typeof a!="object"||a._className!="jsworld.Locale")throw"Constructor error: You must provide a valid jsworld.Locale instance";this.lc=a;this.parse=function(a){if(typeof a!="string")throw"Parse error: Argument must be a string";var b=this._detectCurrencySymbolType(a);var c,d;if(b=="local"){c="local";d=a.replace(this.lc.getCurrencySymbol(),"")}else if(b=="int"){c="int";d=a.replace(this.lc.getIntCurrencySymbol(),"")}else if(b=="none"){c="local";d=a}else throw"Parse error: Internal assert failure";d=jsworld._stringReplaceAll(d,this.lc.mon_thousands_sep,"");d=d.replace(this.lc.mon_decimal_point,".");d=d.replace(/\s*/g,"");d=this._removeLocalNonNegativeSign(d,c);d=this._normaliseNegativeSign(d,c);if(jsworld._isNumber(d))return parseFloat(d,10);else throw"Parse error: Invalid currency amount string"};this._detectCurrencySymbolType=function(a){if(this.lc.getCurrencySymbol().length>this.lc.getIntCurrencySymbol().length){if(a.indexOf(this.lc.getCurrencySymbol())!=-1)return"local";else if(a.indexOf(this.lc.getIntCurrencySymbol())!=-1)return"int";else return"none"}else{if(a.indexOf(this.lc.getIntCurrencySymbol())!=-1)return"int";else if(a.indexOf(this.lc.getCurrencySymbol())!=-1)return"local";else return"none"}};this._removeLocalNonNegativeSign=function(a,b){a=a.replace(this.lc.positive_sign,"");if((b=="local"&&this.lc.p_sign_posn===0||b=="int"&&this.lc.int_p_sign_posn===0)&&/\(\d+\.?\d*\)/.test(a)){a=a.replace("(","");a=a.replace(")","")}return a};this._normaliseNegativeSign=function(a,b){a=a.replace(this.lc.negative_sign,"-");if(b=="local"&&this.lc.n_sign_posn===0||b=="int"&&this.lc.int_n_sign_posn===0){if(/^\(\d+\.?\d*\)$/.test(a)){a=a.replace("(","");a=a.replace(")","");return"-"+a}}if(b=="local"&&this.lc.n_sign_posn==2||b=="int"&&this.lc.int_n_sign_posn==2){if(/^\d+\.?\d*-$/.test(a)){a=a.replace("-","");return"-"+a}}if(b=="local"&&this.lc.n_cs_precedes===0&&this.lc.n_sign_posn==3||b=="local"&&this.lc.n_cs_precedes===0&&this.lc.n_sign_posn==4||b=="int"&&this.lc.int_n_cs_precedes===0&&this.lc.int_n_sign_posn==3||b=="int"&&this.lc.int_n_cs_precedes===0&&this.lc.int_n_sign_posn==4){if(/^\d+\.?\d*-$/.test(a)){a=a.replace("-","");return"-"+a}}return a}}
+
+
+if(typeof POSIX_LC == "undefined") var POSIX_LC = {};
+
+POSIX_LC.en_US = {
+ "decimal_point" : ".",
+ "thousands_sep" : ",",
+ "grouping" : "3",
+ "abday" : ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],
+ "day" : ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],
+ "abmon" : ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],
+ "mon" : ["January","February","March","April","May","June","July","August","September","October","November","December"],
+ "d_fmt" : "%m/%e/%y",
+ "t_fmt" : "%I:%M:%S %p",
+ "d_t_fmt" : "%B %e, %Y %I:%M:%S %p %Z",
+ "am_pm" : ["AM","PM"],
+ "int_curr_symbol" : "USD ",
+ "currency_symbol" : "\u0024",
+ "mon_decimal_point" : ".",
+ "mon_thousands_sep" : ",",
+ "mon_grouping" : "3",
+ "positive_sign" : "",
+ "negative_sign" : "-",
+ "int_frac_digits" : 2,
+ "frac_digits" : 2,
+ "p_cs_precedes" : 1,
+ "n_cs_precedes" : 1,
+ "p_sep_by_space" : 0,
+ "n_sep_by_space" : 0,
+ "p_sign_posn" : 1,
+ "n_sign_posn" : 1,
+ "int_p_cs_precedes" : 1,
+ "int_n_cs_precedes" : 1,
+ "int_p_sep_by_space" : 0,
+ "int_n_sep_by_space" : 0,
+ "int_p_sign_posn" : 1,
+ "int_n_sign_posn" : 1
+}
+
+if(typeof POSIX_LC == "undefined") var POSIX_LC = {};
+
+POSIX_LC.fr_FR = {
+ "decimal_point" : ",",
+ "thousands_sep" : "\u00a0",
+ "grouping" : "3",
+ "abday" : ["dim.","lun.","mar.",
+ "mer.","jeu.","ven.",
+ "sam."],
+ "day" : ["dimanche","lundi","mardi",
+ "mercredi","jeudi","vendredi",
+ "samedi"],
+ "abmon" : ["janv.","f\u00e9vr.","mars",
+ "avr.","mai","juin",
+ "juil.","ao\u00fbt","sept.",
+ "oct.","nov.","d\u00e9c."],
+ "mon" : ["janvier","f\u00e9vrier","mars",
+ "avril","mai","juin",
+ "juillet","ao\u00fbt","septembre",
+ "octobre","novembre","d\u00e9cembre"],
+ "d_fmt" : "%d/%m/%y",
+ "t_fmt" : "%H:%M:%S",
+ "d_t_fmt" : "%e %B %Y %H:%M:%S %Z",
+ "am_pm" : ["AM","PM"],
+ "int_curr_symbol" : "EUR ",
+ "currency_symbol" : "\u20ac",
+ "mon_decimal_point" : ",",
+ "mon_thousands_sep" : "\u00a0",
+ "mon_grouping" : "3",
+ "positive_sign" : "",
+ "negative_sign" : "-",
+ "int_frac_digits" : 2,
+ "frac_digits" : 2,
+ "p_cs_precedes" : 0,
+ "n_cs_precedes" : 0,
+ "p_sep_by_space" : 1,
+ "n_sep_by_space" : 1,
+ "p_sign_posn" : 1,
+ "n_sign_posn" : 1,
+ "int_p_cs_precedes" : 0,
+ "int_n_cs_precedes" : 0,
+ "int_p_sep_by_space" : 1,
+ "int_n_sep_by_space" : 1,
+ "int_p_sign_posn" : 1,
+ "int_n_sign_posn" : 1
+};
+
+/** https://github.com/csnover/js-iso8601 */(function(n,f){var u=n.parse,c=[1,4,5,6,7,10,11];n.parse=function(t){var i,o,a=0;if(o=/^(\d{4}|[+\-]\d{6})(?:-(\d{2})(?:-(\d{2}))?)?(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{3}))?)?(?:(Z)|([+\-])(\d{2})(?::(\d{2}))?)?)?$/.exec(t)){for(var v=0,r;r=c[v];++v)o[r]=+o[r]||0;o[2]=(+o[2]||1)-1,o[3]=+o[3]||1,o[8]!=="Z"&&o[9]!==f&&(a=o[10]*60+o[11],o[9]==="+"&&(a=0-a)),i=n.UTC(o[1],o[2],o[3],o[4],o[5]+a,o[6],o[7])}else i=u?u(t):NaN;return i}})(Date)
+
+/*!
+ * geo-location-javascript v0.4.3
+ * http://code.google.com/p/geo-location-javascript/
+ *
+ * Copyright (c) 2009 Stan Wiechers
+ * Licensed under the MIT licenses.
+ *
+ * Revision: $Rev: 68 $:
+ * Author: $Author: whoisstan $:
+ * Date: $Date: 2010-02-15 13:42:19 +0100 (Mon, 15 Feb 2010) $:
+ */
+var geo_position_js=function() {
+
+ var pub = {};
+ var provider=null;
+
+ pub.getCurrentPosition = function(successCallback,errorCallback,options)
+ {
+ provider.getCurrentPosition(successCallback, errorCallback,options);
+ }
+
+ pub.init = function()
+ {
+ try
+ {
+ if (typeof(geo_position_js_simulator)!="undefined")
+ {
+ provider=geo_position_js_simulator;
+ }
+ else if (typeof(bondi)!="undefined" && typeof(bondi.geolocation)!="undefined")
+ {
+ provider=bondi.geolocation;
+ }
+ else if (typeof(navigator.geolocation)!="undefined")
+ {
+ provider=navigator.geolocation;
+ pub.getCurrentPosition = function(successCallback, errorCallback, options)
+ {
+ function _successCallback(p)
+ {
+ //for mozilla geode,it returns the coordinates slightly differently
+ if(typeof(p.latitude)!="undefined")
+ {
+ successCallback({timestamp:p.timestamp, coords: {latitude:p.latitude,longitude:p.longitude}});
+ }
+ else
+ {
+ successCallback(p);
+ }
+ }
+ provider.getCurrentPosition(_successCallback,errorCallback,options);
+ }
+ }
+ else if(typeof(window.google)!="undefined" && typeof(google.gears)!="undefined")
+ {
+ provider=google.gears.factory.create('beta.geolocation');
+ }
+ else if ( typeof(Mojo) !="undefined" && typeof(Mojo.Service.Request)!="Mojo.Service.Request")
+ {
+ provider=true;
+ pub.getCurrentPosition = function(successCallback, errorCallback, options)
+ {
+
+ parameters={};
+ if(options)
+ {
+ //http://developer.palm.com/index.php?option=com_content&view=article&id=1673#GPS-getCurrentPosition
+ if (options.enableHighAccuracy && options.enableHighAccuracy==true)
+ {
+ parameters.accuracy=1;
+ }
+ if (options.maximumAge)
+ {
+ parameters.maximumAge=options.maximumAge;
+ }
+ if (options.responseTime)
+ {
+ if(options.responseTime<5)
+ {
+ parameters.responseTime=1;
+ }
+ else if (options.responseTime<20)
+ {
+ parameters.responseTime=2;
+ }
+ else
+ {
+ parameters.timeout=3;
+ }
+ }
+ }
+
+
+ r=new Mojo.Service.Request('palm://com.palm.location', {
+ method:"getCurrentPosition",
+ parameters:parameters,
+ onSuccess: function(p){successCallback({timestamp:p.timestamp, coords: {latitude:p.latitude, longitude:p.longitude,heading:p.heading}});},
+ onFailure: function(e){
+ if (e.errorCode==1)
+ {
+ errorCallback({code:3,message:"Timeout"});
+ }
+ else if (e.errorCode==2)
+ {
+ errorCallback({code:2,message:"Position Unavailable"});
+ }
+ else
+ {
+ errorCallback({code:0,message:"Unknown Error: webOS-code"+errorCode});
+ }
+ }
+ });
+ }
+
+ }
+ else if (typeof(device)!="undefined" && typeof(device.getServiceObject)!="undefined")
+ {
+ provider=device.getServiceObject("Service.Location", "ILocation");
+
+ //override default method implementation
+ pub.getCurrentPosition = function(successCallback, errorCallback, options)
+ {
+ function callback(transId, eventCode, result) {
+ if (eventCode == 4)
+ {
+ errorCallback({message:"Position unavailable", code:2});
+ }
+ else
+ {
+ //no timestamp of location given?
+ successCallback({timestamp:null, coords: {latitude:result.ReturnValue.Latitude, longitude:result.ReturnValue.Longitude, altitude:result.ReturnValue.Altitude,heading:result.ReturnValue.Heading}});
+ }
+ }
+ //location criteria
+ var criteria = new Object();
+ criteria.LocationInformationClass = "BasicLocationInformation";
+ //make the call
+ provider.ILocation.GetLocation(criteria,callback);
+ }
+ }
+ }
+ catch (e){
+ alert("error="+e);
+ if(typeof(console)!="undefined")
+ {
+ console.log(e);
+ }
+ return false;
+ }
+ return provider!=null;
+ }
+
+
+ return pub;
+}();
+// Couldn't get unminified version to work , go here for docs => https://github.com/iamnoah/writeCapture
+(function(E,a){var j=a.document;function A(Q){var Z=j.createElement("div");j.body.insertBefore(Z,null);E.replaceWith(Z,'\n \n
Javascript library for localised formatting and parsing of:
+ *
+ *
Numbers
+ *
Dates and times
+ *
Currency
+ *
+ *
+ *
The library classes are configured with standard POSIX locale definitions
+ * derived from Unicode's Common Locale Data Repository (CLDR).
+ *
+ *
Website: JsWorld
+ *
+ * @author Vladimir Dzhuvinov
+ * @version 2.5 (2011-12-23)
+ */
+
+
+
+/**
+ * @namespace Namespace container for the JsWorld library objects.
+ */
+jsworld = {};
+
+
+/**
+ * @function
+ *
+ * @description Formats a JavaScript Date object as an ISO-8601 date/time
+ * string.
+ *
+ * @param {Date} [d] A valid JavaScript Date object. If undefined the
+ * current date/time will be used.
+ * @param {Boolean} [withTZ] Include timezone offset, default false.
+ *
+ * @returns {String} The date/time formatted as YYYY-MM-DD HH:MM:SS.
+ */
+jsworld.formatIsoDateTime = function(d, withTZ) {
+
+ if (typeof d === "undefined")
+ d = new Date(); // now
+
+ if (typeof withTZ === "undefined")
+ withTZ = false;
+
+ var s = jsworld.formatIsoDate(d) + " " + jsworld.formatIsoTime(d);
+
+ if (withTZ) {
+
+ var diff = d.getHours() - d.getUTCHours();
+ var hourDiff = Math.abs(diff);
+
+ var minuteUTC = d.getUTCMinutes();
+ var minute = d.getMinutes();
+
+ if (minute != minuteUTC && minuteUTC < 30 && diff < 0)
+ hourDiff--;
+
+ if (minute != minuteUTC && minuteUTC > 30 && diff > 0)
+ hourDiff--;
+
+ var minuteDiff;
+ if (minute != minuteUTC)
+ minuteDiff = ":30";
+ else
+ minuteDiff = ":00";
+
+ var timezone;
+ if (hourDiff < 10)
+ timezone = "0" + hourDiff + minuteDiff;
+
+ else
+ timezone = "" + hourDiff + minuteDiff;
+
+ if (diff < 0)
+ timezone = "-" + timezone;
+
+ else
+ timezone = "+" + timezone;
+
+ s = s + timezone;
+ }
+
+ return s;
+};
+
+
+/**
+ * @function
+ *
+ * @description Formats a JavaScript Date object as an ISO-8601 date string.
+ *
+ * @param {Date} [d] A valid JavaScript Date object. If undefined the current
+ * date will be used.
+ *
+ * @returns {String} The date formatted as YYYY-MM-DD.
+ */
+jsworld.formatIsoDate = function(d) {
+
+ if (typeof d === "undefined")
+ d = new Date(); // now
+
+ var year = d.getFullYear();
+ var month = d.getMonth() + 1;
+ var day = d.getDate();
+
+ return year + "-" + jsworld._zeroPad(month, 2) + "-" + jsworld._zeroPad(day, 2);
+};
+
+
+/**
+ * @function
+ *
+ * @description Formats a JavaScript Date object as an ISO-8601 time string.
+ *
+ * @param {Date} [d] A valid JavaScript Date object. If undefined the current
+ * time will be used.
+ *
+ * @returns {String} The time formatted as HH:MM:SS.
+ */
+jsworld.formatIsoTime = function(d) {
+
+ if (typeof d === "undefined")
+ d = new Date(); // now
+
+ var hour = d.getHours();
+ var minute = d.getMinutes();
+ var second = d.getSeconds();
+
+ return jsworld._zeroPad(hour, 2) + ":" + jsworld._zeroPad(minute, 2) + ":" + jsworld._zeroPad(second, 2);
+};
+
+
+/**
+ * @function
+ *
+ * @description Parses an ISO-8601 formatted date/time string to a JavaScript
+ * Date object.
+ *
+ * @param {String} isoDateTimeVal An ISO-8601 formatted date/time string.
+ *
+ *
Accepted formats:
+ *
+ *
+ *
YYYY-MM-DD HH:MM:SS
+ *
YYYYMMDD HHMMSS
+ *
YYYY-MM-DD HHMMSS
+ *
YYYYMMDD HH:MM:SS
+ *
+ *
+ * @returns {Date} The corresponding Date object.
+ *
+ * @throws Error on a badly formatted date/time string or on a invalid date.
+ */
+jsworld.parseIsoDateTime = function(isoDateTimeVal) {
+
+ if (typeof isoDateTimeVal != "string")
+ throw "Error: The parameter must be a string";
+
+ // First, try to match "YYYY-MM-DD HH:MM:SS" format
+ var matches = isoDateTimeVal.match(/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d):(\d\d)/);
+
+ // If unsuccessful, try to match "YYYYMMDD HHMMSS" format
+ if (matches === null)
+ matches = isoDateTimeVal.match(/^(\d\d\d\d)(\d\d)(\d\d)[T ](\d\d)(\d\d)(\d\d)/);
+
+ // ... try to match "YYYY-MM-DD HHMMSS" format
+ if (matches === null)
+ matches = isoDateTimeVal.match(/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d)(\d\d)(\d\d)/);
+
+ // ... try to match "YYYYMMDD HH:MM:SS" format
+ if (matches === null)
+ matches = isoDateTimeVal.match(/^(\d\d\d\d)-(\d\d)-(\d\d)[T ](\d\d):(\d\d):(\d\d)/);
+
+ // Report bad date/time string
+ if (matches === null)
+ throw "Error: Invalid ISO-8601 date/time string";
+
+ // Force base 10 parse int as some values may have leading zeros!
+ // (to avoid implicit octal base conversion)
+ var year = parseInt(matches[1], 10);
+ var month = parseInt(matches[2], 10);
+ var day = parseInt(matches[3], 10);
+
+ var hour = parseInt(matches[4], 10);
+ var mins = parseInt(matches[5], 10);
+ var secs = parseInt(matches[6], 10);
+
+ // Simple value range check, leap years not checked
+ // Note: the originial ISO time spec for leap hours (24:00:00) and seconds (00:00:60) is not supported
+ if (month < 1 || month > 12 ||
+ day < 1 || day > 31 ||
+ hour < 0 || hour > 23 ||
+ mins < 0 || mins > 59 ||
+ secs < 0 || secs > 59 )
+
+ throw "Error: Invalid ISO-8601 date/time value";
+
+ var d = new Date(year, month - 1, day, hour, mins, secs);
+
+ // Check if the input date was valid
+ // (JS Date does automatic forward correction)
+ if (d.getDate() != day || d.getMonth() +1 != month)
+ throw "Error: Invalid date";
+
+ return d;
+};
+
+
+/**
+ * @function
+ *
+ * @description Parses an ISO-8601 formatted date string to a JavaScript
+ * Date object.
+ *
+ * @param {String} isoDateVal An ISO-8601 formatted date string.
+ *
+ *
Accepted formats:
+ *
+ *
+ *
YYYY-MM-DD
+ *
YYYYMMDD
+ *
+ *
+ * @returns {Date} The corresponding Date object.
+ *
+ * @throws Error on a badly formatted date string or on a invalid date.
+ */
+jsworld.parseIsoDate = function(isoDateVal) {
+
+ if (typeof isoDateVal != "string")
+ throw "Error: The parameter must be a string";
+
+ // First, try to match "YYYY-MM-DD" format
+ var matches = isoDateVal.match(/^(\d\d\d\d)-(\d\d)-(\d\d)/);
+
+ // If unsuccessful, try to match "YYYYMMDD" format
+ if (matches === null)
+ matches = isoDateVal.match(/^(\d\d\d\d)(\d\d)(\d\d)/);
+
+ // Report bad date/time string
+ if (matches === null)
+ throw "Error: Invalid ISO-8601 date string";
+
+ // Force base 10 parse int as some values may have leading zeros!
+ // (to avoid implicit octal base conversion)
+ var year = parseInt(matches[1], 10);
+ var month = parseInt(matches[2], 10);
+ var day = parseInt(matches[3], 10);
+
+ // Simple value range check, leap years not checked
+ if (month < 1 || month > 12 ||
+ day < 1 || day > 31 )
+
+ throw "Error: Invalid ISO-8601 date value";
+
+ var d = new Date(year, month - 1, day);
+
+ // Check if the input date was valid
+ // (JS Date does automatic forward correction)
+ if (d.getDate() != day || d.getMonth() +1 != month)
+ throw "Error: Invalid date";
+
+ return d;
+};
+
+
+/**
+ * @function
+ *
+ * @description Parses an ISO-8601 formatted time string to a JavaScript
+ * Date object.
+ *
+ * @param {String} isoTimeVal An ISO-8601 formatted time string.
+ *
+ *
Accepted formats:
+ *
+ *
+ *
HH:MM:SS
+ *
HHMMSS
+ *
+ *
+ * @returns {Date} The corresponding Date object, with year, month and day set
+ * to zero.
+ *
+ * @throws Error on a badly formatted time string.
+ */
+jsworld.parseIsoTime = function(isoTimeVal) {
+
+ if (typeof isoTimeVal != "string")
+ throw "Error: The parameter must be a string";
+
+ // First, try to match "HH:MM:SS" format
+ var matches = isoTimeVal.match(/^(\d\d):(\d\d):(\d\d)/);
+
+ // If unsuccessful, try to match "HHMMSS" format
+ if (matches === null)
+ matches = isoTimeVal.match(/^(\d\d)(\d\d)(\d\d)/);
+
+ // Report bad date/time string
+ if (matches === null)
+ throw "Error: Invalid ISO-8601 date/time string";
+
+ // Force base 10 parse int as some values may have leading zeros!
+ // (to avoid implicit octal base conversion)
+ var hour = parseInt(matches[1], 10);
+ var mins = parseInt(matches[2], 10);
+ var secs = parseInt(matches[3], 10);
+
+ // Simple value range check, leap years not checked
+ if (hour < 0 || hour > 23 ||
+ mins < 0 || mins > 59 ||
+ secs < 0 || secs > 59 )
+
+ throw "Error: Invalid ISO-8601 time value";
+
+ return new Date(0, 0, 0, hour, mins, secs);
+};
+
+
+/**
+ * @private
+ *
+ * @description Trims leading and trailing whitespace from a string.
+ *
+ *
Used non-regexp the method from http://blog.stevenlevithan.com/archives/faster-trim-javascript
+ *
+ * @param {String} str The string to trim.
+ *
+ * @returns {String} The trimmed string.
+ */
+jsworld._trim = function(str) {
+
+ var whitespace = ' \n\r\t\f\x0b\xa0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000';
+
+ for (var i = 0; i < str.length; i++) {
+
+ if (whitespace.indexOf(str.charAt(i)) === -1) {
+ str = str.substring(i);
+ break;
+ }
+ }
+
+ for (i = str.length - 1; i >= 0; i--) {
+ if (whitespace.indexOf(str.charAt(i)) === -1) {
+ str = str.substring(0, i + 1);
+ break;
+ }
+ }
+
+ return whitespace.indexOf(str.charAt(0)) === -1 ? str : '';
+};
+
+
+
+/**
+ * @private
+ *
+ * @description Returns true if the argument represents a decimal number.
+ *
+ * @param {Number|String} arg The argument to test.
+ *
+ * @returns {Boolean} true if the argument represents a decimal number,
+ * otherwise false.
+ */
+jsworld._isNumber = function(arg) {
+
+ if (typeof arg == "number")
+ return true;
+
+ if (typeof arg != "string")
+ return false;
+
+ // ensure string
+ var s = arg + "";
+
+ return (/^-?(\d+|\d*\.\d+)$/).test(s);
+};
+
+
+/**
+ * @private
+ *
+ * @description Returns true if the argument represents a decimal integer.
+ *
+ * @param {Number|String} arg The argument to test.
+ *
+ * @returns {Boolean} true if the argument represents an integer, otherwise
+ * false.
+ */
+jsworld._isInteger = function(arg) {
+
+ if (typeof arg != "number" && typeof arg != "string")
+ return false;
+
+ // convert to string
+ var s = arg + "";
+
+ return (/^-?\d+$/).test(s);
+};
+
+
+/**
+ * @private
+ *
+ * @description Returns true if the argument represents a decimal float.
+ *
+ * @param {Number|String} arg The argument to test.
+ *
+ * @returns {Boolean} true if the argument represents a float, otherwise false.
+ */
+jsworld._isFloat = function(arg) {
+
+ if (typeof arg != "number" && typeof arg != "string")
+ return false;
+
+ // convert to string
+ var s = arg + "";
+
+ return (/^-?\.\d+?$/).test(s);
+};
+
+
+/**
+ * @private
+ *
+ * @description Checks if the specified formatting option is contained
+ * within the options string.
+ *
+ * @param {String} option The option to search for.
+ * @param {String} optionsString The options string.
+ *
+ * @returns {Boolean} true if the flag is found, else false
+ */
+jsworld._hasOption = function(option, optionsString) {
+
+ if (typeof option != "string" || typeof optionsString != "string")
+ return false;
+
+ if (optionsString.indexOf(option) != -1)
+ return true;
+ else
+ return false;
+};
+
+
+/**
+ * @private
+ *
+ * @description String replacement function.
+ *
+ * @param {String} s The string to work on.
+ * @param {String} target The string to search for.
+ * @param {String} replacement The replacement.
+ *
+ * @returns {String} The new string.
+ */
+jsworld._stringReplaceAll = function(s, target, replacement) {
+
+ var out;
+
+ if (target.length == 1 && replacement.length == 1) {
+ // simple char/char case somewhat faster
+ out = "";
+
+ for (var i = 0; i < s.length; i++) {
+
+ if (s.charAt(i) == target.charAt(0))
+ out = out + replacement.charAt(0);
+ else
+ out = out + s.charAt(i);
+ }
+
+ return out;
+ }
+ else {
+ // longer target and replacement strings
+ out = s;
+
+ var index = out.indexOf(target);
+
+ while (index != -1) {
+
+ out = out.replace(target, replacement);
+
+ index = out.indexOf(target);
+ }
+
+ return out;
+ }
+};
+
+
+/**
+ * @private
+ *
+ * @description Tests if a string starts with the specified substring.
+ *
+ * @param {String} testedString The string to test.
+ * @param {String} sub The string to match.
+ *
+ * @returns {Boolean} true if the test succeeds.
+ */
+jsworld._stringStartsWith = function (testedString, sub) {
+
+ if (testedString.length < sub.length)
+ return false;
+
+ for (var i = 0; i < sub.length; i++) {
+ if (testedString.charAt(i) != sub.charAt(i))
+ return false;
+ }
+
+ return true;
+};
+
+
+/**
+ * @private
+ *
+ * @description Gets the requested precision from an options string.
+ *
+ *
Example: ".3" returns 3 decimal places precision.
+ *
+ * @param {String} optionsString The options string.
+ *
+ * @returns {integer Number} The requested precision, -1 if not specified.
+ */
+jsworld._getPrecision = function (optionsString) {
+
+ if (typeof optionsString != "string")
+ return -1;
+
+ var m = optionsString.match(/\.(\d)/);
+ if (m)
+ return parseInt(m[1], 10);
+ else
+ return -1;
+};
+
+
+/**
+ * @private
+ *
+ * @description Takes a decimal numeric amount (optionally as string) and
+ * returns its integer and fractional parts packed into an object.
+ *
+ * @param {Number|String} amount The amount, e.g. "123.45" or "-56.78"
+ *
+ * @returns {object} Parsed amount object with properties:
+ * {String} integer : the integer part
+ * {String} fraction : the fraction part
+ */
+jsworld._splitNumber = function (amount) {
+
+ if (typeof amount == "number")
+ amount = amount + "";
+
+ var obj = {};
+
+ // remove negative sign
+ if (amount.charAt(0) == "-")
+ amount = amount.substring(1);
+
+ // split amount into integer and decimal parts
+ var amountParts = amount.split(".");
+ if (!amountParts[1])
+ amountParts[1] = ""; // we need "" instead of null
+
+ obj.integer = amountParts[0];
+ obj.fraction = amountParts[1];
+
+ return obj;
+};
+
+
+/**
+ * @private
+ *
+ * @description Formats the integer part using the specified grouping
+ * and thousands separator.
+ *
+ * @param {String} intPart The integer part of the amount, as string.
+ * @param {String} grouping The grouping definition.
+ * @param {String} thousandsSep The thousands separator.
+ *
+ * @returns {String} The formatted integer part.
+ */
+jsworld._formatIntegerPart = function (intPart, grouping, thousandsSep) {
+
+ // empty separator string? no grouping?
+ // -> return immediately with no formatting!
+ if (thousandsSep == "" || grouping == "-1")
+ return intPart;
+
+ // turn the semicolon-separated string of integers into an array
+ var groupSizes = grouping.split(";");
+
+ // the formatted output string
+ var out = "";
+
+ // the intPart string position to process next,
+ // start at string end, e.g. "10000000 0) {
+
+ // get next group size (if any, otherwise keep last)
+ if (groupSizes.length > 0)
+ size = parseInt(groupSizes.shift(), 10);
+
+ // int parse error?
+ if (isNaN(size))
+ throw "Error: Invalid grouping";
+
+ // size is -1? -> no more grouping, so just copy string remainder
+ if (size == -1) {
+ out = intPart.substring(0, pos) + out;
+ break;
+ }
+
+ pos -= size; // move to next sep. char. position
+
+ // position underrun? -> just copy string remainder
+ if (pos < 1) {
+ out = intPart.substring(0, pos + size) + out;
+ break;
+ }
+
+ // extract group and apply sep. char.
+ out = thousandsSep + intPart.substring(pos, pos + size) + out;
+ }
+
+ return out;
+};
+
+
+/**
+ * @private
+ *
+ * @description Formats the fractional part to the specified decimal
+ * precision.
+ *
+ * @param {String} fracPart The fractional part of the amount
+ * @param {integer Number} precision The desired decimal precision
+ *
+ * @returns {String} The formatted fractional part.
+ */
+jsworld._formatFractionPart = function (fracPart, precision) {
+
+ // append zeroes up to precision if necessary
+ for (var i=0; fracPart.length < precision; i++)
+ fracPart = fracPart + "0";
+
+ return fracPart;
+};
+
+
+/**
+ * @private
+ *
+ * @desription Converts a number to string and pad it with leading zeroes if the
+ * string is shorter than length.
+ *
+ * @param {integer Number} number The number value subjected to selective padding.
+ * @param {integer Number} length If the number has fewer digits than this length
+ * apply padding.
+ *
+ * @returns {String} The formatted string.
+ */
+jsworld._zeroPad = function(number, length) {
+
+ // ensure string
+ var s = number + "";
+
+ while (s.length < length)
+ s = "0" + s;
+
+ return s;
+};
+
+
+/**
+ * @private
+ * @description Converts a number to string and pads it with leading spaces if
+ * the string is shorter than length.
+ *
+ * @param {integer Number} number The number value subjected to selective padding.
+ * @param {integer Number} length If the number has fewer digits than this length
+ * apply padding.
+ *
+ * @returns {String} The formatted string.
+ */
+jsworld._spacePad = function(number, length) {
+
+ // ensure string
+ var s = number + "";
+
+ while (s.length < length)
+ s = " " + s;
+
+ return s;
+};
+
+
+
+/**
+ * @class
+ * Represents a POSIX-style locale with its numeric, monetary and date/time
+ * properties. Also provides a set of locale helper methods.
+ *
+ *
The locale properties follow the POSIX standards:
+ *
+ *
+ *
+ * @public
+ * @constructor
+ * @description Creates a new locale object (POSIX-style) with the specified
+ * properties.
+ *
+ * @param {object} properties An object containing the raw locale properties:
+ *
+ * @param {String} properties.decimal_point
+ *
+ * A string containing the symbol that shall be used as the decimal
+ * delimiter (radix character) in numeric, non-monetary formatted
+ * quantities. This property cannot be omitted and cannot be set to the
+ * empty string.
+ *
+ *
+ * @param {String} properties.thousands_sep
+ *
+ * A string containing the symbol that shall be used as a separator for
+ * groups of digits to the left of the decimal delimiter in numeric,
+ * non-monetary formatted monetary quantities.
+ *
+ *
+ * @param {String} properties.grouping
+ *
+ * Defines the size of each group of digits in formatted non-monetary
+ * quantities. The operand is a sequence of integers separated by
+ * semicolons. Each integer specifies the number of digits in each group,
+ * with the initial integer defining the size of the group immediately
+ * preceding the decimal delimiter, and the following integers defining
+ * the preceding groups. If the last integer is not -1, then the size of
+ * the previous group (if any) shall be repeatedly used for the
+ * remainder of the digits. If the last integer is -1, then no further
+ * grouping shall be performed.
+ *
+ *
+ * @param {String} properties.int_curr_symbol
+ *
+ * The first three letters signify the ISO-4217 currency code,
+ * the fourth letter is the international symbol separation character
+ * (normally a space).
+ *
+ *
+ * @param {String} properties.currency_symbol
+ *
+ * The local shorthand currency symbol, e.g. "$" for the en_US locale
+ *
+ *
+ * @param {String} properties.mon_decimal_point
+ *
+ * The symbol to be used as the decimal delimiter (radix character)
+ *
+ *
+ * @param {String} properties.mon_thousands_sep
+ *
+ * The symbol to be used as a separator for groups of digits to the
+ * left of the decimal delimiter.
+ *
+ *
+ * @param {String} properties.mon_grouping
+ *
+ * A string that defines the size of each group of digits. The
+ * operand is a sequence of integers separated by semicolons (";").
+ * Each integer specifies the number of digits in each group, with the
+ * initial integer defining the size of the group preceding the
+ * decimal delimiter, and the following integers defining the
+ * preceding groups. If the last integer is not -1, then the size of
+ * the previous group (if any) must be repeatedly used for the
+ * remainder of the digits. If the last integer is -1, then no
+ * further grouping is to be performed.
+ *
+ *
+ * @param {String} properties.positive_sign
+ *
+ * The string to indicate a non-negative monetary amount.
+ *
+ *
+ * @param {String} properties.negative_sign
+ *
+ * The string to indicate a negative monetary amount.
+ *
+ *
+ * @param {integer Number} properties.frac_digits
+ *
+ * An integer representing the number of fractional digits (those to
+ * the right of the decimal delimiter) to be written in a formatted
+ * monetary quantity using currency_symbol.
+ *
+ *
+ * @param {integer Number} properties.int_frac_digits
+ *
+ * An integer representing the number of fractional digits (those to
+ * the right of the decimal delimiter) to be written in a formatted
+ * monetary quantity using int_curr_symbol.
+ *
+ *
+ * @param {integer Number} properties.p_cs_precedes
+ *
+ * An integer set to 1 if the currency_symbol precedes the value for a
+ * monetary quantity with a non-negative value, and set to 0 if the
+ * symbol succeeds the value.
+ *
+ *
+ * @param {integer Number} properties.n_cs_precedes
+ *
+ * An integer set to 1 if the currency_symbol precedes the value for a
+ * monetary quantity with a negative value, and set to 0 if the symbol
+ * succeeds the value.
+ *
+ *
+ * @param {integer Number} properties.p_sep_by_space
+ *
+ * Set to a value indicating the separation of the currency_symbol,
+ * the sign string, and the value for a non-negative formatted monetary
+ * quantity:
+ *
+ *
0 No space separates the currency symbol and value.
+ *
+ *
1 If the currency symbol and sign string are adjacent, a space
+ * separates them from the value; otherwise, a space separates
+ * the currency symbol from the value.
+ *
+ *
2 If the currency symbol and sign string are adjacent, a space
+ * separates them; otherwise, a space separates the sign string
+ * from the value.
+ *
+ *
+ * @param {integer Number} properties.n_sep_by_space
+ *
+ * Set to a value indicating the separation of the currency_symbol,
+ * the sign string, and the value for a negative formatted monetary
+ * quantity. Rules same as for p_sep_by_space.
+ *
+ *
+ * @param {integer Number} properties.p_sign_posn
+ *
+ * An integer set to a value indicating the positioning of the
+ * positive_sign for a monetary quantity with a non-negative value:
+ *
+ *
0 Parentheses enclose the quantity and the currency_symbol.
+ *
+ *
1 The sign string precedes the quantity and the currency_symbol.
+ *
+ *
2 The sign string succeeds the quantity and the currency_symbol.
+ *
+ *
3 The sign string precedes the currency_symbol.
+ *
+ *
4 The sign string succeeds the currency_symbol.
+ *
+ *
+ * @param {integer Number} properties.n_sign_posn
+ *
+ * An integer set to a value indicating the positioning of the
+ * negative_sign for a negative formatted monetary quantity. Rules same
+ * as for p_sign_posn.
+ *
+ *
+ * @param {integer Number} properties.int_p_cs_precedes
+ *
+ * An integer set to 1 if the int_curr_symbol precedes the value for a
+ * monetary quantity with a non-negative value, and set to 0 if the
+ * symbol succeeds the value.
+ *
+ *
+ * @param {integer Number} properties.int_n_cs_precedes
+ *
+ * An integer set to 1 if the int_curr_symbol precedes the value for a
+ * monetary quantity with a negative value, and set to 0 if the symbol
+ * succeeds the value.
+ *
+ *
+ * @param {integer Number} properties.int_p_sep_by_space
+ *
+ * Set to a value indicating the separation of the int_curr_symbol,
+ * the sign string, and the value for a non-negative internationally
+ * formatted monetary quantity. Rules same as for p_sep_by_space.
+ *
+ *
+ * @param {integer Number} properties.int_n_sep_by_space
+ *
+ * Set to a value indicating the separation of the int_curr_symbol,
+ * the sign string, and the value for a negative internationally
+ * formatted monetary quantity. Rules same as for p_sep_by_space.
+ *
+ *
+ * @param {integer Number} properties.int_p_sign_posn
+ *
+ * An integer set to a value indicating the positioning of the
+ * positive_sign for a positive monetary quantity formatted with the
+ * international format. Rules same as for p_sign_posn.
+ *
+ *
+ * @param {integer Number} properties.int_n_sign_posn
+ *
+ * An integer set to a value indicating the positioning of the
+ * negative_sign for a negative monetary quantity formatted with the
+ * international format. Rules same as for p_sign_posn.
+ *
+ *
+ * @param {String[] | String} properties.abday
+ *
+ * The abbreviated weekday names, corresponding to the %a conversion
+ * specification. The property must be either an array of 7 strings or
+ * a string consisting of 7 semicolon-separated substrings, each
+ * surrounded by double-quotes. The first must be the abbreviated name
+ * of the day corresponding to Sunday, the second the abbreviated name
+ * of the day corresponding to Monday, and so on.
+ *
+ *
+ * @param {String[] | String} properties.day
+ *
+ * The full weekday names, corresponding to the %A conversion
+ * specification. The property must be either an array of 7 strings or
+ * a string consisting of 7 semicolon-separated substrings, each
+ * surrounded by double-quotes. The first must be the full name of the
+ * day corresponding to Sunday, the second the full name of the day
+ * corresponding to Monday, and so on.
+ *
+ *
+ * @param {String[] | String} properties.abmon
+ *
+ * The abbreviated month names, corresponding to the %b conversion
+ * specification. The property must be either an array of 12 strings or
+ * a string consisting of 12 semicolon-separated substrings, each
+ * surrounded by double-quotes. The first must be the abbreviated name
+ * of the first month of the year (January), the second the abbreviated
+ * name of the second month, and so on.
+ *
+ *
+ * @param {String[] | String} properties.mon
+ *
+ * The full month names, corresponding to the %B conversion
+ * specification. The property must be either an array of 12 strings or
+ * a string consisting of 12 semicolon-separated substrings, each
+ * surrounded by double-quotes. The first must be the full name of the
+ * first month of the year (January), the second the full name of the second
+ * month, and so on.
+ *
+ *
+ * @param {String} properties.d_fmt
+ *
+ * The appropriate date representation. The string may contain any
+ * combination of characters and conversion specifications (%).
+ *
+ *
+ * @param {String} properties.t_fmt
+ *
+ * The appropriate time representation. The string may contain any
+ * combination of characters and conversion specifications (%).
+ *
+ *
+ * @param {String} properties.d_t_fmt
+ *
+ * The appropriate date and time representation. The string may contain
+ * any combination of characters and conversion specifications (%).
+ *
+ *
+ * @param {String[] | String} properties.am_pm
+ *
+ * The appropriate representation of the ante-meridiem and post-meridiem
+ * strings, corresponding to the %p conversion specification. The property
+ * must be either an array of 2 strings or a string consisting of 2
+ * semicolon-separated substrings, each surrounded by double-quotes.
+ * The first string must represent the ante-meridiem designation, the
+ * last string the post-meridiem designation.
+ *
+ *
+ * @throws @throws Error on a undefined or invalid locale property.
+ */
+jsworld.Locale = function(properties) {
+
+
+ /**
+ * @private
+ *
+ * @description Identifies the class for internal library purposes.
+ */
+ this._className = "jsworld.Locale";
+
+
+ /**
+ * @private
+ *
+ * @description Parses a day or month name definition list, which
+ * could be a ready JS array, e.g. ["Mon", "Tue", "Wed"...] or
+ * it could be a string formatted according to the classic POSIX
+ * definition e.g. "Mon";"Tue";"Wed";...
+ *
+ * @param {String[] | String} namesAn array or string defining
+ * the week/month names.
+ * @param {integer Number} expectedItems The number of expected list
+ * items, e.g. 7 for weekdays, 12 for months.
+ *
+ * @returns {String[]} The parsed (and checked) items.
+ *
+ * @throws Error on missing definition, unexpected item count or
+ * missing double-quotes.
+ */
+ this._parseList = function(names, expectedItems) {
+
+ var array = [];
+
+ if (names == null) {
+ throw "Names not defined";
+ }
+ else if (typeof names == "object") {
+ // we got a ready array
+ array = names;
+ }
+ else if (typeof names == "string") {
+ // we got the names in the classic POSIX form, do parse
+ array = names.split(";", expectedItems);
+
+ for (var i = 0; i < array.length; i++) {
+ // check for and strip double quotes
+ if (array[i][0] == "\"" && array[i][array[i].length - 1] == "\"")
+ array[i] = array[i].slice(1, -1);
+ else
+ throw "Missing double quotes";
+ }
+ }
+ else {
+ throw "Names must be an array or a string";
+ }
+
+ if (array.length != expectedItems)
+ throw "Expected " + expectedItems + " items, got " + array.length;
+
+ return array;
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Validates a date/time format string, such as "H:%M:%S".
+ * Checks that the argument is of type "string" and is not empty.
+ *
+ * @param {String} formatString The format string.
+ *
+ * @returns {String} The validated string.
+ *
+ * @throws Error on null or empty string.
+ */
+ this._validateFormatString = function(formatString) {
+
+ if (typeof formatString == "string" && formatString.length > 0)
+ return formatString;
+ else
+ throw "Empty or no string";
+ };
+
+
+ // LC_NUMERIC
+
+ if (properties == null || typeof properties != "object")
+ throw "Error: Invalid/missing locale properties";
+
+
+ if (typeof properties.decimal_point != "string")
+ throw "Error: Invalid/missing decimal_point property";
+
+ this.decimal_point = properties.decimal_point;
+
+
+ if (typeof properties.thousands_sep != "string")
+ throw "Error: Invalid/missing thousands_sep property";
+
+ this.thousands_sep = properties.thousands_sep;
+
+
+ if (typeof properties.grouping != "string")
+ throw "Error: Invalid/missing grouping property";
+
+ this.grouping = properties.grouping;
+
+
+ // LC_MONETARY
+
+ if (typeof properties.int_curr_symbol != "string")
+ throw "Error: Invalid/missing int_curr_symbol property";
+
+ if (! /[A-Za-z]{3}.?/.test(properties.int_curr_symbol))
+ throw "Error: Invalid int_curr_symbol property";
+
+ this.int_curr_symbol = properties.int_curr_symbol;
+
+
+ if (typeof properties.currency_symbol != "string")
+ throw "Error: Invalid/missing currency_symbol property";
+
+ this.currency_symbol = properties.currency_symbol;
+
+
+ if (typeof properties.frac_digits != "number" && properties.frac_digits < 0)
+ throw "Error: Invalid/missing frac_digits property";
+
+ this.frac_digits = properties.frac_digits;
+
+
+ // may be empty string/null for currencies with no fractional part
+ if (properties.mon_decimal_point === null || properties.mon_decimal_point == "") {
+
+ if (this.frac_digits > 0)
+ throw "Error: Undefined mon_decimal_point property";
+ else
+ properties.mon_decimal_point = "";
+ }
+
+ if (typeof properties.mon_decimal_point != "string")
+ throw "Error: Invalid/missing mon_decimal_point property";
+
+ this.mon_decimal_point = properties.mon_decimal_point;
+
+
+ if (typeof properties.mon_thousands_sep != "string")
+ throw "Error: Invalid/missing mon_thousands_sep property";
+
+ this.mon_thousands_sep = properties.mon_thousands_sep;
+
+
+ if (typeof properties.mon_grouping != "string")
+ throw "Error: Invalid/missing mon_grouping property";
+
+ this.mon_grouping = properties.mon_grouping;
+
+
+ if (typeof properties.positive_sign != "string")
+ throw "Error: Invalid/missing positive_sign property";
+
+ this.positive_sign = properties.positive_sign;
+
+
+ if (typeof properties.negative_sign != "string")
+ throw "Error: Invalid/missing negative_sign property";
+
+ this.negative_sign = properties.negative_sign;
+
+
+
+ if (properties.p_cs_precedes !== 0 && properties.p_cs_precedes !== 1)
+ throw "Error: Invalid/missing p_cs_precedes property, must be 0 or 1";
+
+ this.p_cs_precedes = properties.p_cs_precedes;
+
+
+ if (properties.n_cs_precedes !== 0 && properties.n_cs_precedes !== 1)
+ throw "Error: Invalid/missing n_cs_precedes, must be 0 or 1";
+
+ this.n_cs_precedes = properties.n_cs_precedes;
+
+
+ if (properties.p_sep_by_space !== 0 &&
+ properties.p_sep_by_space !== 1 &&
+ properties.p_sep_by_space !== 2)
+ throw "Error: Invalid/missing p_sep_by_space property, must be 0, 1 or 2";
+
+ this.p_sep_by_space = properties.p_sep_by_space;
+
+
+ if (properties.n_sep_by_space !== 0 &&
+ properties.n_sep_by_space !== 1 &&
+ properties.n_sep_by_space !== 2)
+ throw "Error: Invalid/missing n_sep_by_space property, must be 0, 1, or 2";
+
+ this.n_sep_by_space = properties.n_sep_by_space;
+
+
+ if (properties.p_sign_posn !== 0 &&
+ properties.p_sign_posn !== 1 &&
+ properties.p_sign_posn !== 2 &&
+ properties.p_sign_posn !== 3 &&
+ properties.p_sign_posn !== 4)
+ throw "Error: Invalid/missing p_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.p_sign_posn = properties.p_sign_posn;
+
+
+ if (properties.n_sign_posn !== 0 &&
+ properties.n_sign_posn !== 1 &&
+ properties.n_sign_posn !== 2 &&
+ properties.n_sign_posn !== 3 &&
+ properties.n_sign_posn !== 4)
+ throw "Error: Invalid/missing n_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.n_sign_posn = properties.n_sign_posn;
+
+
+ if (typeof properties.int_frac_digits != "number" && properties.int_frac_digits < 0)
+ throw "Error: Invalid/missing int_frac_digits property";
+
+ this.int_frac_digits = properties.int_frac_digits;
+
+
+ if (properties.int_p_cs_precedes !== 0 && properties.int_p_cs_precedes !== 1)
+ throw "Error: Invalid/missing int_p_cs_precedes property, must be 0 or 1";
+
+ this.int_p_cs_precedes = properties.int_p_cs_precedes;
+
+
+ if (properties.int_n_cs_precedes !== 0 && properties.int_n_cs_precedes !== 1)
+ throw "Error: Invalid/missing int_n_cs_precedes property, must be 0 or 1";
+
+ this.int_n_cs_precedes = properties.int_n_cs_precedes;
+
+
+ if (properties.int_p_sep_by_space !== 0 &&
+ properties.int_p_sep_by_space !== 1 &&
+ properties.int_p_sep_by_space !== 2)
+ throw "Error: Invalid/missing int_p_sep_by_spacev, must be 0, 1 or 2";
+
+ this.int_p_sep_by_space = properties.int_p_sep_by_space;
+
+
+ if (properties.int_n_sep_by_space !== 0 &&
+ properties.int_n_sep_by_space !== 1 &&
+ properties.int_n_sep_by_space !== 2)
+ throw "Error: Invalid/missing int_n_sep_by_space property, must be 0, 1, or 2";
+
+ this.int_n_sep_by_space = properties.int_n_sep_by_space;
+
+
+ if (properties.int_p_sign_posn !== 0 &&
+ properties.int_p_sign_posn !== 1 &&
+ properties.int_p_sign_posn !== 2 &&
+ properties.int_p_sign_posn !== 3 &&
+ properties.int_p_sign_posn !== 4)
+ throw "Error: Invalid/missing int_p_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.int_p_sign_posn = properties.int_p_sign_posn;
+
+
+ if (properties.int_n_sign_posn !== 0 &&
+ properties.int_n_sign_posn !== 1 &&
+ properties.int_n_sign_posn !== 2 &&
+ properties.int_n_sign_posn !== 3 &&
+ properties.int_n_sign_posn !== 4)
+ throw "Error: Invalid/missing int_n_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.int_n_sign_posn = properties.int_n_sign_posn;
+
+
+ // LC_TIME
+
+ if (properties == null || typeof properties != "object")
+ throw "Error: Invalid/missing time locale properties";
+
+
+ // parse the supported POSIX LC_TIME properties
+
+ // abday
+ try {
+ this.abday = this._parseList(properties.abday, 7);
+ }
+ catch (error) {
+ throw "Error: Invalid abday property: " + error;
+ }
+
+ // day
+ try {
+ this.day = this._parseList(properties.day, 7);
+ }
+ catch (error) {
+ throw "Error: Invalid day property: " + error;
+ }
+
+ // abmon
+ try {
+ this.abmon = this._parseList(properties.abmon, 12);
+ } catch (error) {
+ throw "Error: Invalid abmon property: " + error;
+ }
+
+ // mon
+ try {
+ this.mon = this._parseList(properties.mon, 12);
+ } catch (error) {
+ throw "Error: Invalid mon property: " + error;
+ }
+
+ // d_fmt
+ try {
+ this.d_fmt = this._validateFormatString(properties.d_fmt);
+ } catch (error) {
+ throw "Error: Invalid d_fmt property: " + error;
+ }
+
+ // t_fmt
+ try {
+ this.t_fmt = this._validateFormatString(properties.t_fmt);
+ } catch (error) {
+ throw "Error: Invalid t_fmt property: " + error;
+ }
+
+ // d_t_fmt
+ try {
+ this.d_t_fmt = this._validateFormatString(properties.d_t_fmt);
+ } catch (error) {
+ throw "Error: Invalid d_t_fmt property: " + error;
+ }
+
+ // am_pm
+ try {
+ var am_pm_strings = this._parseList(properties.am_pm, 2);
+ this.am = am_pm_strings[0];
+ this.pm = am_pm_strings[1];
+ } catch (error) {
+ // ignore empty/null string errors
+ this.am = "";
+ this.pm = "";
+ }
+
+
+ /**
+ * @public
+ *
+ * @description Returns the abbreviated name of the specified weekday.
+ *
+ * @param {integer Number} [weekdayNum] An integer between 0 and 6. Zero
+ * corresponds to Sunday, one to Monday, etc. If omitted the
+ * method will return an array of all abbreviated weekday
+ * names.
+ *
+ * @returns {String | String[]} The abbreviated name of the specified weekday
+ * or an array of all abbreviated weekday names.
+ *
+ * @throws Error on invalid argument.
+ */
+ this.getAbbreviatedWeekdayName = function(weekdayNum) {
+
+ if (typeof weekdayNum == "undefined" || weekdayNum === null)
+ return this.abday;
+
+ if (! jsworld._isInteger(weekdayNum) || weekdayNum < 0 || weekdayNum > 6)
+ throw "Error: Invalid weekday argument, must be an integer [0..6]";
+
+ return this.abday[weekdayNum];
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Returns the name of the specified weekday.
+ *
+ * @param {integer Number} [weekdayNum] An integer between 0 and 6. Zero
+ * corresponds to Sunday, one to Monday, etc. If omitted the
+ * method will return an array of all weekday names.
+ *
+ * @returns {String | String[]} The name of the specified weekday or an
+ * array of all weekday names.
+ *
+ * @throws Error on invalid argument.
+ */
+ this.getWeekdayName = function(weekdayNum) {
+
+ if (typeof weekdayNum == "undefined" || weekdayNum === null)
+ return this.day;
+
+ if (! jsworld._isInteger(weekdayNum) || weekdayNum < 0 || weekdayNum > 6)
+ throw "Error: Invalid weekday argument, must be an integer [0..6]";
+
+ return this.day[weekdayNum];
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Returns the abbreviated name of the specified month.
+ *
+ * @param {integer Number} [monthNum] An integer between 0 and 11. Zero
+ * corresponds to January, one to February, etc. If omitted the
+ * method will return an array of all abbreviated month names.
+ *
+ * @returns {String | String[]} The abbreviated name of the specified month
+ * or an array of all abbreviated month names.
+ *
+ * @throws Error on invalid argument.
+ */
+ this.getAbbreviatedMonthName = function(monthNum) {
+
+ if (typeof monthNum == "undefined" || monthNum === null)
+ return this.abmon;
+
+ if (! jsworld._isInteger(monthNum) || monthNum < 0 || monthNum > 11)
+ throw "Error: Invalid month argument, must be an integer [0..11]";
+
+ return this.abmon[monthNum];
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Returns the name of the specified month.
+ *
+ * @param {integer Number} [monthNum] An integer between 0 and 11. Zero
+ * corresponds to January, one to February, etc. If omitted the
+ * method will return an array of all month names.
+ *
+ * @returns {String | String[]} The name of the specified month or an array
+ * of all month names.
+ *
+ * @throws Error on invalid argument.
+ */
+ this.getMonthName = function(monthNum) {
+
+ if (typeof monthNum == "undefined" || monthNum === null)
+ return this.mon;
+
+ if (! jsworld._isInteger(monthNum) || monthNum < 0 || monthNum > 11)
+ throw "Error: Invalid month argument, must be an integer [0..11]";
+
+ return this.mon[monthNum];
+ };
+
+
+
+ /**
+ * @public
+ *
+ * @description Gets the decimal delimiter (radix) character for
+ * numeric quantities.
+ *
+ * @returns {String} The radix character.
+ */
+ this.getDecimalPoint = function() {
+
+ return this.decimal_point;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the local shorthand currency symbol.
+ *
+ * @returns {String} The currency symbol.
+ */
+ this.getCurrencySymbol = function() {
+
+ return this.currency_symbol;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the internaltion currency symbol (ISO-4217 code).
+ *
+ * @returns {String} The international currency symbol.
+ */
+ this.getIntCurrencySymbol = function() {
+
+ return this.int_curr_symbol.substring(0,3);
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the position of the local (shorthand) currency
+ * symbol relative to the amount. Assumes a non-negative amount.
+ *
+ * @returns {Boolean} True if the symbol precedes the amount, false if
+ * the symbol succeeds the amount.
+ */
+ this.currencySymbolPrecedes = function() {
+
+ if (this.p_cs_precedes == 1)
+ return true;
+ else
+ return false;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the position of the international (ISO-4217 code)
+ * currency symbol relative to the amount. Assumes a non-negative
+ * amount.
+ *
+ * @returns {Boolean} True if the symbol precedes the amount, false if
+ * the symbol succeeds the amount.
+ */
+ this.intCurrencySymbolPrecedes = function() {
+
+ if (this.int_p_cs_precedes == 1)
+ return true;
+ else
+ return false;
+
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the decimal delimiter (radix) for monetary
+ * quantities.
+ *
+ * @returns {String} The radix character.
+ */
+ this.getMonetaryDecimalPoint = function() {
+
+ return this.mon_decimal_point;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the number of fractional digits for local
+ * (shorthand) symbol formatting.
+ *
+ * @returns {integer Number} The number of fractional digits.
+ */
+ this.getFractionalDigits = function() {
+
+ return this.frac_digits;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the number of fractional digits for
+ * international (ISO-4217 code) formatting.
+ *
+ * @returns {integer Number} The number of fractional digits.
+ */
+ this.getIntFractionalDigits = function() {
+
+ return this.int_frac_digits;
+ };
+};
+
+
+
+/**
+ * @class
+ * Class for localised formatting of numbers.
+ *
+ *
See:
+ * POSIX LC_NUMERIC.
+ *
+ *
+ * @public
+ * @constructor
+ * @description Creates a new numeric formatter for the specified locale.
+ *
+ * @param {jsworld.Locale} locale A locale object specifying the required
+ * POSIX LC_NUMERIC formatting properties.
+ *
+ * @throws Error on constructor failure.
+ */
+jsworld.NumericFormatter = function(locale) {
+
+ if (typeof locale != "object" || locale._className != "jsworld.Locale")
+ throw "Constructor error: You must provide a valid jsworld.Locale instance";
+
+ this.lc = locale;
+
+
+ /**
+ * @public
+ *
+ * @description Formats a decimal numeric value according to the preset
+ * locale.
+ *
+ * @param {Number|String} number The number to format.
+ * @param {String} [options] Options to modify the formatted output:
+ *
+ *
"^" suppress grouping
+ *
"+" force positive sign for positive amounts
+ *
"~" suppress positive/negative sign
+ *
".n" specify decimal precision 'n'
+ *
+ *
+ * @returns {String} The formatted number.
+ *
+ * @throws "Error: Invalid input" on bad input.
+ */
+ this.format = function(number, options) {
+
+ if (typeof number == "string")
+ number = jsworld._trim(number);
+
+ if (! jsworld._isNumber(number))
+ throw "Error: The input is not a number";
+
+ var floatAmount = parseFloat(number, 10);
+
+ // get the required precision
+ var reqPrecision = jsworld._getPrecision(options);
+
+ // round to required precision
+ if (reqPrecision != -1)
+ floatAmount = Math.round(floatAmount * Math.pow(10, reqPrecision)) / Math.pow(10, reqPrecision);
+
+
+ // convert the float number to string and parse into
+ // object with properties integer and fraction
+ var parsedAmount = jsworld._splitNumber(String(floatAmount));
+
+ // format integer part with grouping chars
+ var formattedIntegerPart;
+
+ if (floatAmount === 0)
+ formattedIntegerPart = "0";
+ else
+ formattedIntegerPart = jsworld._hasOption("^", options) ?
+ parsedAmount.integer :
+ jsworld._formatIntegerPart(parsedAmount.integer,
+ this.lc.grouping,
+ this.lc.thousands_sep);
+
+ // format the fractional part
+ var formattedFractionPart =
+ reqPrecision != -1 ?
+ jsworld._formatFractionPart(parsedAmount.fraction, reqPrecision) :
+ parsedAmount.fraction;
+
+
+ // join the integer and fraction parts using the decimal_point property
+ var formattedAmount =
+ formattedFractionPart.length ?
+ formattedIntegerPart + this.lc.decimal_point + formattedFractionPart :
+ formattedIntegerPart;
+
+ // prepend sign?
+ if (jsworld._hasOption("~", options) || floatAmount === 0) {
+ // suppress both '+' and '-' signs, i.e. return abs value
+ return formattedAmount;
+ }
+ else {
+ if (jsworld._hasOption("+", options) || floatAmount < 0) {
+ if (floatAmount > 0)
+ // force '+' sign for positive amounts
+ return "+" + formattedAmount;
+ else if (floatAmount < 0)
+ // prepend '-' sign
+ return "-" + formattedAmount;
+ else
+ // zero case
+ return formattedAmount;
+ }
+ else {
+ // positive amount with no '+' sign
+ return formattedAmount;
+ }
+ }
+ };
+};
+
+
+/**
+ * @class
+ * Class for localised formatting of dates and times.
+ *
+ *
See:
+ * POSIX LC_TIME.
+ *
+ * @public
+ * @constructor
+ * @description Creates a new date/time formatter for the specified locale.
+ *
+ * @param {jsworld.Locale} locale A locale object specifying the required
+ * POSIX LC_TIME formatting properties.
+ *
+ * @throws Error on constructor failure.
+ */
+jsworld.DateTimeFormatter = function(locale) {
+
+
+ if (typeof locale != "object" || locale._className != "jsworld.Locale")
+ throw "Constructor error: You must provide a valid jsworld.Locale instance.";
+
+ this.lc = locale;
+
+
+ /**
+ * @public
+ *
+ * @description Formats a date according to the preset locale.
+ *
+ * @param {Date|String} date A valid Date object instance or a string
+ * containing a valid ISO-8601 formatted date, e.g. "2010-31-03"
+ * or "2010-03-31 23:59:59".
+ *
+ * @returns {String} The formatted date
+ *
+ * @throws Error on invalid date argument
+ */
+ this.formatDate = function(date) {
+
+ var d = null;
+
+ if (typeof date == "string") {
+ // assume ISO-8601 date string
+ try {
+ d = jsworld.parseIsoDate(date);
+ } catch (error) {
+ // try full ISO-8601 date/time string
+ d = jsworld.parseIsoDateTime(date);
+ }
+ }
+ else if (date !== null && typeof date == "object") {
+ // assume ready Date object
+ d = date;
+ }
+ else {
+ throw "Error: Invalid date argument, must be a Date object or an ISO-8601 date/time string";
+ }
+
+ return this._applyFormatting(d, this.lc.d_fmt);
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Formats a time according to the preset locale.
+ *
+ * @param {Date|String} date A valid Date object instance or a string
+ * containing a valid ISO-8601 formatted time, e.g. "23:59:59"
+ * or "2010-03-31 23:59:59".
+ *
+ * @returns {String} The formatted time.
+ *
+ * @throws Error on invalid date argument.
+ */
+ this.formatTime = function(date) {
+
+ var d = null;
+
+ if (typeof date == "string") {
+ // assume ISO-8601 time string
+ try {
+ d = jsworld.parseIsoTime(date);
+ } catch (error) {
+ // try full ISO-8601 date/time string
+ d = jsworld.parseIsoDateTime(date);
+ }
+ }
+ else if (date !== null && typeof date == "object") {
+ // assume ready Date object
+ d = date;
+ }
+ else {
+ throw "Error: Invalid date argument, must be a Date object or an ISO-8601 date/time string";
+ }
+
+ return this._applyFormatting(d, this.lc.t_fmt);
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Formats a date/time value according to the preset
+ * locale.
+ *
+ * @param {Date|String} date A valid Date object instance or a string
+ * containing a valid ISO-8601 formatted date/time, e.g.
+ * "2010-03-31 23:59:59".
+ *
+ * @returns {String} The formatted time.
+ *
+ * @throws Error on invalid argument.
+ */
+ this.formatDateTime = function(date) {
+
+ var d = null;
+
+ if (typeof date == "string") {
+ // assume ISO-8601 format
+ d = jsworld.parseIsoDateTime(date);
+ }
+ else if (date !== null && typeof date == "object") {
+ // assume ready Date object
+ d = date;
+ }
+ else {
+ throw "Error: Invalid date argument, must be a Date object or an ISO-8601 date/time string";
+ }
+
+ return this._applyFormatting(d, this.lc.d_t_fmt);
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Apples formatting to the Date object according to the
+ * format string.
+ *
+ * @param {Date} d A valid Date instance.
+ * @param {String} s The formatting string with '%' placeholders.
+ *
+ * @returns {String} The formatted string.
+ */
+ this._applyFormatting = function(d, s) {
+
+ s = s.replace(/%%/g, '%');
+ s = s.replace(/%a/g, this.lc.abday[d.getDay()]);
+ s = s.replace(/%A/g, this.lc.day[d.getDay()]);
+ s = s.replace(/%b/g, this.lc.abmon[d.getMonth()]);
+ s = s.replace(/%B/g, this.lc.mon[d.getMonth()]);
+ s = s.replace(/%d/g, jsworld._zeroPad(d.getDate(), 2));
+ s = s.replace(/%e/g, jsworld._spacePad(d.getDate(), 2));
+ s = s.replace(/%F/g, d.getFullYear() +
+ "-" +
+ jsworld._zeroPad(d.getMonth()+1, 2) +
+ "-" +
+ jsworld._zeroPad(d.getDate(), 2));
+ s = s.replace(/%h/g, this.lc.abmon[d.getMonth()]); // same as %b
+ s = s.replace(/%H/g, jsworld._zeroPad(d.getHours(), 2));
+ s = s.replace(/%I/g, jsworld._zeroPad(this._hours12(d.getHours()), 2));
+ s = s.replace(/%k/g, d.getHours());
+ s = s.replace(/%l/g, this._hours12(d.getHours()));
+ s = s.replace(/%m/g, jsworld._zeroPad(d.getMonth()+1, 2));
+ s = s.replace(/%n/g, "\n");
+ s = s.replace(/%M/g, jsworld._zeroPad(d.getMinutes(), 2));
+ s = s.replace(/%p/g, this._getAmPm(d.getHours()));
+ s = s.replace(/%P/g, this._getAmPm(d.getHours()).toLocaleLowerCase()); // safe?
+ s = s.replace(/%R/g, jsworld._zeroPad(d.getHours(), 2) +
+ ":" +
+ jsworld._zeroPad(d.getMinutes(), 2));
+ s = s.replace(/%S/g, jsworld._zeroPad(d.getSeconds(), 2));
+ s = s.replace(/%T/g, jsworld._zeroPad(d.getHours(), 2) +
+ ":" +
+ jsworld._zeroPad(d.getMinutes(), 2) +
+ ":" +
+ jsworld._zeroPad(d.getSeconds(), 2));
+ s = s.replace(/%w/g, this.lc.day[d.getDay()]);
+ s = s.replace(/%y/g, new String(d.getFullYear()).substring(2));
+ s = s.replace(/%Y/g, d.getFullYear());
+
+ s = s.replace(/%Z/g, ""); // to do: ignored until a reliable TMZ method found
+
+ s = s.replace(/%[a-zA-Z]/g, ""); // ignore all other % sequences
+
+ return s;
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Does 24 to 12 hour conversion.
+ *
+ * @param {integer Number} hour24 Hour [0..23].
+ *
+ * @returns {integer Number} Corresponding hour [1..12].
+ */
+ this._hours12 = function(hour24) {
+
+ if (hour24 === 0)
+ return 12; // 00h is 12AM
+
+ else if (hour24 > 12)
+ return hour24 - 12; // 1PM to 11PM
+
+ else
+ return hour24; // 1AM to 12PM
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Gets the appropriate localised AM or PM string depending
+ * on the day hour. Special cases: midnight is 12AM, noon is 12PM.
+ *
+ * @param {integer Number} hour24 Hour [0..23].
+ *
+ * @returns {String} The corresponding localised AM or PM string.
+ */
+ this._getAmPm = function(hour24) {
+
+ if (hour24 < 12)
+ return this.lc.am;
+ else
+ return this.lc.pm;
+ };
+};
+
+
+
+/**
+ * @class Class for localised formatting of currency amounts.
+ *
+ *
See:
+ * POSIX LC_MONETARY.
+ *
+ * @public
+ * @constructor
+ * @description Creates a new monetary formatter for the specified locale.
+ *
+ * @param {jsworld.Locale} locale A locale object specifying the required
+ * POSIX LC_MONETARY formatting properties.
+ * @param {String} [currencyCode] Set the currency explicitly by
+ * passing its international ISO-4217 code, e.g. "USD", "EUR", "GBP".
+ * Use this optional parameter to override the default local currency
+ * @param {String} [altIntSymbol] Non-local currencies are formatted
+ * with their international ISO-4217 code to prevent ambiguity.
+ * Use this optional argument to force a different symbol, such as the
+ * currency's shorthand sign. This is mostly useful when the shorthand
+ * sign is both internationally recognised and identifies the currency
+ * uniquely (e.g. the Euro sign).
+ *
+ * @throws Error on constructor failure.
+ */
+jsworld.MonetaryFormatter = function(locale, currencyCode, altIntSymbol) {
+
+ if (typeof locale != "object" || locale._className != "jsworld.Locale")
+ throw "Constructor error: You must provide a valid jsworld.Locale instance";
+
+ this.lc = locale;
+
+ /**
+ * @private
+ * @description Lookup table to determine the fraction digits for a
+ * specific currency; most currencies subdivide at 1/100 (2 fractional
+ * digits), so we store only those that deviate from the default.
+ *
+ *
The data is from Unicode's CLDR version 1.7.0. The two currencies
+ * with non-decimal subunits (MGA and MRO) are marked as having no
+ * fractional digits as well as all currencies that have no subunits
+ * in circulation.
+ *
+ *
It is "hard-wired" for referential convenience and is only looked
+ * up when an overriding currencyCode parameter is supplied.
+ */
+ this.currencyFractionDigits = {
+ "AFN" : 0, "ALL" : 0, "AMD" : 0, "BHD" : 3, "BIF" : 0,
+ "BYR" : 0, "CLF" : 0, "CLP" : 0, "COP" : 0, "CRC" : 0,
+ "DJF" : 0, "GNF" : 0, "GYD" : 0, "HUF" : 0, "IDR" : 0,
+ "IQD" : 0, "IRR" : 0, "ISK" : 0, "JOD" : 3, "JPY" : 0,
+ "KMF" : 0, "KRW" : 0, "KWD" : 3, "LAK" : 0, "LBP" : 0,
+ "LYD" : 3, "MGA" : 0, "MMK" : 0, "MNT" : 0, "MRO" : 0,
+ "MUR" : 0, "OMR" : 3, "PKR" : 0, "PYG" : 0, "RSD" : 0,
+ "RWF" : 0, "SLL" : 0, "SOS" : 0, "STD" : 0, "SYP" : 0,
+ "TND" : 3, "TWD" : 0, "TZS" : 0, "UGX" : 0, "UZS" : 0,
+ "VND" : 0, "VUV" : 0, "XAF" : 0, "XOF" : 0, "XPF" : 0,
+ "YER" : 0, "ZMK" : 0
+ };
+
+
+ // optional currencyCode argument?
+ if (typeof currencyCode == "string") {
+ // user wanted to override the local currency
+ this.currencyCode = currencyCode.toUpperCase();
+
+ // must override the frac digits too, for some
+ // currencies have 0, 2 or 3!
+ var numDigits = this.currencyFractionDigits[this.currencyCode];
+ if (typeof numDigits != "number")
+ numDigits = 2; // default for most currencies
+ this.lc.frac_digits = numDigits;
+ this.lc.int_frac_digits = numDigits;
+ }
+ else {
+ // use local currency
+ this.currencyCode = this.lc.int_curr_symbol.substring(0,3).toUpperCase();
+ }
+
+ // extract intl. currency separator
+ this.intSep = this.lc.int_curr_symbol.charAt(3);
+
+ // flag local or intl. sign formatting?
+ if (this.currencyCode == this.lc.int_curr_symbol.substring(0,3)) {
+ // currency matches the local one? ->
+ // formatting with local symbol and parameters
+ this.internationalFormatting = false;
+ this.curSym = this.lc.currency_symbol;
+ }
+ else {
+ // currency doesn't match the local ->
+
+ // do we have an overriding currency symbol?
+ if (typeof altIntSymbol == "string") {
+ // -> force formatting with local parameters, using alt symbol
+ this.curSym = altIntSymbol;
+ this.internationalFormatting = false;
+ }
+ else {
+ // -> force formatting with intl. sign and parameters
+ this.internationalFormatting = true;
+ }
+ }
+
+
+ /**
+ * @public
+ *
+ * @description Gets the currency symbol used in formatting.
+ *
+ * @returns {String} The currency symbol.
+ */
+ this.getCurrencySymbol = function() {
+
+ return this.curSym;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the position of the currency symbol relative to
+ * the amount. Assumes a non-negative amount and local formatting.
+ *
+ * @param {String} intFlag Optional flag to force international
+ * formatting by passing the string "i".
+ *
+ * @returns {Boolean} True if the symbol precedes the amount, false if
+ * the symbol succeeds the amount.
+ */
+ this.currencySymbolPrecedes = function(intFlag) {
+
+ if (typeof intFlag == "string" && intFlag == "i") {
+ // international formatting was forced
+ if (this.lc.int_p_cs_precedes == 1)
+ return true;
+ else
+ return false;
+
+ }
+ else {
+ // check whether local formatting is on or off
+ if (this.internationalFormatting) {
+ if (this.lc.int_p_cs_precedes == 1)
+ return true;
+ else
+ return false;
+ }
+ else {
+ if (this.lc.p_cs_precedes == 1)
+ return true;
+ else
+ return false;
+ }
+ }
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the decimal delimiter (radix) used in formatting.
+ *
+ * @returns {String} The radix character.
+ */
+ this.getDecimalPoint = function() {
+
+ return this.lc.mon_decimal_point;
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Gets the number of fractional digits. Assumes local
+ * formatting.
+ *
+ * @param {String} intFlag Optional flag to force international
+ * formatting by passing the string "i".
+ *
+ * @returns {integer Number} The number of fractional digits.
+ */
+ this.getFractionalDigits = function(intFlag) {
+
+ if (typeof intFlag == "string" && intFlag == "i") {
+ // international formatting was forced
+ return this.lc.int_frac_digits;
+ }
+ else {
+ // check whether local formatting is on or off
+ if (this.internationalFormatting)
+ return this.lc.int_frac_digits;
+ else
+ return this.lc.frac_digits;
+ }
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Formats a monetary amount according to the preset
+ * locale.
+ *
+ *
+ * For local currencies the native shorthand symbol will be used for
+ * formatting.
+ * Example:
+ * locale is en_US
+ * currency is USD
+ * -> the "$" symbol will be used, e.g. $123.45
+ *
+ * For non-local currencies the international ISO-4217 code will be
+ * used for formatting.
+ * Example:
+ * locale is en_US (which has USD as currency)
+ * currency is EUR
+ * -> the ISO three-letter code will be used, e.g. EUR 123.45
+ *
+ * If the currency is non-local, but an alternative currency symbol was
+ * provided, this will be used instead.
+ * Example
+ * locale is en_US (which has USD as currency)
+ * currency is EUR
+ * an alternative symbol is provided - "€"
+ * -> the alternative symbol will be used, e.g. €123.45
+ *
+ *
+ * @param {Number|String} amount The amount to format as currency.
+ * @param {String} [options] Options to modify the formatted output:
+ *
+ *
"^" suppress grouping
+ *
"!" suppress the currency symbol
+ *
"~" suppress the currency symbol and the sign (positive or negative)
+ *
"i" force international sign (ISO-4217 code) formatting
+ *
".n" specify decimal precision
+ *
+ * @returns The formatted currency amount as string.
+ *
+ * @throws "Error: Invalid amount" on bad amount.
+ */
+ this.format = function(amount, options) {
+
+ // if the amount is passed as string, check that it parses to a float
+ var floatAmount;
+
+ if (typeof amount == "string") {
+ amount = jsworld._trim(amount);
+ floatAmount = parseFloat(amount);
+
+ if (typeof floatAmount != "number" || isNaN(floatAmount))
+ throw "Error: Amount string not a number";
+ }
+ else if (typeof amount == "number") {
+ floatAmount = amount;
+ }
+ else {
+ throw "Error: Amount not a number";
+ }
+
+ // get the required precision, ".n" option arg overrides default locale config
+ var reqPrecision = jsworld._getPrecision(options);
+
+ if (reqPrecision == -1) {
+ if (this.internationalFormatting || jsworld._hasOption("i", options))
+ reqPrecision = this.lc.int_frac_digits;
+ else
+ reqPrecision = this.lc.frac_digits;
+ }
+
+ // round
+ floatAmount = Math.round(floatAmount * Math.pow(10, reqPrecision)) / Math.pow(10, reqPrecision);
+
+
+ // convert the float amount to string and parse into
+ // object with properties integer and fraction
+ var parsedAmount = jsworld._splitNumber(String(floatAmount));
+
+ // format integer part with grouping chars
+ var formattedIntegerPart;
+
+ if (floatAmount === 0)
+ formattedIntegerPart = "0";
+ else
+ formattedIntegerPart = jsworld._hasOption("^", options) ?
+ parsedAmount.integer :
+ jsworld._formatIntegerPart(parsedAmount.integer,
+ this.lc.mon_grouping,
+ this.lc.mon_thousands_sep);
+
+
+ // format the fractional part
+ var formattedFractionPart;
+
+ if (reqPrecision == -1) {
+ // pad fraction with trailing zeros accoring to default locale [int_]frac_digits
+ if (this.internationalFormatting || jsworld._hasOption("i", options))
+ formattedFractionPart =
+ jsworld._formatFractionPart(parsedAmount.fraction, this.lc.int_frac_digits);
+ else
+ formattedFractionPart =
+ jsworld._formatFractionPart(parsedAmount.fraction, this.lc.frac_digits);
+ }
+ else {
+ // pad fraction with trailing zeros according to optional format parameter
+ formattedFractionPart =
+ jsworld._formatFractionPart(parsedAmount.fraction, reqPrecision);
+ }
+
+
+ // join integer and decimal parts using the mon_decimal_point property
+ var quantity;
+
+ if (this.lc.frac_digits > 0 || formattedFractionPart.length)
+ quantity = formattedIntegerPart + this.lc.mon_decimal_point + formattedFractionPart;
+ else
+ quantity = formattedIntegerPart;
+
+
+ // do final formatting with sign and symbol
+ if (jsworld._hasOption("~", options)) {
+ return quantity;
+ }
+ else {
+ var suppressSymbol = jsworld._hasOption("!", options) ? true : false;
+
+ var sign = floatAmount < 0 ? "-" : "+";
+
+ if (this.internationalFormatting || jsworld._hasOption("i", options)) {
+
+ // format with ISO-4217 code (suppressed or not)
+ if (suppressSymbol)
+ return this._formatAsInternationalCurrencyWithNoSym(sign, quantity);
+ else
+ return this._formatAsInternationalCurrency(sign, quantity);
+ }
+ else {
+ // format with local currency code (suppressed or not)
+ if (suppressSymbol)
+ return this._formatAsLocalCurrencyWithNoSym(sign, quantity);
+ else
+ return this._formatAsLocalCurrency(sign, quantity);
+ }
+ }
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Assembles the final string with sign, separator and symbol as local
+ * currency.
+ *
+ * @param {String} sign The amount sign: "+" or "-".
+ * @param {String} q The formatted quantity (unsigned).
+ *
+ * @returns {String} The final formatted string.
+ */
+ this._formatAsLocalCurrency = function (sign, q) {
+
+ // assemble final formatted amount by going over all possible value combinations of:
+ // sign {+,-} , sign position {0,1,2,3,4} , separator {0,1,2} , symbol position {0,1}
+ if (sign == "+") {
+
+ // parentheses
+ if (this.lc.p_sign_posn === 0 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return "(" + q + this.curSym + ")";
+ }
+ else if (this.lc.p_sign_posn === 0 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return "(" + this.curSym + q + ")";
+ }
+ else if (this.lc.p_sign_posn === 0 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return "(" + q + " " + this.curSym + ")";
+ }
+ else if (this.lc.p_sign_posn === 0 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return "(" + this.curSym + " " + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return this.lc.positive_sign + q + this.curSym;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.curSym + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return this.lc.positive_sign + q + " " + this.curSym;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.curSym + " " + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return this.lc.positive_sign + " " + q + this.curSym;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + " " + this.curSym + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return q + this.curSym + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.curSym + q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.curSym + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.curSym + " " + q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return q + this.curSym + " " + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.curSym + q + " " + this.lc.positive_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign + this.curSym;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.curSym + q;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.lc.positive_sign + this.curSym;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.curSym + " " + q;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign + " " + this.curSym;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + " " + this.curSym + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return q + this.curSym + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.curSym + this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.curSym + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.curSym + this.lc.positive_sign + " " + q;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return q + this.curSym + " " + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.curSym + " " + this.lc.positive_sign + q;
+ }
+
+ }
+ else if (sign == "-") {
+
+ // parentheses enclose q + sym
+ if (this.lc.n_sign_posn === 0 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return "(" + q + this.curSym + ")";
+ }
+ else if (this.lc.n_sign_posn === 0 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return "(" + this.curSym + q + ")";
+ }
+ else if (this.lc.n_sign_posn === 0 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return "(" + q + " " + this.curSym + ")";
+ }
+ else if (this.lc.n_sign_posn === 0 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return "(" + this.curSym + " " + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return this.lc.negative_sign + q + this.curSym;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.curSym + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return this.lc.negative_sign + q + " " + this.curSym;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.curSym + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return this.lc.negative_sign + " " + q + this.curSym;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + this.curSym + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return q + this.curSym + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.curSym + q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.curSym + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.curSym + " " + q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return q + this.curSym + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.curSym + q + " " + this.lc.negative_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return q + this.lc.negative_sign + this.curSym;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.curSym + q;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.lc.negative_sign + this.curSym;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.curSym + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return q + this.lc.negative_sign + " " + this.curSym;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + this.curSym + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return q + this.curSym + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.curSym + this.lc.negative_sign + q;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.curSym + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.curSym + this.lc.negative_sign + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return q + this.curSym + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.curSym + " " + this.lc.negative_sign + q;
+ }
+ }
+
+ // throw error if we fall through
+ throw "Error: Invalid POSIX LC MONETARY definition";
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Assembles the final string with sign, separator and ISO-4217
+ * currency code.
+ *
+ * @param {String} sign The amount sign: "+" or "-".
+ * @param {String} q The formatted quantity (unsigned).
+ *
+ * @returns {String} The final formatted string.
+ */
+ this._formatAsInternationalCurrency = function (sign, q) {
+
+ // assemble the final formatted amount by going over all possible value combinations of:
+ // sign {+,-} , sign position {0,1,2,3,4} , separator {0,1,2} , symbol position {0,1}
+
+ if (sign == "+") {
+
+ // parentheses
+ if (this.lc.int_p_sign_posn === 0 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return "(" + q + this.currencyCode + ")";
+ }
+ else if (this.lc.int_p_sign_posn === 0 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return "(" + this.currencyCode + q + ")";
+ }
+ else if (this.lc.int_p_sign_posn === 0 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return "(" + q + this.intSep + this.currencyCode + ")";
+ }
+ else if (this.lc.int_p_sign_posn === 0 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return "(" + this.currencyCode + this.intSep + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return this.lc.positive_sign + q + this.currencyCode;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.currencyCode + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return this.lc.positive_sign + q + this.intSep + this.currencyCode;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.currencyCode + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return this.lc.positive_sign + this.intSep + q + this.currencyCode;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + this.currencyCode + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.currencyCode + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.currencyCode + q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.currencyCode + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.currencyCode + this.intSep + q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.currencyCode + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.currencyCode + q + this.intSep + this.lc.positive_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.lc.positive_sign + this.currencyCode;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.currencyCode + q;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.lc.positive_sign + this.currencyCode;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.currencyCode + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.lc.positive_sign + this.intSep + this.currencyCode;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + this.currencyCode + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.currencyCode + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.currencyCode + this.lc.positive_sign + q;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.currencyCode + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.currencyCode + this.lc.positive_sign + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.currencyCode + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.currencyCode + this.intSep + this.lc.positive_sign + q;
+ }
+
+ }
+ else if (sign == "-") {
+
+ // parentheses enclose q + sym
+ if (this.lc.int_n_sign_posn === 0 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return "(" + q + this.currencyCode + ")";
+ }
+ else if (this.lc.int_n_sign_posn === 0 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return "(" + this.currencyCode + q + ")";
+ }
+ else if (this.lc.int_n_sign_posn === 0 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return "(" + q + this.intSep + this.currencyCode + ")";
+ }
+ else if (this.lc.int_n_sign_posn === 0 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return "(" + this.currencyCode + this.intSep + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return this.lc.negative_sign + q + this.currencyCode;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.currencyCode + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return this.lc.negative_sign + q + this.intSep + this.currencyCode;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.currencyCode + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return this.lc.negative_sign + this.intSep + q + this.currencyCode;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + this.currencyCode + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.currencyCode + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.currencyCode + q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.currencyCode + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.currencyCode + this.intSep + q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.currencyCode + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.currencyCode + q + this.intSep + this.lc.negative_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.lc.negative_sign + this.currencyCode;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.currencyCode + q;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.lc.negative_sign + this.currencyCode;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.currencyCode + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.lc.negative_sign + this.intSep + this.currencyCode;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + this.currencyCode + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.currencyCode + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.currencyCode + this.lc.negative_sign + q;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.currencyCode + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.currencyCode + this.lc.negative_sign + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.currencyCode + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.currencyCode + this.intSep + this.lc.negative_sign + q;
+ }
+ }
+
+ // throw error if we fall through
+ throw "Error: Invalid POSIX LC MONETARY definition";
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Assembles the final string with sign and separator, but suppress the
+ * local currency symbol.
+ *
+ * @param {String} sign The amount sign: "+" or "-".
+ * @param {String} q The formatted quantity (unsigned).
+ *
+ * @returns {String} The final formatted string
+ */
+ this._formatAsLocalCurrencyWithNoSym = function (sign, q) {
+
+ // assemble the final formatted amount by going over all possible value combinations of:
+ // sign {+,-} , sign position {0,1,2,3,4} , separator {0,1,2} , symbol position {0,1}
+
+ if (sign == "+") {
+
+ // parentheses
+ if (this.lc.p_sign_posn === 0) {
+ return "(" + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return this.lc.positive_sign + " " + q;
+ }
+ else if (this.lc.p_sign_posn === 1 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + " " + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 2 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return q + " " + this.lc.positive_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + " " + q;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 3 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + " " + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 0 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 1 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + " " + q;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 0) {
+ return q + " " + this.lc.positive_sign;
+ }
+ else if (this.lc.p_sign_posn === 4 && this.lc.p_sep_by_space === 2 && this.lc.p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+
+ }
+ else if (sign == "-") {
+
+ // parentheses enclose q + sym
+ if (this.lc.n_sign_posn === 0) {
+ return "(" + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return this.lc.negative_sign + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 1 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 2 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return q + " " + this.lc.negative_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 3 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 0 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 1 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + " " + q;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 0) {
+ return q + " " + this.lc.negative_sign;
+ }
+ else if (this.lc.n_sign_posn === 4 && this.lc.n_sep_by_space === 2 && this.lc.n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ }
+
+ // throw error if we fall through
+ throw "Error: Invalid POSIX LC MONETARY definition";
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Assembles the final string with sign and separator, but suppress
+ * the ISO-4217 currency code.
+ *
+ * @param {String} sign The amount sign: "+" or "-".
+ * @param {String} q The formatted quantity (unsigned).
+ *
+ * @returns {String} The final formatted string.
+ */
+ this._formatAsInternationalCurrencyWithNoSym = function (sign, q) {
+
+ // assemble the final formatted amount by going over all possible value combinations of:
+ // sign {+,-} , sign position {0,1,2,3,4} , separator {0,1,2} , symbol position {0,1}
+
+ if (sign == "+") {
+
+ // parentheses
+ if (this.lc.int_p_sign_posn === 0) {
+ return "(" + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return this.lc.positive_sign + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 1 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 2 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return q + this.intSep + this.lc.positive_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 3 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 0 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 1 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + this.intSep + q;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 0) {
+ return q + this.intSep + this.lc.positive_sign;
+ }
+ else if (this.lc.int_p_sign_posn === 4 && this.lc.int_p_sep_by_space === 2 && this.lc.int_p_cs_precedes === 1) {
+ return this.lc.positive_sign + q;
+ }
+
+ }
+ else if (sign == "-") {
+
+ // parentheses enclose q + sym
+ if (this.lc.int_n_sign_posn === 0) {
+ return "(" + q + ")";
+ }
+
+ // sign before q + sym
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return this.lc.negative_sign + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 1 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + q;
+ }
+
+ // sign after q + sym
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 2 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return q + this.intSep + this.lc.negative_sign;
+ }
+
+ // sign before sym
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 3 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + q;
+ }
+
+ // sign after symbol
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 0 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 1 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + this.intSep + q;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 0) {
+ return q + this.intSep + this.lc.negative_sign;
+ }
+ else if (this.lc.int_n_sign_posn === 4 && this.lc.int_n_sep_by_space === 2 && this.lc.int_n_cs_precedes === 1) {
+ return this.lc.negative_sign + q;
+ }
+ }
+
+ // throw error if we fall through
+ throw "Error: Invalid POSIX LC_MONETARY definition";
+ };
+};
+
+
+/**
+ * @class
+ * Class for parsing localised number strings.
+ *
+ * @public
+ * @constructor
+ * @description Creates a new numeric parser for the specified locale.
+ *
+ * @param {jsworld.Locale} locale A locale object specifying the required
+ * POSIX LC_NUMERIC formatting properties.
+ *
+ * @throws Error on constructor failure.
+ */
+jsworld.NumericParser = function(locale) {
+
+ if (typeof locale != "object" || locale._className != "jsworld.Locale")
+ throw "Constructor error: You must provide a valid jsworld.Locale instance";
+
+ this.lc = locale;
+
+
+ /**
+ * @public
+ *
+ * @description Parses a numeric string formatted according to the
+ * preset locale. Leading and trailing whitespace is ignored; the number
+ * may also be formatted without thousands separators.
+ *
+ * @param {String} formattedNumber The formatted number.
+ *
+ * @returns {Number} The parsed number.
+ *
+ * @throws Error on a parse exception.
+ */
+ this.parse = function(formattedNumber) {
+
+ if (typeof formattedNumber != "string")
+ throw "Parse error: Argument must be a string";
+
+ // trim whitespace
+ var s = jsworld._trim(formattedNumber);
+
+ // remove any thousand separator symbols
+ s = jsworld._stringReplaceAll(formattedNumber, this.lc.thousands_sep, "");
+
+ // replace any local decimal point symbols with the symbol used
+ // in JavaScript "."
+ s = jsworld._stringReplaceAll(s, this.lc.decimal_point, ".");
+
+ // test if the string represents a number
+ if (jsworld._isNumber(s))
+ return parseFloat(s, 10);
+ else
+ throw "Parse error: Invalid number string";
+ };
+};
+
+
+/**
+ * @class
+ * Class for parsing localised date and time strings.
+ *
+ * @public
+ * @constructor
+ * @description Creates a new date/time parser for the specified locale.
+ *
+ * @param {jsworld.Locale} locale A locale object specifying the required
+ * POSIX LC_TIME formatting properties.
+ *
+ * @throws Error on constructor failure.
+ */
+jsworld.DateTimeParser = function(locale) {
+
+ if (typeof locale != "object" || locale._className != "jsworld.Locale")
+ throw "Constructor error: You must provide a valid jsworld.Locale instance.";
+
+ this.lc = locale;
+
+
+ /**
+ * @public
+ *
+ * @description Parses a time string formatted according to the
+ * POSIX LC_TIME t_fmt property of the preset locale.
+ *
+ * @param {String} formattedTime The formatted time.
+ *
+ * @returns {String} The parsed time in ISO-8601 format (HH:MM:SS), e.g.
+ * "23:59:59".
+ *
+ * @throws Error on a parse exception.
+ */
+ this.parseTime = function(formattedTime) {
+
+ if (typeof formattedTime != "string")
+ throw "Parse error: Argument must be a string";
+
+ var dt = this._extractTokens(this.lc.t_fmt, formattedTime);
+
+ var timeDefined = false;
+
+ if (dt.hour !== null && dt.minute !== null && dt.second !== null) {
+ timeDefined = true;
+ }
+ else if (dt.hourAmPm !== null && dt.am !== null && dt.minute !== null && dt.second !== null) {
+ if (dt.am) {
+ // AM [12(midnight), 1 .. 11]
+ if (dt.hourAmPm == 12)
+ dt.hour = 0;
+ else
+ dt.hour = parseInt(dt.hourAmPm, 10);
+ }
+ else {
+ // PM [12(noon), 1 .. 11]
+ if (dt.hourAmPm == 12)
+ dt.hour = 12;
+ else
+ dt.hour = parseInt(dt.hourAmPm, 10) + 12;
+ }
+ timeDefined = true;
+ }
+
+ if (timeDefined)
+ return jsworld._zeroPad(dt.hour, 2) +
+ ":" +
+ jsworld._zeroPad(dt.minute, 2) +
+ ":" +
+ jsworld._zeroPad(dt.second, 2);
+ else
+ throw "Parse error: Invalid/ambiguous time string";
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Parses a date string formatted according to the
+ * POSIX LC_TIME d_fmt property of the preset locale.
+ *
+ * @param {String} formattedDate The formatted date, must be valid.
+ *
+ * @returns {String} The parsed date in ISO-8601 format (YYYY-MM-DD),
+ * e.g. "2010-03-31".
+ *
+ * @throws Error on a parse exception.
+ */
+ this.parseDate = function(formattedDate) {
+
+ if (typeof formattedDate != "string")
+ throw "Parse error: Argument must be a string";
+
+ var dt = this._extractTokens(this.lc.d_fmt, formattedDate);
+
+ var dateDefined = false;
+
+ if (dt.year !== null && dt.month !== null && dt.day !== null) {
+ dateDefined = true;
+ }
+
+ if (dateDefined)
+ return jsworld._zeroPad(dt.year, 4) +
+ "-" +
+ jsworld._zeroPad(dt.month, 2) +
+ "-" +
+ jsworld._zeroPad(dt.day, 2);
+ else
+ throw "Parse error: Invalid date string";
+ };
+
+
+ /**
+ * @public
+ *
+ * @description Parses a date/time string formatted according to the
+ * POSIX LC_TIME d_t_fmt property of the preset locale.
+ *
+ * @param {String} formattedDateTime The formatted date/time, must be
+ * valid.
+ *
+ * @returns {String} The parsed date/time in ISO-8601 format
+ * (YYYY-MM-DD HH:MM:SS), e.g. "2010-03-31 23:59:59".
+ *
+ * @throws Error on a parse exception.
+ */
+ this.parseDateTime = function(formattedDateTime) {
+
+ if (typeof formattedDateTime != "string")
+ throw "Parse error: Argument must be a string";
+
+ var dt = this._extractTokens(this.lc.d_t_fmt, formattedDateTime);
+
+ var timeDefined = false;
+ var dateDefined = false;
+
+ if (dt.hour !== null && dt.minute !== null && dt.second !== null) {
+ timeDefined = true;
+ }
+ else if (dt.hourAmPm !== null && dt.am !== null && dt.minute !== null && dt.second !== null) {
+ if (dt.am) {
+ // AM [12(midnight), 1 .. 11]
+ if (dt.hourAmPm == 12)
+ dt.hour = 0;
+ else
+ dt.hour = parseInt(dt.hourAmPm, 10);
+ }
+ else {
+ // PM [12(noon), 1 .. 11]
+ if (dt.hourAmPm == 12)
+ dt.hour = 12;
+ else
+ dt.hour = parseInt(dt.hourAmPm, 10) + 12;
+ }
+ timeDefined = true;
+ }
+
+ if (dt.year !== null && dt.month !== null && dt.day !== null) {
+ dateDefined = true;
+ }
+
+ if (dateDefined && timeDefined)
+ return jsworld._zeroPad(dt.year, 4) +
+ "-" +
+ jsworld._zeroPad(dt.month, 2) +
+ "-" +
+ jsworld._zeroPad(dt.day, 2) +
+ " " +
+ jsworld._zeroPad(dt.hour, 2) +
+ ":" +
+ jsworld._zeroPad(dt.minute, 2) +
+ ":" +
+ jsworld._zeroPad(dt.second, 2);
+ else
+ throw "Parse error: Invalid/ambiguous date/time string";
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Parses a string according to the specified format
+ * specification.
+ *
+ * @param {String} fmtSpec The format specification, e.g. "%I:%M:%S %p".
+ * @param {String} s The string to parse.
+ *
+ * @returns {object} An object with set properties year, month, day,
+ * hour, minute and second if the corresponding values are
+ * found in the parsed string.
+ *
+ * @throws Error on a parse exception.
+ */
+ this._extractTokens = function(fmtSpec, s) {
+
+ // the return object containing the parsed date/time properties
+ var dt = {
+ // for date and date/time strings
+ "year" : null,
+ "month" : null,
+ "day" : null,
+
+ // for time and date/time strings
+ "hour" : null,
+ "hourAmPm" : null,
+ "am" : null,
+ "minute" : null,
+ "second" : null,
+
+ // used internally only
+ "weekday" : null
+ };
+
+
+ // extract and process each token in the date/time spec
+ while (fmtSpec.length > 0) {
+
+ // Do we have a valid "%\w" placeholder in stream?
+ if (fmtSpec.charAt(0) == "%" && fmtSpec.charAt(1) != "") {
+
+ // get placeholder
+ var placeholder = fmtSpec.substring(0,2);
+
+ if (placeholder == "%%") {
+ // escaped '%''
+ s = s.substring(1);
+ }
+ else if (placeholder == "%a") {
+ // abbreviated weekday name
+ for (var i = 0; i < this.lc.abday.length; i++) {
+
+ if (jsworld._stringStartsWith(s, this.lc.abday[i])) {
+ dt.weekday = i;
+ s = s.substring(this.lc.abday[i].length);
+ break;
+ }
+ }
+
+ if (dt.weekday === null)
+ throw "Parse error: Unrecognised abbreviated weekday name (%a)";
+ }
+ else if (placeholder == "%A") {
+ // weekday name
+ for (var i = 0; i < this.lc.day.length; i++) {
+
+ if (jsworld._stringStartsWith(s, this.lc.day[i])) {
+ dt.weekday = i;
+ s = s.substring(this.lc.day[i].length);
+ break;
+ }
+ }
+
+ if (dt.weekday === null)
+ throw "Parse error: Unrecognised weekday name (%A)";
+ }
+ else if (placeholder == "%b" || placeholder == "%h") {
+ // abbreviated month name
+ for (var i = 0; i < this.lc.abmon.length; i++) {
+
+ if (jsworld._stringStartsWith(s, this.lc.abmon[i])) {
+ dt.month = i + 1;
+ s = s.substring(this.lc.abmon[i].length);
+ break;
+ }
+ }
+
+ if (dt.month === null)
+ throw "Parse error: Unrecognised abbreviated month name (%b)";
+ }
+ else if (placeholder == "%B") {
+ // month name
+ for (var i = 0; i < this.lc.mon.length; i++) {
+
+ if (jsworld._stringStartsWith(s, this.lc.mon[i])) {
+ dt.month = i + 1;
+ s = s.substring(this.lc.mon[i].length);
+ break;
+ }
+ }
+
+ if (dt.month === null)
+ throw "Parse error: Unrecognised month name (%B)";
+ }
+ else if (placeholder == "%d") {
+ // day of the month [01..31]
+ if (/^0[1-9]|[1-2][0-9]|3[0-1]/.test(s)) {
+ dt.day = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised day of the month (%d)";
+ }
+ else if (placeholder == "%e") {
+ // day of the month [1..31]
+
+ // Note: if %e is leading in fmt string -> space padded!
+
+ var day = s.match(/^\s?(\d{1,2})/);
+ dt.day = parseInt(day, 10);
+
+ if (isNaN(dt.day) || dt.day < 1 || dt.day > 31)
+ throw "Parse error: Unrecognised day of the month (%e)";
+
+ s = s.substring(day.length);
+ }
+ else if (placeholder == "%F") {
+ // equivalent to %Y-%m-%d (ISO-8601 date format)
+
+ // year [nnnn]
+ if (/^\d\d\d\d/.test(s)) {
+ dt.year = parseInt(s.substring(0,4), 10);
+ s = s.substring(4);
+ }
+ else {
+ throw "Parse error: Unrecognised date (%F)";
+ }
+
+ // -
+ if (jsworld._stringStartsWith(s, "-"))
+ s = s.substring(1);
+ else
+ throw "Parse error: Unrecognised date (%F)";
+
+ // month [01..12]
+ if (/^0[1-9]|1[0-2]/.test(s)) {
+ dt.month = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised date (%F)";
+
+ // -
+ if (jsworld._stringStartsWith(s, "-"))
+ s = s.substring(1);
+ else
+ throw "Parse error: Unrecognised date (%F)";
+
+ // day of the month [01..31]
+ if (/^0[1-9]|[1-2][0-9]|3[0-1]/.test(s)) {
+ dt.day = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised date (%F)";
+ }
+ else if (placeholder == "%H") {
+ // hour [00..23]
+ if (/^[0-1][0-9]|2[0-3]/.test(s)) {
+ dt.hour = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised hour (%H)";
+ }
+ else if (placeholder == "%I") {
+ // hour [01..12]
+ if (/^0[1-9]|1[0-2]/.test(s)) {
+ dt.hourAmPm = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised hour (%I)";
+ }
+ else if (placeholder == "%k") {
+ // hour [0..23]
+ var h = s.match(/^(\d{1,2})/);
+ dt.hour = parseInt(h, 10);
+
+ if (isNaN(dt.hour) || dt.hour < 0 || dt.hour > 23)
+ throw "Parse error: Unrecognised hour (%k)";
+
+ s = s.substring(h.length);
+ }
+ else if (placeholder == "%l") {
+ // hour AM/PM [1..12]
+ var h = s.match(/^(\d{1,2})/);
+ dt.hourAmPm = parseInt(h, 10);
+
+ if (isNaN(dt.hourAmPm) || dt.hourAmPm < 1 || dt.hourAmPm > 12)
+ throw "Parse error: Unrecognised hour (%l)";
+
+ s = s.substring(h.length);
+ }
+ else if (placeholder == "%m") {
+ // month [01..12]
+ if (/^0[1-9]|1[0-2]/.test(s)) {
+ dt.month = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised month (%m)";
+ }
+ else if (placeholder == "%M") {
+ // minute [00..59]
+ if (/^[0-5][0-9]/.test(s)) {
+ dt.minute = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised minute (%M)";
+ }
+ else if (placeholder == "%n") {
+ // new line
+
+ if (s.charAt(0) == "\n")
+ s = s.substring(1);
+ else
+ throw "Parse error: Unrecognised new line (%n)";
+ }
+ else if (placeholder == "%p") {
+ // locale's equivalent of AM/PM
+ if (jsworld._stringStartsWith(s, this.lc.am)) {
+ dt.am = true;
+ s = s.substring(this.lc.am.length);
+ }
+ else if (jsworld._stringStartsWith(s, this.lc.pm)) {
+ dt.am = false;
+ s = s.substring(this.lc.pm.length);
+ }
+ else
+ throw "Parse error: Unrecognised AM/PM value (%p)";
+ }
+ else if (placeholder == "%P") {
+ // same as %p but forced lower case
+ if (jsworld._stringStartsWith(s, this.lc.am.toLowerCase())) {
+ dt.am = true;
+ s = s.substring(this.lc.am.length);
+ }
+ else if (jsworld._stringStartsWith(s, this.lc.pm.toLowerCase())) {
+ dt.am = false;
+ s = s.substring(this.lc.pm.length);
+ }
+ else
+ throw "Parse error: Unrecognised AM/PM value (%P)";
+ }
+ else if (placeholder == "%R") {
+ // same as %H:%M
+
+ // hour [00..23]
+ if (/^[0-1][0-9]|2[0-3]/.test(s)) {
+ dt.hour = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised time (%R)";
+
+ // :
+ if (jsworld._stringStartsWith(s, ":"))
+ s = s.substring(1);
+ else
+ throw "Parse error: Unrecognised time (%R)";
+
+ // minute [00..59]
+ if (/^[0-5][0-9]/.test(s)) {
+ dt.minute = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised time (%R)";
+
+ }
+ else if (placeholder == "%S") {
+ // second [00..59]
+ if (/^[0-5][0-9]/.test(s)) {
+ dt.second = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised second (%S)";
+ }
+ else if (placeholder == "%T") {
+ // same as %H:%M:%S
+
+ // hour [00..23]
+ if (/^[0-1][0-9]|2[0-3]/.test(s)) {
+ dt.hour = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised time (%T)";
+
+ // :
+ if (jsworld._stringStartsWith(s, ":"))
+ s = s.substring(1);
+ else
+ throw "Parse error: Unrecognised time (%T)";
+
+ // minute [00..59]
+ if (/^[0-5][0-9]/.test(s)) {
+ dt.minute = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised time (%T)";
+
+ // :
+ if (jsworld._stringStartsWith(s, ":"))
+ s = s.substring(1);
+ else
+ throw "Parse error: Unrecognised time (%T)";
+
+ // second [00..59]
+ if (/^[0-5][0-9]/.test(s)) {
+ dt.second = parseInt(s.substring(0,2), 10);
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised time (%T)";
+ }
+ else if (placeholder == "%w") {
+ // weekday [0..6]
+ if (/^\d/.test(s)) {
+ dt.weekday = parseInt(s.substring(0,1), 10);
+ s = s.substring(1);
+ }
+ else
+ throw "Parse error: Unrecognised weekday number (%w)";
+ }
+ else if (placeholder == "%y") {
+ // year [00..99]
+ if (/^\d\d/.test(s)) {
+ var year2digits = parseInt(s.substring(0,2), 10);
+
+ // this conversion to year[nnnn] is arbitrary!!!
+ if (year2digits > 50)
+ dt.year = 1900 + year2digits;
+ else
+ dt.year = 2000 + year2digits;
+
+ s = s.substring(2);
+ }
+ else
+ throw "Parse error: Unrecognised year (%y)";
+ }
+ else if (placeholder == "%Y") {
+ // year [nnnn]
+ if (/^\d\d\d\d/.test(s)) {
+ dt.year = parseInt(s.substring(0,4), 10);
+ s = s.substring(4);
+ }
+ else
+ throw "Parse error: Unrecognised year (%Y)";
+ }
+
+ else if (placeholder == "%Z") {
+ // time-zone place holder is not supported
+
+ if (fmtSpec.length === 0)
+ break; // ignore rest of fmt spec
+ }
+
+ // remove the spec placeholder that was just parsed
+ fmtSpec = fmtSpec.substring(2);
+ }
+ else {
+ // If we don't have a placeholder, the chars
+ // at pos. 0 of format spec and parsed string must match
+
+ // Note: Space chars treated 1:1 !
+
+ if (fmtSpec.charAt(0) != s.charAt(0))
+ throw "Parse error: Unexpected symbol \"" + s.charAt(0) + "\" in date/time string";
+
+ fmtSpec = fmtSpec.substring(1);
+ s = s.substring(1);
+ }
+ }
+
+ // parsing finished, return composite date/time object
+ return dt;
+ };
+};
+
+
+/**
+ * @class
+ * Class for parsing localised currency amount strings.
+ *
+ * @public
+ * @constructor
+ * @description Creates a new monetary parser for the specified locale.
+ *
+ * @param {jsworld.Locale} locale A locale object specifying the required
+ * POSIX LC_MONETARY formatting properties.
+ *
+ * @throws Error on constructor failure.
+ */
+jsworld.MonetaryParser = function(locale) {
+
+ if (typeof locale != "object" || locale._className != "jsworld.Locale")
+ throw "Constructor error: You must provide a valid jsworld.Locale instance";
+
+
+ this.lc = locale;
+
+
+ /**
+ * @public
+ *
+ * @description Parses a currency amount string formatted according to
+ * the preset locale. Leading and trailing whitespace is ignored; the
+ * amount may also be formatted without thousands separators. Both
+ * the local (shorthand) symbol and the ISO 4217 code are accepted to
+ * designate the currency in the formatted amount.
+ *
+ * @param {String} formattedCurrency The formatted currency amount.
+ *
+ * @returns {Number} The parsed amount.
+ *
+ * @throws Error on a parse exception.
+ */
+ this.parse = function(formattedCurrency) {
+
+ if (typeof formattedCurrency != "string")
+ throw "Parse error: Argument must be a string";
+
+ // Detect the format type and remove the currency symbol
+ var symbolType = this._detectCurrencySymbolType(formattedCurrency);
+
+ var formatType, s;
+
+ if (symbolType == "local") {
+ formatType = "local";
+ s = formattedCurrency.replace(this.lc.getCurrencySymbol(), "");
+ }
+ else if (symbolType == "int") {
+ formatType = "int";
+ s = formattedCurrency.replace(this.lc.getIntCurrencySymbol(), "");
+ }
+ else if (symbolType == "none") {
+ formatType = "local"; // assume local
+ s = formattedCurrency;
+ }
+ else
+ throw "Parse error: Internal assert failure";
+
+ // Remove any thousands separators
+ s = jsworld._stringReplaceAll(s, this.lc.mon_thousands_sep, "");
+
+ // Replace any local radix char with JavaScript's "."
+ s = s.replace(this.lc.mon_decimal_point, ".");
+
+ // Remove all whitespaces
+ s = s.replace(/\s*/g, "");
+
+ // Remove any local non-negative sign
+ s = this._removeLocalNonNegativeSign(s, formatType);
+
+ // Replace any local minus sign with JavaScript's "-" and put
+ // it in front of the amount if necessary
+ // (special parentheses rule checked too)
+ s = this._normaliseNegativeSign(s, formatType);
+
+ // Finally, we should be left with a bare parsable decimal number
+ if (jsworld._isNumber(s))
+ return parseFloat(s, 10);
+ else
+ throw "Parse error: Invalid currency amount string";
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Tries to detect the symbol type used in the specified
+ * formatted currency string: local(shorthand),
+ * international (ISO-4217 code) or none.
+ *
+ * @param {String} formattedCurrency The the formatted currency string.
+ *
+ * @return {String} With possible values "local", "int" or "none".
+ */
+ this._detectCurrencySymbolType = function(formattedCurrency) {
+
+ // Check for whichever sign (int/local) is longer first
+ // to cover cases such as MOP/MOP$ and ZAR/R
+
+ if (this.lc.getCurrencySymbol().length > this.lc.getIntCurrencySymbol().length) {
+
+ if (formattedCurrency.indexOf(this.lc.getCurrencySymbol()) != -1)
+ return "local";
+ else if (formattedCurrency.indexOf(this.lc.getIntCurrencySymbol()) != -1)
+ return "int";
+ else
+ return "none";
+ }
+ else {
+ if (formattedCurrency.indexOf(this.lc.getIntCurrencySymbol()) != -1)
+ return "int";
+ else if (formattedCurrency.indexOf(this.lc.getCurrencySymbol()) != -1)
+ return "local";
+ else
+ return "none";
+ }
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Removes a local non-negative sign in a formatted
+ * currency string if it is found. This is done according to the
+ * locale properties p_sign_posn and int_p_sign_posn.
+ *
+ * @param {String} s The input string.
+ * @param {String} formatType With possible values "local" or "int".
+ *
+ * @returns {String} The processed string.
+ */
+ this._removeLocalNonNegativeSign = function(s, formatType) {
+
+ s = s.replace(this.lc.positive_sign, "");
+
+ // check for enclosing parentheses rule
+ if (((formatType == "local" && this.lc.p_sign_posn === 0) ||
+ (formatType == "int" && this.lc.int_p_sign_posn === 0) ) &&
+ /\(\d+\.?\d*\)/.test(s)) {
+ s = s.replace("(", "");
+ s = s.replace(")", "");
+ }
+
+ return s;
+ };
+
+
+ /**
+ * @private
+ *
+ * @description Replaces a local negative sign with the standard
+ * JavaScript minus ("-") sign placed in the correct position
+ * (preceding the amount). This is done according to the locale
+ * properties for negative sign symbol and relative position.
+ *
+ * @param {String} s The input string.
+ * @param {String} formatType With possible values "local" or "int".
+ *
+ * @returns {String} The processed string.
+ */
+ this._normaliseNegativeSign = function(s, formatType) {
+
+ // replace local negative symbol with JavaScript's "-"
+ s = s.replace(this.lc.negative_sign, "-");
+
+ // check for enclosing parentheses rule and replace them
+ // with negative sign before the amount
+ if ((formatType == "local" && this.lc.n_sign_posn === 0) ||
+ (formatType == "int" && this.lc.int_n_sign_posn === 0) ) {
+
+ if (/^\(\d+\.?\d*\)$/.test(s)) {
+
+ s = s.replace("(", "");
+ s = s.replace(")", "");
+ return "-" + s;
+ }
+ }
+
+ // check for rule negative sign succeeding the amount
+ if (formatType == "local" && this.lc.n_sign_posn == 2 ||
+ formatType == "int" && this.lc.int_n_sign_posn == 2 ) {
+
+ if (/^\d+\.?\d*-$/.test(s)) {
+ s = s.replace("-", "");
+ return "-" + s;
+ }
+ }
+
+ // check for rule cur. sym. succeeds and sign adjacent
+ if (formatType == "local" && this.lc.n_cs_precedes === 0 && this.lc.n_sign_posn == 3 ||
+ formatType == "local" && this.lc.n_cs_precedes === 0 && this.lc.n_sign_posn == 4 ||
+ formatType == "int" && this.lc.int_n_cs_precedes === 0 && this.lc.int_n_sign_posn == 3 ||
+ formatType == "int" && this.lc.int_n_cs_precedes === 0 && this.lc.int_n_sign_posn == 4 ) {
+
+ if (/^\d+\.?\d*-$/.test(s)) {
+ s = s.replace("-", "");
+ return "-" + s;
+ }
+ }
+
+ return s;
+ };
+};
+
+// end-of-file
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/tmp/uglify-hangs2.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/tmp/uglify-hangs2.js
new file mode 100644
index 0000000..4e9f967
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/tmp/uglify-hangs2.js
@@ -0,0 +1,166 @@
+jsworld.Locale = function(properties) {
+
+ // LC_NUMERIC
+
+
+ this.frac_digits = properties.frac_digits;
+
+
+ // may be empty string/null for currencies with no fractional part
+ if (properties.mon_decimal_point === null || properties.mon_decimal_point == "") {
+
+ if (this.frac_digits > 0)
+ throw "Error: Undefined mon_decimal_point property";
+ else
+ properties.mon_decimal_point = "";
+ }
+
+ if (typeof properties.mon_decimal_point != "string")
+ throw "Error: Invalid/missing mon_decimal_point property";
+
+ this.mon_decimal_point = properties.mon_decimal_point;
+
+
+ if (typeof properties.mon_thousands_sep != "string")
+ throw "Error: Invalid/missing mon_thousands_sep property";
+
+ this.mon_thousands_sep = properties.mon_thousands_sep;
+
+
+ if (typeof properties.mon_grouping != "string")
+ throw "Error: Invalid/missing mon_grouping property";
+
+ this.mon_grouping = properties.mon_grouping;
+
+
+ if (typeof properties.positive_sign != "string")
+ throw "Error: Invalid/missing positive_sign property";
+
+ this.positive_sign = properties.positive_sign;
+
+
+ if (typeof properties.negative_sign != "string")
+ throw "Error: Invalid/missing negative_sign property";
+
+ this.negative_sign = properties.negative_sign;
+
+
+ if (properties.p_cs_precedes !== 0 && properties.p_cs_precedes !== 1)
+ throw "Error: Invalid/missing p_cs_precedes property, must be 0 or 1";
+
+ this.p_cs_precedes = properties.p_cs_precedes;
+
+
+ if (properties.n_cs_precedes !== 0 && properties.n_cs_precedes !== 1)
+ throw "Error: Invalid/missing n_cs_precedes, must be 0 or 1";
+
+ this.n_cs_precedes = properties.n_cs_precedes;
+
+
+ if (properties.p_sep_by_space !== 0 &&
+ properties.p_sep_by_space !== 1 &&
+ properties.p_sep_by_space !== 2)
+ throw "Error: Invalid/missing p_sep_by_space property, must be 0, 1 or 2";
+
+ this.p_sep_by_space = properties.p_sep_by_space;
+
+
+ if (properties.n_sep_by_space !== 0 &&
+ properties.n_sep_by_space !== 1 &&
+ properties.n_sep_by_space !== 2)
+ throw "Error: Invalid/missing n_sep_by_space property, must be 0, 1, or 2";
+
+ this.n_sep_by_space = properties.n_sep_by_space;
+
+
+ if (properties.p_sign_posn !== 0 &&
+ properties.p_sign_posn !== 1 &&
+ properties.p_sign_posn !== 2 &&
+ properties.p_sign_posn !== 3 &&
+ properties.p_sign_posn !== 4)
+ throw "Error: Invalid/missing p_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.p_sign_posn = properties.p_sign_posn;
+
+
+ if (properties.n_sign_posn !== 0 &&
+ properties.n_sign_posn !== 1 &&
+ properties.n_sign_posn !== 2 &&
+ properties.n_sign_posn !== 3 &&
+ properties.n_sign_posn !== 4)
+ throw "Error: Invalid/missing n_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.n_sign_posn = properties.n_sign_posn;
+
+
+ if (typeof properties.int_frac_digits != "number" && properties.int_frac_digits < 0)
+ throw "Error: Invalid/missing int_frac_digits property";
+
+ this.int_frac_digits = properties.int_frac_digits;
+
+
+ if (properties.int_p_cs_precedes !== 0 && properties.int_p_cs_precedes !== 1)
+ throw "Error: Invalid/missing int_p_cs_precedes property, must be 0 or 1";
+
+ this.int_p_cs_precedes = properties.int_p_cs_precedes;
+
+
+ if (properties.int_n_cs_precedes !== 0 && properties.int_n_cs_precedes !== 1)
+ throw "Error: Invalid/missing int_n_cs_precedes property, must be 0 or 1";
+
+ this.int_n_cs_precedes = properties.int_n_cs_precedes;
+
+
+ if (properties.int_p_sep_by_space !== 0 &&
+ properties.int_p_sep_by_space !== 1 &&
+ properties.int_p_sep_by_space !== 2)
+ throw "Error: Invalid/missing int_p_sep_by_spacev, must be 0, 1 or 2";
+
+ this.int_p_sep_by_space = properties.int_p_sep_by_space;
+
+
+ if (properties.int_n_sep_by_space !== 0 &&
+ properties.int_n_sep_by_space !== 1 &&
+ properties.int_n_sep_by_space !== 2)
+ throw "Error: Invalid/missing int_n_sep_by_space property, must be 0, 1, or 2";
+
+ this.int_n_sep_by_space = properties.int_n_sep_by_space;
+
+
+ if (properties.int_p_sign_posn !== 0 &&
+ properties.int_p_sign_posn !== 1 &&
+ properties.int_p_sign_posn !== 2 &&
+ properties.int_p_sign_posn !== 3 &&
+ properties.int_p_sign_posn !== 4)
+ throw "Error: Invalid/missing int_p_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.int_p_sign_posn = properties.int_p_sign_posn;
+
+
+ if (properties.int_n_sign_posn !== 0 &&
+ properties.int_n_sign_posn !== 1 &&
+ properties.int_n_sign_posn !== 2 &&
+ properties.int_n_sign_posn !== 3 &&
+ properties.int_n_sign_posn !== 4)
+ throw "Error: Invalid/missing int_n_sign_posn property, must be 0, 1, 2, 3 or 4";
+
+ this.int_n_sign_posn = properties.int_n_sign_posn;
+
+
+ // LC_TIME
+
+ if (properties == null || typeof properties != "object")
+ throw "Error: Invalid/missing time locale properties";
+
+
+ // parse the supported POSIX LC_TIME properties
+
+ // abday
+ try {
+ this.abday = this._parseList(properties.abday, 7);
+ }
+ catch (error) {
+ throw "Error: Invalid abday property: " + error;
+ }
+
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/uglify-js.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/uglify-js.js
new file mode 100644
index 0000000..4305e23
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/uglify-js/uglify-js.js
@@ -0,0 +1,17 @@
+//convienence function(src, [options]);
+function uglify(orig_code, options){
+ options || (options = {});
+ var jsp = uglify.parser;
+ var pro = uglify.uglify;
+
+ var ast = jsp.parse(orig_code, options.strict_semicolons); // parse code and get the initial AST
+ ast = pro.ast_mangle(ast, options.mangle_options); // get a new AST with mangled names
+ ast = pro.ast_squeeze(ast, options.squeeze_options); // get an AST with compression optimizations
+ var final_code = pro.gen_code(ast, options.gen_options); // compressed code here
+ return final_code;
+};
+
+uglify.parser = require("./lib/parse-js");
+uglify.uglify = require("./lib/process");
+
+module.exports = uglify
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/.npmignore b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/.npmignore
new file mode 100644
index 0000000..8233793
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/.npmignore
@@ -0,0 +1,6 @@
+npm-debug.log
+node_modules
+.*.swp
+.lock-*
+build
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/.travis.yml b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/.travis.yml
new file mode 100644
index 0000000..5471c18
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+npm_args: --ws:native
+node_js:
+ - 0.6
+ - 0.7
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/History.md b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/History.md
new file mode 100644
index 0000000..8742ba5
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/History.md
@@ -0,0 +1,230 @@
+v0.4.20 - June 26th, 2012
+=====================
+* node v0.8.0 compatibility release.
+
+v0.4.19 - June 19th, 2012
+=====================
+* Change sender to merge buffers for relatively small payloads, may improve perf in some cases [einaros]
+* Avoid EventEmitter for Receiver classes. As above this may improve perf. [einaros]
+* Renamed fallback files from the somewhat misleading '*Windows'. [einaros]
+
+v0.4.18 - June 14th 2012
+=====================
+* Fixed incorrect md5 digest encoding in Hixie handshake [nicokaiser]
+* Added example of use with Express 3 [einaros]
+* Change installation procedure to not require --ws:native to build native extensions. They will now build if a compiler is available. [einaros]
+
+v0.4.17 - June 13th 2012
+=====================
+* Improve error handling during connection handshaking [einaros]
+* Ensure that errors are caught also after connection teardown [nicokaiser]
+* Update 'mocha' version to 1.1.0. [einaros]
+* Stop showing 'undefined' for some error logs. [tricknotes]
+* Update 'should' version to 0.6.3 [tricknotes]
+
+v0.4.16 - June 1st 2012
+=====================
+* Build fix for Windows. [einaros]
+
+v0.4.15 - May 20th 2012
+=====================
+* Enable fauxe streaming for hixie tansport. [einaros]
+* Allow hixie sender to deal with buffers. [einaros/pigne]
+* Allow error code 1011. [einaros]
+* Fix framing for empty packets (empty pings and pongs might break). [einaros]
+* Improve error and close handling, to avoid connections lingering in CLOSING state. [einaros]
+
+v0.4.14 - Apr 30th 2012
+=====================
+* use node-gyp instead of node-waf [TooTallNate]
+* remove old windows compatibility makefile, and silently fall back to native modules [einaros]
+* ensure connection status [nicokaiser]
+* websocket client updated to use port 443 by default for wss:// connections [einaros]
+* support unix sockets [kschzt]
+
+v0.4.13 - Apr 12th 2012
+=====================
+
+* circumvent node 0.6+ related memory leak caused by Object.defineProperty [nicokaiser]
+* improved error handling, improving stability in massive load use cases [nicokaiser]
+
+v0.4.12 - Mar 30th 2012
+=====================
+
+* various memory leak / possible memory leak cleanups [einaros]
+* api documentation [nicokaiser]
+* add option to disable client tracking [nicokaiser]
+
+v0.4.11 - Mar 24th 2012
+=====================
+
+* node v0.7 compatibillity release
+* gyp support [TooTallNate]
+* commander dependency update [jwueller]
+* loadbalancer support [nicokaiser]
+
+v0.4.10 - Mar 22th 2012
+=====================
+
+* Final hixie close frame fixes. [nicokaiser]
+
+v0.4.9 - Mar 21st 2012
+=====================
+
+* Various hixie bugfixes (such as proper close frame handling). [einaros]
+
+v0.4.8 - Feb 29th 2012
+=====================
+
+* Allow verifyClient to run asynchronously [karlsequin]
+* Various bugfixes and cleanups. [einaros]
+
+v0.4.7 - Feb 21st 2012
+=====================
+
+* Exposed bytesReceived from websocket client object, which makes it possible to implement bandwidth sampling. [einaros]
+* Updated browser based file upload example to include and output per websocket channel bandwidth sampling. [einaros]
+* Changed build scripts to check which architecture is currently in use. Required after the node.js changes to have prebuilt packages target ia32 by default. [einaros]
+
+v0.4.6 - Feb 9th 2012
+=====================
+
+* Added browser based file upload example. [einaros]
+* Added server-to-browser status push example. [einaros]
+* Exposed pause() and resume() on WebSocket object, to enable client stream shaping. [einaros]
+
+v0.4.5 - Feb 7th 2012
+=====================
+
+* Corrected regression bug in handling of connections with the initial frame delivered across both http upgrade head and a standalone packet. This would lead to a race condition, which in some cases could cause message corruption. [einaros]
+
+v0.4.4 - Feb 6th 2012
+=====================
+
+* Pass original request object to verifyClient, for cookie or authentication verifications. [einaros]
+* Implemented addEventListener and slightly improved the emulation API by adding a MessageEvent with a readonly data attribute. [aslakhellesoy]
+* Rewrite parts of hybi receiver to avoid stack overflows for large amounts of packets bundled in the same buffer / packet. [einaros]
+
+v0.4.3 - Feb 4th 2012
+=====================
+
+* Prioritized update: Corrected issue which would cause sockets to stay open longer than necessary, and resource leakage because of this. [einaros]
+
+v0.4.2 - Feb 4th 2012
+=====================
+
+* Breaking change: WebSocketServer's verifyOrigin option has been renamed to verifyClient. [einaros]
+* verifyClient now receives { origin: 'origin header', secure: true/false }, where 'secure' will be true for ssl connections. [einaros]
+* Split benchmark, in preparation for more thorough case. [einaros]
+* Introduced hixie-76 draft support for server, since Safari (iPhone / iPad / OS X) and Opera still aren't updated to use Hybi. [einaros]
+* Expose 'supports' object from WebSocket, to indicate e.g. the underlying transport's support for binary data. [einaros]
+* Test and code cleanups. [einaros]
+
+v0.4.1 - Jan 25th 2012
+=====================
+
+* Use readline in wscat [tricknotes]
+* Refactor _state away, in favor of the new _readyState [tricknotes]
+* travis-ci integration [einaros]
+* Fixed race condition in testsuite, causing a few tests to fail (without actually indicating errors) on travis [einaros]
+* Expose pong event [paddybyers]
+* Enabled running of WebSocketServer in noServer-mode, meaning that upgrades are passed in manually. [einaros]
+* Reworked connection procedure for WebSocketServer, and cleaned up tests. [einaros]
+
+v0.4.0 - Jan 2nd 2012
+=====================
+
+* Windows compatibility [einaros]
+* Windows compatible test script [einaros]
+
+v0.3.9 - Jan 1st 2012
+======================
+
+* Improved protocol framing performance [einaros]
+* WSS support [kazuyukitanimura]
+* WSS tests [einaros]
+* readyState exposed [justinlatimer, tricknotes]
+* url property exposed [justinlatimer]
+* Removed old 'state' property [einaros]
+* Test cleanups [einaros]
+
+v0.3.8 - Dec 27th 2011
+======================
+
+* Made it possible to listen on specific paths, which is especially good to have for precreated http servers [einaros]
+* Extensive WebSocket / WebSocketServer cleanup, including changing all internal properties to unconfigurable, unenumerable properties [einaros]
+* Receiver modifications to ensure even better performance with fragmented sends [einaros]
+* Fixed issue in sender.js, which would cause SlowBuffer instances (such as returned from the crypto library's randomBytes) to be copied (and thus be dead slow) [einaros]
+* Removed redundant buffer copy in sender.js, which should improve server performance [einaros]
+
+v0.3.7 - Dec 25nd 2011
+======================
+
+* Added a browser based API which uses EventEmitters internally [3rd-Eden]
+* Expose request information from upgrade event for websocket server clients [mmalecki]
+
+v0.3.6 - Dec 19th 2011
+======================
+
+* Added option to let WebSocket.Server use an already existing http server [mmalecki]
+* Migrating various option structures to use options.js module [einaros]
+* Added a few more tests, options and handshake verifications to ensure that faulty connections are dealt with [einaros]
+* Code cleanups in Sender and Receiver, to ensure even faster parsing [einaros]
+
+v0.3.5 - Dec 13th 2011
+======================
+
+* Optimized Sender.js, Receiver.js and bufferutil.cc:
+ * Apply loop-unrolling-like small block copies rather than use node.js Buffer#copy() (which is slow).
+ * Mask blocks of data using combination of 32bit xor and loop-unrolling, instead of single bytes.
+ * Keep pre-made send buffer for small transfers.
+* Leak fixes and code cleanups.
+
+v0.3.3 - Dec 12th 2011
+======================
+
+* Compile fix for Linux.
+* Rewrote parts of WebSocket.js, to avoid try/catch and thus avoid optimizer bailouts.
+
+v0.3.2 - Dec 11th 2011
+======================
+
+* Further performance updates, including the additions of a native BufferUtil module, which deals with several of the cpu intensive WebSocket operations.
+
+v0.3.1 - Dec 8th 2011
+======================
+
+* Service release, fixing broken tests.
+
+v0.3.0 - Dec 8th 2011
+======================
+
+* Node.js v0.4.x compatibility.
+* Code cleanups and efficiency improvements.
+* WebSocket server added, although this will still mainly be a client library.
+* WebSocket server certified to pass the Autobahn test suite.
+* Protocol improvements and corrections - such as handling (redundant) masks for empty fragments.
+* 'wscat' command line utility added, which can act as either client or server.
+
+v0.2.6 - Dec 3rd 2011
+======================
+
+* Renamed to 'ws'. Big woop, right -- but easy-websocket really just doesn't cut it anymore!
+
+v0.2.5 - Dec 3rd 2011
+======================
+
+ * Rewrote much of the WebSocket parser, to ensure high speed for highly fragmented messages.
+ * Added a BufferPool, as a start to more efficiently deal with allocations for WebSocket connections. More work to come, in that area.
+ * Updated the Autobahn report, at http://einaros.github.com/easy-websocket, with comparisons against WebSocket-Node 1.0.2 and Chrome 16.
+
+v0.2.0 - Nov 25th 2011
+======================
+
+ * Major rework to make sure all the Autobahn test cases pass. Also updated the internal tests to cover more corner cases.
+
+v0.1.2 - Nov 14th 2011
+======================
+
+ * Back and forth, back and forth: now settled on keeping the api (event names, methods) closer to the websocket browser api. This will stick now.
+ * Started keeping this history record. Better late than never, right?
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/Makefile b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/Makefile
new file mode 100644
index 0000000..1998e38
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/Makefile
@@ -0,0 +1,38 @@
+ALL_TESTS = $(shell find test/ -name '*.test.js')
+ALL_INTEGRATION = $(shell find test/ -name '*.integration.js')
+
+all:
+ node-gyp configure build
+
+clean:
+ node-gyp clean
+
+run-tests:
+ @./node_modules/.bin/mocha \
+ -t 2000 \
+ $(TESTFLAGS) \
+ $(TESTS)
+
+run-integrationtests:
+ @./node_modules/.bin/mocha \
+ -t 5000 \
+ $(TESTFLAGS) \
+ $(TESTS)
+
+test:
+ @$(MAKE) NODE_PATH=lib TESTS="$(ALL_TESTS)" run-tests
+
+integrationtest:
+ @$(MAKE) NODE_PATH=lib TESTS="$(ALL_INTEGRATION)" run-integrationtests
+
+benchmark:
+ @node bench/sender.benchmark.js
+ @node bench/parser.benchmark.js
+
+autobahn:
+ @NODE_PATH=lib node test/autobahn.js
+
+autobahn-server:
+ @NODE_PATH=lib node test/autobahn-server.js
+
+.PHONY: test
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/README.md b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/README.md
new file mode 100644
index 0000000..7c63118
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/README.md
@@ -0,0 +1,159 @@
+[](http://travis-ci.org/einaros/ws)
+
+# ws: a node.js websocket library #
+
+`ws` is a simple to use websocket implementation, up-to-date against RFC-6455, and [probably the fastest WebSocket library for node.js](http://hobbycoding.posterous.com/the-fastest-websocket-module-for-nodejs).
+
+Passes the quite extensible Autobahn test suite. See http://einaros.github.com/ws for the full reports.
+
+Comes with a command line utility, `wscat`, which can either act as a server (--listen), or client (--connect); Use it to debug simple websocket services.
+
+## Protocol support ##
+
+* **Hixie draft 76** (Old and deprecated, but still in use by Safari and Opera. Added to ws version 0.4.2, but server only. Can be disabled by setting the `disableHixie` option to true.)
+* **HyBi drafts 07-12** (Use the option `protocolVersion: 8`, or argument `-p 8` for wscat)
+* **HyBi drafts 13-17** (Current default, alternatively option `protocolVersion: 13`, or argument `-p 13` for wscat)
+
+_See the echo.websocket.org example below for how to use the `protocolVersion` option._
+
+## Usage ##
+
+### Installing ###
+
+`npm install ws`
+
+### Sending and receiving text data ###
+
+```js
+var WebSocket = require('ws');
+var ws = new WebSocket('ws://www.host.com/path');
+ws.on('open', function() {
+ ws.send('something');
+});
+ws.on('message', function(data, flags) {
+ // flags.binary will be set if a binary data is received
+ // flags.masked will be set if the data was masked
+});
+```
+
+### Sending binary data ###
+
+```js
+var WebSocket = require('ws');
+var ws = new WebSocket('ws://www.host.com/path');
+ws.on('open', function() {
+ var array = new Float32Array(5);
+ for (var i = 0; i < array.length; ++i) array[i] = i / 2;
+ ws.send(array, {binary: true, mask: true});
+});
+```
+
+Setting `mask`, as done for the send options above, will cause the data to be masked according to the websocket protocol. The same option applies for text data.
+
+### Server example ###
+
+```js
+var WebSocketServer = require('ws').Server
+ , wss = new WebSocketServer({port: 8080});
+wss.on('connection', function(ws) {
+ ws.on('message', function(message) {
+ console.log('received: %s', message);
+ });
+ ws.send('something');
+});
+```
+
+### Error handling best practices ###
+
+```js
+// If the WebSocket is closed before the following send is attempted
+ws.send('something');
+
+// Errors (both immediate and async write errors) can be detected in an optional callback.
+// The callback is also the only way of being notified that data has actually been sent.
+ws.send('something', function(error) {
+ // if error is null, the send has been completed,
+ // otherwise the error object will indicate what failed.
+});
+
+// Immediate errors can also be handled with try/catch-blocks, but **note**
+// that since sends are inherently asynchronous, socket write failures will *not*
+// be captured when this technique is used.
+try {
+ ws.send('something');
+}
+catch (e) {
+ // handle error
+}
+```
+
+### echo.websocket.org demo ###
+
+```js
+var WebSocket = require('ws');
+var ws = new WebSocket('ws://echo.websocket.org/', {protocolVersion: 8, origin: 'http://websocket.org'});
+ws.on('open', function() {
+ console.log('connected');
+ ws.send(Date.now().toString(), {mask: true});
+});
+ws.on('close', function() {
+ console.log('disconnected');
+});
+ws.on('message', function(data, flags) {
+ console.log('Roundtrip time: ' + (Date.now() - parseInt(data)) + 'ms', flags);
+ setTimeout(function() {
+ ws.send(Date.now().toString(), {mask: true});
+ }, 500);
+});
+```
+
+### wscat against echo.websocket.org ###
+
+ $ npm install -g ws
+ $ wscat -c ws://echo.websocket.org -p 8
+ connected (press CTRL+C to quit)
+ > hi there
+ < hi there
+ > are you a happy parrot?
+ < are you a happy parrot?
+
+### Other examples ###
+
+For a full example with a browser client communicating with a ws server, see the examples folder.
+
+Note that the usage together with Express 3.0 is quite different from Express 2.x. The difference is expressed in the two different serverstats-examples.
+
+Otherwise, see the test cases.
+
+### Running the tests ###
+
+`make test`
+
+## API Docs ##
+
+See the doc/ directory for Node.js-like docs for the ws classes.
+
+## License ##
+
+(The MIT License)
+
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/parser.benchmark.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/parser.benchmark.js
new file mode 100644
index 0000000..ff5f737
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/parser.benchmark.js
@@ -0,0 +1,115 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik
+ * MIT Licensed
+ */
+
+/**
+ * Benchmark dependencies.
+ */
+
+var benchmark = require('benchmark')
+ , Receiver = require('../').Receiver
+ , suite = new benchmark.Suite('Receiver');
+require('tinycolor');
+require('./util');
+
+/**
+ * Setup receiver.
+ */
+
+suite.on('start', function () {
+ receiver = new Receiver();
+});
+
+suite.on('cycle', function () {
+ receiver = new Receiver();
+});
+
+/**
+ * Benchmarks.
+ */
+
+var pingMessage = 'Hello'
+ , pingPacket1 = getBufferFromHexString('89 ' + (pack(2, 0x80 | pingMessage.length)) +
+ ' 34 83 a8 68 '+ getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68')));
+suite.add('ping message', function () {
+ receiver.add(pingPacket1);
+});
+
+var pingPacket2 = getBufferFromHexString('89 00')
+suite.add('ping with no data', function () {
+ receiver.add(pingPacket2);
+});
+
+var closePacket = getBufferFromHexString('88 00');
+suite.add('close message', function () {
+ receiver.add(closePacket);
+ receiver.endPacket();
+});
+
+var maskedTextPacket = getBufferFromHexString('81 93 34 83 a8 68 01 b9 92 52 4f a1 c6 09 59 e6 8a 52 16 e6 cb 00 5b a1 d5');
+suite.add('masked text message', function () {
+ receiver.add(maskedTextPacket);
+});
+
+binaryDataPacket = (function() {
+ var length = 125
+ , message = new Buffer(length)
+ for (var i = 0; i < length; ++i) message[i] = i % 10;
+ return getBufferFromHexString('82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 '
+ + getHexStringFromBuffer(mask(message), '34 83 a8 68'));
+})();
+suite.add('binary data (125 bytes)', function () {
+ try {
+ receiver.add(binaryDataPacket);
+
+ }
+ catch(e) {console.log(e)}
+});
+
+binaryDataPacket2 = (function() {
+ var length = 65535
+ , message = new Buffer(length)
+ for (var i = 0; i < length; ++i) message[i] = i % 10;
+ return getBufferFromHexString('82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 '
+ + getHexStringFromBuffer(mask(message), '34 83 a8 68'));
+})();
+suite.add('binary data (65535 bytes)', function () {
+ receiver.add(binaryDataPacket2);
+});
+
+binaryDataPacket3 = (function() {
+ var length = 200*1024
+ , message = new Buffer(length)
+ for (var i = 0; i < length; ++i) message[i] = i % 10;
+ return getBufferFromHexString('82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 '
+ + getHexStringFromBuffer(mask(message), '34 83 a8 68'));
+})();
+suite.add('binary data (200 kB)', function () {
+ receiver.add(binaryDataPacket3);
+});
+
+/**
+ * Output progress.
+ */
+
+suite.on('cycle', function (bench, details) {
+ console.log('\n ' + suite.name.grey, details.name.white.bold);
+ console.log(' ' + [
+ details.hz.toFixed(2).cyan + ' ops/sec'.grey
+ , details.count.toString().white + ' times executed'.grey
+ , 'benchmark took '.grey + details.times.elapsed.toString().white + ' sec.'.grey
+ ,
+ ].join(', '.grey));
+});
+
+/**
+ * Run/export benchmarks.
+ */
+
+if (!module.parent) {
+ suite.run();
+} else {
+ module.exports = suite;
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/sender.benchmark.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/sender.benchmark.js
new file mode 100644
index 0000000..20c171a
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/sender.benchmark.js
@@ -0,0 +1,66 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik
+ * MIT Licensed
+ */
+
+/**
+ * Benchmark dependencies.
+ */
+
+var benchmark = require('benchmark')
+ , Sender = require('../').Sender
+ , suite = new benchmark.Suite('Sender');
+require('tinycolor');
+require('./util');
+
+/**
+ * Setup sender.
+ */
+
+suite.on('start', function () {
+ sender = new Sender();
+ sender._socket = { write: function() {} };
+});
+
+suite.on('cycle', function () {
+ sender = new Sender();
+ sender._socket = { write: function() {} };
+});
+
+/**
+ * Benchmarks
+ */
+
+framePacket = new Buffer(200*1024);
+framePacket.fill(99);
+suite.add('frameAndSend, unmasked (200 kB)', function () {
+ sender.frameAndSend(0x2, framePacket, true, false);
+});
+suite.add('frameAndSend, masked (200 kB)', function () {
+ sender.frameAndSend(0x2, framePacket, true, true);
+});
+
+/**
+ * Output progress.
+ */
+
+suite.on('cycle', function (bench, details) {
+ console.log('\n ' + suite.name.grey, details.name.white.bold);
+ console.log(' ' + [
+ details.hz.toFixed(2).cyan + ' ops/sec'.grey
+ , details.count.toString().white + ' times executed'.grey
+ , 'benchmark took '.grey + details.times.elapsed.toString().white + ' sec.'.grey
+ ,
+ ].join(', '.grey));
+});
+
+/**
+ * Run/export benchmarks.
+ */
+
+if (!module.parent) {
+ suite.run();
+} else {
+ module.exports = suite;
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/speed.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/speed.js
new file mode 100644
index 0000000..3ce6414
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/speed.js
@@ -0,0 +1,105 @@
+var cluster = require('cluster')
+ , WebSocket = require('../')
+ , WebSocketServer = WebSocket.Server
+ , crypto = require('crypto')
+ , util = require('util')
+ , ansi = require('ansi');
+require('tinycolor');
+
+function roundPrec(num, prec) {
+ var mul = Math.pow(10, prec);
+ return Math.round(num * mul) / mul;
+}
+
+function humanSize(bytes) {
+ if (bytes >= 1048576) return roundPrec(bytes / 1048576, 2) + ' MB';
+ if (bytes >= 1024) return roundPrec(bytes / 1024, 2) + ' kB';
+ return roundPrec(bytes, 2) + ' B';
+}
+
+function generateRandomData(size) {
+ var buffer = new Buffer(size);
+ for (var i = 0; i < size; ++i) {
+ buffer[i] = ~~(Math.random() * 127);
+ }
+ return buffer;
+}
+
+if (cluster.isMaster) {
+ var wss = new WebSocketServer({port: 8181}, function() {
+ cluster.fork();
+ });
+ wss.on('connection', function(ws) {
+ ws.on('message', function(data, flags) {
+ ws.send(data, {binary: flags&&flags.binary});
+ });
+ ws.on('close', function() {});
+ });
+ cluster.on('death', function(worker) {
+ wss.close();
+ });
+}
+else {
+ var cursor = ansi(process.stdout);
+
+ var configs = [
+ [true, 10000, 64],
+ [true, 5000, 16*1024],
+ [true, 1000, 128*1024],
+ [true, 100, 1024*1024],
+ [true, 1, 500*1024*1024],
+ [false, 10000, 64],
+ [false, 5000, 16*1024],
+ [false, 1000, 128*1024],
+ [false, 100, 1024*1024],
+ ];
+
+ var largest = configs[0][1];
+ for (var i = 0, l = configs.length; i < l; ++i) {
+ if (configs[i][2] > largest) largest = configs[i][2];
+ }
+
+ console.log('Generating %s of test data ...', humanSize(largest));
+ var randomBytes = generateRandomData(largest);
+
+ function roundtrip(useBinary, roundtrips, size, cb) {
+ var data = randomBytes.slice(0, size);
+ var prefix = util.format('Running %d roundtrips of %s %s data', roundtrips, humanSize(size), useBinary ? 'binary' : 'text');
+ console.log(prefix);
+ var client = new WebSocket('ws://localhost:' + '8181');
+ var dt;
+ var roundtrip = 0;
+ function send() {
+ client.send(data, {binary: useBinary});
+ }
+ client.on('error', function(e) {
+ console.error(e);
+ process.exit();
+ });
+ client.on('open', function() {
+ dt = Date.now();
+ send();
+ });
+ client.on('message', function(data, flags) {
+ if (++roundtrip == roundtrips) {
+ var elapsed = Date.now() - dt;
+ cursor.up();
+ console.log('%s:\t%ss\t%s'
+ , useBinary ? prefix.green : prefix.cyan
+ , roundPrec(elapsed / 1000, 1).toString().green.bold
+ , (humanSize((size * roundtrips) / elapsed * 1000) + '/s').blue.bold);
+ client.close();
+ cb();
+ return;
+ }
+ process.nextTick(send);
+ });
+ }
+
+ (function run() {
+ if (configs.length == 0) process.exit();
+ var config = configs.shift();
+ config.push(run);
+ roundtrip.apply(null, config);
+ })();
+}
\ No newline at end of file
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/util.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/util.js
new file mode 100644
index 0000000..5f01281
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bench/util.js
@@ -0,0 +1,105 @@
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik
+ * MIT Licensed
+ */
+
+/**
+ * Returns a Buffer from a "ff 00 ff"-type hex string.
+ */
+
+getBufferFromHexString = function(byteStr) {
+ var bytes = byteStr.split(' ');
+ var buf = new Buffer(bytes.length);
+ for (var i = 0; i < bytes.length; ++i) {
+ buf[i] = parseInt(bytes[i], 16);
+ }
+ return buf;
+}
+
+/**
+ * Returns a hex string from a Buffer.
+ */
+
+getHexStringFromBuffer = function(data) {
+ var s = '';
+ for (var i = 0; i < data.length; ++i) {
+ s += padl(data[i].toString(16), 2, '0') + ' ';
+ }
+ return s.trim();
+}
+
+/**
+ * Splits a buffer in two parts.
+ */
+
+splitBuffer = function(buffer) {
+ var b1 = new Buffer(Math.ceil(buffer.length / 2));
+ buffer.copy(b1, 0, 0, b1.length);
+ var b2 = new Buffer(Math.floor(buffer.length / 2));
+ buffer.copy(b2, 0, b1.length, b1.length + b2.length);
+ return [b1, b2];
+}
+
+/**
+ * Performs hybi07+ type masking on a hex string or buffer.
+ */
+
+mask = function(buf, maskString) {
+ if (typeof buf == 'string') buf = new Buffer(buf);
+ var mask = getBufferFromHexString(maskString || '34 83 a8 68');
+ for (var i = 0; i < buf.length; ++i) {
+ buf[i] ^= mask[i % 4];
+ }
+ return buf;
+}
+
+/**
+ * Returns a hex string representing the length of a message
+ */
+
+getHybiLengthAsHexString = function(len, masked) {
+ if (len < 126) {
+ var buf = new Buffer(1);
+ buf[0] = (masked ? 0x80 : 0) | len;
+ }
+ else if (len < 65536) {
+ var buf = new Buffer(3);
+ buf[0] = (masked ? 0x80 : 0) | 126;
+ getBufferFromHexString(pack(4, len)).copy(buf, 1);
+ }
+ else {
+ var buf = new Buffer(9);
+ buf[0] = (masked ? 0x80 : 0) | 127;
+ getBufferFromHexString(pack(16, len)).copy(buf, 1);
+ }
+ return getHexStringFromBuffer(buf);
+}
+
+/**
+ * Unpacks a Buffer into a number.
+ */
+
+unpack = function(buffer) {
+ var n = 0;
+ for (var i = 0; i < buffer.length; ++i) {
+ n = (i == 0) ? buffer[i] : (n * 256) + buffer[i];
+ }
+ return n;
+}
+
+/**
+ * Returns a hex string, representing a specific byte count 'length', from a number.
+ */
+
+pack = function(length, number) {
+ return padl(number.toString(16), length, '0').replace(/([0-9a-f][0-9a-f])/gi, '$1 ').trim();
+}
+
+/**
+ * Left pads the string 's' to a total length of 'n' with char 'c'.
+ */
+
+padl = function(s, n, c) {
+ return new Array(1 + n - s.length).join(c) + s;
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bin/wscat b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bin/wscat
new file mode 100755
index 0000000..7075f7f
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/bin/wscat
@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+/*!
+ * ws: a node.js websocket client
+ * Copyright(c) 2011 Einar Otto Stangvik
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var WebSocket = require('../')
+ , fs = require('fs')
+ , program = require('commander')
+ , util = require('util')
+ , events = require('events')
+ , readline = require('readline');
+
+/**
+ * InputReader - processes console input
+ */
+
+function Console() {
+ this.stdin = process.stdin;
+ this.stdout = process.stdout;
+
+ this.readlineInterface = readline.createInterface(this.stdin, this.stdout);
+
+ var self = this;
+ this.readlineInterface.on('line', function(data) {
+ self.emit('line', data);
+ });
+ this.readlineInterface.on('close', function() {
+ self.emit('close');
+ });
+
+ this._resetInput = function() {
+ self.clear();
+ }
+}
+util.inherits(Console, events.EventEmitter);
+
+Console.Colors = {
+ Red: '\033[31m',
+ Green: '\033[32m',
+ Yellow: '\033[33m',
+ Blue: '\033[34m',
+ Default: '\033[39m'
+};
+
+Console.prototype.prompt = function() {
+ this.readlineInterface.prompt();
+}
+
+Console.prototype.print = function(msg, color) {
+ this.clear();
+ color = color || Console.Colors.Default;
+ this.stdout.write(color + msg + Console.Colors.Default + '\n');
+ this.prompt();
+}
+
+Console.prototype.clear = function() {
+ this.stdout.write('\033[2K\033[E');
+}
+
+Console.prototype.pause = function() {
+ this.stdin.on('keypress', this._resetInput);
+}
+
+Console.prototype.resume = function() {
+ this.stdin.removeListener('keypress', this._resetInput);
+}
+
+/**
+ * The actual application
+ */
+
+var version = JSON.parse(fs.readFileSync(__dirname + '/../package.json', 'utf8')).version;
+program
+ .version(version)
+ .usage('[options] ')
+ .option('-l, --listen ', 'listen on port')
+ .option('-c, --connect ', 'connect to a websocket server')
+ .option('-p, --protocol ', 'optional protocol version')
+ .option('-o, --origin ', 'optional origin')
+ .parse(process.argv);
+
+if (program.listen && program.connect) {
+ console.error('\033[33merror: use either --listen or --connect\033[39m');
+ process.exit(-1);
+}
+else if (program.listen) {
+ var wsConsole = new Console();
+ wsConsole.pause();
+ var options = {};
+ if (program.protocol) options.protocolVersion = program.protocol;
+ if (program.origin) options.origin = program.origin;
+ var ws = null;
+ var wss = new WebSocket.Server({port: program.listen}, function() {
+ wsConsole.print('listening on port ' + program.listen + ' (press CTRL+C to quit)', Console.Colors.Green);
+ wsConsole.clear();
+ });
+ wsConsole.on('close', function() {
+ if (ws) {
+ try {
+ ws.close();
+ }
+ catch (e) {}
+ }
+ process.exit(0);
+ });
+ wsConsole.on('line', function(data) {
+ if (ws) {
+ ws.send(data, {mask: true});
+ wsConsole.prompt();
+ }
+ });
+ wss.on('connection', function(newClient) {
+ if (ws) {
+ // limit to one client
+ newClient.terminate();
+ return;
+ };
+ ws = newClient;
+ wsConsole.resume();
+ wsConsole.prompt();
+ wsConsole.print('client connected', Console.Colors.Green);
+ ws.on('close', function() {
+ wsConsole.print('disconnected', Console.Colors.Green);
+ wsConsole.clear();
+ wsConsole.pause();
+ ws = null;
+ });
+ ws.on('error', function(code, description) {
+ wsConsole.print('error: ' + code + (description ? ' ' + description : ''), Console.Colors.Yellow);
+ });
+ ws.on('message', function(data, flags) {
+ wsConsole.print('< ' + data, Console.Colors.Blue);
+ });
+ });
+ wss.on('error', function(error) {
+ wsConsole.print('error: ' + error.toString(), Console.Colors.Yellow);
+ process.exit(-1);
+ });
+}
+else if (program.connect) {
+ var wsConsole = new Console();
+ var options = {};
+ if (program.protocol) options.protocolVersion = program.protocol;
+ if (program.origin) options.origin = program.origin;
+ var ws = new WebSocket(program.connect, options);
+ ws.on('open', function() {
+ wsConsole.print('connected (press CTRL+C to quit)', Console.Colors.Green);
+ wsConsole.on('line', function(data) {
+ ws.send(data, {mask: true});
+ wsConsole.prompt();
+ });
+ });
+ ws.on('close', function() {
+ wsConsole.print('disconnected', Console.Colors.Green);
+ wsConsole.clear();
+ process.exit();
+ });
+ ws.on('error', function(code, description) {
+ wsConsole.print('error: ' + code + (description ? ' ' + description : ''), Console.Colors.Yellow);
+ process.exit(-1);
+ });
+ ws.on('message', function(data, flags) {
+ wsConsole.print('< ' + data, Console.Colors.Blue);
+ });
+ wsConsole.on('close', function() {
+ if (ws) {
+ try {
+ ws.close();
+ }
+ catch(e) {}
+ process.exit();
+ }
+ });
+}
+else {
+ console.error('\033[33merror: use either --listen or --connect\033[39m');
+ process.exit(-1);
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/binding.gyp b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/binding.gyp
new file mode 100644
index 0000000..a83d279
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/binding.gyp
@@ -0,0 +1,14 @@
+{
+ 'targets': [
+ {
+ 'target_name': 'validation',
+ 'cflags': [ '-O3' ],
+ 'sources': [ 'src/validation.cc' ]
+ },
+ {
+ 'target_name': 'bufferutil',
+ 'cflags': [ '-O3' ],
+ 'sources': [ 'src/bufferutil.cc' ]
+ }
+ ]
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Makefile b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Makefile
new file mode 100644
index 0000000..882a23f
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Makefile
@@ -0,0 +1,349 @@
+# We borrow heavily from the kernel build setup, though we are simpler since
+# we don't have Kconfig tweaking settings on us.
+
+# The implicit make rules have it looking for RCS files, among other things.
+# We instead explicitly write all the rules we care about.
+# It's even quicker (saves ~200ms) to pass -r on the command line.
+MAKEFLAGS=-r
+
+# The source directory tree.
+srcdir := ..
+abs_srcdir := $(abspath $(srcdir))
+
+# The name of the builddir.
+builddir_name ?= .
+
+# The V=1 flag on command line makes us verbosely print command lines.
+ifdef V
+ quiet=
+else
+ quiet=quiet_
+endif
+
+# Specify BUILDTYPE=Release on the command line for a release build.
+BUILDTYPE ?= Release
+
+# Directory all our build output goes into.
+# Note that this must be two directories beneath src/ for unit tests to pass,
+# as they reach into the src/ directory for data with relative paths.
+builddir ?= $(builddir_name)/$(BUILDTYPE)
+abs_builddir := $(abspath $(builddir))
+depsdir := $(builddir)/.deps
+
+# Object output directory.
+obj := $(builddir)/obj
+abs_obj := $(abspath $(obj))
+
+# We build up a list of every single one of the targets so we can slurp in the
+# generated dependency rule Makefiles in one pass.
+all_deps :=
+
+
+
+# C++ apps need to be linked with g++.
+#
+# Note: flock is used to seralize linking. Linking is a memory-intensive
+# process so running parallel links can often lead to thrashing. To disable
+# the serialization, override LINK via an envrionment variable as follows:
+#
+# export LINK=g++
+#
+# This will allow make to invoke N linker processes as specified in -jN.
+LINK ?= flock $(builddir)/linker.lock $(CXX)
+
+CC.target ?= $(CC)
+CFLAGS.target ?= $(CFLAGS)
+CXX.target ?= $(CXX)
+CXXFLAGS.target ?= $(CXXFLAGS)
+LINK.target ?= $(LINK)
+LDFLAGS.target ?= $(LDFLAGS)
+AR.target ?= $(AR)
+ARFLAGS.target ?= crsT
+
+# N.B.: the logic of which commands to run should match the computation done
+# in gyp's make.py where ARFLAGS.host etc. is computed.
+# TODO(evan): move all cross-compilation logic to gyp-time so we don't need
+# to replicate this environment fallback in make as well.
+CC.host ?= gcc
+CFLAGS.host ?=
+CXX.host ?= g++
+CXXFLAGS.host ?=
+LINK.host ?= g++
+LDFLAGS.host ?=
+AR.host ?= ar
+ARFLAGS.host := crsT
+
+# Define a dir function that can handle spaces.
+# http://www.gnu.org/software/make/manual/make.html#Syntax-of-Functions
+# "leading spaces cannot appear in the text of the first argument as written.
+# These characters can be put into the argument value by variable substitution."
+empty :=
+space := $(empty) $(empty)
+
+# http://stackoverflow.com/questions/1189781/using-make-dir-or-notdir-on-a-path-with-spaces
+replace_spaces = $(subst $(space),?,$1)
+unreplace_spaces = $(subst ?,$(space),$1)
+dirx = $(call unreplace_spaces,$(dir $(call replace_spaces,$1)))
+
+# Flags to make gcc output dependency info. Note that you need to be
+# careful here to use the flags that ccache and distcc can understand.
+# We write to a dep file on the side first and then rename at the end
+# so we can't end up with a broken dep file.
+depfile = $(depsdir)/$(call replace_spaces,$@).d
+DEPFLAGS = -MMD -MF $(depfile).raw
+
+# We have to fixup the deps output in a few ways.
+# (1) the file output should mention the proper .o file.
+# ccache or distcc lose the path to the target, so we convert a rule of
+# the form:
+# foobar.o: DEP1 DEP2
+# into
+# path/to/foobar.o: DEP1 DEP2
+# (2) we want missing files not to cause us to fail to build.
+# We want to rewrite
+# foobar.o: DEP1 DEP2 \
+# DEP3
+# to
+# DEP1:
+# DEP2:
+# DEP3:
+# so if the files are missing, they're just considered phony rules.
+# We have to do some pretty insane escaping to get those backslashes
+# and dollar signs past make, the shell, and sed at the same time.
+# Doesn't work with spaces, but that's fine: .d files have spaces in
+# their names replaced with other characters.
+define fixup_dep
+# The depfile may not exist if the input file didn't have any #includes.
+touch $(depfile).raw
+# Fixup path as in (1).
+sed -e "s|^$(notdir $@)|$@|" $(depfile).raw >> $(depfile)
+# Add extra rules as in (2).
+# We remove slashes and replace spaces with new lines;
+# remove blank lines;
+# delete the first line and append a colon to the remaining lines.
+sed -e 's|\\||' -e 'y| |\n|' $(depfile).raw |\
+ grep -v '^$$' |\
+ sed -e 1d -e 's|$$|:|' \
+ >> $(depfile)
+rm $(depfile).raw
+endef
+
+# Command definitions:
+# - cmd_foo is the actual command to run;
+# - quiet_cmd_foo is the brief-output summary of the command.
+
+quiet_cmd_cc = CC($(TOOLSET)) $@
+cmd_cc = $(CC.$(TOOLSET)) $(GYP_CFLAGS) $(DEPFLAGS) $(CFLAGS.$(TOOLSET)) -c -o $@ $<
+
+quiet_cmd_cxx = CXX($(TOOLSET)) $@
+cmd_cxx = $(CXX.$(TOOLSET)) $(GYP_CXXFLAGS) $(DEPFLAGS) $(CXXFLAGS.$(TOOLSET)) -c -o $@ $<
+
+quiet_cmd_touch = TOUCH $@
+cmd_touch = touch $@
+
+quiet_cmd_copy = COPY $@
+# send stderr to /dev/null to ignore messages when linking directories.
+cmd_copy = ln -f "$<" "$@" 2>/dev/null || (rm -rf "$@" && cp -af "$<" "$@")
+
+quiet_cmd_alink = AR($(TOOLSET)) $@
+cmd_alink = rm -f $@ && $(AR.$(TOOLSET)) $(ARFLAGS.$(TOOLSET)) $@ $(filter %.o,$^)
+
+# Due to circular dependencies between libraries :(, we wrap the
+# special "figure out circular dependencies" flags around the entire
+# input list during linking.
+quiet_cmd_link = LINK($(TOOLSET)) $@
+cmd_link = $(LINK.$(TOOLSET)) $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -o $@ -Wl,--start-group $(LD_INPUTS) -Wl,--end-group $(LIBS)
+
+# We support two kinds of shared objects (.so):
+# 1) shared_library, which is just bundling together many dependent libraries
+# into a link line.
+# 2) loadable_module, which is generating a module intended for dlopen().
+#
+# They differ only slightly:
+# In the former case, we want to package all dependent code into the .so.
+# In the latter case, we want to package just the API exposed by the
+# outermost module.
+# This means shared_library uses --whole-archive, while loadable_module doesn't.
+# (Note that --whole-archive is incompatible with the --start-group used in
+# normal linking.)
+
+# Other shared-object link notes:
+# - Set SONAME to the library filename so our binaries don't reference
+# the local, absolute paths used on the link command-line.
+quiet_cmd_solink = SOLINK($(TOOLSET)) $@
+cmd_solink = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--whole-archive $(LD_INPUTS) -Wl,--no-whole-archive $(LIBS)
+
+quiet_cmd_solink_module = SOLINK_MODULE($(TOOLSET)) $@
+cmd_solink_module = $(LINK.$(TOOLSET)) -shared $(GYP_LDFLAGS) $(LDFLAGS.$(TOOLSET)) -Wl,-soname=$(@F) -o $@ -Wl,--start-group $(filter-out FORCE_DO_CMD, $^) -Wl,--end-group $(LIBS)
+
+
+# Define an escape_quotes function to escape single quotes.
+# This allows us to handle quotes properly as long as we always use
+# use single quotes and escape_quotes.
+escape_quotes = $(subst ','\'',$(1))
+# This comment is here just to include a ' to unconfuse syntax highlighting.
+# Define an escape_vars function to escape '$' variable syntax.
+# This allows us to read/write command lines with shell variables (e.g.
+# $LD_LIBRARY_PATH), without triggering make substitution.
+escape_vars = $(subst $$,$$$$,$(1))
+# Helper that expands to a shell command to echo a string exactly as it is in
+# make. This uses printf instead of echo because printf's behaviour with respect
+# to escape sequences is more portable than echo's across different shells
+# (e.g., dash, bash).
+exact_echo = printf '%s\n' '$(call escape_quotes,$(1))'
+
+# Helper to compare the command we're about to run against the command
+# we logged the last time we ran the command. Produces an empty
+# string (false) when the commands match.
+# Tricky point: Make has no string-equality test function.
+# The kernel uses the following, but it seems like it would have false
+# positives, where one string reordered its arguments.
+# arg_check = $(strip $(filter-out $(cmd_$(1)), $(cmd_$@)) \
+# $(filter-out $(cmd_$@), $(cmd_$(1))))
+# We instead substitute each for the empty string into the other, and
+# say they're equal if both substitutions produce the empty string.
+# .d files contain ? instead of spaces, take that into account.
+command_changed = $(or $(subst $(cmd_$(1)),,$(cmd_$(call replace_spaces,$@))),\
+ $(subst $(cmd_$(call replace_spaces,$@)),,$(cmd_$(1))))
+
+# Helper that is non-empty when a prerequisite changes.
+# Normally make does this implicitly, but we force rules to always run
+# so we can check their command lines.
+# $? -- new prerequisites
+# $| -- order-only dependencies
+prereq_changed = $(filter-out FORCE_DO_CMD,$(filter-out $|,$?))
+
+# Helper that executes all postbuilds, and deletes the output file when done
+# if any of the postbuilds failed.
+define do_postbuilds
+ @E=0;\
+ for p in $(POSTBUILDS); do\
+ eval $$p;\
+ F=$$?;\
+ if [ $$F -ne 0 ]; then\
+ E=$$F;\
+ fi;\
+ done;\
+ if [ $$E -ne 0 ]; then\
+ rm -rf "$@";\
+ exit $$E;\
+ fi
+endef
+
+# do_cmd: run a command via the above cmd_foo names, if necessary.
+# Should always run for a given target to handle command-line changes.
+# Second argument, if non-zero, makes it do asm/C/C++ dependency munging.
+# Third argument, if non-zero, makes it do POSTBUILDS processing.
+# Note: We intentionally do NOT call dirx for depfile, since it contains ? for
+# spaces already and dirx strips the ? characters.
+define do_cmd
+$(if $(or $(command_changed),$(prereq_changed)),
+ @$(call exact_echo, $($(quiet)cmd_$(1)))
+ @mkdir -p "$(call dirx,$@)" "$(dir $(depfile))"
+ $(if $(findstring flock,$(word 1,$(cmd_$1))),
+ @$(cmd_$(1))
+ @echo " $(quiet_cmd_$(1)): Finished",
+ @$(cmd_$(1))
+ )
+ @$(call exact_echo,$(call escape_vars,cmd_$(call replace_spaces,$@) := $(cmd_$(1)))) > $(depfile)
+ @$(if $(2),$(fixup_dep))
+ $(if $(and $(3), $(POSTBUILDS)),
+ $(call do_postbuilds)
+ )
+)
+endef
+
+# Declare the "all" target first so it is the default,
+# even though we don't have the deps yet.
+.PHONY: all
+all:
+
+# Use FORCE_DO_CMD to force a target to run. Should be coupled with
+# do_cmd.
+.PHONY: FORCE_DO_CMD
+FORCE_DO_CMD:
+
+TOOLSET := target
+# Suffix rules, putting all outputs into $(obj).
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cpp FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.cxx FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.S FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(srcdir)/%.s FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+# Try building from generated source, too.
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cpp FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.cxx FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.S FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj).$(TOOLSET)/%.s FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+$(obj).$(TOOLSET)/%.o: $(obj)/%.c FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cpp FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.cxx FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.S FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+$(obj).$(TOOLSET)/%.o: $(obj)/%.s FORCE_DO_CMD
+ @$(call do_cmd,cc,1)
+
+
+ifeq ($(strip $(foreach prefix,$(NO_LOAD),\
+ $(findstring $(join ^,$(prefix)),\
+ $(join ^,bufferutil.target.mk)))),)
+ include bufferutil.target.mk
+endif
+ifeq ($(strip $(foreach prefix,$(NO_LOAD),\
+ $(findstring $(join ^,$(prefix)),\
+ $(join ^,validation.target.mk)))),)
+ include validation.target.mk
+endif
+
+quiet_cmd_regen_makefile = ACTION Regenerating $@
+cmd_regen_makefile = /home/logsol/.node-gyp/0.6.13/tools/gyp_addon -fmake --ignore-environment "--toplevel-dir=." -I/home/logsol/projects/js/chuck.js/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/config.gypi -I/home/logsol/.node-gyp/0.6.13/tools/addon.gypi -I/home/logsol/.node-gyp/0.6.13/common.gypi "--depth=." "-Goutput_dir=." "--generator-output=build" "-Dlibrary=shared_library" "-Dvisibility=default" "-Dnode_root_dir=/home/logsol/.node-gyp/0.6.13" "-Dmodule_root_dir=/home/logsol/projects/js/chuck.js/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws" binding.gyp
+Makefile: $(srcdir)/../../../../../../../../../.node-gyp/0.6.13/tools/addon.gypi $(srcdir)/build/config.gypi $(srcdir)/binding.gyp $(srcdir)/../../../../../../../../../.node-gyp/0.6.13/common.gypi
+ $(call do_cmd,regen_makefile)
+
+# "all" is a concatenation of the "all" targets from all the included
+# sub-makefiles. This is just here to clarify.
+all:
+
+# Add in dependency-tracking rules. $(all_deps) is the list of every single
+# target in our tree. Only consider the ones with .d (dependency) info:
+d_files := $(wildcard $(foreach f,$(all_deps),$(depsdir)/$(f).d))
+ifneq ($(d_files),)
+ # Rather than include each individual .d file, concatenate them into a
+ # single file which make is able to load faster. We split this into
+ # commands that take 1000 files at a time to avoid overflowing the
+ # command line.
+ $(shell cat $(wordlist 1,1000,$(d_files)) > $(depsdir)/all.deps)
+
+ ifneq ($(word 1001,$(d_files)),)
+ $(error Found unprocessed dependency files (gyp didn't generate enough rules!))
+ endif
+
+ # make looks for ways to re-generate included makefiles, but in our case, we
+ # don't have a direct way. Explicitly telling make that it has nothing to do
+ # for them makes it go faster.
+ $(depsdir)/all.deps: ;
+
+ include $(depsdir)/all.deps
+endif
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/bufferutil.node.d b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/bufferutil.node.d
new file mode 100644
index 0000000..0695fcc
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/bufferutil.node.d
@@ -0,0 +1 @@
+cmd_Release/bufferutil.node := ln -f "Release/obj.target/bufferutil.node" "Release/bufferutil.node" 2>/dev/null || (rm -rf "Release/bufferutil.node" && cp -af "Release/obj.target/bufferutil.node" "Release/bufferutil.node")
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/bufferutil.node.d b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/bufferutil.node.d
new file mode 100644
index 0000000..4520998
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/bufferutil.node.d
@@ -0,0 +1 @@
+cmd_Release/obj.target/bufferutil.node := flock ./Release/linker.lock g++ -shared -pthread -rdynamic -Wl,-soname=bufferutil.node -o Release/obj.target/bufferutil.node -Wl,--start-group Release/obj.target/bufferutil/src/bufferutil.o -Wl,--end-group
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/bufferutil/src/bufferutil.o.d b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/bufferutil/src/bufferutil.o.d
new file mode 100644
index 0000000..61f233b
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/bufferutil/src/bufferutil.o.d
@@ -0,0 +1,27 @@
+cmd_Release/obj.target/bufferutil/src/bufferutil.o := g++ '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' -I/home/logsol/.node-gyp/0.6.13/src -I/home/logsol/.node-gyp/0.6.13/deps/uv/include -I/home/logsol/.node-gyp/0.6.13/deps/v8/include -fPIC -Wall -pthread -ansi -O3 -O3 -fdata-sections -ffunction-sections -fno-strict-aliasing -fno-rtti -fno-exceptions -MMD -MF ./Release/.deps/Release/obj.target/bufferutil/src/bufferutil.o.d.raw -c -o Release/obj.target/bufferutil/src/bufferutil.o ../src/bufferutil.cc
+Release/obj.target/bufferutil/src/bufferutil.o: ../src/bufferutil.cc \
+ /home/logsol/.node-gyp/0.6.13/deps/v8/include/v8.h \
+ /home/logsol/.node-gyp/0.6.13/deps/v8/include/v8stdint.h \
+ /home/logsol/.node-gyp/0.6.13/src/node.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/ares.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/ares_version.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/uv-unix.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ngx-queue.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ev.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/eio.h \
+ /home/logsol/.node-gyp/0.6.13/src/node_object_wrap.h \
+ /home/logsol/.node-gyp/0.6.13/src/node_buffer.h
+../src/bufferutil.cc:
+/home/logsol/.node-gyp/0.6.13/deps/v8/include/v8.h:
+/home/logsol/.node-gyp/0.6.13/deps/v8/include/v8stdint.h:
+/home/logsol/.node-gyp/0.6.13/src/node.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/ares.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/ares_version.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/uv-unix.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ngx-queue.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ev.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/eio.h:
+/home/logsol/.node-gyp/0.6.13/src/node_object_wrap.h:
+/home/logsol/.node-gyp/0.6.13/src/node_buffer.h:
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/validation.node.d b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/validation.node.d
new file mode 100644
index 0000000..7fdebfd
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/validation.node.d
@@ -0,0 +1 @@
+cmd_Release/obj.target/validation.node := flock ./Release/linker.lock g++ -shared -pthread -rdynamic -Wl,-soname=validation.node -o Release/obj.target/validation.node -Wl,--start-group Release/obj.target/validation/src/validation.o -Wl,--end-group
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/validation/src/validation.o.d b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/validation/src/validation.o.d
new file mode 100644
index 0000000..66b9f32
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/obj.target/validation/src/validation.o.d
@@ -0,0 +1,27 @@
+cmd_Release/obj.target/validation/src/validation.o := g++ '-D_LARGEFILE_SOURCE' '-D_FILE_OFFSET_BITS=64' -I/home/logsol/.node-gyp/0.6.13/src -I/home/logsol/.node-gyp/0.6.13/deps/uv/include -I/home/logsol/.node-gyp/0.6.13/deps/v8/include -fPIC -Wall -pthread -ansi -O3 -O3 -fdata-sections -ffunction-sections -fno-strict-aliasing -fno-rtti -fno-exceptions -MMD -MF ./Release/.deps/Release/obj.target/validation/src/validation.o.d.raw -c -o Release/obj.target/validation/src/validation.o ../src/validation.cc
+Release/obj.target/validation/src/validation.o: ../src/validation.cc \
+ /home/logsol/.node-gyp/0.6.13/deps/v8/include/v8.h \
+ /home/logsol/.node-gyp/0.6.13/deps/v8/include/v8stdint.h \
+ /home/logsol/.node-gyp/0.6.13/src/node.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/ares.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/ares_version.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/uv-unix.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ngx-queue.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ev.h \
+ /home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/eio.h \
+ /home/logsol/.node-gyp/0.6.13/src/node_object_wrap.h \
+ /home/logsol/.node-gyp/0.6.13/src/node_buffer.h
+../src/validation.cc:
+/home/logsol/.node-gyp/0.6.13/deps/v8/include/v8.h:
+/home/logsol/.node-gyp/0.6.13/deps/v8/include/v8stdint.h:
+/home/logsol/.node-gyp/0.6.13/src/node.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/ares.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/ares_version.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/uv-unix.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ngx-queue.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/ev.h:
+/home/logsol/.node-gyp/0.6.13/deps/uv/include/uv-private/eio.h:
+/home/logsol/.node-gyp/0.6.13/src/node_object_wrap.h:
+/home/logsol/.node-gyp/0.6.13/src/node_buffer.h:
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/validation.node.d b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/validation.node.d
new file mode 100644
index 0000000..e0ff2cf
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/.deps/Release/validation.node.d
@@ -0,0 +1 @@
+cmd_Release/validation.node := ln -f "Release/obj.target/validation.node" "Release/validation.node" 2>/dev/null || (rm -rf "Release/validation.node" && cp -af "Release/obj.target/validation.node" "Release/validation.node")
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/bufferutil.node b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/bufferutil.node
new file mode 100755
index 0000000..492c2a8
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/bufferutil.node differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/linker.lock b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/linker.lock
new file mode 100644
index 0000000..e69de29
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/bufferutil.node b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/bufferutil.node
new file mode 100755
index 0000000..492c2a8
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/bufferutil.node differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/bufferutil/src/bufferutil.o b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/bufferutil/src/bufferutil.o
new file mode 100644
index 0000000..eeabb77
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/bufferutil/src/bufferutil.o differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/validation.node b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/validation.node
new file mode 100755
index 0000000..a1fa9a3
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/validation.node differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/validation/src/validation.o b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/validation/src/validation.o
new file mode 100644
index 0000000..0aca573
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/obj.target/validation/src/validation.o differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/validation.node b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/validation.node
new file mode 100755
index 0000000..a1fa9a3
Binary files /dev/null and b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/Release/validation.node differ
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/binding.Makefile b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/binding.Makefile
new file mode 100644
index 0000000..a69b3d2
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/binding.Makefile
@@ -0,0 +1,6 @@
+# This file is generated by gyp; do not edit.
+
+export builddir_name ?= build/./.
+.PHONY: all
+all:
+ $(MAKE) bufferutil validation
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/bufferutil.target.mk b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/bufferutil.target.mk
new file mode 100644
index 0000000..3048933
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/bufferutil.target.mk
@@ -0,0 +1,113 @@
+# This file is generated by gyp; do not edit.
+
+TOOLSET := target
+TARGET := bufferutil
+DEFS_Debug := '-D_LARGEFILE_SOURCE' \
+ '-D_FILE_OFFSET_BITS=64' \
+ '-DDEBUG' \
+ '-D_DEBUG'
+
+# Flags passed to all source files.
+CFLAGS_Debug := -fPIC \
+ -Wall \
+ -pthread \
+ -ansi \
+ -O3 \
+ -g \
+ -O0
+
+# Flags passed to only C files.
+CFLAGS_C_Debug :=
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Debug := -fno-rtti \
+ -fno-exceptions
+
+INCS_Debug := -I/home/logsol/.node-gyp/0.6.13/src \
+ -I/home/logsol/.node-gyp/0.6.13/deps/uv/include \
+ -I/home/logsol/.node-gyp/0.6.13/deps/v8/include
+
+DEFS_Release := '-D_LARGEFILE_SOURCE' \
+ '-D_FILE_OFFSET_BITS=64'
+
+# Flags passed to all source files.
+CFLAGS_Release := -fPIC \
+ -Wall \
+ -pthread \
+ -ansi \
+ -O3 \
+ -O3 \
+ -fdata-sections \
+ -ffunction-sections \
+ -fno-strict-aliasing
+
+# Flags passed to only C files.
+CFLAGS_C_Release :=
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Release := -fno-rtti \
+ -fno-exceptions
+
+INCS_Release := -I/home/logsol/.node-gyp/0.6.13/src \
+ -I/home/logsol/.node-gyp/0.6.13/deps/uv/include \
+ -I/home/logsol/.node-gyp/0.6.13/deps/v8/include
+
+OBJS := $(obj).target/$(TARGET)/src/bufferutil.o
+
+# Add to the list of files we specially track dependencies for.
+all_deps += $(OBJS)
+
+# CFLAGS et al overrides must be target-local.
+# See "Target-specific Variable Values" in the GNU Make manual.
+$(OBJS): TOOLSET := $(TOOLSET)
+$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE))
+$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE))
+
+# Suffix rules, putting all outputs into $(obj).
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+# Try building from generated source, too.
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+# End of this set of suffix rules
+### Rules for final target.
+LDFLAGS_Debug := -pthread \
+ -rdynamic
+
+LDFLAGS_Release := -pthread \
+ -rdynamic
+
+LIBS :=
+
+$(obj).target/bufferutil.node: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))
+$(obj).target/bufferutil.node: LIBS := $(LIBS)
+$(obj).target/bufferutil.node: TOOLSET := $(TOOLSET)
+$(obj).target/bufferutil.node: $(OBJS) FORCE_DO_CMD
+ $(call do_cmd,solink_module)
+
+all_deps += $(obj).target/bufferutil.node
+# Add target alias
+.PHONY: bufferutil
+bufferutil: $(builddir)/bufferutil.node
+
+# Copy this to the executable output path.
+$(builddir)/bufferutil.node: TOOLSET := $(TOOLSET)
+$(builddir)/bufferutil.node: $(obj).target/bufferutil.node FORCE_DO_CMD
+ $(call do_cmd,copy)
+
+all_deps += $(builddir)/bufferutil.node
+# Short alias for building this executable.
+.PHONY: bufferutil.node
+bufferutil.node: $(obj).target/bufferutil.node $(builddir)/bufferutil.node
+
+# Add executable to "all" target.
+.PHONY: all
+all: $(builddir)/bufferutil.node
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/config.gypi b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/config.gypi
new file mode 100644
index 0000000..21c38ba
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/config.gypi
@@ -0,0 +1,13 @@
+# Do not edit. File was generated by node-gyp's "configure" step
+{
+ "target_defaults": {
+ "cflags": [],
+ "default_configuration": "Release",
+ "defines": [],
+ "include_dirs": [],
+ "libraries": []
+ },
+ "variables": {
+ "target_arch": "x64"
+ }
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/validation.target.mk b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/validation.target.mk
new file mode 100644
index 0000000..be7ee4d
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/build/validation.target.mk
@@ -0,0 +1,113 @@
+# This file is generated by gyp; do not edit.
+
+TOOLSET := target
+TARGET := validation
+DEFS_Debug := '-D_LARGEFILE_SOURCE' \
+ '-D_FILE_OFFSET_BITS=64' \
+ '-DDEBUG' \
+ '-D_DEBUG'
+
+# Flags passed to all source files.
+CFLAGS_Debug := -fPIC \
+ -Wall \
+ -pthread \
+ -ansi \
+ -O3 \
+ -g \
+ -O0
+
+# Flags passed to only C files.
+CFLAGS_C_Debug :=
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Debug := -fno-rtti \
+ -fno-exceptions
+
+INCS_Debug := -I/home/logsol/.node-gyp/0.6.13/src \
+ -I/home/logsol/.node-gyp/0.6.13/deps/uv/include \
+ -I/home/logsol/.node-gyp/0.6.13/deps/v8/include
+
+DEFS_Release := '-D_LARGEFILE_SOURCE' \
+ '-D_FILE_OFFSET_BITS=64'
+
+# Flags passed to all source files.
+CFLAGS_Release := -fPIC \
+ -Wall \
+ -pthread \
+ -ansi \
+ -O3 \
+ -O3 \
+ -fdata-sections \
+ -ffunction-sections \
+ -fno-strict-aliasing
+
+# Flags passed to only C files.
+CFLAGS_C_Release :=
+
+# Flags passed to only C++ files.
+CFLAGS_CC_Release := -fno-rtti \
+ -fno-exceptions
+
+INCS_Release := -I/home/logsol/.node-gyp/0.6.13/src \
+ -I/home/logsol/.node-gyp/0.6.13/deps/uv/include \
+ -I/home/logsol/.node-gyp/0.6.13/deps/v8/include
+
+OBJS := $(obj).target/$(TARGET)/src/validation.o
+
+# Add to the list of files we specially track dependencies for.
+all_deps += $(OBJS)
+
+# CFLAGS et al overrides must be target-local.
+# See "Target-specific Variable Values" in the GNU Make manual.
+$(OBJS): TOOLSET := $(TOOLSET)
+$(OBJS): GYP_CFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_C_$(BUILDTYPE))
+$(OBJS): GYP_CXXFLAGS := $(DEFS_$(BUILDTYPE)) $(INCS_$(BUILDTYPE)) $(CFLAGS_$(BUILDTYPE)) $(CFLAGS_CC_$(BUILDTYPE))
+
+# Suffix rules, putting all outputs into $(obj).
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(srcdir)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+# Try building from generated source, too.
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj).$(TOOLSET)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+$(obj).$(TOOLSET)/$(TARGET)/%.o: $(obj)/%.cc FORCE_DO_CMD
+ @$(call do_cmd,cxx,1)
+
+# End of this set of suffix rules
+### Rules for final target.
+LDFLAGS_Debug := -pthread \
+ -rdynamic
+
+LDFLAGS_Release := -pthread \
+ -rdynamic
+
+LIBS :=
+
+$(obj).target/validation.node: GYP_LDFLAGS := $(LDFLAGS_$(BUILDTYPE))
+$(obj).target/validation.node: LIBS := $(LIBS)
+$(obj).target/validation.node: TOOLSET := $(TOOLSET)
+$(obj).target/validation.node: $(OBJS) FORCE_DO_CMD
+ $(call do_cmd,solink_module)
+
+all_deps += $(obj).target/validation.node
+# Add target alias
+.PHONY: validation
+validation: $(builddir)/validation.node
+
+# Copy this to the executable output path.
+$(builddir)/validation.node: TOOLSET := $(TOOLSET)
+$(builddir)/validation.node: $(obj).target/validation.node FORCE_DO_CMD
+ $(call do_cmd,copy)
+
+all_deps += $(builddir)/validation.node
+# Short alias for building this executable.
+.PHONY: validation.node
+validation.node: $(obj).target/validation.node $(builddir)/validation.node
+
+# Add executable to "all" target.
+.PHONY: all
+all: $(builddir)/validation.node
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/doc/ws.md b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/doc/ws.md
new file mode 100644
index 0000000..3719fc5
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/doc/ws.md
@@ -0,0 +1,156 @@
+# ws
+
+## Class: ws.Server
+
+This class is a WebSocket server. It is an `EventEmitter`.
+
+### new ws.Server([options], [callback])
+
+* `options` Object
+ * `host` String
+ * `port` Number
+ * `server` http.Server
+ * `verifyClient` Function
+ * `path` String
+ * `noServer` Boolean
+ * `disableHixie` Boolean
+ * `clientTracking` Boolean
+* `callback` Function
+
+Construct a new server object.
+
+Either `port` or `server` must be provided, otherwise you might enable `noServer` if you want to pass the requests directly.
+
+### server.close([code], [data])
+
+Close the server and terminate all clients
+
+### server.handleUpgrade(request, socket, upgradeHead, callback)
+
+Handles a HTTP Upgrade request. `request` is an instance of `http.ServerRequest`, `socket` is an instance of `net.Socket`.
+
+When the Upgrade was successfully, the `callback` will be called with a `ws.WebSocket` object as parameter.
+
+### Event: 'error'
+
+`function (error) { }`
+
+If the underlying server emits an error, it will be forwarded here.
+
+### Event: 'connection'
+
+`function (socket) { }`
+
+When a new WebSocket connection is established. `socket` is an object of type `ws.WebSocket`.
+
+
+## Class: ws.WebSocket
+
+This class represents a WebSocket connection. It is an `EventEmitter`.
+
+### new ws.WebSocket(address, [options])
+
+Instantiating with an `address` creates a new WebSocket client object. If `address` is an Array (request, socket, rest), it is instantiated as a Server client (e.g. called from the `ws.Server`).
+
+### websocket.bytesReceived
+
+Received bytes count.
+
+### websocket.readyState
+
+Possible states are `WebSocket.CONNECTING`, `WebSocket.OPEN`, `WebSocket.CLOSING`, `WebSocket.CLOSED`.
+
+### websocket.protocolVersion
+
+The WebSocket protocol version used for this connection, `8`, `13` or `hixie-76` (the latter only for server clients).
+
+### websocket.url
+
+The URL of the WebSocket server (only for clients)
+
+### websocket.supports
+
+Describes the feature of the used protocol version. E.g. `supports.binary` is a boolean that describes if the connection supports binary messages.
+
+### websocket.close([code], [data])
+
+Gracefully closes the connection, after sending a description message
+
+### websocket.pause()
+
+Pause the client stream
+
+### websocket.ping([data], [options], [dontFailWhenClosed])
+
+Sends a ping. `data` is sent, `options` is an object with members `mask` and `binary`. `dontFailWhenClosed` indicates whether or not to throw if the connection isnt open.
+
+### websocket.pong([data], [options], [dontFailWhenClosed])
+
+Sends a pong. `data` is sent, `options` is an object with members `mask` and `binary`. `dontFailWhenClosed` indicates whether or not to throw if the connection isnt open.
+
+
+### websocket.resume()
+
+Resume the client stream
+
+### websocket.send(data, [options], [callback])
+
+Sends `data` through the connection. `options` can be an object with members `mask` and `binary`. The optional `callback` is executed after the send completes.
+
+### websocket.stream([options], callback)
+
+Streams data through calls to a user supplied function. `options` can be an object with members `mask` and `binary`. `callback` is executed on successive ticks of which send is `function (data, final)`.
+
+### websocket.terminate()
+
+Immediately shuts down the connection
+
+### websocket.onopen
+### websocket.onerror
+### websocket.onclose
+### websocket.onmessage
+
+Emulates the W3C Browser based WebSocket interface using function members.
+
+### websocket.addEventListener(method, listener)
+
+Emulates the W3C Browser based WebSocket interface using addEventListener.
+
+### Event: 'error'
+
+`function (error) { }`
+
+If the client emits an error, this event is emitted (errors from the underlying `net.Socket` are forwarded here).
+
+### Event: 'close'
+
+`function (code, message) { }`
+
+Is emitted when the connection is closed. `code` is defined in the WebSocket specification.
+
+The `close` event is also emitted when then underlying `net.Socket` closes the connection (`end` or `close`).
+
+### Event: 'message'
+
+`function (data, flags) { }`
+
+Is emitted when data is received. `flags` is an object with member `binary`.
+
+### Event: 'ping'
+
+`function (data, flags) { }`
+
+Is emitted when a ping is received. `flags` is an object with member `binary`.
+
+### Event: 'pong'
+
+`function (data, flags) { }`
+
+Is emitted when a pong is received. `flags` is an object with member `binary`.
+
+### Event: 'open'
+
+`function () { }`
+
+Emitted when the connection is established.
+
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/.npmignore b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/.npmignore
new file mode 100644
index 0000000..dcd5756
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/.npmignore
@@ -0,0 +1 @@
+uploaded
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/package.json b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/package.json
new file mode 100644
index 0000000..7816f27
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/package.json
@@ -0,0 +1,18 @@
+{
+ "author": "",
+ "name": "fileapi",
+ "version": "0.0.0",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/einaros/ws.git"
+ },
+ "engines": {
+ "node": "~0.6.8"
+ },
+ "dependencies": {
+ "express": "latest",
+ "ansi": "https://github.com/einaros/ansi.js/tarball/master"
+ },
+ "devDependencies": {},
+ "optionalDependencies": {}
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/public/app.js b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/public/app.js
new file mode 100644
index 0000000..e812cc3
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/public/app.js
@@ -0,0 +1,39 @@
+function onFilesSelected(e) {
+ var button = e.srcElement;
+ button.disabled = true;
+ var progress = document.querySelector('div#progress');
+ progress.innerHTML = '0%';
+ var files = e.target.files;
+ var totalFiles = files.length;
+ var filesSent = 0;
+ if (totalFiles) {
+ var uploader = new Uploader('ws://localhost:8080', function () {
+ Array.prototype.slice.call(files, 0).forEach(function(file) {
+ if (file.name == '.') {
+ --totalFiles;
+ return;
+ }
+ uploader.sendFile(file, function(error) {
+ if (error) {
+ console.log(error);
+ return;
+ }
+ ++filesSent;
+ progress.innerHTML = ~~(filesSent / totalFiles * 100) + '%';
+ console.log('Sent: ' + file.name);
+ });
+ });
+ });
+ }
+ uploader.ondone = function() {
+ uploader.close();
+ progress.innerHTML = '100% done, ' + totalFiles + ' files sent.';
+ }
+}
+
+window.onload = function() {
+ var importButtons = document.querySelectorAll('[type="file"]');
+ Array.prototype.slice.call(importButtons, 0).forEach(function(importButton) {
+ importButton.addEventListener('change', onFilesSelected, false);
+ });
+}
diff --git a/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/public/index.html b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/public/index.html
new file mode 100644
index 0000000..0d463dd
--- /dev/null
+++ b/node_modules/socket.io/node_modules/socket.io-client/node_modules/ws/examples/fileapi/public/index.html
@@ -0,0 +1,22 @@
+
+
+
+
+
+
+
+
+
This example will upload an entire directory tree to the node.js server via a fast and persistent WebSocket connection.
';
+html += '
'
+) + ';
+ __out.push(__sanitize(alphabet[index]));
+ __out.push('.png)
\n 
\n 
\n');
+ };
+ __out.push('\n');
+ fareBreakdown = this.trip.get('fare_breakdown');
+ __out.push('\n\n');
+ printFares = __bind(function(fare, index, list) {
+ var _ref;
+ __out.push('\n\n 
![](https://www.google.com/mapfiles/marker" + alphabet[index] + ".png)