How to use the any-promise.reject function in any-promise

.then(function (tree) {
        var name = expName || tree.name;
        if (!name) {
            return Promise.reject(new TypeError("Unable to install dependency from \"" + tree.raw + "\" without a name"));
        }
        if (tree.postmessage) {
            emitter.emit('postmessage', { name: name, message: tree.postmessage });
        }
        return compile_1.compile(tree, Object.keys(resolutions), {
            cwd: cwd,
            name: name,
            global: global,
            emitter: emitter,
            meta: true
        });
    });
}

function bundle(options) {
    var cwd = options.cwd, ambient = options.ambient, out = options.out;
    var emitter = options.emitter || new events_1.EventEmitter();
    if (out == null) {
        return Promise.reject(new TypeError('Out directory is required for bundle'));
    }
    return dependencies_1.resolveAllDependencies({ cwd: cwd, dev: false, ambient: false, emitter: emitter })
        .then(function (tree) {
        var name = options.name || tree.name;
        if (name == null) {
            return Promise.reject(new TypeError('Unable to infer typings name from project. Use the `--name` flag to specify it manually'));
        }
        return compile_1.default(tree, { cwd: cwd, name: name, ambient: ambient, emitter: emitter, meta: true });
    })
        .then(function (output) {
        var path = path_1.resolve(cwd, out);
        return fs_1.mkdirp(path)
            .then(function () {
            return Promise.all([
                fs_1.writeFile(path_1.join(path, 'main.d.ts'), output.main),
                fs_1.writeFile(path_1.join(path, 'browser.d.ts'), output.browser)

function get(url, method, body) {
        if (requestCount++ > maxRedirects) {
            return Promise.reject(request.error("Exceeded maximum of " + maxRedirects + " redirects", 'EMAXREDIRECTS'));
        }
        return appendCookies(request)
            .then(function () {
            return new Promise(function (resolve, reject) {
                var arg = urlLib.parse(url);
                var isHttp = arg.protocol !== 'https:';
                var engine = isHttp ? http_1.request : https_1.request;
                arg.method = method;
                arg.headers = request.toHeaders();
                arg.agent = options.agent;
                arg.rejectUnauthorized = options.rejectUnauthorized !== false;
                arg.ca = options.ca;
                arg.cert = options.cert;
                arg.key = options.key;
                var req = engine(arg);
                var requestProxy = new stream_1.PassThrough();

v: sigs[0][0],
                r: sigs[0][1],
                s: sigs[0][2],
                rawTransaction,
                txHash: Hash.keccak256(rawTransaction),
                senderTxHash: getSenderTxHash(rawTransaction),
            }

            if (isFeePayer) {
                result.feePayerSignatures = feePayerSignatures
            } else {
                result.signatures = signatures
            }
        } catch (e) {
            callback(e)
            return Promise.reject(e)
        }

        callback(null, result)
        return result
    }

}, function (cause) {
        var authorPhrase = options.parent ? "The author of \"" + options.parent.name + "\" needs to" : 'You should';
        var relativePath = path_3.relativeTo(tree.src, path);
        if (originalPath == null) {
            return Promise.reject(new error_1.default(("Unable to read typings for \"" + options.name + "\". ") +
                (authorPhrase + " check the entry paths in \"" + path_1.basename(tree.src) + "\" are up to date"), cause));
        }
        return Promise.reject(new error_1.default(("Unable to read \"" + relativePath + "\" from \"" + options.name + "\". ") +
            (authorPhrase + " validate all import paths are accurate (case sensitive and relative)"), cause));
    });
}

function get(url, method, body) {
        if (requestCount++ > maxRedirects) {
            return Promise.reject(request.error("Exceeded maximum of " + maxRedirects + " redirects", 'EMAXREDIRECTS'));
        }
        return attachCookies(url)
            .then(function () {
            return new Promise(function (resolve, reject) {
                var arg = urlLib.parse(url);
                var isHttp = arg.protocol !== 'https:';
                var engine = isHttp ? http_1.request : https_1.request;
                arg.method = method;
                arg.headers = request.toHeaders();
                arg.agent = agent;
                arg.rejectUnauthorized = rejectUnauthorized !== false;
                arg.ca = ca;
                arg.cert = cert;
                arg.key = key;
                var rawRequest = engine(arg);
                var requestStream = new stream_1.PassThrough();

const handleError = e => {
        e = e instanceof Error ? e : new Error(e)
        if (callback) callback(e)
        return Promise.reject(e)
    }

var rlpEncoded = ethTx.serialize().toString('hex');
            var rawTransaction = '0x' + rlpEncoded;
            var transactionHash = utils.keccak256(rawTransaction);

            return {
                messageHash: '0x' + Buffer.from(ethTx.hash(false)).toString('hex'),
                v: '0x' + Buffer.from(ethTx.v).toString('hex'),
                r: '0x' + Buffer.from(ethTx.r).toString('hex'),
                s: '0x' + Buffer.from(ethTx.s).toString('hex'),
                rawTransaction: rawTransaction,
                transactionHash: transactionHash
            };

        } catch (e) {
            callback(e);
            return Promise.reject(e);
        }

        callback(null, result);
        return result;
    }

}, function (error) {
        return Promise.reject(resolveError(raw, error, options));
    });
}