twitst4tz

util.js (11379B)

---

 "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;