raptor
Version:
RaptorJS provides an AMD module loader that works in Node, Rhino and the web browser. It also includes various sub-modules to support building optimized web applications.
1,116 lines (1,038 loc) • 41.6 kB
JavaScript
// vim: ts=4 sts=4 sw=4 expandtab
// -- kriskowal Kris Kowal Copyright (C) 2009-2011 MIT License
// -- tlrobinson Tom Robinson Copyright (C) 2009-2010 MIT License (Narwhal Project)
// -- dantman Daniel Friesen Copyright (C) 2010 XXX TODO License or CLA
// -- fschaefer Florian Sch�fer Copyright (C) 2010 MIT License
// -- Gozala Irakli Gozalishvili Copyright (C) 2010 MIT License
// -- kitcambridge Kit Cambridge Copyright (C) 2011 MIT License
// -- kossnocorp Sasha Koss XXX TODO License or CLA
// -- bryanforbes Bryan Forbes XXX TODO License or CLA
// -- killdream Quildreen Motta Copyright (C) 2011 MIT Licence
// -- michaelficarra Michael Ficarra Copyright (C) 2011 3-clause BSD License
// -- sharkbrainguy Gerard Paapu Copyright (C) 2011 MIT License
// -- bbqsrc Brendan Molloy (C) 2011 Creative Commons Zero (public domain)
// -- iwyg XXX TODO License or CLA
// -- DomenicDenicola Domenic Denicola Copyright (C) 2011 MIT License
// -- xavierm02 Montillet Xavier Copyright (C) 2011 MIT License
// -- Raynos Jake Verbaten Copyright (C) 2011 MIT Licence
// -- samsonjs Sami Samhuri Copyright (C) 2010 MIT License
// -- rwldrn Rick Waldron Copyright (C) 2011 MIT License
// -- lexer Alexey Zakharov XXX TODO License or CLA
/*!
Copyright (c) 2009, 280 North Inc. http://280north.com/
MIT License. http://github.com/280north/narwhal/blob/master/README.md
*/
// Module systems magic dance
//(function (definition) {
// // RequireJS
// if (typeof define == "function") {
// define(definition);
// // YUI3
// } else if (typeof YUI == "function") {
// YUI.add("es5", definition);
// // CommonJS and <script>
// } else {
// definition();
// }
//})
(function () {
/*jshint evil: true, strict: false, regexp: false */
/**
* Brings an environment as close to ECMAScript 5 compliance
* as is possible with the facilities of erstwhile engines.
*
* Annotated ES5: http://es5.github.com/ (specific links below)
* ES5 Spec: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf
* Required reading: http://javascriptweblog.wordpress.com/2011/12/05/extending-javascript-natives/
*/
//
// Util
// ======
//
// ES5 9.4
// http://es5.github.com/#x9.4
// http://jsperf.com/to-integer
var toInteger = function (n) {
n = +n;
if (n !== n) { // isNaN
n = 0;
} else if (n !== 0 && n !== (1/0) && n !== -(1/0)) {
n = (n > 0 || -1) * Math.floor(Math.abs(n));
}
return n;
};
var prepareString = "a"[0] != "a";
// ES5 9.9
// http://es5.github.com/#x9.9
var toObject = function (o) {
if (o == null) { // this matches both null and undefined
throw new TypeError("can't convert "+o+" to object");
}
// If the implementation doesn't support by-index access of
// string characters (ex. IE < 9), split the string
if (prepareString && typeof o == "string" && o) {
return o.split("");
}
return Object(o);
};
var call = Function.prototype.call;
var prototypeOfArray = Array.prototype;
var prototypeOfObject = Object.prototype;
var slice = prototypeOfArray.slice;
//
// Function
// ========
//
// ES-5 15.3.4.5
// http://es5.github.com/#x15.3.4.5
if (!Function.prototype.bind) {
Function.prototype.bind = function bind(that) { // .length is 1
// 1. Let Target be the this value.
var target = this;
// 2. If IsCallable(Target) is false, throw a TypeError exception.
if (typeof target != "function") {
throw new TypeError("Function.prototype.bind called on incompatible " + target);
}
// 3. Let A be a new (possibly empty) internal list of all of the
// argument values provided after thisArg (arg1, arg2 etc), in order.
// XXX slicedArgs will stand in for "A" if used
var args = slice.call(arguments, 1); // for normal call
// 4. Let F be a new native ECMAScript object.
// 11. Set the [[Prototype]] internal property of F to the standard
// built-in Function prototype object as specified in 15.3.3.1.
// 12. Set the [[Call]] internal property of F as described in
// 15.3.4.5.1.
// 13. Set the [[Construct]] internal property of F as described in
// 15.3.4.5.2.
// 14. Set the [[HasInstance]] internal property of F as described in
// 15.3.4.5.3.
var bound = function () {
if (this instanceof bound) {
// 15.3.4.5.2 [[Construct]]
// When the [[Construct]] internal method of a function object,
// F that was created using the bind function is called with a
// list of arguments ExtraArgs, the following steps are taken:
// 1. Let target be the value of F's [[TargetFunction]]
// internal property.
// 2. If target has no [[Construct]] internal method, a
// TypeError exception is thrown.
// 3. Let boundArgs be the value of F's [[BoundArgs]] internal
// property.
// 4. Let args be a new list containing the same values as the
// list boundArgs in the same order followed by the same
// values as the list ExtraArgs in the same order.
// 5. Return the result of calling the [[Construct]] internal
// method of target providing args as the arguments.
var F = function(){};
F.prototype = target.prototype;
var self = new F;
var result = target.apply(
self,
args.concat(slice.call(arguments))
);
if (Object(result) === result) {
return result;
}
return self;
} else {
// 15.3.4.5.1 [[Call]]
// When the [[Call]] internal method of a function object, F,
// which was created using the bind function is called with a
// this value and a list of arguments ExtraArgs, the following
// steps are taken:
// 1. Let boundArgs be the value of F's [[BoundArgs]] internal
// property.
// 2. Let boundThis be the value of F's [[BoundThis]] internal
// property.
// 3. Let target be the value of F's [[TargetFunction]] internal
// property.
// 4. Let args be a new list containing the same values as the
// list boundArgs in the same order followed by the same
// values as the list ExtraArgs in the same order.
// 5. Return the result of calling the [[Call]] internal method
// of target providing boundThis as the this value and
// providing args as the arguments.
// equiv: target.call(this, ...boundArgs, ...args)
return target.apply(
that,
args.concat(slice.call(arguments))
);
}
};
// XXX bound.length is never writable, so don't even try
//
// 15. If the [[Class]] internal property of Target is "Function", then
// a. Let L be the length property of Target minus the length of A.
// b. Set the length own property of F to either 0 or L, whichever is
// larger.
// 16. Else set the length own property of F to 0.
// 17. Set the attributes of the length own property of F to the values
// specified in 15.3.5.1.
// TODO
// 18. Set the [[Extensible]] internal property of F to true.
// TODO
// 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
// 20. Call the [[DefineOwnProperty]] internal method of F with
// arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
// thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
// false.
// 21. Call the [[DefineOwnProperty]] internal method of F with
// arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
// [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
// and false.
// TODO
// NOTE Function objects created using Function.prototype.bind do not
// have a prototype property or the [[Code]], [[FormalParameters]], and
// [[Scope]] internal properties.
// XXX can't delete prototype in pure-js.
// 22. Return F.
return bound;
};
}
// Shortcut to an often accessed properties, in order to avoid multiple
// dereference that costs universally.
// _Please note: Shortcuts are defined after `Function.prototype.bind` as we
// us it in defining shortcuts.
// Having a toString local variable name breaks in Opera so use _toString.
var _toString = call.bind(prototypeOfObject.toString);
var owns = call.bind(prototypeOfObject.hasOwnProperty);
//// If JS engine supports accessors creating shortcuts.
//var defineGetter;
//var defineSetter;
//var lookupGetter;
//var lookupSetter;
//var supportsAccessors;
//if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
// defineGetter = call.bind(prototypeOfObject.__defineGetter__);
// defineSetter = call.bind(prototypeOfObject.__defineSetter__);
// lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
// lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
//}
//
// Array
// =====
//
// ES5 15.4.3.2
// http://es5.github.com/#x15.4.3.2
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray
if (!Array.isArray) {
Array.isArray = function isArray(obj) {
return _toString(obj) == "[object Array]";
};
}
// The IsCallable() check in the Array functions
// has been replaced with a strict check on the
// internal class of the object to trap cases where
// the provided function was actually a regular
// expression literal, which in V8 and
// JavaScriptCore is a typeof "function". Only in
// V8 are regular expression literals permitted as
// reduce parameters, so it is desirable in the
// general case for the shim to match the more
// strict and common behavior of rejecting regular
// expressions.
// ES5 15.4.4.18
// http://es5.github.com/#x15.4.4.18
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/array/forEach
if (!Array.prototype.forEach) {
Array.prototype.forEach = function forEach(fun /*, thisp*/) {
var self = toObject(this),
thisp = arguments[1],
i = -1,
length = self.length >>> 0;
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(); // TODO message
}
while (++i < length) {
if (i in self) {
// Invoke the callback function with call, passing arguments:
// context, property value, property key, thisArg object context
fun.call(thisp, self[i], i, self);
}
}
};
}
// ES5 15.4.4.19
// http://es5.github.com/#x15.4.4.19
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/map
if (!Array.prototype.map) {
Array.prototype.map = function map(fun /*, thisp*/) {
var self = toObject(this),
length = self.length >>> 0,
result = Array(length),
thisp = arguments[1];
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(fun + " is not a function");
}
for (var i = 0; i < length; i++) {
if (i in self)
result[i] = fun.call(thisp, self[i], i, self);
}
return result;
};
}
// ES5 15.4.4.20
// http://es5.github.com/#x15.4.4.20
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/filter
if (!Array.prototype.filter) {
Array.prototype.filter = function filter(fun /*, thisp */) {
var self = toObject(this),
length = self.length >>> 0,
result = [],
value,
thisp = arguments[1];
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(fun + " is not a function");
}
for (var i = 0; i < length; i++) {
if (i in self) {
value = self[i];
if (fun.call(thisp, value, i, self)) {
result.push(value);
}
}
}
return result;
};
}
// ES5 15.4.4.16
// http://es5.github.com/#x15.4.4.16
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every
if (!Array.prototype.every) {
Array.prototype.every = function every(fun /*, thisp */) {
var self = toObject(this),
length = self.length >>> 0,
thisp = arguments[1];
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(fun + " is not a function");
}
for (var i = 0; i < length; i++) {
if (i in self && !fun.call(thisp, self[i], i, self)) {
return false;
}
}
return true;
};
}
// ES5 15.4.4.17
// http://es5.github.com/#x15.4.4.17
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some
if (!Array.prototype.some) {
Array.prototype.some = function some(fun /*, thisp */) {
var self = toObject(this),
length = self.length >>> 0,
thisp = arguments[1];
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(fun + " is not a function");
}
for (var i = 0; i < length; i++) {
if (i in self && fun.call(thisp, self[i], i, self)) {
return true;
}
}
return false;
};
}
// ES5 15.4.4.21
// http://es5.github.com/#x15.4.4.21
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
if (!Array.prototype.reduce) {
Array.prototype.reduce = function reduce(fun /*, initial*/) {
var self = toObject(this),
length = self.length >>> 0;
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(fun + " is not a function");
}
// no value to return if no initial value and an empty array
if (!length && arguments.length == 1) {
throw new TypeError('reduce of empty array with no initial value');
}
var i = 0;
var result;
if (arguments.length >= 2) {
result = arguments[1];
} else {
do {
if (i in self) {
result = self[i++];
break;
}
// if array contains no values, no initial value to return
if (++i >= length) {
throw new TypeError('reduce of empty array with no initial value');
}
} while (true);
}
for (; i < length; i++) {
if (i in self) {
result = fun.call(void 0, result, self[i], i, self);
}
}
return result;
};
}
// ES5 15.4.4.22
// http://es5.github.com/#x15.4.4.22
// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
if (!Array.prototype.reduceRight) {
Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {
var self = toObject(this),
length = self.length >>> 0;
// If no callback function or if callback is not a callable function
if (_toString(fun) != "[object Function]") {
throw new TypeError(fun + " is not a function");
}
// no value to return if no initial value, empty array
if (!length && arguments.length == 1) {
throw new TypeError('reduceRight of empty array with no initial value');
}
var result, i = length - 1;
if (arguments.length >= 2) {
result = arguments[1];
} else {
do {
if (i in self) {
result = self[i--];
break;
}
// if array contains no values, no initial value to return
if (--i < 0) {
throw new TypeError('reduceRight of empty array with no initial value');
}
} while (true);
}
do {
if (i in this) {
result = fun.call(void 0, result, self[i], i, self);
}
} while (i--);
return result;
};
}
// ES5 15.4.4.14
// http://es5.github.com/#x15.4.4.14
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) {
var self = toObject(this),
length = self.length >>> 0;
if (!length) {
return -1;
}
var i = 0;
if (arguments.length > 1) {
i = toInteger(arguments[1]);
}
// handle negative indices
i = i >= 0 ? i : Math.max(0, length + i);
for (; i < length; i++) {
if (i in self && self[i] === sought) {
return i;
}
}
return -1;
};
}
// ES5 15.4.4.15
// http://es5.github.com/#x15.4.4.15
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf
if (!Array.prototype.lastIndexOf) {
Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) {
var self = toObject(this),
length = self.length >>> 0;
if (!length) {
return -1;
}
var i = length - 1;
if (arguments.length > 1) {
i = Math.min(i, toInteger(arguments[1]));
}
// handle negative indices
i = i >= 0 ? i : length - Math.abs(i);
for (; i >= 0; i--) {
if (i in self && sought === self[i]) {
return i;
}
}
return -1;
};
}
//
// Object
// ======
//
//// ES5 15.2.3.2
//// http://es5.github.com/#x15.2.3.2
//if (!Object.getPrototypeOf) {
// // https://github.com/kriskowal/es5-shim/issues#issue/2
// // http://ejohn.org/blog/objectgetprototypeof/
// // recommended by fschaefer on github
// Object.getPrototypeOf = function getPrototypeOf(object) {
// return object.__proto__ || (
// object.constructor
// ? object.constructor.prototype
// : prototypeOfObject
// );
// };
//}
//
//// ES5 15.2.3.3
//// http://es5.github.com/#x15.2.3.3
//if (!Object.getOwnPropertyDescriptor) {
// var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a non-object: ";
//
// Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
// if ((typeof object != "object" && typeof object != "function") || object === null) {
// throw new TypeError(ERR_NON_OBJECT + object);
// }
// // If object does not owns property return undefined immediately.
// if (!owns(object, property)) {
// return;
// }
//
// // If object has a property then it's for sure both `enumerable` and
// // `configurable`.
// var descriptor = { enumerable: true, configurable: true };
//
// // If JS engine supports accessor properties then property may be a
// // getter or setter.
// if (supportsAccessors) {
// // Unfortunately `__lookupGetter__` will return a getter even
// // if object has own non getter property along with a same named
// // inherited getter. To avoid misbehavior we temporary remove
// // `__proto__` so that `__lookupGetter__` will return getter only
// // if it's owned by an object.
// var prototype = object.__proto__;
// object.__proto__ = prototypeOfObject;
//
// var getter = lookupGetter(object, property);
// var setter = lookupSetter(object, property);
//
// // Once we have getter and setter we can put values back.
// object.__proto__ = prototype;
//
// if (getter || setter) {
// if (getter) {
// descriptor.get = getter;
// }
// if (setter) {
// descriptor.set = setter;
// }
// // If it was accessor property we're done and return here
// // in order to avoid adding `value` to the descriptor.
// return descriptor;
// }
// }
//
// // If we got this far we know that object has an own property that is
// // not an accessor so we set it as a value and return descriptor.
// descriptor.value = object[property];
// return descriptor;
// };
//}
//
//// ES5 15.2.3.4
//// http://es5.github.com/#x15.2.3.4
//if (!Object.getOwnPropertyNames) {
// Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
// return Object.keys(object);
// };
//}
//
//// ES5 15.2.3.5
//// http://es5.github.com/#x15.2.3.5
//if (!Object.create) {
// Object.create = function create(prototype, properties) {
// var object;
// if (prototype === null) {
// object = { "__proto__": null };
// } else {
// if (typeof prototype != "object") {
// throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'");
// }
// var Type = function () {};
// Type.prototype = prototype;
// object = new Type();
// // IE has no built-in implementation of `Object.getPrototypeOf`
// // neither `__proto__`, but this manually setting `__proto__` will
// // guarantee that `Object.getPrototypeOf` will work as expected with
// // objects created using `Object.create`
// object.__proto__ = prototype;
// }
// if (properties !== void 0) {
// Object.defineProperties(object, properties);
// }
// return object;
// };
//}
//
//// ES5 15.2.3.6
//// http://es5.github.com/#x15.2.3.6
//
//// Patch for WebKit and IE8 standard mode
//// Designed by hax <hax.github.com>
//// related issue: https://github.com/kriskowal/es5-shim/issues#issue/5
//// IE8 Reference:
//// http://msdn.microsoft.com/en-us/library/dd282900.aspx
//// http://msdn.microsoft.com/en-us/library/dd229916.aspx
//// WebKit Bugs:
//// https://bugs.webkit.org/show_bug.cgi?id=36423
//
//function doesDefinePropertyWork(object) {
// try {
// Object.defineProperty(object, "sentinel", {});
// return "sentinel" in object;
// } catch (exception) {
// // returns falsy
// }
//}
//
//// check whether defineProperty works if it's given. Otherwise,
//// shim partially.
//if (Object.defineProperty) {
// var definePropertyWorksOnObject = doesDefinePropertyWork({});
// var definePropertyWorksOnDom = typeof document == "undefined" ||
// doesDefinePropertyWork(document.createElement("div"));
// if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
// var definePropertyFallback = Object.defineProperty;
// }
//}
//
//if (!Object.defineProperty || definePropertyFallback) {
// var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";
// var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: "
// var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " +
// "on this javascript engine";
//
// Object.defineProperty = function defineProperty(object, property, descriptor) {
// if ((typeof object != "object" && typeof object != "function") || object === null) {
// throw new TypeError(ERR_NON_OBJECT_TARGET + object);
// }
// if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null) {
// throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
// }
// // make a valiant attempt to use the real defineProperty
// // for I8's DOM elements.
// if (definePropertyFallback) {
// try {
// return definePropertyFallback.call(Object, object, property, descriptor);
// } catch (exception) {
// // try the shim if the real one doesn't work
// }
// }
//
// // If it's a data property.
// if (owns(descriptor, "value")) {
// // fail silently if "writable", "enumerable", or "configurable"
// // are requested but not supported
// /*
// // alternate approach:
// if ( // can't implement these features; allow false but not true
// !(owns(descriptor, "writable") ? descriptor.writable : true) ||
// !(owns(descriptor, "enumerable") ? descriptor.enumerable : true) ||
// !(owns(descriptor, "configurable") ? descriptor.configurable : true)
// )
// throw new RangeError(
// "This implementation of Object.defineProperty does not " +
// "support configurable, enumerable, or writable."
// );
// */
//
// if (supportsAccessors && (lookupGetter(object, property) ||
// lookupSetter(object, property)))
// {
// // As accessors are supported only on engines implementing
// // `__proto__` we can safely override `__proto__` while defining
// // a property to make sure that we don't hit an inherited
// // accessor.
// var prototype = object.__proto__;
// object.__proto__ = prototypeOfObject;
// // Deleting a property anyway since getter / setter may be
// // defined on object itself.
// delete object[property];
// object[property] = descriptor.value;
// // Setting original `__proto__` back now.
// object.__proto__ = prototype;
// } else {
// object[property] = descriptor.value;
// }
// } else {
// if (!supportsAccessors) {
// throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
// }
// // If we got that far then getters and setters can be defined !!
// if (owns(descriptor, "get")) {
// defineGetter(object, property, descriptor.get);
// }
// if (owns(descriptor, "set")) {
// defineSetter(object, property, descriptor.set);
// }
// }
// return object;
// };
//}
//
//// ES5 15.2.3.7
//// http://es5.github.com/#x15.2.3.7
//if (!Object.defineProperties) {
// Object.defineProperties = function defineProperties(object, properties) {
// for (var property in properties) {
// if (owns(properties, property) && property != "__proto__") {
// Object.defineProperty(object, property, properties[property]);
// }
// }
// return object;
// };
//}
//
//// ES5 15.2.3.8
//// http://es5.github.com/#x15.2.3.8
//if (!Object.seal) {
// Object.seal = function seal(object) {
// // this is misleading and breaks feature-detection, but
// // allows "securable" code to "gracefully" degrade to working
// // but insecure code.
// return object;
// };
//}
//
//// ES5 15.2.3.9
//// http://es5.github.com/#x15.2.3.9
//if (!Object.freeze) {
// Object.freeze = function freeze(object) {
// // this is misleading and breaks feature-detection, but
// // allows "securable" code to "gracefully" degrade to working
// // but insecure code.
// return object;
// };
//}
//
//// detect a Rhino bug and patch it
//try {
// Object.freeze(function () {});
//} catch (exception) {
// Object.freeze = (function freeze(freezeObject) {
// return function freeze(object) {
// if (typeof object == "function") {
// return object;
// } else {
// return freezeObject(object);
// }
// };
// })(Object.freeze);
//}
//
//// ES5 15.2.3.10
//// http://es5.github.com/#x15.2.3.10
//if (!Object.preventExtensions) {
// Object.preventExtensions = function preventExtensions(object) {
// // this is misleading and breaks feature-detection, but
// // allows "securable" code to "gracefully" degrade to working
// // but insecure code.
// return object;
// };
//}
//
//// ES5 15.2.3.11
//// http://es5.github.com/#x15.2.3.11
//if (!Object.isSealed) {
// Object.isSealed = function isSealed(object) {
// return false;
// };
//}
//
//// ES5 15.2.3.12
//// http://es5.github.com/#x15.2.3.12
//if (!Object.isFrozen) {
// Object.isFrozen = function isFrozen(object) {
// return false;
// };
//}
//
//// ES5 15.2.3.13
//// http://es5.github.com/#x15.2.3.13
//if (!Object.isExtensible) {
// Object.isExtensible = function isExtensible(object) {
// // 1. If Type(O) is not Object throw a TypeError exception.
// if (Object(object) !== object) {
// throw new TypeError(); // TODO message
// }
// // 2. Return the Boolean value of the [[Extensible]] internal property of O.
// var name = '';
// while (owns(object, name)) {
// name += '?';
// }
// object[name] = true;
// var returnValue = owns(object, name);
// delete object[name];
// return returnValue;
// };
//}
// ES5 15.2.3.14
// http://es5.github.com/#x15.2.3.14
if (!Object.keys) {
// http://whattheheadsaid.com/2010/10/a-safer-object-keys-compatibility-implementation
var hasDontEnumBug = true,
dontEnums = [
"toString",
"toLocaleString",
"valueOf",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"constructor"
],
dontEnumsLength = dontEnums.length;
for (var key in {"toString": null}) {
hasDontEnumBug = false;
}
Object.keys = function keys(object) {
if ((typeof object != "object" && typeof object != "function") || object === null) {
throw new TypeError("Object.keys called on a non-object");
}
var keys = [];
for (var name in object) {
if (owns(object, name)) {
keys.push(name);
}
}
if (hasDontEnumBug) {
for (var i = 0, ii = dontEnumsLength; i < ii; i++) {
var dontEnum = dontEnums[i];
if (owns(object, dontEnum)) {
keys.push(dontEnum);
}
}
}
return keys;
};
}
////
//// Date
//// ====
////
//
//// ES5 15.9.5.43
//// http://es5.github.com/#x15.9.5.43
//// This function returns a String value represent the instance in time
//// represented by this Date object. The format of the String is the Date Time
//// string format defined in 15.9.1.15. All fields are present in the String.
//// The time zone is always UTC, denoted by the suffix Z. If the time value of
//// this object is not a finite Number a RangeError exception is thrown.
//if (!Date.prototype.toISOString || (new Date(-62198755200000).toISOString().indexOf('-000001') === -1)) {
// Date.prototype.toISOString = function toISOString() {
// var result, length, value, year;
// if (!isFinite(this)) {
// throw new RangeError("Date.prototype.toISOString called on non-finite value.");
// }
//
// // the date time string format is specified in 15.9.1.15.
// result = [this.getUTCMonth() + 1, this.getUTCDate(),
// this.getUTCHours(), this.getUTCMinutes(), this.getUTCSeconds()];
// year = this.getUTCFullYear();
// year = (year < 0 ? '-' : (year > 9999 ? '+' : '')) + ('00000' + Math.abs(year)).slice(0 <= year && year <= 9999 ? -4 : -6);
//
// length = result.length;
// while (length--) {
// value = result[length];
// // pad months, days, hours, minutes, and seconds to have two digits.
// if (value < 10) {
// result[length] = "0" + value;
// }
// }
// // pad milliseconds to have three digits.
// return year + "-" + result.slice(0, 2).join("-") + "T" + result.slice(2).join(":") + "." +
// ("000" + this.getUTCMilliseconds()).slice(-3) + "Z";
// }
//}
//
// ES5 15.9.4.4
// http://es5.github.com/#x15.9.4.4
if (!Date.now) {
Date.now = function now() {
return new Date().getTime();
};
}
//
//// ES5 15.9.5.44
//// http://es5.github.com/#x15.9.5.44
//// This function provides a String representation of a Date object for use by
//// JSON.stringify (15.12.3).
//if (!Date.prototype.toJSON) {
// Date.prototype.toJSON = function toJSON(key) {
// // When the toJSON method is called with argument key, the following
// // steps are taken:
//
// // 1. Let O be the result of calling ToObject, giving it the this
// // value as its argument.
// // 2. Let tv be ToPrimitive(O, hint Number).
// // 3. If tv is a Number and is not finite, return null.
// // XXX
// // 4. Let toISO be the result of calling the [[Get]] internal method of
// // O with argument "toISOString".
// // 5. If IsCallable(toISO) is false, throw a TypeError exception.
// if (typeof this.toISOString != "function") {
// throw new TypeError('toISOString property is not callable');
// }
// // 6. Return the result of calling the [[Call]] internal method of
// // toISO with O as the this value and an empty argument list.
// return this.toISOString();
//
// // NOTE 1 The argument is ignored.
//
// // NOTE 2 The toJSON function is intentionally generic; it does not
// // require that its this value be a Date object. Therefore, it can be
// // transferred to other kinds of objects for use as a method. However,
// // it does require that any such object have a toISOString method. An
// // object is free to use the argument key to filter its
// // stringification.
// };
//}
//
//// ES5 15.9.4.2
//// http://es5.github.com/#x15.9.4.2
//// based on work shared by Daniel Friesen (dantman)
//// http://gist.github.com/303249
//if (!Date.parse || Date.parse("+275760-09-13T00:00:00.000Z") !== 8.64e15) {
// // XXX global assignment won't work in embeddings that use
// // an alternate object for the context.
// Date = (function(NativeDate) {
//
// // Date.length === 7
// var Date = function Date(Y, M, D, h, m, s, ms) {
// var length = arguments.length;
// if (this instanceof NativeDate) {
// var date = length == 1 && String(Y) === Y ? // isString(Y)
// // We explicitly pass it through parse:
// new NativeDate(Date.parse(Y)) :
// // We have to manually make calls depending on argument
// // length here
// length >= 7 ? new NativeDate(Y, M, D, h, m, s, ms) :
// length >= 6 ? new NativeDate(Y, M, D, h, m, s) :
// length >= 5 ? new NativeDate(Y, M, D, h, m) :
// length >= 4 ? new NativeDate(Y, M, D, h) :
// length >= 3 ? new NativeDate(Y, M, D) :
// length >= 2 ? new NativeDate(Y, M) :
// length >= 1 ? new NativeDate(Y) :
// new NativeDate();
// // Prevent mixups with unfixed Date object
// date.constructor = Date;
// return date;
// }
// return NativeDate.apply(this, arguments);
// };
//
// // 15.9.1.15 Date Time String Format.
// var isoDateExpression = new RegExp("^" +
// "(\\d{4}|[\+\-]\\d{6})" + // four-digit year capture or sign + 6-digit extended year
// "(?:-(\\d{2})" + // optional month capture
// "(?:-(\\d{2})" + // optional day capture
// "(?:" + // capture hours:minutes:seconds.milliseconds
// "T(\\d{2})" + // hours capture
// ":(\\d{2})" + // minutes capture
// "(?:" + // optional :seconds.milliseconds
// ":(\\d{2})" + // seconds capture
// "(?:\\.(\\d{3}))?" + // milliseconds capture
// ")?" +
// "(?:" + // capture UTC offset component
// "Z|" + // UTC capture
// "(?:" + // offset specifier +/-hours:minutes
// "([-+])" + // sign capture
// "(\\d{2})" + // hours offset capture
// ":(\\d{2})" + // minutes offset capture
// ")" +
// ")?)?)?)?" +
// "$");
//
// // Copy any custom methods a 3rd party library may have added
// for (var key in NativeDate) {
// Date[key] = NativeDate[key];
// }
//
// // Copy "native" methods explicitly; they may be non-enumerable
// Date.now = NativeDate.now;
// Date.UTC = NativeDate.UTC;
// Date.prototype = NativeDate.prototype;
// Date.prototype.constructor = Date;
//
// // Upgrade Date.parse to handle simplified ISO 8601 strings
// Date.parse = function parse(string) {
// var match = isoDateExpression.exec(string);
// if (match) {
// match.shift(); // kill match[0], the full match
// // parse months, days, hours, minutes, seconds, and milliseconds
// for (var i = 1; i < 7; i++) {
// // provide default values if necessary
// match[i] = +(match[i] || (i < 3 ? 1 : 0));
// // match[1] is the month. Months are 0-11 in JavaScript
// // `Date` objects, but 1-12 in ISO notation, so we
// // decrement.
// if (i == 1) {
// match[i]--;
// }
// }
//
// // parse the UTC offset component
// var minuteOffset = +match.pop(), hourOffset = +match.pop(), sign = match.pop();
//
// // compute the explicit time zone offset if specified
// var offset = 0;
// if (sign) {
// // detect invalid offsets and return early
// if (hourOffset > 23 || minuteOffset > 59) {
// return NaN;
// }
//
// // express the provided time zone offset in minutes. The offset is
// // negative for time zones west of UTC; positive otherwise.
// offset = (hourOffset * 60 + minuteOffset) * 6e4 * (sign == "+" ? -1 : 1);
// }
//
// // Date.UTC for years between 0 and 99 converts year to 1900 + year
// // The Gregorian calendar has a 400-year cycle, so
// // to Date.UTC(year + 400, .... ) - 12622780800000 == Date.UTC(year, ...),
// // where 12622780800000 - number of milliseconds in Gregorian calendar 400 years
// var year = +match[0];
// if (0 <= year && year <= 99) {
// match[0] = year + 400;
// return NativeDate.UTC.apply(this, match) + offset - 12622780800000;
// }
//
// // compute a new UTC date value, accounting for the optional offset
// return NativeDate.UTC.apply(this, match) + offset;
// }
// return NativeDate.parse.apply(this, arguments);
// };
//
// return Date;
// })(Date);
//}
//
// String
// ======
//
// ES5 15.5.4.20
// http://es5.github.com/#x15.5.4.20
var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" +
"\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" +
"\u2029\uFEFF";
if (!String.prototype.trim || ws.trim()) {
// http://blog.stevenlevithan.com/archives/faster-trim-javascript
// http://perfectionkills.com/whitespace-deviations/
ws = "[" + ws + "]";
var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),
trimEndRegexp = new RegExp(ws + ws + "*$");
String.prototype.trim = function trim() {
if (this === undefined || this === null) {
throw new TypeError("can't convert "+this+" to object");
}
return String(this).replace(trimBeginRegexp, "").replace(trimEndRegexp, "");
};
}
}());