| "use strict"; |
| var es5 = require("./es5"); |
| var canEvaluate = typeof navigator == "undefined"; |
| |
| var errorObj = {e: {}}; |
| var tryCatchTarget; |
| var globalObject = typeof self !== "undefined" ? self : |
| typeof window !== "undefined" ? window : |
| typeof global !== "undefined" ? global : |
| this !== undefined ? this : null; |
| |
| function tryCatcher() { |
| try { |
| var target = tryCatchTarget; |
| tryCatchTarget = null; |
| return target.apply(this, arguments); |
| } catch (e) { |
| errorObj.e = e; |
| return errorObj; |
| } |
| } |
| function tryCatch(fn) { |
| tryCatchTarget = fn; |
| return tryCatcher; |
| } |
| |
| var inherits = function(Child, Parent) { |
| var hasProp = {}.hasOwnProperty; |
| |
| function T() { |
| this.constructor = Child; |
| this.constructor$ = Parent; |
| for (var propertyName in Parent.prototype) { |
| if (hasProp.call(Parent.prototype, propertyName) && |
| propertyName.charAt(propertyName.length-1) !== "$" |
| ) { |
| this[propertyName + "$"] = Parent.prototype[propertyName]; |
| } |
| } |
| } |
| T.prototype = Parent.prototype; |
| Child.prototype = new T(); |
| return Child.prototype; |
| }; |
| |
| |
| function isPrimitive(val) { |
| return val == null || val === true || val === false || |
| typeof val === "string" || typeof val === "number"; |
| |
| } |
| |
| function isObject(value) { |
| return typeof value === "function" || |
| typeof value === "object" && value !== null; |
| } |
| |
| function maybeWrapAsError(maybeError) { |
| if (!isPrimitive(maybeError)) return maybeError; |
| |
| return new Error(safeToString(maybeError)); |
| } |
| |
| function withAppended(target, appendee) { |
| var len = target.length; |
| var ret = new Array(len + 1); |
| var i; |
| for (i = 0; i < len; ++i) { |
| ret[i] = target[i]; |
| } |
| ret[i] = appendee; |
| return ret; |
| } |
| |
| function getDataPropertyOrDefault(obj, key, defaultValue) { |
| if (es5.isES5) { |
| var desc = Object.getOwnPropertyDescriptor(obj, key); |
| |
| if (desc != null) { |
| return desc.get == null && desc.set == null |
| ? desc.value |
| : defaultValue; |
| } |
| } else { |
| return {}.hasOwnProperty.call(obj, key) ? obj[key] : undefined; |
| } |
| } |
| |
| function notEnumerableProp(obj, name, value) { |
| if (isPrimitive(obj)) return obj; |
| var descriptor = { |
| value: value, |
| configurable: true, |
| enumerable: false, |
| writable: true |
| }; |
| es5.defineProperty(obj, name, descriptor); |
| return obj; |
| } |
| |
| function thrower(r) { |
| throw r; |
| } |
| |
| var inheritedDataKeys = (function() { |
| var excludedPrototypes = [ |
| Array.prototype, |
| Object.prototype, |
| Function.prototype |
| ]; |
| |
| var isExcludedProto = function(val) { |
| for (var i = 0; i < excludedPrototypes.length; ++i) { |
| if (excludedPrototypes[i] === val) { |
| return true; |
| } |
| } |
| return false; |
| }; |
| |
| if (es5.isES5) { |
| var getKeys = Object.getOwnPropertyNames; |
| return function(obj) { |
| var ret = []; |
| var visitedKeys = Object.create(null); |
| while (obj != null && !isExcludedProto(obj)) { |
| var keys; |
| try { |
| keys = getKeys(obj); |
| } catch (e) { |
| return ret; |
| } |
| for (var i = 0; i < keys.length; ++i) { |
| var key = keys[i]; |
| if (visitedKeys[key]) continue; |
| visitedKeys[key] = true; |
| var desc = Object.getOwnPropertyDescriptor(obj, key); |
| if (desc != null && desc.get == null && desc.set == null) { |
| ret.push(key); |
| } |
| } |
| obj = es5.getPrototypeOf(obj); |
| } |
| return ret; |
| }; |
| } else { |
| var hasProp = {}.hasOwnProperty; |
| return function(obj) { |
| if (isExcludedProto(obj)) return []; |
| var ret = []; |
| |
| /*jshint forin:false */ |
| enumeration: for (var key in obj) { |
| if (hasProp.call(obj, key)) { |
| ret.push(key); |
| } else { |
| for (var i = 0; i < excludedPrototypes.length; ++i) { |
| if (hasProp.call(excludedPrototypes[i], key)) { |
| continue enumeration; |
| } |
| } |
| ret.push(key); |
| } |
| } |
| return ret; |
| }; |
| } |
| |
| })(); |
| |
| var thisAssignmentPattern = /this\s*\.\s*\S+\s*=/; |
| function isClass(fn) { |
| try { |
| if (typeof fn === "function") { |
| var keys = es5.names(fn.prototype); |
| |
| var hasMethods = es5.isES5 && keys.length > 1; |
| var hasMethodsOtherThanConstructor = keys.length > 0 && |
| !(keys.length === 1 && keys[0] === "constructor"); |
| var hasThisAssignmentAndStaticMethods = |
| thisAssignmentPattern.test(fn + "") && es5.names(fn).length > 0; |
| |
| if (hasMethods || hasMethodsOtherThanConstructor || |
| hasThisAssignmentAndStaticMethods) { |
| return true; |
| } |
| } |
| return false; |
| } catch (e) { |
| return false; |
| } |
| } |
| |
| function toFastProperties(obj) { |
| /*jshint -W027,-W055,-W031*/ |
| function FakeConstructor() {} |
| FakeConstructor.prototype = obj; |
| var receiver = new FakeConstructor(); |
| function ic() { |
| return typeof receiver.foo; |
| } |
| ic(); |
| ic(); |
| return obj; |
| eval(obj); |
| } |
| |
| var rident = /^[a-z$_][a-z$_0-9]*$/i; |
| function isIdentifier(str) { |
| return rident.test(str); |
| } |
| |
| function filledRange(count, prefix, suffix) { |
| var ret = new Array(count); |
| for(var i = 0; i < count; ++i) { |
| ret[i] = prefix + i + suffix; |
| } |
| return ret; |
| } |
| |
| function safeToString(obj) { |
| try { |
| return obj + ""; |
| } catch (e) { |
| return "[no string representation]"; |
| } |
| } |
| |
| function isError(obj) { |
| return obj instanceof Error || |
| (obj !== null && |
| typeof obj === "object" && |
| typeof obj.message === "string" && |
| typeof obj.name === "string"); |
| } |
| |
| function markAsOriginatingFromRejection(e) { |
| try { |
| notEnumerableProp(e, "isOperational", true); |
| } |
| catch(ignore) {} |
| } |
| |
| function originatesFromRejection(e) { |
| if (e == null) return false; |
| return ((e instanceof Error["__BluebirdErrorTypes__"].OperationalError) || |
| e["isOperational"] === true); |
| } |
| |
| function canAttachTrace(obj) { |
| return isError(obj) && es5.propertyIsWritable(obj, "stack"); |
| } |
| |
| var ensureErrorObject = (function() { |
| if (!("stack" in new Error())) { |
| return function(value) { |
| if (canAttachTrace(value)) return value; |
| try {throw new Error(safeToString(value));} |
| catch(err) {return err;} |
| }; |
| } else { |
| return function(value) { |
| if (canAttachTrace(value)) return value; |
| return new Error(safeToString(value)); |
| }; |
| } |
| })(); |
| |
| function classString(obj) { |
| return {}.toString.call(obj); |
| } |
| |
| function copyDescriptors(from, to, filter) { |
| var keys = es5.names(from); |
| for (var i = 0; i < keys.length; ++i) { |
| var key = keys[i]; |
| if (filter(key)) { |
| try { |
| es5.defineProperty(to, key, es5.getDescriptor(from, key)); |
| } catch (ignore) {} |
| } |
| } |
| } |
| |
| var asArray = function(v) { |
| if (es5.isArray(v)) { |
| return v; |
| } |
| return null; |
| }; |
| |
| if (typeof Symbol !== "undefined" && Symbol.iterator) { |
| var ArrayFrom = typeof Array.from === "function" ? function(v) { |
| return Array.from(v); |
| } : function(v) { |
| var ret = []; |
| var it = v[Symbol.iterator](); |
| var itResult; |
| while (!((itResult = it.next()).done)) { |
| ret.push(itResult.value); |
| } |
| return ret; |
| }; |
| |
| asArray = function(v) { |
| if (es5.isArray(v)) { |
| return v; |
| } else if (v != null && typeof v[Symbol.iterator] === "function") { |
| return ArrayFrom(v); |
| } |
| return null; |
| }; |
| } |
| |
| var isNode = typeof process !== "undefined" && |
| classString(process).toLowerCase() === "[object process]"; |
| |
| var hasEnvVariables = typeof process !== "undefined" && |
| typeof process.env !== "undefined"; |
| |
| function env(key) { |
| return hasEnvVariables ? process.env[key] : undefined; |
| } |
| |
| function getNativePromise() { |
| if (typeof Promise === "function") { |
| try { |
| var promise = new Promise(function(){}); |
| if (classString(promise) === "[object Promise]") { |
| return Promise; |
| } |
| } catch (e) {} |
| } |
| } |
| |
| var reflectHandler; |
| function contextBind(ctx, cb) { |
| if (ctx === null || |
| typeof cb !== "function" || |
| cb === reflectHandler) { |
| return cb; |
| } |
| |
| if (ctx.domain !== null) { |
| cb = ctx.domain.bind(cb); |
| } |
| |
| var async = ctx.async; |
| if (async !== null) { |
| var old = cb; |
| cb = function() { |
| var $_len = arguments.length + 2;var args = new Array($_len); for(var $_i = 2; $_i < $_len ; ++$_i) {args[$_i] = arguments[$_i - 2];}; |
| args[0] = old; |
| args[1] = this; |
| return async.runInAsyncScope.apply(async, args); |
| }; |
| } |
| return cb; |
| } |
| |
| var ret = { |
| setReflectHandler: function(fn) { |
| reflectHandler = fn; |
| }, |
| isClass: isClass, |
| isIdentifier: isIdentifier, |
| inheritedDataKeys: inheritedDataKeys, |
| getDataPropertyOrDefault: getDataPropertyOrDefault, |
| thrower: thrower, |
| isArray: es5.isArray, |
| asArray: asArray, |
| notEnumerableProp: notEnumerableProp, |
| isPrimitive: isPrimitive, |
| isObject: isObject, |
| isError: isError, |
| canEvaluate: canEvaluate, |
| errorObj: errorObj, |
| tryCatch: tryCatch, |
| inherits: inherits, |
| withAppended: withAppended, |
| maybeWrapAsError: maybeWrapAsError, |
| toFastProperties: toFastProperties, |
| filledRange: filledRange, |
| toString: safeToString, |
| canAttachTrace: canAttachTrace, |
| ensureErrorObject: ensureErrorObject, |
| originatesFromRejection: originatesFromRejection, |
| markAsOriginatingFromRejection: markAsOriginatingFromRejection, |
| classString: classString, |
| copyDescriptors: copyDescriptors, |
| isNode: isNode, |
| hasEnvVariables: hasEnvVariables, |
| env: env, |
| global: globalObject, |
| getNativePromise: getNativePromise, |
| contextBind: contextBind |
| }; |
| ret.isRecentNode = ret.isNode && (function() { |
| var version; |
| if (process.versions && process.versions.node) { |
| version = process.versions.node.split(".").map(Number); |
| } else if (process.version) { |
| version = process.version.split(".").map(Number); |
| } |
| return (version[0] === 0 && version[1] > 10) || (version[0] > 0); |
| })(); |
| ret.nodeSupportsAsyncResource = ret.isNode && (function() { |
| var supportsAsync = false; |
| try { |
| var res = require("async_hooks").AsyncResource; |
| supportsAsync = typeof res.prototype.runInAsyncScope === "function"; |
| } catch (e) { |
| supportsAsync = false; |
| } |
| return supportsAsync; |
| })(); |
| |
| if (ret.isNode) ret.toFastProperties(process); |
| |
| try {throw new Error(); } catch (e) {ret.lastLineError = e;} |
| module.exports = ret; |