“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® {

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 = /thiss*.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$_]*$/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;