@mvx/identity/fesm2017/identity.js

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var tslib = _interopDefault(require('tslib'));
var mvc = _interopDefault(require('@mvx/mvc'));
var ioc = _interopDefault(require('@tsdi/ioc'));
var koaSession = _interopDefault(require('koa-session'));
var components = _interopDefault(require('@tsdi/components'));
var url = _interopDefault(require('url'));
var jsonwebtoken = _interopDefault(require('jsonwebtoken'));
var http = _interopDefault(require('http'));
var boot = _interopDefault(require('@tsdi/boot'));
var https = _interopDefault(require('https'));
var querystring = _interopDefault(require('querystring'));
var crypto = _interopDefault(require('crypto'));
var webfinger = _interopDefault(require('webfinger'));
var request = _interopDefault(require('request'));
var core = _interopDefault(require('@tsdi/core'));

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function unwrapExports (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var NoOpenIDError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

class NoOpenIDError extends mvc.HttpError {
    constructor(message, response) {
        super(400, message);
        this.response = response;
    }
    static d0Ann() {
        return { "name": "NoOpenIDError" };
    }
}
exports.NoOpenIDError = NoOpenIDError;


});

unwrapExports(NoOpenIDError_1);
var NoOpenIDError_2 = NoOpenIDError_1.NoOpenIDError;

var AuthenticationError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


/**
 * error.
 *
 * @export
 * @class OIDCError
 * @extends {HttpError}
 */
class AuthenticationError extends mvc.HttpError {
    // tslint:disable-next-line: variable-name
    constructor(status, message, error_description) {
        super(status, message);
        this.error_description = error_description;
        this.name = ioc.lang.getClassName(this);
        this.error = message;
        this.expose = status < 500;
    }
    static d0Ann() {
        return { "name": "AuthenticationError" };
    }
}
exports.AuthenticationError = AuthenticationError;


});

unwrapExports(AuthenticationError_1);
var AuthenticationError_2 = AuthenticationError_1.AuthenticationError;

var OIDCError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * error.
 *
 * @export
 * @class OIDCError
 * @extends {HttpError}
 */
class OIDCError extends AuthenticationError_1.AuthenticationError {
    constructor(message, code, uri, status) {
        super(status, message);
        this.code = code;
        this.uri = uri;
        if (!status) {
            switch (code) {
                case 'access_denied':
                    status = 403;
                    break;
                case 'server_error':
                    status = 502;
                    break;
                case 'temporarily_unavailable':
                    status = 503;
                    break;
            }
        }
        this.expose = status < 500;
    }
    static d0Ann() {
        return { "name": "OIDCError" };
    }
}
exports.OIDCError = OIDCError;


});

unwrapExports(OIDCError_1);
var OIDCError_2 = OIDCError_1.OIDCError;

var InvalidToken_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * invalid token.
 *
 * @export
 * @class InvalidToken
 * @extends {AuthenticationError}
 */
class InvalidToken extends AuthenticationError_1.AuthenticationError {
    constructor(detail) {
        super(401, 'invalid_token', 'invalid token provided');
        this.error_detail = detail;
    }
    static d0Ann() {
        return { "name": "InvalidToken" };
    }
}
exports.InvalidToken = InvalidToken;


});

unwrapExports(InvalidToken_1);
var InvalidToken_2 = InvalidToken_1.InvalidToken;

var InvalidRequest_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * invaild request error.
 *
 * @export
 * @class InvalidRequest
 * @extends {HttpError}
 */
class InvalidRequest extends AuthenticationError_1.AuthenticationError {
    constructor(description, status = 400) {
        super(status, '', description || 'request is invalid');
    }
    static d0Ann() {
        return { "name": "InvalidRequest" };
    }
}
exports.InvalidRequest = InvalidRequest;


});

unwrapExports(InvalidRequest_1);
var InvalidRequest_2 = InvalidRequest_1.InvalidRequest;

var InternalOAuthError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * internal oauth error.
 *
 * @export
 * @class InternalOAuthError
 * @extends {AuthenticationError}
 */
class InternalOAuthError extends AuthenticationError_1.AuthenticationError {
    constructor(message, oauthError) {
        super(400, message);
        this.oauthError = oauthError;
    }
    static d0Ann() {
        return { "name": "InternalOAuthError" };
    }
}
exports.InternalOAuthError = InternalOAuthError;


});

unwrapExports(InternalOAuthError_1);
var InternalOAuthError_2 = InternalOAuthError_1.InternalOAuthError;

var errors = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(NoOpenIDError_1, exports);
tslib.__exportStar(AuthenticationError_1, exports);
tslib.__exportStar(OIDCError_1, exports);
tslib.__exportStar(InvalidToken_1, exports);
tslib.__exportStar(InvalidRequest_1, exports);
tslib.__exportStar(InternalOAuthError_1, exports);


});

unwrapExports(errors);

var SessionMiddleware_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




/**
 * Session storage.
 */
let SessionStorage = class SessionStorage {
    constructor() {
    }
    static d0Ann() {
        return { "name": "SessionStorage", "params": { "constructor": [], "get": ["key", "maxAge", "data"], "set": ["key", "sess", "maxAge", "data"], "destroy": ["key"] } };
    }
};
SessionStorage = tslib.__decorate([
    ioc.Abstract(),
    tslib.__metadata("design:paramtypes", [])
], SessionStorage);
exports.SessionStorage = SessionStorage;
/**
 * session middleware.
 *
 * @export
 * @class SessionMiddleware
 * @extends {MvcMiddleware}
 */
let SessionMiddleware = class SessionMiddleware extends mvc.MvcMiddleware {
    constructor() {
        super(...arguments);
        this.hasInit = false;
    }
    getMiddleware(context, koa) {
        if (!this.hasInit && !this.middleware) {
            let sessCfg = context.getConfiguration().session;
            this.hasInit = true;
            if (sessCfg) {
                sessCfg = Object.assign({
                    key: 'typemvc:sess',
                    /** (number || 'session') maxAge in ms (default is 1 days) */
                    /** 'session' will result in a cookie that expires when session/browser is closed */
                    /** Warning: If a session cookie is stolen, this cookie will never expire */
                    maxAge: 36000000,
                    overwrite: true,
                    httpOnly: true,
                    signed: true,
                    rolling: false /** (boolean) Force a session identifier cookie to be set on every response. The expiration is reset to the original maxAge, resetting the expiration countdown. default is false **/
                }, sessCfg);
                if (!sessCfg.store) {
                    let storage = context.getContainer().getService(SessionStorage);
                    if (storage) {
                        sessCfg.store = storage;
                    }
                }
                this.middleware = koaSession(sessCfg, koa);
            }
            else {
                this.middleware = koaSession(koa);
            }
        }
        return this.middleware;
    }
    execute(ctx, next) {
        let middleware = this.getMiddleware(ctx.mvcContext, ctx.app);
        return middleware(ctx, next);
    }
    static d0Ann() {
        return { "name": "SessionMiddleware", "params": { "getMiddleware": ["context", "koa"], "execute": ["ctx", "next"] } };
    }
};
SessionMiddleware = tslib.__decorate([
    mvc.Middleware({
        name: mvc.MiddlewareTypes.Session,
        before: mvc.MiddlewareTypes.BodyParser
    })
], SessionMiddleware);
exports.SessionMiddleware = SessionMiddleware;


});

unwrapExports(SessionMiddleware_1);
var SessionMiddleware_2 = SessionMiddleware_1.SessionStorage;
var SessionMiddleware_3 = SessionMiddleware_1.SessionMiddleware;

var IAuthenticator = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * IAuthenticator token.
 */
exports.AuthenticatorToken = new ioc.InjectToken('Authenticator');


});

unwrapExports(IAuthenticator);
var IAuthenticator_1 = IAuthenticator.AuthenticatorToken;

var ValidationResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * auth action
 *
 * @export
 * @class AuthAction
 */
class ValidationResult {
    constructor() {
    }
    static d0Ann() {
        return { "name": "ValidationResult" };
    }
}
exports.ValidationResult = ValidationResult;


});

unwrapExports(ValidationResult_1);
var ValidationResult_2 = ValidationResult_1.ValidationResult;

var FailResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * Fail authentication, with optional `challenge` and `status`, defaulting
 * to 401.
 *
 * Strategies should return this action to fail an authentication attempt.
 *
 * @param {String} challenge
 * @param {Number} status
 * @api public
 */
class FailResult extends ValidationResult_1.ValidationResult {
    constructor(challenge, status) {
        super();
        this.challenge = challenge;
        this.status = status;
    }
    async execute(ctx, next) {
        ctx.failures.push({ challenge: this.challenge, status: this.status });
    }
    static d0Ann() {
        return { "name": "FailResult" };
    }
}
exports.FailResult = FailResult;


});

unwrapExports(FailResult_1);
var FailResult_2 = FailResult_1.FailResult;

var PassResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * Pass without making a success or fail decision.
 *
 * Under most circumstances, Strategies should not need to call this
 * function.  It exists primarily to allow previous authentication state
 * to be restored, for example from an HTTP session.
 *
 */
class PassResult extends ValidationResult_1.ValidationResult {
    execute(ctx, next) {
        return next();
    }
    static d0Ann() {
        return { "name": "PassResult" };
    }
}
exports.PassResult = PassResult;


});

unwrapExports(PassResult_1);
var PassResult_2 = PassResult_1.PassResult;

var RedirectResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * Redirect to `url` with optional `status`, defaulting to 302.
 *
 * Strategies should return this function to redirect the user (via their
 * user agent) to a third-party website for authentication.
 *
 * @param {String} url
 * @param {Number} status
 * @api public
 */
class RedirectResult extends ValidationResult_1.ValidationResult {
    constructor(url, status = 302) {
        super();
        this.url = url;
        this.status = status;
    }
    /**
     * execute.
     *
     * @param {Context} ctx
     * @param {() => Promise<void>} next
     * @returns {Promise<void>}
     * @memberof RedirectResult
     */
    async execute(ctx, next) {
        ctx.status = this.status;
        ctx.redirect(this.url);
    }
    static d0Ann() {
        return { "name": "RedirectResult" };
    }
}
exports.RedirectResult = RedirectResult;


});

unwrapExports(RedirectResult_1);
var RedirectResult_2 = RedirectResult_1.RedirectResult;

var SuccessResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * Authenticate `user`, with optional `info`.
 *
 * Strategies should return this action to successfully authenticate a
 * user.  `user` should be an object supplied by the application after it
 * has been given an opportunity to verify credentials.  `info` is an
 * optional argument containing additional user information.  This is
 * useful for third-party authentication strategies to pass profile
 * details.
 *
 * @param {Object} user
 * @param {Object} info
 * @api public
 */
class SuccessResult extends ValidationResult_1.ValidationResult {
    constructor(options, user, info) {
        super();
        this.options = options;
        this.user = user;
        this.info = info;
    }
    async execute(ctx, next, callback) {
        let user = this.user;
        let info = this.info || {};
        if (callback) {
            return callback(null, user, info);
        }
        let msg;
        let options = this.options;
        if (options.successFlash) {
            var flash = options.successFlash;
            if (typeof flash === 'string') {
                flash = { type: 'success', message: flash };
            }
            flash.type = flash.type || 'success';
            var type = flash.type || info.type || 'success';
            msg = flash.message || info.message || info;
            if (typeof msg === 'string') {
                ctx.session.flash = { type: type, message: msg };
            }
        }
        if (options.successMessage) {
            if (!(info.type in ctx.session.message)) {
                ctx.session.message[info.type] = [];
            }
            ctx.session.message[info.type].push(info.message);
        }
        if (options.assignProperty) {
            ctx.state[options.assignProperty] = user;
        }
        await ctx.login(user);
        if (options.authInfo !== false) {
            ctx.state.authInfo = await ctx.passport.transformAuthInfo(info, ctx);
        }
        if (options.successReturnToOrRedirect) {
            let url = options.successReturnToOrRedirect;
            if (ctx.session && ctx.session.returnTo) {
                url = ctx.session.returnTo;
                delete ctx.session.returnTo;
            }
            return ctx.redirect(url);
        }
        if (options.successRedirect) {
            return ctx.redirect(options.successRedirect);
        }
    }
    static d0Ann() {
        return { "name": "SuccessResult" };
    }
}
exports.SuccessResult = SuccessResult;


});

unwrapExports(SuccessResult_1);
var SuccessResult_2 = SuccessResult_1.SuccessResult;

var results = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(ValidationResult_1, exports);
tslib.__exportStar(FailResult_1, exports);
tslib.__exportStar(PassResult_1, exports);
tslib.__exportStar(RedirectResult_1, exports);
tslib.__exportStar(SuccessResult_1, exports);
tslib.__exportStar(ValidationResult_1, exports);


});

unwrapExports(results);

var Strategy_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




let Strategy = class Strategy {
    static d0Ann() {
        return { "name": "Strategy", "params": { "authenticate": ["ctx", "options"] } };
    }
};
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], Strategy.prototype, "name", void 0);
tslib.__decorate([
    ioc.Inject(IAuthenticator.AuthenticatorToken),
    tslib.__metadata("design:type", Object)
], Strategy.prototype, "authenticator", void 0);
Strategy = tslib.__decorate([
    ioc.Abstract()
], Strategy);
exports.Strategy = Strategy;


});

unwrapExports(Strategy_1);
var Strategy_2 = Strategy_1.Strategy;

var SessionStrategy_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


/**
 * session.
 *
 * @export
 * @class SessionStrategy
 * @extends {Strategy}
 */
class SessionStrategy extends Strategy_1.Strategy {
    /**
     * `SessionStrategy` constructor.
     *
     */
    constructor() {
        super();
        this.name = 'session';
    }
    /**
     * Authenticate request based on the current session state.
     *
     * The session authentication strategy uses the session to restore any login
     * state across requests.  If a login session has been established, `req.user`
     * will be populated with the current user.
     *
     * This strategy is registered automatically by Passport.
     *
     */
    async authenticate(ctx, options = {}) {
        if (!ctx.passport) {
            throw new Error('passport.initialize() middleware not in use');
        }
        let su;
        if (ctx.session.passport) {
            su = ctx.session.passport.user;
        }
        if (su || su === 0) {
            // NOTE: Stream pausing is desirable in the case where later middleware is
            //       listening for events emitted from request.  For discussion on the
            //       matter, refer to: https://github.com/jaredhanson/passport/pull/106
            const user = await ctx.passport.deserializeUser(su, ctx);
            if (!user) {
                ctx.session.passport.user = undefined;
                return new results.PassResult();
            }
            const property = ctx.passport.userProperty;
            ctx.state[property] = user;
        }
        return new results.PassResult();
    }
    static d0Ann() {
        return { "name": "SessionStrategy" };
    }
}
exports.SessionStrategy = SessionStrategy;


});

unwrapExports(SessionStrategy_1);
var SessionStrategy_2 = SessionStrategy_1.SessionStrategy;

var LocalStrategy_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




/**
 * Local authenticate strategy
 *
 * @export
 * @class LocalStrategy
 * @extends {Strategy}
 * @implements {AfterInit}
 */
let LocalStrategy = class LocalStrategy extends Strategy_1.Strategy {
    async onAfterInit() {
        if (!this.name) {
            this.name = 'local';
        }
        if (!this.usernameField) {
            this.usernameField = 'username';
        }
        if (!this.passwordField) {
            this.passwordField = 'password';
        }
    }
    async authenticate(ctx, options) {
        let username = ctx.request.body[this.usernameField] || ctx.query[this.usernameField];
        let password = ctx.request.body[this.passwordField] || ctx.query[this.passwordField];
        let { user, info } = await this.verify(username, password, ctx);
        if (!user) {
            // TODO, not sure 401 is the correct meaning
            return new results.FailResult(info, 401);
        }
        return new results.SuccessResult(options, user, info);
    }
    static d0Ann() {
        return { "name": "LocalStrategy", "params": { "onAfterInit": [], "authenticate": ["ctx", "options"] } };
    }
};
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], LocalStrategy.prototype, "verify", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], LocalStrategy.prototype, "usernameField", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], LocalStrategy.prototype, "passwordField", void 0);
LocalStrategy = tslib.__decorate([
    components.Component({
        selector: 'local'
    })
], LocalStrategy);
exports.LocalStrategy = LocalStrategy;


});

unwrapExports(LocalStrategy_1);
var LocalStrategy_2 = LocalStrategy_1.LocalStrategy;

var JwtStrategy_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });







/**
 * Jwt authenticate strategy
 */
let JwtStrategy = class JwtStrategy extends Strategy_1.Strategy {
    async onAfterInit() {
        if (!this.name) {
            this.name = 'jwt';
        }
        if (this.secretOrKey) {
            if (this.secretOrKeyProvider) {
                throw new TypeError('JwtStrategy has been given both a secretOrKey and a secretOrKeyProvider');
            }
            this.secretOrKeyProvider = async (request, rawJwtToken) => {
                return this.secretOrKey;
            };
        }
        if (!this.secretOrKeyProvider) {
            throw new TypeError('JwtStrategy requires a secret or key');
        }
        if (!this.verify) {
            throw new TypeError('JwtStrategy requires a verify');
        }
        if (!this.jwtFromRequest) {
            throw new TypeError('JwtStrategy requires a function to retrieve jwt from requests (see option jwtFromRequest)');
        }
    }
    async authenticate(ctx, options) {
        let token = this.jwtFromRequest(ctx.request);
        if (!token) {
            return new results.FailResult('No auth token', 401);
        }
        let secretOrKey = this.secretOrKey = await this.secretOrKeyProvider(ctx.request, token);
        let payload = await new Promise((r, j) => {
            jsonwebtoken.verify(token, secretOrKey, {
                audience: this.audience,
                issuer: this.issuer,
                algorithms: this.algorithms,
                ignoreExpiration: this.ignoreExpiration
            }, (err, decoded) => {
                if (err) {
                    j(err);
                }
                else {
                    r(decoded);
                }
            });
        });
        let { user, info } = await this.verify(payload, ctx);
        if (!user) {
            // TODO, not sure 401 is the correct meaning
            return new results.FailResult(info, 401);
        }
        return new results.SuccessResult(options, user, info);
    }
    sign(payload, secretOrKey, options) {
        let defer = ioc.PromiseUtil.defer();
        jsonwebtoken.sign(payload, secretOrKey || this.secretOrKey, Object.assign({ audience: this.audience, issuer: this.issuer }, (options || {})
        // ignoreExpiration: this.ignoreExpiration
        ), (err, decoded) => {
            if (err) {
                defer.reject(err);
            }
            else {
                defer.resolve(decoded);
            }
        });
        return defer.promise;
    }
    static d0Ann() {
        return { "name": "JwtStrategy", "params": { "onAfterInit": [], "authenticate": ["ctx", "options"], "sign": ["payload", "secretOrKey", "options"] } };
    }
};
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], JwtStrategy.prototype, "verify", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], JwtStrategy.prototype, "issuer", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], JwtStrategy.prototype, "audience", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Array)
], JwtStrategy.prototype, "algorithms", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Boolean)
], JwtStrategy.prototype, "ignoreExpiration", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], JwtStrategy.prototype, "secretOrKey", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], JwtStrategy.prototype, "secretOrKeyProvider", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], JwtStrategy.prototype, "jwtFromRequest", void 0);
JwtStrategy = tslib.__decorate([
    components.Component({
        selector: 'jwt'
    })
], JwtStrategy);
exports.JwtStrategy = JwtStrategy;
const matcExp = /(\S+)\s+(\S+)/;
function parseAuthHeader(hdrValue) {
    if (typeof hdrValue !== 'string') {
        return null;
    }
    var matches = hdrValue.match(matcExp);
    return matches && { scheme: matches[1], value: matches[2] };
}
// Note: express http converts all headers
// to lower case.
const AUTH_HEADER = 'authorization', LEGACY_AUTH_SCHEME = 'JWT', BEARER_AUTH_SCHEME = 'bearer';
var JwtRequest;
(function (JwtRequest) {
    function fromHeader(headerName) {
        return function (request) {
            var token = null;
            if (request.headers[headerName]) {
                token = request.headers[headerName];
            }
            return token;
        };
    }
    JwtRequest.fromHeader = fromHeader;
    function fromBodyField(fieldName) {
        return function (request) {
            var token = null;
            if (request.body && Object.prototype.hasOwnProperty.call(request.body, fieldName)) {
                token = request.body[fieldName];
            }
            return token;
        };
    }
    JwtRequest.fromBodyField = fromBodyField;
    function fromUrlQueryParameter(paramName) {
        return function (request) {
            let token = null, parsedUrl = url.parse(request.url, true);
            if (parsedUrl.query && Object.prototype.hasOwnProperty.call(parsedUrl.query, paramName)) {
                token = parsedUrl.query[paramName];
            }
            return token;
        };
    }
    JwtRequest.fromUrlQueryParameter = fromUrlQueryParameter;
    function fromAuthHeaderWithScheme(authScheme) {
        var authSchemeLower = authScheme.toLowerCase();
        return function (request) {
            var token = null;
            if (request.headers[AUTH_HEADER]) {
                var authParams = parseAuthHeader(request.headers[AUTH_HEADER]);
                if (authParams && authSchemeLower === authParams.scheme.toLowerCase()) {
                    token = authParams.value;
                }
            }
            return token;
        };
    }
    JwtRequest.fromAuthHeaderWithScheme = fromAuthHeaderWithScheme;
    function fromAuthHeaderAsBearerToken() {
        return fromAuthHeaderWithScheme(BEARER_AUTH_SCHEME);
    }
    JwtRequest.fromAuthHeaderAsBearerToken = fromAuthHeaderAsBearerToken;
    function fromExtractors(extractors) {
        if (!Array.isArray(extractors)) {
            throw new TypeError('export function fromExtractors expects an array');
        }
        return function (request) {
            var token = null;
            var index = 0;
            while (!token && index < length) {
                token = extractors[index].call(this, request);
                index++;
            }
            return token;
        };
    }
    JwtRequest.fromExtractors = fromExtractors;
    /**
     * This extractor mimics the behavior of the v1.*.* extraction logic.
     *
     * This extractor exists only to provide an easy transition from the v1.*.* API to the v2.0.0
     * API.
     *
     * This extractor first checks the auth header, if it doesn't find a token there then it checks the
     * specified body field and finally the url query parameters.
     *
     * @param options
     *          authScheme: Expected scheme when JWT can be found in HTTP Authorize header. Default is JWT.
     *          tokenBodyField: Field in request body containing token. Default is auth_token.
     *          tokenQueryParameterName: Query parameter name containing the token. Default is auth_token.
     */
    function versionOneCompatibility(options) {
        var authScheme = options.authScheme || LEGACY_AUTH_SCHEME, bodyField = options.tokenBodyField || 'auth_token', queryParam = options.tokenQueryParameterName || 'auth_token';
        return function (request) {
            var authHeaderExtractor = fromAuthHeaderWithScheme(authScheme);
            var token = authHeaderExtractor(request);
            if (!token) {
                var bodyExtractor = fromBodyField(bodyField);
                token = bodyExtractor(request);
            }
            if (!token) {
                var queryExtractor = fromUrlQueryParameter(queryParam);
                token = queryExtractor(request);
            }
            return token;
        };
    }
    JwtRequest.versionOneCompatibility = versionOneCompatibility;
})(JwtRequest = exports.JwtRequest || (exports.JwtRequest = {}));


});

unwrapExports(JwtStrategy_1);
var JwtStrategy_2 = JwtStrategy_1.JwtStrategy;
var JwtStrategy_3 = JwtStrategy_1.JwtRequest;

var ContextExtends = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

/**
 * Intiate a login session for `user`.
 *
 * Options:
 *   - `session`  Save login state in session, defaults to `true`
 *
 * Examples:
 *
 *     await req.logIn(user, { session: false });
 *
 * @api public
 */
async function login(user) {
    if (!this.passport) {
        throw new Error('passport.initialize() middleware not in use');
    }
    const property = (this.passport && this.passport.userProperty);
    this.state[property] = user;
    let obj;
    try {
        obj = await this.passport.serializeUser(user, this);
    }
    catch (err) {
        this.state[property] = null;
        throw err;
    }
    if (!this.session) {
        throw new Error('Should use session middleware before passport middleware');
    }
    this.session.passport.user = obj;
}
/**
 * Terminate an existing login session.
 *
 * @api public
 */
function logout() {
    if (!this.passport || !this.session) {
        return;
    }
    const property = this.passport.userProperty;
    delete this.state[property];
    delete this.session.passport.user;
}
/**
 * Test if request is authenticated.
 *
 * @api public
 */
function isAuthenticated() {
    if (!this.passport) {
        return false;
    }
    const property = this.passport.userProperty;
    return (this.state[property]) ? true : false;
}
/**
 * Test if request is unauthenticated.
 *
 * @api public
 */
function isUnauthenticated() {
    return !this.isAuthenticated();
}
function hasRole(...roles) {
    if (!this.passport) {
        return false;
    }
    if (!roles.length) {
        return true;
    }
    const property = this.passport.rolesProperty;
    if ((this.state[property])) {
        return this.state[property].some(role => roles.indexOf(role) > 0);
    }
    return false;
}
/**
 * context extends.
 *
 * @export
 * @param {BaseContext} ctx
 * @returns {void}
 */
function contextExtends(ctx) {
    // add passport http.IncomingMessage extensions
    if (ctx.hasOwnProperty('login') || ctx.hasOwnProperty('logout') ||
        ctx.hasOwnProperty('isAuthenticated') || ctx.hasOwnProperty('isUnauthenticated')) {
        return;
    }
    Object.defineProperties(ctx, {
        login: {
            value: login,
            writable: false,
            enumerable: false,
        },
        logout: {
            value: logout,
            writable: false,
            enumerable: false,
        },
        isAuthenticated: {
            value: isAuthenticated,
            writable: false,
            enumerable: false,
        },
        isUnauthenticated: {
            value: isUnauthenticated,
            writable: false,
            enumerable: false,
        },
        hasRole: {
            value: hasRole,
            writable: false,
            enumerable: false,
        }
    });
}
exports.contextExtends = contextExtends;


});

unwrapExports(ContextExtends);
var ContextExtends_1 = ContextExtends.contextExtends;

var Authenticator_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });








/**
 * `Authenticator` constructor.
 *
 */
let Authenticator = class Authenticator {
    constructor() {
        this._userProperty = 'user';
        this._rolesProperty = 'roles';
        this.strategies = new Map();
        this.serializers = [];
        this.deserializers = [];
        this.infoTransformers = [];
        this.use(new SessionStrategy_1.SessionStrategy());
    }
    get userProperty() {
        return this._userProperty;
    }
    get rolesProperty() {
        return this._rolesProperty;
    }
    /**
     * get strategy.
     *
     * @param {string} name
     * @returns {IStrategy}
     * @memberof IAuthenticator
     */
    get(name) {
        return this.strategies.get(name);
    }
    use(name, strategy) {
        if (strategy === undefined) {
            strategy = name;
            name = strategy.name;
        }
        if (!name) {
            throw new Error('Authentication strategies must have a name');
        }
        this.strategies.set(name, strategy);
        return this;
    }
    /**
     * Un-utilize the `strategy` with given `name`.
     *
     * In typical applications, the necessary authentication strategies are static,
     * configured once and always available.  As such, there is often no need to
     * invoke this function.
     *
     * However, in certain situations, applications may need dynamically configure
     * and de-configure authentication strategies.  The `use()`/`unuse()`
     * combination satisfies these scenarios.
     *
     * Examples:
     *
     *     passport.unuse('legacy-api');
     *
     */
    unuse(name) {
        this.strategies.delete(name);
        return this;
    }
    /**
     * Passport's primary initialization middleware.
     *
     * Intializes Passport for incoming requests, allowing
     * authentication strategies to be applied.
     *
     * If sessions are being utilized, applications must set up Passport with
     * functions to serialize a user into and out of a session.  For example, a
     * common pattern is to serialize just the user ID into the session (due to the
     * fact that it is desirable to store the minimum amount of data in a session).
     * When a subsequent request arrives for the session, the full User object can
     * be loaded from the database by ID.
     *
     * Note that additional middleware is required to persist login state, so we
     * must use the `connect.session()` middleware _before_ `passport.initialize()`.
     *
     * If sessions are being used, this middleware must be in use by the
     * Koa application for Passport to operate.  If the application is
     * entirely stateless (not using sessions), this middleware is not necessary,
     * but its use will not have any adverse impact.
     *
     * Options:
     *   - `userProperty`  Property to set on `ctx.state` upon login, defaults to _user_
     *
     * Examples:
     *     app.use(connect.cookieParser());
     *
     *     app.use(connect.session({ secret: 'keyboard cat' }));
     *     app.use(passport.initialize());
     *     app.use(passport.initialize({ userProperty: 'currentUser' }));
     *     app.use(passport.session());
     *
     *     passport.serializeUser(function(user, done) {
     *       done(null, user.id);
     *     });
     *
     *     passport.deserializeUser(function(id, done) {
     *       User.findById(id, function (err, user) {
     *         done(err, user);
     *       });
     *     });
     *
     */
    initialize(options = {}) {
        this._userProperty = options.userProperty || 'user';
        this._rolesProperty = options.rolesProperty || 'roles';
        return async (ctx, next) => {
            ctx.passport = this;
            const session = ctx.session;
            if (!session) {
                throw new Error('Session middleware is needed with passport middleware!');
            }
            if (!('passport' in session)) {
                ctx.session.passport = { user: undefined };
            }
            if (!('message' in session)) {
                session.message = {};
            }
            ctx.session = session;
            ContextExtends.contextExtends(ctx);
            await next();
        };
    }
    authenticate(strategyNames, options = {}, callback) {
        if (ioc.isFunction(options)) {
            callback = options;
            options = {};
        }
        let multi = true;
        // Cast `strategy` to an array, allowing authentication to pass through a chain of
        // strategies.  The first strategy to succeed, redirect, or error will halt
        // the chain.  Authentication failures will proceed through each strategy in
        // series, ultimately failing if all strategies fail.
        //
        // This is typically used on API endpoints to allow clients to authenticate
        // using their preferred choice of Basic, Digest, token-based schemes, etc.
        // It is not feasible to construct a chain of multiple strategies that involve
        // redirection (for example both Facebook and Twitter), since the first one to
        // redirect will halt the chain.
        if (ioc.isString(strategyNames)) {
            strategyNames = [strategyNames];
            multi = false;
        }
        return async (ctx, next) => {
            // accumulator for failures from each strategy in the chain
            const failures = ctx.failures = [];
            function allFailed() {
                if (callback) {
                    if (!multi) {
                        return callback(null, false, failures[0].challenge, failures[0].status);
                    }
                    else {
                        const challenges = failures.map(f => f.challenge);
                        const statuses = failures.map(f => f.status);
                        return callback(null, false, challenges, statuses);
                    }
                }
                // Strategies are ordered by priority.  For the purpose of flashing a
                // message, the first failure will be displayed.
                // const challenge = (failures[0] || {}).challenge || {};
                if (options.failureMessage && failures[0].challenge.type) {
                    const challenge = failures[0].challenge;
                    if (!(challenge.type in ctx.session.message)) {
                        ctx.session.message[challenge.type] = [];
                    }
                    ctx.session.message[challenge.type].push(challenge.messages);
                }
                if (options.failureRedirect) {
                    return ctx.redirect(options.failureRedirect);
                }
                // When failure handling is not delegated to the application, the default
                // is to respond with 401 Unauthorized.  Note that the WWW-Authenticate
                // header will be set according to the strategies in use (see
                // actions#fail).  If multiple strategies failed, each of their challenges
                // will be included in the response.
                const rchallenge = [];
                let rstatus;
                let status;
                for (const failure of failures) {
                    status = failure.status;
                    rstatus = rstatus || status;
                    if (ioc.isString(failure.challenge)) {
                        rchallenge.push(failure.challenge);
                    }
                }
                ctx.status = rstatus || 401;
                if (ctx.status === 401 && rchallenge.length) {
                    ctx.set('WWW-Authenticate', rchallenge);
                }
                if (options.failWithError) {
                    throw new errors.AuthenticationError(rstatus, http.STATUS_CODES[ctx.status]);
                }
                // ctx.res.statusMessage = http.STATUS_CODES[ctx.status];
                ctx.response.message = http.STATUS_CODES[ctx.status];
                ctx.res.end(http.STATUS_CODES[ctx.status]);
            }
            for (const strategyName of strategyNames) {
                const strategy = this.strategies.get(strategyName);
                if (!strategy) {
                    throw new Error(`Unknown authentication strategy "${strategyName}"`);
                }
                try {
                    const res = await strategy.authenticate(ctx, options);
                    if (res instanceof results.FailResult) {
                        await res.execute(ctx, next);
                    }
                    else {
                        return await res.execute(ctx, next, callback);
                    }
                }
                catch (error) {
                    if (callback) {
                        return callback(error);
                    }
                    throw error;
                }
            }
            return allFailed();
        };
    }
    /**
     * Middleware that will authorize a third-party account using the given
     * `strategy` name, with optional `options`.
     *
     * If authorization is successful, the result provided by the strategy's verify
     * callback will be assigned to `ctx.state.account`.  The existing login session and
     * `ctx.state.user` will be unaffected.
     *
     * This function is particularly useful when connecting third-party accounts
     * to the local account of a user that is currently authenticated.
     *
     * Examples:
     *
     *    passport.authorize('twitter-authz', { failureRedirect: '/account' });
     */
    authorize(strategy, options = {}, callback) {
        options.assignProperty = 'account';
        return this.authenticate(strategy, options, callback);
    }
    /**
     * Middleware that will restore login state from a session.
     *
     * Web applications typically use sessions to maintain login state between
     * requests.  For example, a user will authenticate by entering credentials into
     * a form which is submitted to the server.  If the credentials are valid, a
     * login session is established by setting a cookie containing a session
     * identifier in the user's web browser.  The web browser will send this cookie
     * in subsequent requests to the server, allowing a session to be maintained.
     *
     * If sessions are being utilized, and a login session has been established,
     * this middleware will populate `req.user` with the current user.
     *
     * Note that sessions are not strictly required for Passport to operate.
     * However, as a general rule, most web applications will make use of sessions.
     * An exception to this rule would be an API server, which expects each HTTP
     * request to provide credentials in an Authorization header.
     *
     * Examples:
     *
     *     app.use(connect.cookieParser());
     *     app.use(connect.session({ secret: 'keyboard cat' }));
     *     app.use(passport.initialize());
     *     app.use(passport.session());
     *
     * Options:
     *   - `pauseStream`      Pause the request stream before deserializing the user
     *                        object from the session.  Defaults to _false_.  Should
     *                        be set to true in cases where middleware consuming the
     *                        request body is configured after passport and the
     *                        deserializeUser method is asynchronous.
     *
     * @api public
     */
    session(options) {
        return this.authenticate('session', options);
    }
    async serializeUser(user, ctx) {
        if (typeof user === 'function') {
            return this.serializers.push(user);
        }
        for (const layer of this.serializers) {
            const obj = await layer(user, ctx);
            if (obj || obj === 0) {
                return obj;
            }
        }
        throw new Error('Failed to serialize user into session');
    }
    async deserializeUser(obj, ctx) {
        if (ioc.isFunction(obj)) {
            return this.deserializers.push(obj);
        }
        for (const layer of this.deserializers) {
            const user = await layer(obj, ctx);
            if (user) {
                return user;
            }
            else if (user === null || user === false) {
                return false;
            }
        }
        throw new Error('Failed to deserialize user out of session');
    }
    async transformAuthInfo(info, ctx) {
        if (ioc.isFunction(info)) {
            return this.infoTransformers.push(info);
        }
        // private implementation that traverses the chain of transformers,
        // attempting to transform auth info
        for (const layer of this.infoTransformers) {
            const tinfo = await layer(info, ctx);
            if (tinfo) {
                return tinfo;
            }
        }
        return info;
    }
    static d0Ann() {
        return { "name": "Authenticator", "params": { "constructor": [], "get": ["name"], "use": ["name", "strategy"], "unuse": ["name"], "initialize": ["options"], "authenticate": ["strategyNames", "options", "callback"], "authorize": ["strategy", "options", "callback"], "session": ["options"], "serializeUser": ["user", "ctx"], "deserializeUser": ["obj", "ctx"], "transformAuthInfo": ["info", "ctx"] } };
    }
};
Authenticator = tslib.__decorate([
    ioc.Singleton(IAuthenticator.AuthenticatorToken),
    tslib.__metadata("design:paramtypes", [])
], Authenticator);
exports.Authenticator = Authenticator;


});

unwrapExports(Authenticator_1);
var Authenticator_2 = Authenticator_1.Authenticator;

var StrategySelectorHandle_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


class StrategySelectorHandle extends components.ComponentSelectorHandle {
    getSelector(template, compdr) {
        return ioc.isMetadataObject(template) ? template.strategy : null;
    }
    static d0Ann() {
        return { "name": "StrategySelectorHandle" };
    }
}
exports.StrategySelectorHandle = StrategySelectorHandle;


});

unwrapExports(StrategySelectorHandle_1);
var StrategySelectorHandle_2 = StrategySelectorHandle_1.StrategySelectorHandle;

var SerializeUser_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


let SerializeUser = class SerializeUser {
    static d0Ann() {
        return { "name": "SerializeUser", "params": { "serializeUser": ["user", "ctx"] } };
    }
};
SerializeUser = tslib.__decorate([
    ioc.Abstract()
], SerializeUser);
exports.SerializeUser = SerializeUser;


});

unwrapExports(SerializeUser_1);
var SerializeUser_2 = SerializeUser_1.SerializeUser;

var DeserializeUser_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


let DeserializeUser = class DeserializeUser {
    static d0Ann() {
        return { "name": "DeserializeUser", "params": { "deserializeUser": ["obj", "ctx"] } };
    }
};
DeserializeUser = tslib.__decorate([
    ioc.Abstract()
], DeserializeUser);
exports.DeserializeUser = DeserializeUser;


});

unwrapExports(DeserializeUser_1);
var DeserializeUser_2 = DeserializeUser_1.DeserializeUser;

var TransformAuthInfo_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


let TransformAuthInfo = class TransformAuthInfo {
    static d0Ann() {
        return { "name": "TransformAuthInfo", "params": { "authInfo": ["user", "ctx"] } };
    }
};
TransformAuthInfo = tslib.__decorate([
    ioc.Abstract()
], TransformAuthInfo);
exports.TransformAuthInfo = TransformAuthInfo;


});

unwrapExports(TransformAuthInfo_1);
var TransformAuthInfo_2 = TransformAuthInfo_1.TransformAuthInfo;

var services = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(SerializeUser_1, exports);
tslib.__exportStar(DeserializeUser_1, exports);
tslib.__exportStar(TransformAuthInfo_1, exports);


});

unwrapExports(services);

var PassportBuildService_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });







/**
 * PassportBuildService
 *
 * @export
 * @abstract
 * @class PassportBuildService
 */
let PassportBuildService = class PassportBuildService {
    async createStrategy(option) {
        return await this.builder.resolveTemplate({ template: option, injector: this.injector });
    }
    static d0Ann() {
        return { "name": "PassportBuildService", "params": { "build": ["passport", "configuration"], "createStrategy": ["option"] } };
    }
};
tslib.__decorate([
    ioc.Inject(ioc.INJECTOR),
    tslib.__metadata("design:type", Object)
], PassportBuildService.prototype, "injector", void 0);
tslib.__decorate([
    ioc.Inject(),
    tslib.__metadata("design:type", components.ComponentBuilder)
], PassportBuildService.prototype, "builder", void 0);
PassportBuildService = tslib.__decorate([
    ioc.Abstract()
], PassportBuildService);
exports.PassportBuildService = PassportBuildService;
/**
 * register passport strategy in configuare.
 *
 * @export
 * @class ConfigurePassportBuildService
 * @extends {PassportBuildService}
 */
let ConfigurePassportBuildService = class ConfigurePassportBuildService extends PassportBuildService {
    async build(passport, configuration) {
        let actInj = this.injector.getInstance(ioc.ActionInjectorToken);
        let register = actInj.getInstance(boot.StartupDecoratorRegisterer).getRegisterer('TranslateTemplate');
        if (!register.has(StrategySelectorHandle_1.StrategySelectorHandle)) {
            register.registerBefore(components.Component, components.ComponentSelectorHandle, StrategySelectorHandle_1.StrategySelectorHandle);
        }
        if (configuration.passports) {
            let { strategies, serializers, deserializers, authInfos } = configuration.passports;
            if (strategies.length) {
                await Promise.all(strategies.map(async (p) => {
                    let strategy = await this.createStrategy(p);
                    if (strategy instanceof Strategy_1.Strategy) {
                        passport.use(strategy);
                    }
                }));
            }
            if (serializers && serializers.length) {
                serializers.forEach(ser => {
                    if (ioc.isClass(ser)) {
                        if (!this.injector.has(ser)) {
                            this.injector.register(ser);
                        }
                        passport.serializeUser((user, ctx) => this.injector.resolve(ser).serializeUser(user, ctx));
                    }
                    else if (ioc.isFunction(ser)) {
                        passport.serializeUser(ser);
                    }
                });
            }
            else {
                this.injector.getServices(services.SerializeUser)
                    .forEach(ser => {
                    passport.serializeUser((user, ctx) => ser.serializeUser(user, ctx));
                });
            }
            if (deserializers && deserializers.length) {
                deserializers.forEach(desr => {
                    if (ioc.isClass(desr)) {
                        if (!this.injector.has(desr)) {
                            this.injector.register(desr);
                        }
                        passport.deserializeUser((obj, ctx) => this.injector.resolve(desr).deserializeUser(obj, ctx));
                    }
                    else if (ioc.isFunction(desr)) {
                        passport.deserializeUser(desr);
                    }
                });
            }
            else {
                this.injector.getServices(services.DeserializeUser)
                    .forEach(desr => {
                    passport.deserializeUser((obj, ctx) => desr.deserializeUser(obj, ctx));
                });
            }
            if (authInfos && authInfos.length) {
                authInfos.forEach(trans => {
                    if (ioc.isClass(trans)) {
                        if (!this.injector.has(trans)) {
                            this.injector.register(trans);
                        }
                        passport.transformAuthInfo((info, ctx) => this.injector.resolve(trans).authInfo(info, ctx));
                    }
                    else if (ioc.isFunction(trans)) {
                        passport.transformAuthInfo(trans);
                    }
                });
            }
            else {
                this.injector.getServices(services.TransformAuthInfo)
                    .forEach(ser => {
                    passport.transformAuthInfo((info, ctx) => ser.authInfo(info, ctx));
                });
            }
        }
    }
    static d0Ann() {
        return { "name": "ConfigurePassportBuildService", "params": { "build": ["passport", "configuration"] } };
    }
};
ConfigurePassportBuildService = tslib.__decorate([
    ioc.Injectable()
], ConfigurePassportBuildService);
exports.ConfigurePassportBuildService = ConfigurePassportBuildService;


});

unwrapExports(PassportBuildService_1);
var PassportBuildService_2 = PassportBuildService_1.PassportBuildService;
var PassportBuildService_3 = PassportBuildService_1.ConfigurePassportBuildService;

var oauth2 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });





/**
 * oauth2 error.
 *
 * @export
 * @class OAuth2Error
 * @extends {AuthenticationError}
 */
class OAuth2Error extends errors.AuthenticationError {
    // tslint:disable-next-line:variable-name
    constructor(status, message, error_description) {
        super(status, message, error_description);
    }
    static d0Ann() {
        return { "name": "OAuth2Error" };
    }
}
exports.OAuth2Error = OAuth2Error;
/**
 * oauth2
 *
 * @export
 * @class OAuth2
 */
class OAuth2 {
    constructor(clientId, clientSecret, baseSite, authorizeUrl = '/oauth/authorize', accessTokenUrl = '/oauth/access_token', customHeader = {}) {
        this.clientId = clientId;
        this.clientSecret = clientSecret;
        this.baseSite = baseSite;
        this.authorizeUrl = authorizeUrl;
        this.accessTokenUrl = accessTokenUrl;
        this.customHeader = customHeader;
        this.accessTokenName = 'access_token';
        this.authMethod = 'Bearer';
        this.useAuthorizationHeaderForGET = false;
        this.agent = undefined;
    }
    // Allows you to set an agent to use instead of the default HTTP or
    // HTTPS agents. Useful when dealing with your own certificates.
    set Agent(agent) {
        this.agent = agent;
    }
    get Agent() {
        return this.agent;
    }
    // This 'hack' method is required for sites that don't use
    // 'access_token' as the name of the access token (for requests).
    // ( http://tools.ietf.org/html/draft-ietf-oauth-v2-16#section-7 )
    // it isn't clear what the correct value should be atm, so allowing
    // for specific (temporary?) override for now.
    set AccessTokenName(name) {
        this.accessTokenName = name;
    }
    get AccessTokenName() {
        return this.accessTokenName;
    }
    // Sets the authorization method for Authorization header.
    // e.g. Authorization: Bearer <token>  # "Bearer" is the authorization method.
    set AuthMethod(authMethod) {
        this.authMethod = authMethod;
    }
    get AuthMethod() {
        return this.authMethod;
    }
    // If you use the OAuth2 exposed 'get' method (and don't construct your own _request call )
    // this will specify whether to use an 'Authorize' header instead of passing the access_token as a query parameter
    set UseAuthorizationHeaderForGET(useIt) {
        this.useAuthorizationHeaderForGET = useIt;
    }
    get UseAuthorizationHeaderForGET() {
        return this.useAuthorizationHeaderForGET;
    }
    get ClientId() {
        return this.clientId;
    }
    get AuthorizeUrl() {
        return this.authorizeUrl;
    }
    get AccessTokenUrl() {
        return `${this.baseSite}${this.accessTokenUrl}`; /* + "?" + querystring.stringify(params); */
    }
    // Build the authorization header. In particular, build the part after the colon.
    // e.g. Authorization: Bearer <token>  # Build "Bearer <token>"
    buildAuthHeader(token) {
        return `${this.authMethod} ${token}`;
    }
    getAuthorizeUrl(params = {}) {
        params.client_id = this.clientId;
        return `${this.baseSite}${this.authorizeUrl}?${querystring.stringify(params)}`;
    }
    async getOAuthAccessToken(code, params = {}) {
        params.client_id = this.clientId;
        params.client_secret = this.clientSecret;
        const codeParam = (params.grant_type === 'refresh_token') ? 'refresh_token' : 'code';
        params[codeParam] = code;
        const postData = querystring.stringify(params);
        const postHeaders = {
            'Content-Type': 'application/x-www-form-urlencoded',
        };
        const { result } = await this.request('POST', this.AccessTokenUrl, postHeaders, postData, null);
        let data;
        try {
            // As of http://tools.ietf.org/html/draft-ietf-oauth-v2-07
            // responses should be in JSON
            data = JSON.parse(result);
        }
        catch (error) {
            // .... However both Facebook + Github currently use rev05 of the spec
            // and neither seem to specify a content-type correctly in their response headers :(
            // clients of these services will suffer a *minor* performance cost of the exception
            // being thrown
            data = querystring.parse(result);
        }
        const accessToken = data[this.AccessTokenName];
        if (!accessToken) {
            throw new OAuth2Error(400, JSON.stringify(params));
        }
        const refreshToken = data.refresh_token;
        delete data.refresh_token;
        return {
            accessToken,
            refreshToken,
            result: data,
        };
    }
    async get(url, accessToken) {
        let headers = {};
        if (this.useAuthorizationHeaderForGET) {
            headers = { Authorization: this.buildAuthHeader(accessToken) };
            accessToken = null;
        }
        return await this.request('GET', url, headers, '', accessToken);
    }
    request(method, url$1, headers = {}, postBody, accessToken) {
        const parsedUrl = url.parse(url$1, true);
        if (parsedUrl.protocol === 'https:' && !parsedUrl.port) {
            parsedUrl.port = '443';
        }
        const realHeaders = Object.assign({}, this.customHeader, headers);
        realHeaders.Host = parsedUrl.host;
        if (!realHeaders['User-Agent']) {
            realHeaders['User-Agent'] = 'Node-oauth';
        }
        realHeaders['Content-Length'] = 0;
        if (postBody) {
            realHeaders['Content-Length'] = Buffer.isBuffer(postBody) ? postBody.length :
                Buffer.byteLength(postBody);
        }
        if (accessToken && !('Authorization' in realHeaders)) {
            // It seems that the default value of .query return by URL.parse is {}.
            // if (!parsedUrl.query) {
            //     parsedUrl.query = {};
            // }
            parsedUrl.query[this.accessTokenName] = accessToken;
        }
        let queryStr = querystring.stringify(parsedUrl.query);
        if (queryStr) {
            queryStr = '?' + queryStr;
        }
        const options = {
            protocol: parsedUrl.protocol,
            host: parsedUrl.hostname,
            port: parsedUrl.port,
            path: parsedUrl.pathname + queryStr,
            method,
            headers: realHeaders,
        };
        return new Promise((resolve, reject) => {
            this.executeRequest(options, postBody, (err, result, response) => err ? reject(err) : resolve({ result, response }));
        });
    }
    executeRequest(options, postBody, callback) {
        let callbackCalled = false;
        let result = '';
        // set the agent on the request options
        if (this.agent) {
            options.agent = this.agent;
        }
        const request = options.protocol !== 'https:' ? http.request(options) : https.request(options);
        request.on('response', (response) => {
            response.on('data', (chunk) => {
                result += chunk;
            });
            response.addListener('end', () => {
                if (!callbackCalled) {
                    callbackCalled = true;
                    if (!(response.statusCode >= 200 && response.statusCode <= 299) &&
                        (response.statusCode !== 301) && (response.statusCode !== 302)) {
                        callback(new OAuth2Error(response.statusCode, result));
                    }
                    else {
                        callback(null, result, response);
                    }
                }
            });
        });
        request.on('error', (e) => {
            callbackCalled = true;
            callback(e);
        });
        if ((options.method === 'POST' || options.method === 'PUT') && postBody) {
            request.write(postBody);
        }
        request.end();
    }
    static d0Ann() {
        return { "name": "OAuth2" };
    }
}
exports.OAuth2 = OAuth2;


});

unwrapExports(oauth2);
var oauth2_1 = oauth2.OAuth2Error;
var oauth2_2 = oauth2.OAuth2;

var utils = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

var OIDCUtils;
(function (OIDCUtils) {
    /**
     * Reconstructs the original URL of the request.
     *
     * This function builds a URL that corresponds the original URL requested by the
     * client, including the protocol (http or https) and host.
     *
     * If the request passed through any proxies that terminate SSL, the
     * `X-Forwarded-Proto` header is used to detect if the request was encrypted to
     * the proxy.
     *
     * @return {String}
     * @api private
     */
    function originalURL(ctx, options) {
        options = options || {};
        var app = ctx.app;
        if (app && ctx.get && ctx.get('trust proxy')) {
            options.proxy = true;
        }
        var trustProxy = options.proxy;
        var proto = (ctx.headers['x-forwarded-proto'] || '').toLowerCase(), tls = ctx.connection.encrypted || (trustProxy && 'https' === proto.split(/\s*,\s*/)[0]), host = (trustProxy && ctx.headers['x-forwarded-host']) || ctx.headers.host, protocol = tls ? 'https' : 'http', path = ctx.url || '';
        return protocol + '://' + host + path;
    }
    OIDCUtils.originalURL = originalURL;
    /**
     * Merge object b with object a.
     *
     *     var a = { foo: 'bar' }
     *       , b = { bar: 'baz' };
     *
     *     utils.merge(a, b);
     *     // => { foo: 'bar', bar: 'baz' }
     *
     * @param {Object} a
     * @param {Object} b
     * @return {Object}
     * @api private
     */
    function merge(a, b) {
        if (a && b) {
            for (var key in b) {
                a[key] = b[key];
            }
        }
        return a;
    }
    OIDCUtils.merge = merge;
    /**
     * Return a unique identifier with the given `len`.
     *
     *     utils.uid(10);
     *     // => "FDaS435D2z"
     *
     * CREDIT: Connect -- utils.uid
     *         https://github.com/senchalabs/connect/blob/2.7.2/lib/utils.js
     *
     * @param {Number} len
     * @return {String}
     * @api private
     */
    function uid(len) {
        return crypto.randomBytes(Math.ceil(len * 3 / 4))
            .toString('base64')
            .slice(0, len);
    }
    OIDCUtils.uid = uid;
})(OIDCUtils = exports.OIDCUtils || (exports.OIDCUtils = {}));


});

unwrapExports(utils);
var utils_1 = utils.OIDCUtils;

var StateStore_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
class StateStore {
    constructor() {
    }
    static d0Ann() {
        return { "name": "StateStore" };
    }
}
exports.StateStore = StateStore;


});

unwrapExports(StateStore_1);
var StateStore_2 = StateStore_1.StateStore;

var SessionStore_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


/**
 * Creates an instance of `SessionStore`.
 *
 * This is the state store implementation for the OAuth2Strategy used when
 * the `state` option is enabled.  It generates a random state and stores it in
 * `req.session` and verifies it when the service provider redirects the user
 * back to the application.
 *
 * This state store requires session support.  If no session exists, an error
 * will be thrown.
 *
 */
class SessionStore extends StateStore_1.StateStore {
    constructor(key) {
        super();
        this.key = key;
    }
    /**
     * Store request state.
     *
     * This implementation simply generates a random string and stores the value in
     * the session, where it will be used for verification when the user is
     * redirected back to the application.
     *
     */
    async store(ctx, meta) {
        if (!ctx.session) {
            throw new Error(`OAuth 2.0 authentication requires session support
             when using state. Did you forget to use session middleware?`);
        }
        const key = this.key;
        const state = utils.OIDCUtils.uid(24);
        if (!ctx.session[key]) {
            ctx.session[key] = {};
        }
        ctx.session[key].state = state;
        return state;
    }
    /**
     * Verify request state.
     *
     * This implementation simply compares the state parameter in the request to the
     * value generated earlier and stored in the session.
     *
     */
    async verify(ctx, providedState) {
        if (!ctx.session) {
            throw new Error(`OAuth 2.0 authentication requires session support
            when using state. Did you forget to use koa-session middleware?`);
        }
        const key = this.key;
        if (!ctx.session[key]) {
            return {
                result: false,
                message: 'Unable to verify authorization request state.',
            };
        }
        const state = ctx.session[key].state;
        if (!state) {
            return {
                result: false,
                message: 'Unable to verify authorization request state.',
            };
        }
        delete ctx.session[key].state;
        if (Object.keys(ctx.session[key]).length === 0) {
            delete ctx.session[key];
        }
        if (state !== providedState) {
            return {
                result: false,
                message: 'Invalid authorization request state.',
            };
        }
        return { result: true, state: state, message: '' };
    }
    static d0Ann() {
        return { "name": "SessionStore" };
    }
}
exports.SessionStore = SessionStore;


});

unwrapExports(SessionStore_1);
var SessionStore_2 = SessionStore_1.SessionStore;

var stores = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(utils, exports);
tslib.__exportStar(StateStore_1, exports);
tslib.__exportStar(SessionStore_1, exports);


});

unwrapExports(stores);

var OAuth2Strategy_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });








/**
* Creates an instance of `OAuth2Strategy`.
*
* The OAuth 2.0 authentication strategy authenticates requests using the OAuth
* 2.0 framework.
*
* OAuth 2.0 provides a facility for delegated authentication, whereby users can
* authenticate using a third-party service such as Facebook.  Delegating in
* this manner involves a sequence of events, including redirecting the user to
* the third-party service for authorization.  Once authorization has been
* granted, the user is redirected back to the application and an authorization
* code can be used to obtain credentials.
*
* Applications must supply a `verify` callback, for which the function
* signature is:
*
*     function(accessToken, refreshToken, profile, done) { ... }
*
* The verify callback is responsible for finding or creating the user, and
* invoking `done` with the following arguments:
*
*     done(err, user, info);
*
* `user` should be set to `false` to indicate an authentication failure.
* Additional `info` can optionally be passed as a third argument, typically
* used to display informational messages.  If an exception occured, `err`
* should be set.
*
* Params:
*
*   - `authorizationURL`  URL used to obtain an authorization grant
*   - `tokenURL`          URL used to obtain an access token
*   - `clientId`          identifies client to service provider
*   - `clientSecret`      secret used to establish ownership of the client identifer
*   - `callbackURL`       URL to which the service provider will redirect the user after obtaining authorization
*   - `passReqToCallback` when `true`, `req` is the first argument to the verify callback (default: `false`)
*
* Examples:
*
*     passport.use(new OAuth2Strategy({
*         authorizationURL: 'https://www.example.com/oauth2/authorize',
*         tokenURL: 'https://www.example.com/oauth2/token',
*         clientId: '123-456-789',
*         clientSecret: 'shhh-its-a-secret'
*         callbackURL: 'https://www.example.net/auth/example/callback'
*       },
*       function(accessToken, refreshToken, profile, done) {
*         User.findOrCreate(..., function (err, user) {
*           done(err, user);
*         });
*       }
*     ));
*
*/
let OAuth2Strategy = class OAuth2Strategy extends Strategy_1.Strategy {
    async onAfterInit() {
        if (!this.name) {
            this.name = 'oauth2';
        }
        // NOTE: The _oauth2 property is considered "protected".  Subclasses are
        //       allowed to use it when making protected resource requests to retrieve
        //       the user profile.
        this.oauth2 = new oauth2.OAuth2(this.clientId, this.clientSecret, '', this.authorizationURL, this.tokenURL, this.customHeaders);
        if (!this.sessionKey) {
            this.sessionKey = ('oauth2:' + url.parse(this.authorizationURL).hostname);
        }
        if (!this.stateStore) { // if stateStore is `true`, use default session stateStore
            this.stateStore = new stores.SessionStore(this.sessionKey);
        }
        if (!this.userProfile) {
            this.userProfile = (accessToken) => new Object();
        }
        if (!this.tokenParams) {
            this.tokenParams = (options) => new Object();
        }
        if (!this.authorizationParams) {
            this.authorizationParams = (options) => new Object();
        }
    }
    async authenticate(ctx, options = {}) {
        if (ctx.query && ctx.query.error) {
            if (ctx.query.error === 'access_denied') {
                return new results.FailResult(ctx.query.error_description, 401);
            }
            throw new errors.AuthenticationError(ctx.query.error_description, ctx.query.error_uri, ctx.query.error);
        }
        let callbackURL = options.callbackURL || this.callbackURL;
        if (callbackURL) {
            const parsed = url.parse(callbackURL);
            if (!parsed.protocol) {
                // The callback URL is relative, resolve a fully qualified URL from the
                // URL of the originating request.
                callbackURL = url.resolve(ctx.request.origin, callbackURL);
            }
        }
        const meta = {
            authorizationURL: this.authorizationURL,
            tokenURL: this.tokenURL,
            clientId: this.clientId,
        };
        if (ctx.query && ctx.query.code) {
            const state = ctx.query.state;
            const { result: verifiedResult, message: verifiedMsg } = await this.stateStore.verify(ctx, state);
            if (!verifiedResult) {
                return new results.FailResult(verifiedMsg, 403);
            }
            const code = ctx.query.code;
            const params = this.tokenParams(options);
            params.grant_type = 'authorization_code';
            if (callbackURL) {
                params.redirect_uri = callbackURL;
            }
            let accessToken;
            let refreshToken;
            let accessTokenResult;
            try {
                ({
                    accessToken,
                    refreshToken,
                    result: accessTokenResult,
                } = await this.oauth2.getOAuthAccessToken(code, params));
            }
            catch (err) {
                throw this.parseOAuthError(err);
            }
            const profile = await this.loadUserProfile(accessToken);
            const { user, info } = await this.verify(accessToken, refreshToken, accessTokenResult, profile);
            if (!user) {
                // TODO, not sure 401 is the correct meaning
                return new results.FailResult(info, 401);
            }
            return new results.SuccessResult(options, user, info);
        }
        else {
            const params = this.authorizationParams(options);
            params.response_type = 'code';
            if (callbackURL) {
                params.redirect_uri = callbackURL;
            }
            let scope = options.scope || this.scope;
            if (scope) {
                if (Array.isArray(scope)) {
                    scope = scope.join(this.scopeSeparator);
                }
                params.scope = scope;
            }
            let state = options.state;
            if (state) {
                params.state = state;
            }
            else {
                state = await this.stateStore.store(ctx, meta);
                if (state) {
                    params.state = state;
                }
            }
            const parsed = url.parse(this.oauth2.AuthorizeUrl, true);
            parsed.query = Object.assign({}, parsed.query, params);
            parsed.query.client_id = this.oauth2.ClientId;
            delete parsed.search;
            const location = url.format(parsed);
            return new results.RedirectResult(location);
        }
    }
    /**
     * Parse error response from OAuth 2.0 endpoint.
     *
     * OAuth 2.0-based authentication strategies can overrride this function in
     * order to parse error responses received from the token endpoint, allowing the
     * most informative message to be displayed.
     *
     * If this function is not overridden, the body will be parsed in accordance
     * with RFC 6749, section 5.2.
     *
     */
    parseOAuthError(err) {
        let e;
        if (err instanceof oauth2.OAuth2Error) {
            try {
                const json = JSON.parse(err.message);
                if (json.error) {
                    e = new errors.InternalOAuthError(`Failed to obtain access token:${json.error_description}`, json.error);
                }
            }
            catch (_) {
                // console.warn('============This error can be ignored==============');
                // console.warn(_);
                // console.warn('===================================================');
            }
        }
        if (!e) {
            err.message = `Failed to obtain access token:${err.message}`;
            e = err;
        }
        return e;
    }
    /**
     * Load user profile, contingent upon options.
     *
     */
    async loadUserProfile(accessToken) {
        if (this.skipUserProfile) {
            return Promise.resolve(null);
        }
        return await this.userProfile(accessToken);
    }
    static d0Ann() {
        return { "name": "OAuth2Strategy", "params": { "onAfterInit": [], "authenticate": ["ctx", "options"], "parseOAuthError": ["err"], "loadUserProfile": ["accessToken"] } };
    }
};
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", stores.StateStore)
], OAuth2Strategy.prototype, "stateStore", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "clientId", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "authorizationURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "tokenURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], OAuth2Strategy.prototype, "verify", void 0);
tslib.__decorate([
    components.Input({ defaultValue: false }),
    tslib.__metadata("design:type", Boolean)
], OAuth2Strategy.prototype, "skipUserProfile", void 0);
tslib.__decorate([
    components.Input({ defaultValue: ' ' }),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "scopeSeparator", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "callbackURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], OAuth2Strategy.prototype, "scope", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "sessionKey", void 0);
tslib.__decorate([
    components.Input({ defaultValue: '' }),
    tslib.__metadata("design:type", String)
], OAuth2Strategy.prototype, "clientSecret", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], OAuth2Strategy.prototype, "customHeaders", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], OAuth2Strategy.prototype, "userProfile", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], OAuth2Strategy.prototype, "tokenParams", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], OAuth2Strategy.prototype, "authorizationParams", void 0);
OAuth2Strategy = tslib.__decorate([
    components.Component({
        selector: 'oauth2'
    })
], OAuth2Strategy);
exports.OAuth2Strategy = OAuth2Strategy;


});

unwrapExports(OAuth2Strategy_1);
var OAuth2Strategy_2 = OAuth2Strategy_1.OAuth2Strategy;

var OIDCStrategy_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });










const webfinger$1 = webfinger.webfinger;

/**
 * OIDC authenticate strategy
 *
 * @export
 * @class OIDCStrategy
 * @extends {Strategy}
 * @implements {AfterInit}
 */
let OIDCStrategy = class OIDCStrategy extends Strategy_1.Strategy {
    async onAfterInit() {
        if (!this.name) {
            this.name = 'openidconnect';
        }
        if (!this.identifierField) {
            this.identifierField = 'openid_identifier';
        }
        if (!this.sessionKey) {
            this.sessionKey = ('oauth2:' + url.parse(this.authorizationURL).hostname);
        }
        if (this.stateStore) {
            this.stateStore = new stores.SessionStore(this.sessionKey);
        }
        if (!(this.authorizationURL && this.tokenURL) && this.options.getClient) {
            throw new Error('OpenID Connect authentication requires getClientCallback option');
        }
    }
    async authenticate(ctx, options) {
        options = options || {};
        if (ctx.query && ctx.query.error) {
            if (ctx.query.error === 'access_denied') {
                return new results.FailResult(ctx.query.error_description, 403);
            }
            else {
                throw new errors.OIDCError(ctx.query.error_description, ctx.query.error, ctx.query.error_uri);
            }
        }
        if (ctx.query && ctx.query.code) {
            let state = ctx.query.state;
            const { result: verifiedResult, state: meta, message: verifiedMsg } = await this.stateStore.verify(ctx, state);
            if (!verifiedResult) {
                return new results.FailResult(verifiedMsg, 403);
            }
            const code = ctx.query.code;
            let callbackURL = meta.callbackURL;
            let oauth2$1 = new oauth2.OAuth2(meta.clientID, meta.clientSecret, '', meta.authorizationURL, meta.tokenURL, meta.customHeaders);
            let accessToken;
            let refreshToken;
            let accessTokenResult;
            try {
                ({
                    accessToken,
                    refreshToken,
                    result: accessTokenResult,
                } = await oauth2$1.getOAuthAccessToken(code, { grant_type: 'authorization_code', redirect_uri: callbackURL }));
            }
            catch (err) {
                throw this.parseOAuthError(err);
            }
            var idToken = accessTokenResult['id_token'];
            if (!idToken) {
                throw new Error('ID Token not present in token response');
            }
            let idTokenSegments = idToken.split('.'), jwtClaimsStr, jwtClaims;
            try {
                jwtClaimsStr = new Buffer(idTokenSegments[1], 'base64').toString();
                jwtClaims = JSON.parse(jwtClaimsStr);
            }
            catch (ex) {
                throw ex;
            }
            var missing = ['iss', 'sub', 'aud', 'exp', 'iat'].filter(param => !jwtClaims[param]);
            if (missing.length) {
                throw new Error('id token is missing required parameter(s) - ' + missing.join(', '));
            }
            // https://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation - check 1.
            if (jwtClaims.iss !== meta.issuer) {
                throw new Error('id token not issued by correct OpenID provider - ' +
                    'expected: ' + meta.issuer + ' | from: ' + jwtClaims.iss);
            }
            // https://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation - checks 2 and 3.
            if (typeof jwtClaims.aud === 'string') {
                if (jwtClaims.aud !== meta.clientID) {
                    throw new Error('aud parameter does not include this client - is: '
                        + jwtClaims.aud + '| expected: ' + meta.clientID);
                }
            }
            else if (ioc.isArray(jwtClaims.aud)) {
                if (jwtClaims.aud.indexOf(meta.clientID) === -1) {
                    throw new Error('aud parameter does not include this client - is: ' +
                        jwtClaims.aud + ' | expected to include: ' + meta.clientID);
                }
                if (jwtClaims.length > 1 && !jwtClaims.azp) {
                    throw new Error('azp parameter required with multiple audiences');
                }
            }
            else {
                throw new Error('Invalid aud parameter type');
            }
            // https://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation - check 4.
            if (jwtClaims.azp && jwtClaims.azp !== meta.clientID) {
                throw new Error('this client is not the authorized party - ' +
                    'expected: ' + meta.clientID + ' | is: ' + jwtClaims.azp);
            }
            // Possible TODO: Add accounting for some clock skew.
            // https://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation - check 5.
            if (jwtClaims.exp < (Date.now() / 1000)) {
                throw new Error('id token has expired');
            }
            // Note: https://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation - checks 6 and 7 are out of scope of this library.
            // https://openid.net/specs/openid-connect-basic-1_0.html#IDTokenValidation - check 8.
            if (meta.params.max_age && (!jwtClaims.auth_time || ((meta.timestamp - meta.params.max_age) > jwtClaims.auth_time))) {
                throw new Error('auth_time in id_token not included or too old');
            }
            if (meta.params.nonce && (!jwtClaims.nonce || jwtClaims.nonce !== meta.params.nonce)) {
                throw new Error('Invalid nonce in id_token');
            }
            var iss = jwtClaims.iss;
            var sub = jwtClaims.sub;
            // Prior to OpenID Connect Basic Client Profile 1.0 - draft 22, the
            // "sub" claim was named "user_id".  Many providers still issue the
            // claim under the old field, so fallback to that.
            if (!sub) {
                sub = jwtClaims.user_id;
            }
            let load = await this.shouldLoadUserProfile(iss, sub);
            let profile = undefined;
            if (load) {
                var parsed = url.parse(meta.userInfoURL, true);
                parsed.query['schema'] = 'openid';
                delete parsed.search;
                var userInfoURL = url.format(parsed);
                // NOTE: We are calling node-oauth's internal `_request` function (as
                //       opposed to `get`) in order to send the access token in the
                //       `Authorization` header rather than as a query parameter.
                //
                //       Additionally, the master branch of node-oauth (as of
                //       2013-02-16) will include the access token in *both* headers
                //       and query parameters, which is a violation of the spec.
                //       Setting the fifth argument of `_request` to `null` works
                //       around this issue.  I've noted this in comments here:
                //       https://github.com/ciaranj/node-oauth/issues/117
                const { result: body, response: res } = await oauth2$1.request('GET', userInfoURL, { 'Authorization': 'Bearer ' + accessToken, 'Accept': 'application/json' }, null, null);
                profile = {};
                try {
                    var json = JSON.parse(body);
                    profile.id = json.sub;
                    // Prior to OpenID Connect Basic Client Profile 1.0 - draft 22, the
                    // "sub" key was named "user_id".  Many providers still use the old
                    // key, so fallback to that.
                    if (!profile.id) {
                        profile.id = json.user_id;
                    }
                    profile.displayName = json.name;
                    profile.name = {
                        familyName: json.family_name,
                        givenName: json.given_name,
                        middleName: json.middle_name
                    };
                    profile._raw = body;
                    profile._json = json;
                }
                catch (ex) {
                    throw ex;
                }
            }
            const { user, info } = await this.verify(ctx, this.passReqToCallback ? iss : undefined, sub, profile, jwtClaims, accessToken, refreshToken, accessTokenResult);
            if (!user) {
                // TODO, not sure 401 is the correct meaning
                return new results.FailResult(info, 401);
            }
            return new results.SuccessResult(options, user, info);
        }
        else {
            // The request being authenticated is initiating OpenID Connect
            // authentication.  Prior to redirecting to the provider, configuration will
            // be loaded.  The configuration is typically either pre-configured or
            // discovered dynamically.  When using dynamic discovery, a user supplies
            // their identifer as input.
            let identifier;
            let idfield = this.identifierField;
            if (ctx.request.body && ctx.request.body[idfield]) {
                identifier = ctx.request.body[idfield];
            }
            else if (ctx.query && ctx.query[idfield]) {
                identifier = ctx.query[idfield];
            }
            let meta = await this.getConfigure(identifier);
            let callbackURL = options.callbackURL || this.callbackURL;
            if (callbackURL) {
                const parsed = url.parse(callbackURL);
                if (!parsed.protocol) {
                    // The callback URL is relative, resolve a fully qualified URL from the
                    // URL of the originating request.
                    callbackURL = url.resolve(ctx.request.origin, callbackURL);
                }
            }
            meta.callbackURL = callbackURL;
            let params = await this.authorizationParams(options);
            params['response_type'] = 'code';
            params['client_id'] = meta.clientID;
            if (callbackURL) {
                params.redirect_uri = callbackURL;
            }
            let scope = options.scope || this.scope;
            if (ioc.isArray(scope)) {
                scope = scope.join(' ');
            }
            if (scope) {
                params.scope = 'openid ' + scope;
            }
            else {
                params.scope = 'openid';
            }
            // Optional Parameters
            ['max_age', 'ui_locals', 'id_token_hint', 'login_hint', 'acr_values']
                .filter(x => { return x in meta; })
                .forEach(y => { params[y] = meta[y]; });
            if (meta.display && ['page', 'popup', 'touch', 'wap'].indexOf(meta.display) !== -1) {
                params.display = meta.display;
            }
            if (meta.prompt && ['none', 'login', 'consent', 'select_account'].indexOf(meta.prompt) !== -1) {
                params.prompt = meta.prompt;
            }
            if (meta.nonce && typeof meta.nonce === 'boolean') {
                params.nonce = stores.OIDCUtils.uid(20);
            }
            if (meta.nonce && typeof meta.nonce === 'number') {
                params.nonce = stores.OIDCUtils.uid(meta.nonce);
            }
            if (meta.nonce && typeof meta.nonce === 'string') {
                params.nonce = meta.nonce;
            }
            if (params.max_age) {
                meta.timestamp = Math.floor(Date.now() / 1000);
            }
            meta.params = params;
            for (let param in params) {
                if (meta[param]) {
                    delete meta[param]; // Remove redundant information.
                }
            }
            // State Storage/Management
            try {
                let state = await this.stateStore.store(ctx, meta);
                params.state = state;
                var location = meta.authorizationURL + '?' + querystring.stringify(params);
                return new results.RedirectResult(location);
            }
            catch (ex) {
                throw ex;
            }
        }
    }
    async shouldLoadUserProfile(issuer, subject) {
        if (this.skipUserProfile) {
            return ioc.isFunction(this.skipUserProfile) ? await this.skipUserProfile(issuer, subject) : false;
        }
        return true;
    }
    parseOAuthError(err) {
        let e;
        if (err instanceof oauth2.OAuth2Error) {
            try {
                const json = JSON.parse(err.message);
                if (json.error) {
                    e = new errors.InternalOAuthError(`Failed to obtain access token:${json.error_description}`, json.error);
                }
            }
            catch (_) {
                // console.warn('============This error can be ignored==============');
                // console.warn(_);
                // console.warn('===================================================');
            }
        }
        if (!e) {
            err.message = `Failed to obtain access token:${err.message}`;
            e = err;
        }
        return e;
    }
    async getConfigure(identifier) {
        if (this.authorizationURL && this.tokenURL) {
            return await this.manualConfigure(identifier);
        }
        else {
            return await this.dynamicConfigure(identifier);
        }
    }
    async dynamicConfigure(identifier) {
        let issuer = await this.injector.getInstance(Resolver).resolve(identifier);
        let url = issuer + '/.well-known/openid-configuration';
        let defer = ioc.PromiseUtil.defer();
        request.get(url, async (err, res, body) => {
            if (err) {
                return defer.reject(err);
            }
            if (res.statusCode !== 200) {
                return defer.reject(new Error('Unexpected status code from OpenID provider configuration: ' + res.statusCode));
            }
            var config = {};
            try {
                var json = JSON.parse(body);
                config.issuer = json.issuer;
                config.authorizationURL = json.authorization_endpoint;
                config.tokenURL = json.token_endpoint;
                config.userInfoURL = json.userinfo_endpoint;
                config.registrationURL = json.registration_endpoint;
                config._raw = json;
            }
            catch (ex) {
                return defer.reject(new Error('Failed to parse OpenID provider configuration'));
            }
            // TODO: Pass registrationURL here.
            let client = await this.options.getClient(config.issuer);
            config.clientID = client.id;
            config.clientSecret = client.secret;
            if (client.redirectURIs) {
                config.callbackURL = client.redirectURIs[0];
            }
            return defer.resolve(config);
        });
        return defer.promise;
    }
    async manualConfigure(identifier) {
        let missing = ['issuer', 'authorizationURL', 'tokenURL', 'clientID', 'clientSecret'].filter(opt => !this.options[opt]);
        if (missing.length) {
            throw new Error('Manual OpenID configuration is missing required parameter(s) - ' + missing.join(', '));
        }
        let params = {
            issuer: this.issuer,
            authorizationURL: this.authorizationURL,
            tokenURL: this.tokenURL,
            userInfoURL: this.userInfoURL,
            clientID: this.clientID,
            clientSecret: this.clientSecret,
            callbackURL: this.callbackURL
        };
        Object.keys(this.options).map(opt => {
            if (['nonce', 'display', 'prompt', 'max_age', 'ui_locals', 'id_token_hint', 'login_hint', 'acr_values'].indexOf(opt) !== -1) {
                params[opt] = this.options[opt];
            }
        });
        return params;
    }
    static d0Ann() {
        return { "name": "OIDCStrategy", "params": { "onAfterInit": [], "authenticate": ["ctx", "options"], "shouldLoadUserProfile": ["issuer", "subject"], "parseOAuthError": ["err"], "getConfigure": ["identifier"], "dynamicConfigure": ["identifier"], "manualConfigure": ["identifier"] } };
    }
};
tslib.__decorate([
    components.Input('store'),
    tslib.__metadata("design:type", stores.StateStore)
], OIDCStrategy.prototype, "stateStore", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], OIDCStrategy.prototype, "scope", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "identifierField", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "issuer", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "sessionKey", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "tokenURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "authorizationURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "clientID", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "clientSecret", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "callbackURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "userInfoURL", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], OIDCStrategy.prototype, "customHeaders", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], OIDCStrategy.prototype, "verify", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", String)
], OIDCStrategy.prototype, "passReqToCallback", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Object)
], OIDCStrategy.prototype, "skipUserProfile", void 0);
tslib.__decorate([
    components.Input(),
    tslib.__metadata("design:type", Function)
], OIDCStrategy.prototype, "authorizationParams", void 0);
tslib.__decorate([
    ioc.Inject(components.TemplateOptionToken),
    tslib.__metadata("design:type", Object)
], OIDCStrategy.prototype, "options", void 0);
tslib.__decorate([
    ioc.Inject(ioc.INJECTOR),
    tslib.__metadata("design:type", Object)
], OIDCStrategy.prototype, "injector", void 0);
OIDCStrategy = tslib.__decorate([
    components.Component({
        selector: 'oidc'
    })
], OIDCStrategy);
exports.OIDCStrategy = OIDCStrategy;
const REL = 'http://openid.net/specs/connect/1.0/issuer';
let Resolver = class Resolver {
    resolve(identifier) {
        let defer = ioc.PromiseUtil.defer();
        webfinger$1(identifier, REL, { webfingerOnly: true }, (err, jrd) => {
            if (err) {
                return defer.reject(err);
            }
            if (!jrd.links) {
                return defer.reject(new errors.NoOpenIDError('No links in resource descriptor', jrd));
            }
            let issuer;
            for (let i = 0; i < jrd.links.length; i++) {
                let link = jrd.links[i];
                if (link.rel === REL) {
                    issuer = link.href;
                    break;
                }
            }
            if (!issuer) {
                return defer.reject(new errors.NoOpenIDError('No OpenID Connect issuer in resource descriptor', jrd));
            }
            return defer.resolve(issuer);
        });
        return defer.promise;
    }
    static d0Ann() {
        return { "name": "Resolver", "params": { "resolve": ["identifier"] } };
    }
};
Resolver = tslib.__decorate([
    ioc.Singleton()
], Resolver);
exports.Resolver = Resolver;


});

unwrapExports(OIDCStrategy_1);
var OIDCStrategy_2 = OIDCStrategy_1.OIDCStrategy;
var OIDCStrategy_3 = OIDCStrategy_1.Resolver;

var passports = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(IAuthenticator, exports);
tslib.__exportStar(results, exports);
tslib.__exportStar(Strategy_1, exports);
tslib.__exportStar(SessionStrategy_1, exports);
tslib.__exportStar(LocalStrategy_1, exports);
tslib.__exportStar(JwtStrategy_1, exports);
tslib.__exportStar(ContextExtends, exports);
tslib.__exportStar(Authenticator_1, exports);
tslib.__exportStar(PassportBuildService_1, exports);
tslib.__exportStar(oauth2, exports);
tslib.__exportStar(OAuth2Strategy_1, exports);
tslib.__exportStar(OIDCStrategy_1, exports);
tslib.__exportStar(StrategySelectorHandle_1, exports);


});

unwrapExports(passports);

var AuthMiddleware_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });





/**
 * authentication middleware.
 *
 * @export
 * @class AuthMiddleware
 * @extends {CompositeMiddleware}
 */
let AuthMiddleware = class AuthMiddleware extends mvc.CompositeMiddleware {
    constructor() {
        super(...arguments);
        this.hasInit = false;
    }
    getChecker() {
        if (!this.checker) {
            this.checker = this.injector.get(mvc.RouteChecker);
        }
        return this.checker;
    }
    async execute(ctx, next) {
        if (!this.hasInit) {
            await this.setup(ctx.mvcContext);
            this.hasInit = true;
        }
        await super.execute(ctx);
        ctx.passport = this.passport;
        return await next();
    }
    async setup(context) {
        let configuration = context.getConfiguration();
        this.use(this.passport.initialize(configuration.passports.initialize || {}));
        this.use(this.passport.session());
    }
    static d0Ann() {
        return { "name": "AuthMiddleware", "params": { "getChecker": [], "execute": ["ctx", "next"], "setup": ["context"] } };
    }
};
tslib.__decorate([
    ioc.Inject(passports.AuthenticatorToken),
    tslib.__metadata("design:type", Object)
], AuthMiddleware.prototype, "passport", void 0);
AuthMiddleware = tslib.__decorate([
    mvc.Middleware({
        name: 'auth',
        before: mvc.MiddlewareTypes.View
    })
], AuthMiddleware);
exports.AuthMiddleware = AuthMiddleware;
// @Middleware({
//     name: 'authcheck',
//     scope: 'route'
// })
// export class AuthCheckMiddleware extends MvcMiddleware {
//     @Inject(AuthenticatorToken)
//     passport: IAuthenticator;
//     async execute(ctx: IContext, next: () => Promise<void>): Promise<void> {
//         let configuration: IConfiguration = ctx.mvcContext.configuration;
//         if (configuration.passports.default) {
//             let flowOption = configuration.passports.default;
//             await this.passport.authenticate(flowOption.strategy, flowOption.options)(ctx, next);
//         }
//         await next();
//     }
// }


});

unwrapExports(AuthMiddleware_1);
var AuthMiddleware_2 = AuthMiddleware_1.AuthMiddleware;

var AuthFlowService_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




let AuthFlowService = class AuthFlowService extends mvc.AuthorizationService {
    getAuthMiddlewares(ctx, controller, propertyKey) {
        let middlewares = [];
        let mvcCtx = ctx.mvcContext;
        let configuration = mvcCtx.getConfiguration();
        let flowOption = configuration.passports.default;
        if (!flowOption) {
            return middlewares;
        }
        let refl = mvcCtx.reflects;
        if (propertyKey) {
            if (refl.hasMethodMetadata(mvc.Authorization, controller, propertyKey)) {
                middlewares.push(this.passport.authenticate(flowOption.strategy, flowOption.options));
            }
        }
        else if (refl.hasMetadata(mvc.Authorization, controller)) {
            middlewares.push(this.passport.authenticate(flowOption.strategy, flowOption.options));
        }
        return middlewares;
    }
    static d0Ann() {
        return { "name": "AuthFlowService", "params": { "getAuthMiddlewares": ["ctx", "controller", "propertyKey"] } };
    }
};
tslib.__decorate([
    ioc.Inject(passports.AuthenticatorToken),
    tslib.__metadata("design:type", Object)
], AuthFlowService.prototype, "passport", void 0);
AuthFlowService = tslib.__decorate([
    ioc.Singleton()
], AuthFlowService);
exports.AuthFlowService = AuthFlowService;


});

unwrapExports(AuthFlowService_1);
var AuthFlowService_2 = AuthFlowService_1.AuthFlowService;

var middlewares = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(SessionMiddleware_1, exports);
tslib.__exportStar(AuthMiddleware_1, exports);
tslib.__exportStar(AuthFlowService_1, exports);


});

unwrapExports(middlewares);

var aop_umd = createCommonjsModule(function (module, exports) {
(function (global, factory) {
	 module.exports = factory(tslib, ioc) ;
}(commonjsGlobal, (function (tslib, ioc) {
	tslib = tslib && tslib.hasOwnProperty('default') ? tslib['default'] : tslib;
	ioc = ioc && ioc.hasOwnProperty('default') ? ioc['default'] : ioc;

	function unwrapExports (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
	}

	function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	var Advice = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	function createAdviceDecorator(adviceName, actions, afterPointcutActions, metadataExtends) {
	    actions = actions || [];
	    actions.push(function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg) || ioc.isRegExp(arg)) {
	            ctx.metadata.pointcut = arg;
	            ctx.next(next);
	        }
	    });
	    if (afterPointcutActions) {
	        if (ioc.isArray(afterPointcutActions)) {
	            actions.push.apply(actions, afterPointcutActions);
	        }
	        else {
	            actions.push(afterPointcutActions);
	        }
	    }
	    actions.push(function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg) && ctx.args.indexOf(arg) === 1) {
	            ctx.metadata.annotationArgName = arg;
	            ctx.next(next);
	        }
	    }, function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg)) {
	            ctx.metadata.annotationName = arg;
	            ctx.next(next);
	        }
	    });
	    return ioc.createMethodDecorator('Advice', actions, function (metadata) {
	        if (metadataExtends) {
	            metadataExtends(metadata);
	        }
	        metadata.adviceName = adviceName;
	        return metadata;
	    });
	}
	exports.createAdviceDecorator = createAdviceDecorator;
	/**
	 * aop advice decorator.
	 *
	 * @Advice
	 */
	exports.Advice = createAdviceDecorator('Advice');


	});

	unwrapExports(Advice);
	var Advice_1 = Advice.createAdviceDecorator;
	var Advice_2 = Advice.Advice;

	var Aspect = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	/**
	 * Aspect decorator. define aspect service.
	 *
	 * @Aspect
	 */
	exports.Aspect = ioc.createClassDecorator('Aspect', [
	    function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg)) {
	            ctx.metadata.annotation = arg;
	            ctx.next(next);
	        }
	    },
	    function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isArray(arg) || ioc.isClass(arg)) {
	            ctx.metadata.within = arg;
	            ctx.next(next);
	        }
	    }
	], true);


	});

	unwrapExports(Aspect);
	var Aspect_1 = Aspect.Aspect;

	var After = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	/**
	 * aop after advice decorator.
	 *
	 * @After
	 */
	exports.After = Advice.createAdviceDecorator('After');


	});

	unwrapExports(After);
	var After_1 = After.After;

	var AfterReturning = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });


	/**
	 * aop after returning advice decorator.
	 *
	 * @AfterReturning
	 */
	exports.AfterReturning = Advice.createAdviceDecorator('AfterReturning', null, function (ctx, next) {
	    var arg = ctx.currArg;
	    if (ioc.isString(arg)) {
	        ctx.metadata.returning = arg;
	        ctx.next(next);
	    }
	});


	});

	unwrapExports(AfterReturning);
	var AfterReturning_1 = AfterReturning.AfterReturning;

	var AfterThrowing = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });


	/**
	 * aop after throwing advice decorator.
	 *
	 * @AfterThrowing
	 */
	exports.AfterThrowing = Advice.createAdviceDecorator('AfterThrowing', null, function (ctx, next) {
	    var arg = ctx.currArg;
	    if (ioc.isString(arg)) {
	        ctx.metadata.throwing = arg;
	        ctx.next(next);
	    }
	});


	});

	unwrapExports(AfterThrowing);
	var AfterThrowing_1 = AfterThrowing.AfterThrowing;

	var Around = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });


	/**
	 * aop Around advice decorator.
	 *
	 * @Around
	 */
	exports.Around = Advice.createAdviceDecorator('Around', null, [
	    function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg)) {
	            ctx.metadata.args = arg;
	            ctx.next(next);
	        }
	    },
	    function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg)) {
	            ctx.metadata.returning = arg;
	            ctx.next(next);
	        }
	    },
	    function (ctx, next) {
	        var arg = ctx.currArg;
	        if (ioc.isString(arg)) {
	            ctx.metadata.throwing = arg;
	            ctx.next(next);
	        }
	    }
	]);


	});

	unwrapExports(Around);
	var Around_1 = Around.Around;

	var Before = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	/**
	 * aop Before advice decorator.
	 *
	 * @Before
	 */
	exports.Before = Advice.createAdviceDecorator('Before');


	});

	unwrapExports(Before);
	var Before_1 = Before.Before;

	var Pointcut = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	/**
	 * aop Pointcut advice decorator.
	 *
	 * @Pointcut
	 */
	exports.Pointcut = Advice.createAdviceDecorator('Pointcut');


	});

	unwrapExports(Pointcut);
	var Pointcut_1 = Pointcut.Pointcut;

	var NonePointcut = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	/**
	 * NonePointcut decorator, define class not work with aop.
	 *
	 * @NonePointcut
	 */
	exports.NonePointcut = ioc.createClassDecorator('NonePointcut');


	});

	unwrapExports(NonePointcut);
	var NonePointcut_1 = NonePointcut.NonePointcut;

	var JoinpointState_1 = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });
	var JoinpointState;
	(function (JoinpointState) {
	    JoinpointState["Before"] = "Before";
	    JoinpointState["Pointcut"] = "Pointcut";
	    JoinpointState["After"] = "After";
	    JoinpointState["AfterReturning"] = "AfterReturning";
	    JoinpointState["AfterThrowing"] = "AfterThrowing";
	})(JoinpointState = exports.JoinpointState || (exports.JoinpointState = {}));


	});

	unwrapExports(JoinpointState_1);
	var JoinpointState_2 = JoinpointState_1.JoinpointState;

	var Joinpoint_1 = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });


	exports.AOP_METHOD_NAME = ioc.tokenId('AOP_METHOD_NAME');
	exports.AOP_METHOD_FULLNAME = ioc.tokenId('AOP_METHOD_FULLNAME');
	exports.AOP_METHOD_ORIGIN = ioc.tokenId('AOP_METHOD_ORIGIN');
	exports.AOP_METHOD_PARAMS = ioc.tokenId('AOP_METHOD_PARAMS');
	exports.AOP_METHOD_ANNOTATIONS = ioc.tokenId('AOP_METHOD_ANNOTATIONS');
	exports.AOP_METHOD_PROVIDERS = ioc.tokenId('AOP_METHOD_PROVIDERS');
	exports.AOP_PROV_JOINPOINT = ioc.tokenId('AOP_PROV_JOINPOINT');
	exports.AOP_ARGS = ioc.tokenId('AOP_ARGS');
	exports.AOP_TARGET = ioc.tokenId('AOP_TARGET');
	exports.AOP_TARGET_TYPE = ioc.tokenId('AOP_TARGET_TYPE');
	exports.AOP_RETURNING = ioc.tokenId('AOP_RETURNING');
	exports.AOP_THROWING = ioc.tokenId('AOP_THROWING');
	exports.AOP_STATE = ioc.tokenId('AOP_STATE');
	exports.AOP_ADVICES = ioc.tokenId('AOP_ADVICES');
	/**
	 * Join point data.
	 *
	 * @export
	 * @class Joinpoint
	 * @implements {IJoinpoint}
	 */
	var Joinpoint = /** @class */ (function (_super) {
	    tslib.__extends(Joinpoint, _super);
	    function Joinpoint() {
	        return _super !== null && _super.apply(this, arguments) || this;
	    }
	    Object.defineProperty(Joinpoint.prototype, "name", {
	        /**
	         * method name
	         *
	         * @type {string}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_METHOD_NAME);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "provJoinpoint", {
	        /**
	         * prov joinpoint.
	         *
	         * @type {IJoinpoint}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_PROV_JOINPOINT);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Joinpoint.prototype.routeValue = function (token) {
	        var value;
	        var currj = this;
	        var key = this.injector.getTokenKey(token);
	        while (ioc.isNullOrUndefined(value) && currj) {
	            value = currj.getValue(key);
	            currj = currj.provJoinpoint;
	        }
	        return value;
	    };
	    Object.defineProperty(Joinpoint.prototype, "fullName", {
	        /**
	         * full name.
	         *
	         * @type {string}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_METHOD_FULLNAME);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "originMethod", {
	        get: function () {
	            return this.getValue(exports.AOP_METHOD_ORIGIN);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "state", {
	        /**
	         * join point state.
	         *
	         * @type {JoinpointState}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_STATE);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "params", {
	        /**
	         * params of pointcut.
	         *
	         * @type {IParameter[]}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_METHOD_PARAMS);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "args", {
	        /**
	         * args of pointcut.
	         *
	         * @type {any[]}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            var _a;
	            return _a = this.getValue(exports.AOP_ARGS), (_a !== null && _a !== void 0 ? _a : []);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "returning", {
	        /**
	         * pointcut returing
	         *
	         * @type {*}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_RETURNING);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "throwing", {
	        /**
	         * pointcut throwing error.
	         *
	         * @type {*}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_THROWING);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "advices", {
	        /**
	         * advicer of joinpoint
	         *
	         * @type {Advicer}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_ADVICES);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "annotations", {
	        /**
	         * orgin pointcut method metadatas.
	         *
	         * @type {TypeMetadata[]}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.routeValue(exports.AOP_METHOD_ANNOTATIONS);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "target", {
	        /**
	         * pointcut target instance
	         *
	         * @type {*}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_TARGET);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "targetType", {
	        /**
	         * pointcut target type.
	         *
	         * @type {Type}
	         * @memberof Joinpoint
	         */
	        get: function () {
	            return this.getValue(exports.AOP_TARGET_TYPE);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Object.defineProperty(Joinpoint.prototype, "providers", {
	        get: function () {
	            if (!this.hasValue(exports.AOP_METHOD_PROVIDERS)) {
	                this.setValue(exports.AOP_METHOD_PROVIDERS, this.injector.getInstance(ioc.PROVIDERS));
	            }
	            return this.getValue(exports.AOP_METHOD_PROVIDERS);
	        },
	        enumerable: true,
	        configurable: true
	    });
	    Joinpoint.prototype.getProvProviders = function () {
	        var pdrs = [];
	        var currj = this.provJoinpoint;
	        while (currj) {
	            var pdr = currj.hasValue(exports.AOP_METHOD_PROVIDERS) ? currj.providers : null;
	            if (pdr && pdr.size) {
	                pdrs.push(pdr);
	            }
	            currj = currj.provJoinpoint;
	        }
	        return pdrs;
	    };
	    Joinpoint.prototype.setOptions = function (options) {
	        if (!options) {
	            return this;
	        }
	        _super.prototype.setOptions.call(this, options);
	        this.setValue(exports.AOP_TARGET_TYPE, options.targetType);
	        options.target && this.setValue(exports.AOP_TARGET, options.target);
	        options.originMethod && this.setValue(exports.AOP_METHOD_ORIGIN, options.originMethod);
	        this.setValue(exports.AOP_METHOD_NAME, options.name);
	        this.setValue(exports.AOP_METHOD_FULLNAME, options.fullName);
	        this.setValue(exports.AOP_METHOD_PARAMS, options.params);
	        this.setValue(exports.AOP_ARGS, options.args);
	        this.setValue(exports.AOP_ADVICES, options.advices);
	        options.state && this.setValue(exports.AOP_STATE, options.state);
	        options.providers && this.setValue(exports.AOP_METHOD_PROVIDERS, options.providers);
	        options.annotations && this.setValue(exports.AOP_METHOD_ANNOTATIONS, options.annotations);
	        options.provJoinpoint && this.setValue(exports.AOP_PROV_JOINPOINT, options.provJoinpoint);
	    };
	    /**
	     * create resolve context via options.
	     *
	     * @static
	     * @param {IInjector} injector
	     * @param {ResolveActionOption} options
	     * @returns {ResolveActionContext}
	     * @memberof ResolveActionContext
	     */
	    Joinpoint.parse = function (injector, options) {
	        return ioc.createContext(injector, Joinpoint, options);
	    };
	    return Joinpoint;
	}(ioc.IocContext));
	exports.Joinpoint = Joinpoint;


	});

	unwrapExports(Joinpoint_1);
	var Joinpoint_2 = Joinpoint_1.AOP_METHOD_NAME;
	var Joinpoint_3 = Joinpoint_1.AOP_METHOD_FULLNAME;
	var Joinpoint_4 = Joinpoint_1.AOP_METHOD_ORIGIN;
	var Joinpoint_5 = Joinpoint_1.AOP_METHOD_PARAMS;
	var Joinpoint_6 = Joinpoint_1.AOP_METHOD_ANNOTATIONS;
	var Joinpoint_7 = Joinpoint_1.AOP_METHOD_PROVIDERS;
	var Joinpoint_8 = Joinpoint_1.AOP_PROV_JOINPOINT;
	var Joinpoint_9 = Joinpoint_1.AOP_ARGS;
	var Joinpoint_10 = Joinpoint_1.AOP_TARGET;
	var Joinpoint_11 = Joinpoint_1.AOP_TARGET_TYPE;
	var Joinpoint_12 = Joinpoint_1.AOP_RETURNING;
	var Joinpoint_13 = Joinpoint_1.AOP_THROWING;
	var Joinpoint_14 = Joinpoint_1.AOP_STATE;
	var Joinpoint_15 = Joinpoint_1.AOP_ADVICES;
	var Joinpoint_16 = Joinpoint_1.Joinpoint;

	var Advices = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	exports.AdvicesToken = ioc.tokenId('AOP_ADVICES');


	});

	unwrapExports(Advices);
	var Advices_1 = Advices.AdvicesToken;

	var IAdvisor = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	exports.AOP_EXTEND_TARGET_TOKEN = ioc.tokenId('AOP_EXTEND_TARGET_TOKEN');
	/**
	 * Aop IAdvisor interface token.
	 * it is a token id, you can register yourself IAdvisor for this.
	 */
	exports.AdvisorToken = ioc.tokenId('DI_IAdvisor');


	});

	unwrapExports(IAdvisor);
	var IAdvisor_1 = IAdvisor.AOP_EXTEND_TARGET_TOKEN;
	var IAdvisor_2 = IAdvisor.AdvisorToken;

	var regexps = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });
	exports.aExp = /^@/;
	exports.annPreChkExp = /^\^?@\w+/;
	exports.annContentExp = /^@annotation\(.*\)$/;
	exports.executionChkExp = /^execution\(\S+\)$/;
	exports.execContentExp = /^execution\(.*\)$/;
	exports.mthNameExp = /^\w+(\((\s*\w+\s*,)*\s*\w*\))?$/;
	exports.tgMthChkExp = /^([\w\*]+\.)+[\w\*]+(\((\s*\w+\s*,)*\s*\w*\))?$/;
	exports.preParam = /^\(/;
	exports.endParam = /\)$/;
	exports.withInChkExp = /^@within\(\s*\w+/;
	exports.targetChkExp = /^@target\(\s*\w+/;
	exports.replAny = /\*\*/gi;
	exports.replAny1 = /\*/gi;
	exports.replDot = /\./gi;
	exports.replNav = /\//gi;


	});

	unwrapExports(regexps);
	var regexps_1 = regexps.aExp;
	var regexps_2 = regexps.annPreChkExp;
	var regexps_3 = regexps.annContentExp;
	var regexps_4 = regexps.executionChkExp;
	var regexps_5 = regexps.execContentExp;
	var regexps_6 = regexps.mthNameExp;
	var regexps_7 = regexps.tgMthChkExp;
	var regexps_8 = regexps.preParam;
	var regexps_9 = regexps.endParam;
	var regexps_10 = regexps.withInChkExp;
	var regexps_11 = regexps.targetChkExp;
	var regexps_12 = regexps.replAny;
	var regexps_13 = regexps.replAny1;
	var regexps_14 = regexps.replDot;
	var regexps_15 = regexps.replNav;

	var ProceedingScope_1 = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });






	var proxyFlag = '_proxy';
	var ctor = 'constructor';
	exports.AOP_ADVICE_INVOKER = ioc.tokenId('AOP_ADVICE_INVOKER');
	/**
	 * Proxy method.
	 *
	 * @export
	 * @class ProxyMethod
	 * @implements {IProxyMethod}
	 */
	var ProceedingScope = /** @class */ (function (_super) {
	    tslib.__extends(ProceedingScope, _super);
	    function ProceedingScope() {
	        return _super !== null && _super.apply(this, arguments) || this;
	    }
	    ProceedingScope.prototype.execute = function (ctx, next) {
	        var _this = this;
	        ctx.providers.inject({ provide: Joinpoint_1.Joinpoint, useValue: ctx });
	        ctx.setValue(exports.AOP_ADVICE_INVOKER, function (j, a) { return _this.invokeAdvice(j, a, _this.reflects); });
	        _super.prototype.execute.call(this, ctx, next);
	    };
	    Object.defineProperty(ProceedingScope.prototype, "reflects", {
	        get: function () {
	            if (!this._reflects) {
	                this._reflects = this.actInjector.getInstance(ioc.TypeReflectsToken);
	            }
	            return this._reflects;
	        },
	        enumerable: true,
	        configurable: true
	    });
	    ProceedingScope.prototype.beforeConstr = function (targetType, params, args, providers) {
	        var propertykey = ctor;
	        var advices = this.actInjector.getInstance(IAdvisor.AdvisorToken).getAdvices(targetType, propertykey);
	        if (!advices) {
	            return;
	        }
	        var className = ioc.lang.getClassName(targetType);
	        var joinPoint = Joinpoint_1.Joinpoint.parse(this.reflects.getInjector(targetType), {
	            name: ctor,
	            state: JoinpointState_1.JoinpointState.Before,
	            advices: advices,
	            fullName: className + '.' + ctor,
	            args: args,
	            params: params,
	            targetType: targetType,
	            providers: providers
	        });
	        this.execute(joinPoint);
	    };
	    ProceedingScope.prototype.afterConstr = function (target, targetType, params, args, providers) {
	        var propertykey = ctor;
	        var advices = this.actInjector.getInstance(IAdvisor.AdvisorToken).getAdvices(targetType, propertykey);
	        if (!advices) {
	            return;
	        }
	        var className = ioc.lang.getClassName(targetType);
	        var joinPoint = Joinpoint_1.Joinpoint.parse(this.reflects.getInjector(targetType), {
	            name: ctor,
	            state: JoinpointState_1.JoinpointState.After,
	            advices: advices,
	            fullName: className + '.' + ctor,
	            args: args,
	            params: params,
	            target: target,
	            targetType: targetType,
	            providers: providers
	        });
	        this.execute(joinPoint);
	    };
	    /**
	     * proceed the proxy method.
	     *
	     * @param {*} target
	     * @param {Type} targetType
	     * @param {IPointcut} pointcut
	     * @param {Joinpoint} [provJoinpoint]
	     * @memberof ProxyMethod
	     */
	    ProceedingScope.prototype.proceed = function (target, targetType, advices, pointcut, provJoinpoint) {
	        var methodName = pointcut.name;
	        if (advices && pointcut) {
	            if (pointcut.descriptor && (pointcut.descriptor.get || pointcut.descriptor.set)) {
	                if (pointcut.descriptor.get && !pointcut.descriptor.get[proxyFlag]) {
	                    var getMethod = pointcut.descriptor.get.bind(target);
	                    pointcut.descriptor.get = this.proxy(getMethod, advices, target, targetType, pointcut, provJoinpoint);
	                    pointcut.descriptor.get[proxyFlag] = true;
	                }
	                if (pointcut.descriptor.set && !pointcut.descriptor.set[proxyFlag]) {
	                    var setMethod = pointcut.descriptor.set.bind(target);
	                    pointcut.descriptor.set = this.proxy(setMethod, advices, target, targetType, pointcut, provJoinpoint);
	                    pointcut.descriptor.set[proxyFlag] = true;
	                }
	                Reflect.defineProperty(target, methodName, pointcut.descriptor);
	            }
	            else if (ioc.isFunction(target[methodName]) && !target[methodName][proxyFlag]) {
	                var propertyMethod = target[methodName].bind(target);
	                target[methodName] = this.proxy(propertyMethod, advices, target, targetType, pointcut, provJoinpoint);
	                target[methodName][proxyFlag] = true;
	            }
	        }
	    };
	    ProceedingScope.prototype.proxy = function (propertyMethod, advices, target, targetType, pointcut, provJoinpoint) {
	        var fullName = pointcut.fullName;
	        var methodName = pointcut.name;
	        var reflects = this.reflects;
	        var self = this;
	        return function () {
	            var args = [];
	            for (var _i = 0; _i < arguments.length; _i++) {
	                args[_i] = arguments[_i];
	            }
	            var larg = ioc.lang.last(args);
	            var cuurPrd = null;
	            if (larg instanceof ioc.InvokedProviders) {
	                args = args.slice(0, args.length - 1);
	                cuurPrd = larg;
	            }
	            var joinPoint = Joinpoint_1.Joinpoint.parse(reflects.getInjector(targetType), {
	                name: methodName,
	                fullName: fullName,
	                params: reflects.getParameters(targetType, target, methodName),
	                args: args,
	                target: target,
	                targetType: targetType,
	                advices: advices,
	                originMethod: propertyMethod,
	                provJoinpoint: provJoinpoint,
	                annotations: reflects.getMetadatas(targetType, methodName, 'method'),
	                providers: cuurPrd
	            });
	            self.execute(joinPoint);
	            var returning = joinPoint.returning;
	            return returning;
	        };
	    };
	    ProceedingScope.prototype.setup = function () {
	        this.use(CtorAdvicesScope)
	            .use(MethodAdvicesScope);
	    };
	    ProceedingScope.prototype.invokeAdvice = function (joinPoint, advicer, reflects) {
	        var metadata = advicer.advice;
	        var providers = joinPoint.providers;
	        if (ioc.isDefined(joinPoint.args) && metadata.args) {
	            providers.inject({ provide: metadata.args, useValue: joinPoint.args });
	        }
	        if (metadata.annotationArgName) {
	            providers.inject({
	                provide: metadata.annotationArgName,
	                useFactory: function () {
	                    var curj = joinPoint;
	                    var annotations = curj.annotations;
	                    if (ioc.isArray(annotations)) {
	                        if (metadata.annotationName) {
	                            var d_1 = metadata.annotationName;
	                            d_1 = regexps.aExp.test(d_1) ? d_1 : "@" + d_1;
	                            return annotations.filter(function (a) { return a.decorator === d_1; });
	                        }
	                        return annotations;
	                    }
	                    else {
	                        return [];
	                    }
	                }
	            });
	        }
	        if (joinPoint.hasValue(Joinpoint_1.AOP_RETURNING) && metadata.returning) {
	            providers.inject({ provide: metadata.returning, useValue: joinPoint.returning });
	        }
	        if (joinPoint.throwing && metadata.throwing) {
	            providers.inject({ provide: metadata.throwing, useValue: joinPoint.throwing });
	        }
	        return reflects.getInjector(advicer.aspectType).invoke(advicer.aspectType, advicer.advice.propertyKey, providers);
	    };
	    return ProceedingScope;
	}(ioc.IocCompositeAction));
	exports.ProceedingScope = ProceedingScope;
	var CtorAdvicesScope = /** @class */ (function (_super) {
	    tslib.__extends(CtorAdvicesScope, _super);
	    function CtorAdvicesScope() {
	        return _super !== null && _super.apply(this, arguments) || this;
	    }
	    CtorAdvicesScope.prototype.execute = function (ctx, next) {
	        if (ctx.name === ctor) {
	            _super.prototype.execute.call(this, ctx);
	        }
	        else {
	            next();
	        }
	    };
	    CtorAdvicesScope.prototype.setup = function () {
	        this.use(exports.CtorBeforeAdviceAction)
	            .use(exports.CtorAfterAdviceAction);
	    };
	    return CtorAdvicesScope;
	}(ioc.IocCompositeAction));
	exports.CtorAdvicesScope = CtorAdvicesScope;
	exports.CtorBeforeAdviceAction = function (ctx, next) {
	    if (ctx.state === JoinpointState_1.JoinpointState.Before) {
	        var advices = ctx.advices;
	        var invoker_1 = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	        advices.Before.forEach(function (advicer) {
	            invoker_1(ctx, advicer);
	        });
	        advices.Pointcut.forEach(function (advicer) {
	            invoker_1(ctx, advicer);
	        });
	        advices.Around.forEach(function (advicer) {
	            invoker_1(ctx, advicer);
	        });
	    }
	    next();
	};
	exports.CtorAfterAdviceAction = function (ctx, next) {
	    if (ctx.state === JoinpointState_1.JoinpointState.After) {
	        var advices = ctx.advices;
	        var invoker_2 = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	        advices.After.forEach(function (advicer) {
	            invoker_2(ctx, advicer);
	        });
	        advices.Around.forEach(function (advicer) {
	            invoker_2(ctx, advicer);
	        });
	    }
	    next();
	};
	var MethodAdvicesScope = /** @class */ (function (_super) {
	    tslib.__extends(MethodAdvicesScope, _super);
	    function MethodAdvicesScope() {
	        return _super !== null && _super.apply(this, arguments) || this;
	    }
	    MethodAdvicesScope.prototype.execute = function (ctx, next) {
	        var _a;
	        (_a = ctx.providers).inject.apply(_a, ctx.getProvProviders());
	        _super.prototype.execute.call(this, ctx, next);
	    };
	    MethodAdvicesScope.prototype.setup = function () {
	        this.use(exports.BeforeAdvicesAction)
	            .use(exports.PointcutAdvicesAction)
	            .use(exports.ExecuteOriginMethodAction)
	            .use(exports.AfterAdvicesAction)
	            .use(exports.AfterAsyncReturningAdvicesAction)
	            .use(exports.AfterReturningAdvicesAction)
	            .use(exports.AfterThrowingAdvicesAction);
	    };
	    return MethodAdvicesScope;
	}(ioc.IocCompositeAction));
	exports.MethodAdvicesScope = MethodAdvicesScope;
	exports.BeforeAdvicesAction = function (ctx, next) {
	    if (ctx.throwing) {
	        return next();
	    }
	    ctx.setValue(Joinpoint_1.AOP_STATE, JoinpointState_1.JoinpointState.Before);
	    var advices = ctx.advices;
	    var invoker = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	    advices.Around.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	    advices.Before.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	    next();
	};
	exports.PointcutAdvicesAction = function (ctx, next) {
	    if (ctx.throwing) {
	        return next();
	    }
	    ctx.setValue(Joinpoint_1.AOP_STATE, JoinpointState_1.JoinpointState.Pointcut);
	    var advices = ctx.advices;
	    var invoker = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	    advices.Pointcut.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	    next();
	};
	exports.ExecuteOriginMethodAction = function (ctx, next) {
	    if (ctx.throwing) {
	        return next();
	    }
	    try {
	        var val = ctx.originMethod.apply(ctx, ctx.args);
	        ctx.setValue(Joinpoint_1.AOP_RETURNING, val);
	    }
	    catch (err) {
	        ctx.setValue(Joinpoint_1.AOP_THROWING, err);
	    }
	    next();
	};
	exports.AfterAdvicesAction = function (ctx, next) {
	    if (ctx.throwing) {
	        return next();
	    }
	    ctx.setValue(Joinpoint_1.AOP_STATE, JoinpointState_1.JoinpointState.After);
	    var advices = ctx.advices;
	    var invoker = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	    advices.Around.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	    advices.After.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	    next();
	};
	exports.AfterAsyncReturningAdvicesAction = function (ctx, next) {
	    if (ctx.throwing || !ioc.isPromise(ctx.returning)) {
	        return next();
	    }
	    ctx.setValue(Joinpoint_1.AOP_STATE, JoinpointState_1.JoinpointState.AfterReturning);
	    var advices = ctx.advices;
	    var invoker = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	    ctx.setValue(Joinpoint_1.AOP_RETURNING, ioc.PromiseUtil.step(tslib.__spreadArrays([
	        ctx.returning
	    ], advices.Around.map(function (a) { return function () { return invoker(ctx, a); }; }), advices.AfterReturning.map(function (a) { return function () { return invoker(ctx, a); }; }), [
	        ctx.returning
	    ])));
	};
	exports.AfterReturningAdvicesAction = function (ctx, next) {
	    if (ctx.throwing) {
	        return next();
	    }
	    if (ctx.hasValue(Joinpoint_1.AOP_RETURNING)) {
	        ctx.setValue(Joinpoint_1.AOP_STATE, JoinpointState_1.JoinpointState.AfterReturning);
	        var advices = ctx.advices;
	        var invoker_3 = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	        advices.Around.forEach(function (advicer) {
	            invoker_3(ctx, advicer);
	        });
	        advices.AfterReturning.forEach(function (advicer) {
	            invoker_3(ctx, advicer);
	        });
	    }
	};
	exports.AfterThrowingAdvicesAction = function (ctx, next) {
	    if (ctx.throwing) {
	        ctx.setValue(Joinpoint_1.AOP_STATE, JoinpointState_1.JoinpointState.AfterThrowing);
	    }
	    var advices = ctx.advices;
	    var invoker = ctx.getValue(exports.AOP_ADVICE_INVOKER);
	    advices.Around.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	    advices.AfterThrowing.forEach(function (advicer) {
	        invoker(ctx, advicer);
	    });
	};


	});

	unwrapExports(ProceedingScope_1);
	var ProceedingScope_2 = ProceedingScope_1.AOP_ADVICE_INVOKER;
	var ProceedingScope_3 = ProceedingScope_1.ProceedingScope;
	var ProceedingScope_4 = ProceedingScope_1.CtorAdvicesScope;
	var ProceedingScope_5 = ProceedingScope_1.CtorBeforeAdviceAction;
	var ProceedingScope_6 = ProceedingScope_1.CtorAfterAdviceAction;
	var ProceedingScope_7 = ProceedingScope_1.MethodAdvicesScope;
	var ProceedingScope_8 = ProceedingScope_1.BeforeAdvicesAction;
	var ProceedingScope_9 = ProceedingScope_1.PointcutAdvicesAction;
	var ProceedingScope_10 = ProceedingScope_1.ExecuteOriginMethodAction;
	var ProceedingScope_11 = ProceedingScope_1.AfterAdvicesAction;
	var ProceedingScope_12 = ProceedingScope_1.AfterAsyncReturningAdvicesAction;
	var ProceedingScope_13 = ProceedingScope_1.AfterReturningAdvicesAction;
	var ProceedingScope_14 = ProceedingScope_1.AfterThrowingAdvicesAction;

	var Advisor_1 = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });



	/**
	 * for global aop advisor.
	 *
	 * @export
	 * @class Advisor
	 */
	var Advisor = /** @class */ (function () {
	    function Advisor(reflects) {
	        this.reflects = reflects;
	        this.aspects = new Map();
	        this.advices = new Map();
	    }
	    /**
	     * set advices.
	     *
	     * @param {string} key
	     * @param {Advices} advices
	     * @memberof Advisor
	     */
	    Advisor.prototype.setAdvices = function (type, key, advices) {
	        if (!this.advices.has(type)) {
	            this.advices.set(type, new Map());
	        }
	        this.advices.get(type).set(key, advices);
	    };
	    Advisor.prototype.hasAdvices = function (type) {
	        return this.advices.has(type);
	    };
	    /**
	     * get advices.
	     *
	     * @param {string} key
	     * @returns
	     * @memberof Advisor
	     */
	    Advisor.prototype.getAdvices = function (type, key) {
	        var _a;
	        return ((_a = this.advices.get(type)) === null || _a === void 0 ? void 0 : _a.get(key)) || null;
	    };
	    /**
	     * get advices.
	     *
	     * @param {string} key
	     * @returns {Advices}
	     * @memberof IAdvisor
	     */
	    Advisor.prototype.getAdviceMap = function (type) {
	        return this.advices.get(type);
	    };
	    /**
	     * add aspect.
	     *
	     * @param {Type} aspect
	     * @param {IInjector} injector
	     * @memberof Advisor
	     */
	    Advisor.prototype.add = function (aspect) {
	        if (!this.aspects.has(aspect)) {
	            var metas = this.reflects.getMethodMetadata(Advice.Advice, aspect);
	            this.aspects.set(aspect, metas);
	        }
	    };
	    /**
	     * resolve aspect.
	     *
	     * @template T
	     * @param {Type<T>} aspect
	     * @param {...ParamProviders[]} providers
	     * @returns {T}
	     * @memberof Advisor
	     */
	    Advisor.prototype.resolve = function (aspect) {
	        var _a;
	        var providers = [];
	        for (var _i = 1; _i < arguments.length; _i++) {
	            providers[_i - 1] = arguments[_i];
	        }
	        return (_a = this.reflects.getInjector(aspect)).resolve.apply(_a, tslib.__spreadArrays([aspect], providers));
	    };
	    Advisor = tslib.__decorate([
	        tslib.__param(0, ioc.Inject(ioc.TypeReflectsToken)),
	        tslib.__metadata("design:paramtypes", [Object])
	    ], Advisor);
	    return Advisor;
	}());
	exports.Advisor = Advisor;


	});

	unwrapExports(Advisor_1);
	var Advisor_2 = Advisor_1.Advisor;

	var AdviceMatcher_1 = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });





	/**
	 * advice matcher, use to match advice when a registered create instance.
	 *
	 * @export
	 * @class AdviceMatcher
	 * @implements {IAdviceMatcher}
	 */
	var AdviceMatcher = /** @class */ (function () {
	    function AdviceMatcher(reflects) {
	        this.reflects = reflects;
	    }
	    AdviceMatcher.prototype.match = function (aspectType, targetType, adviceMetas, target) {
	        var _this = this;
	        var refs = this.reflects;
	        var aspectMeta = ioc.lang.first(refs.getMetadata(Aspect.Aspect, aspectType));
	        if (aspectMeta) {
	            if (aspectMeta.without) {
	                var outs = ioc.isArray(aspectMeta.without) ? aspectMeta.without : [aspectMeta.without];
	                if (outs.some(function (t) { return refs.isExtends(targetType, t); })) {
	                    return [];
	                }
	            }
	            if (aspectMeta.within) {
	                var ins = ioc.isArray(aspectMeta.within) ? aspectMeta.within : [aspectMeta.within];
	                if (!ins.some(function (t) { return refs.isExtends(targetType, t); })) {
	                    if (!aspectMeta.annotation) {
	                        return [];
	                    }
	                }
	            }
	            if (aspectMeta.annotation) {
	                var annotation = ioc.isFunction(aspectMeta.annotation) ? aspectMeta.annotation.toString() : aspectMeta.annotation;
	                var anno = (regexps.annPreChkExp.test(annotation) ? '' : '@') + annotation;
	                if (!refs.hasMetadata(anno, targetType)) {
	                    return [];
	                }
	            }
	        }
	        var className = ioc.lang.getClassName(targetType);
	        adviceMetas = adviceMetas || refs.getMethodMetadata(Advice.Advice, targetType);
	        var matched = [];
	        if (targetType === aspectType) {
	            var adviceNames = Object.keys(adviceMetas);
	            if (adviceNames.length > 1) {
	                var advices_1 = [];
	                adviceNames.forEach(function (n) {
	                    advices_1 = advices_1.concat(adviceMetas[n]);
	                });
	                adviceNames.forEach(function (n) {
	                    advices_1.forEach(function (adv) {
	                        if (adv.propertyKey !== n) {
	                            if (_this.matchAspectSelf(n, adv)) {
	                                matched.push({
	                                    name: n,
	                                    fullName: className + "." + n,
	                                    advice: adv
	                                });
	                            }
	                        }
	                    });
	                });
	            }
	        }
	        else {
	            var points_1 = [];
	            var decorators = refs.create(targetType).defines.getPropertyDescriptors();
	            // match method.
	            for (var name_1 in decorators) {
	                // if (name !== 'constructor') {
	                points_1.push({
	                    name: name_1,
	                    fullName: className + "." + name_1
	                });
	                // }
	            }
	            Object.getOwnPropertyNames(adviceMetas).forEach(function (name) {
	                var advices = adviceMetas[name];
	                advices.forEach(function (metadata) {
	                    matched = matched.concat(_this.filterPointcut(targetType, points_1, metadata));
	                });
	            });
	        }
	        return matched;
	    };
	    AdviceMatcher.prototype.matchAspectSelf = function (name, metadata) {
	        if (metadata.pointcut) {
	            var pointcut = metadata.pointcut;
	            if (ioc.isString(pointcut)) {
	                if (regexps.executionChkExp.test(pointcut)) {
	                    pointcut = pointcut.substring(10, pointcut.length - 1);
	                }
	                return pointcut.startsWith(name);
	            }
	            else if (ioc.isRegExp(pointcut)) {
	                return pointcut.test(name);
	            }
	        }
	        return false;
	    };
	    AdviceMatcher.prototype.filterPointcut = function (type, points, metadata, target) {
	        if (!metadata.pointcut) {
	            return [];
	        }
	        var matchedPointcut;
	        if (metadata.pointcut) {
	            var match_1 = this.matchTypeFactory(type, metadata);
	            matchedPointcut = points.filter(function (p) { return match_1(p.name, p.fullName, type, target, p); });
	        }
	        matchedPointcut = matchedPointcut || [];
	        return matchedPointcut.map(function (p) {
	            return Object.assign({}, p, { advice: metadata });
	        });
	    };
	    AdviceMatcher.prototype.matchTypeFactory = function (type, metadata) {
	        var _this = this;
	        var pointcut = metadata.pointcut;
	        var expresses = [];
	        if (metadata.within) {
	            expresses.push(function (method, fullName, targetType) {
	                if (ioc.isArray(metadata.within)) {
	                    return metadata.within.some(function (t) { return _this.reflects.isExtends(targetType, t); });
	                }
	                else {
	                    return _this.reflects.isExtends(targetType, metadata.within);
	                }
	            });
	            expresses.push('&&');
	        }
	        if (metadata.target) {
	            expresses.push(function (method, fullName, targetType, target) {
	                return metadata.target = target;
	            });
	            expresses.push('&&');
	        }
	        if (metadata.annotation) {
	            expresses.push(function (method, fullName, targetType, target) {
	                return _this.reflects.hasMethodMetadata(metadata.annotation, targetType, method);
	            });
	            expresses.push('&&');
	        }
	        if (ioc.isString(pointcut)) {
	            var pointcuts = (pointcut || '').trim();
	            expresses.push(this.tranlateExpress(type, pointcuts));
	        }
	        else if (ioc.isRegExp(pointcut)) {
	            var pointcutReg_1 = pointcut;
	            if (regexps.annPreChkExp.test(pointcutReg_1.source)) {
	                expresses.push(function (name, fullName, targetType) {
	                    var decName = Reflect.getMetadataKeys(type, name);
	                    return decName.some(function (n) { return ioc.isString(n) && pointcutReg_1.test(n); });
	                });
	            }
	            else {
	                expresses.push(function (name, fullName) { return pointcutReg_1.test(fullName); });
	            }
	        }
	        return this.mergeExpress.apply(this, expresses);
	    };
	    AdviceMatcher.prototype.spiltBrace = function (strExp) {
	        strExp = strExp.trim();
	        if (regexps.preParam.test(strExp) && regexps.endParam.test(strExp)) {
	            strExp = strExp.substring(1, strExp.length - 1).trim();
	        }
	        if (regexps.preParam.test(strExp) && regexps.endParam.test(strExp)) {
	            return this.spiltBrace(strExp);
	        }
	        else {
	            return strExp;
	        }
	    };
	    AdviceMatcher.prototype.expressToFunc = function (type, strExp) {
	        var _this = this;
	        if (regexps.annContentExp.test(strExp)) {
	            var exp = strExp.substring(12, strExp.length - 1);
	            var annotation_1 = regexps.aExp.test(exp) ? exp : ('@' + exp);
	            return function (name, fullName) {
	                if (name === 'constructor') {
	                    return _this.reflects.hasMetadata(annotation_1, type);
	                }
	                return _this.reflects.hasMethodMetadata(annotation_1, type, name);
	            };
	        }
	        else if (regexps.execContentExp.test(strExp)) {
	            var exp = strExp.substring(10, strExp.length - 1);
	            if (exp === '*' || exp === '*.*') {
	                return function (name, fullName) { return !!name && !_this.reflects.hasMetadata(Aspect.Aspect, type); };
	            }
	            else if (regexps.mthNameExp.test(exp)) {
	                // if is method name, will match aspect self only.
	                return function () { return false; };
	            }
	            else if (regexps.tgMthChkExp.test(exp)) {
	                exp = exp.replace(regexps.replAny, '(\\\w+(\\\.|\\\/)){0,}\\\w+')
	                    .replace(regexps.replAny1, '\\\w+')
	                    .replace(regexps.replDot, '\\\.')
	                    .replace(regexps.replNav, '\\\/');
	                var matcher_1 = new RegExp(exp + '$');
	                return function (name, fullName) { return matcher_1.test(fullName); };
	            }
	            else {
	                return function () { return false; };
	            }
	        }
	        else if (regexps.withInChkExp.test(strExp)) {
	            var classnames_1 = strExp.substring(strExp.indexOf('(') + 1, strExp.length - 1).split(',').map(function (n) { return n.trim(); });
	            return function (name, fullName, targetType) { return classnames_1.indexOf(ioc.lang.getClassName(targetType)) >= 0; };
	        }
	        else if (regexps.targetChkExp.test(strExp)) {
	            var torken_1 = strExp.substring(strExp.indexOf('(') + 1, strExp.length - 1).trim();
	            return function (name, fullName, targetType) { return _this.reflects.getInjector(type).getTokenProvider(torken_1) === targetType; };
	        }
	        else {
	            return function () { return false; };
	        }
	    };
	    AdviceMatcher.prototype.tranlateExpress = function (type, strExp) {
	        var expresses = [];
	        var idxOr = strExp.indexOf('||');
	        var idxAd = strExp.indexOf('&&');
	        if (idxAd < 0 && idxOr < 0) {
	            expresses.push(this.expressToFunc(type, this.spiltBrace(strExp)));
	        }
	        else {
	            if (idxOr > idxAd) {
	                var leftExp = this.spiltBrace(strExp.substring(0, idxOr));
	                if (leftExp) {
	                    expresses.push(this.tranlateExpress(type, leftExp));
	                }
	                var rightExp = this.spiltBrace(strExp.substring(idxOr + 2));
	                if (rightExp) {
	                    expresses.push('||');
	                    expresses.push(this.tranlateExpress(type, rightExp));
	                }
	            }
	            else if (idxAd > idxOr) {
	                var leftExp = this.spiltBrace(strExp.substring(0, idxAd));
	                if (leftExp) {
	                    expresses.push(this.tranlateExpress(type, leftExp));
	                }
	                var rightExp = this.spiltBrace(strExp.substring(idxAd + 2));
	                if (rightExp) {
	                    expresses.push('&&');
	                    expresses.push(this.tranlateExpress(type, rightExp));
	                }
	            }
	        }
	        return this.mergeExpress.apply(this, expresses);
	    };
	    AdviceMatcher.prototype.mergeExpress = function () {
	        var expresses = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            expresses[_i] = arguments[_i];
	        }
	        return function (method, fullName, targetType, pointcut) {
	            var flag;
	            expresses.forEach(function (express, idx) {
	                if (ioc.isDefined(flag)) {
	                    return;
	                }
	                if (ioc.isFunction(express)) {
	                    var rel = express(method, fullName, targetType, pointcut);
	                    if (idx < expresses.length - 2) {
	                        if (!rel && express[idx + 1] === '&&') {
	                            flag = false;
	                        }
	                        if (rel && express[idx + 1] === '||') {
	                            flag = true;
	                        }
	                    }
	                    else {
	                        flag = rel;
	                    }
	                }
	            });
	            return flag;
	        };
	    };
	    AdviceMatcher = tslib.__decorate([
	        tslib.__param(0, ioc.Inject(ioc.TypeReflectsToken)),
	        tslib.__metadata("design:paramtypes", [Object])
	    ], AdviceMatcher);
	    return AdviceMatcher;
	}());
	exports.AdviceMatcher = AdviceMatcher;


	});

	unwrapExports(AdviceMatcher_1);
	var AdviceMatcher_2 = AdviceMatcher_1.AdviceMatcher;

	var IAdviceMatcher = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	/**
	 * Aop advice matcher interface token.
	 * it is a token id, you can register yourself IActionBuilder for this.
	 */
	exports.AdviceMatcherToken = ioc.tokenId('DI_IAdviceMatcher');


	});

	unwrapExports(IAdviceMatcher);
	var IAdviceMatcher_1 = IAdviceMatcher.AdviceMatcherToken;

	var aopActions = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });





	/**
	 * execute bind method pointcut action.
	 */
	exports.BindMthPointcutAction = function (ctx, next) {
	    // aspect class do nothing.
	    var reflects = ctx.reflects;
	    if (!ctx.target || !isValAspectTag(ctx.type, reflects)) {
	        return next();
	    }
	    var scope = reflects.getActionInjector().getInstance(ProceedingScope_1.ProceedingScope);
	    var target = ctx.target;
	    var targetType = ctx.type;
	    var className = ioc.lang.getClassName(targetType);
	    var decorators = ctx.targetReflect.defines.getPropertyDescriptors();
	    var advisor = reflects.getActionInjector().getInstance(IAdvisor.AdvisorToken);
	    var advicesMap = advisor.getAdviceMap(targetType);
	    if (advicesMap && advicesMap.size) {
	        advicesMap.forEach(function (advices, name) {
	            if (name === 'constructor') {
	                return;
	            }
	            var pointcut = {
	                name: name,
	                fullName: className + "." + name,
	                descriptor: decorators[name]
	            };
	            scope.proceed(target, targetType, advices, pointcut);
	        });
	    }
	    next();
	};
	/**
	 * before constructor advice actions.
	 *
	 * @export
	 */
	exports.BeforeCtorAdviceAction = function (ctx, next) {
	    // aspect class do nothing.
	    var reflects = ctx.reflects;
	    if (!isValAspectTag(ctx.type, reflects)) {
	        return next();
	    }
	    reflects.getActionInjector().getInstance(ioc.ActionInjectorToken)
	        .getInstance(ProceedingScope_1.ProceedingScope)
	        .beforeConstr(ctx.type, ctx.getValue(ioc.CTX_PARAMS), ctx.getValue(ioc.CTX_ARGS), ctx.providers);
	    next();
	};
	/**
	 * after constructor advice actions.
	 *
	 * @export
	 */
	exports.AfterCtorAdviceAction = function (ctx, next) {
	    // aspect class do nothing.
	    var reflects = ctx.reflects;
	    if (!ctx.target || !isValAspectTag(ctx.type, reflects)) {
	        return next();
	    }
	    reflects.getActionInjector().getInstance(ioc.ActionInjectorToken)
	        .getInstance(ProceedingScope_1.ProceedingScope)
	        .afterConstr(ctx.target, ctx.type, ctx.getValue(ioc.CTX_PARAMS), ctx.getValue(ioc.CTX_ARGS), ctx.providers);
	    next();
	};
	/**
	 * regist aspect action.
	 *
	 * @export
	 */
	exports.RegistAspectAction = function (ctx, next) {
	    var type = ctx.type;
	    var aspectMgr = ctx.reflects.getActionInjector().getInstance(IAdvisor.AdvisorToken);
	    aspectMgr.add(type);
	    next();
	};
	/**
	 *  match pointcut action.
	 *
	 * @export
	 */
	exports.MatchPointcutAction = function (ctx, next) {
	    // aspect class do nothing.
	    var reflects = ctx.reflects;
	    if (!isValAspectTag(ctx.type, reflects)) {
	        return next();
	    }
	    var advisor = reflects.getActionInjector().getInstance(IAdvisor.AdvisorToken);
	    var matcher = reflects.getActionInjector().getInstance(IAdviceMatcher.AdviceMatcherToken);
	    var targetType = ctx.type;
	    advisor.aspects.forEach(function (adviceMetas, type) {
	        var matchpoints = matcher.match(type, targetType, adviceMetas, ctx.target);
	        matchpoints.forEach(function (mpt) {
	            var name = mpt.name;
	            var advice = mpt.advice;
	            var advices = advisor.getAdvices(targetType, name);
	            if (!advices) {
	                advices = {
	                    Before: [],
	                    Pointcut: [],
	                    After: [],
	                    Around: [],
	                    AfterThrowing: [],
	                    AfterReturning: []
	                };
	                advisor.setAdvices(targetType, name, advices);
	            }
	            var advicer = Object.assign(mpt, {
	                aspectType: type
	            });
	            if (advice.adviceName === 'Before') {
	                if (!advices.Before.some(function (a) { return equals(a, advicer); })) {
	                    advices.Before.push(advicer);
	                }
	            }
	            else if (advice.adviceName === 'Pointcut') {
	                if (!advices.Pointcut.some(function (a) { return equals(a, advicer); })) {
	                    advices.Pointcut.push(advicer);
	                }
	            }
	            else if (advice.adviceName === 'Around') {
	                if (!advices.Around.some(function (a) { return equals(a, advicer); })) {
	                    advices.Around.push(advicer);
	                }
	            }
	            else if (advice.adviceName === 'After') {
	                if (!advices.After.some(function (a) { return equals(a, advicer); })) {
	                    advices.After.push(advicer);
	                }
	            }
	            else if (advice.adviceName === 'AfterThrowing') {
	                if (!advices.AfterThrowing.some(function (a) { return equals(a, advicer); })) {
	                    advices.AfterThrowing.push(advicer);
	                }
	            }
	            else if (advice.adviceName === 'AfterReturning') {
	                if (!advices.AfterReturning.some(function (a) { return equals(a, advicer); })) {
	                    advices.AfterReturning.push(advicer);
	                }
	            }
	        });
	    });
	    next();
	};
	function equals(a, b) {
	    return a.aspectType === b.aspectType && a.advice.propertyKey === b.advice.propertyKey;
	}
	/**
	 * is target can aspect or not.
	 *
	 * @export
	 * @param {Type} targetType
	 * @returns {boolean}
	 */
	function isValAspectTag(targetType, reflects) {
	    if (!ioc.isClass(targetType) || ioc.isBaseType(targetType)) {
	        return false;
	    }
	    if (targetType.d0NPT) {
	        return false;
	    }
	    return !reflects.hasMetadata(NonePointcut.NonePointcut, targetType);
	}


	});

	unwrapExports(aopActions);
	var aopActions_1 = aopActions.BindMthPointcutAction;
	var aopActions_2 = aopActions.BeforeCtorAdviceAction;
	var aopActions_3 = aopActions.AfterCtorAdviceAction;
	var aopActions_4 = aopActions.RegistAspectAction;
	var aopActions_5 = aopActions.MatchPointcutAction;

	var AopModule_1 = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });









	/**
	 * aop ext for ioc. auto run setup after registered.
	 * @export
	 * @class AopModule
	 */
	var AopModule = /** @class */ (function () {
	    function AopModule() {
	    }
	    /**
	     * register aop for container.
	     *
	     * @memberof AopModule
	     */
	    AopModule.prototype.setup = function (container) {
	        var actInjector = container.getSingleton(ioc.ActionInjector);
	        var reflects = container.getSingleton(ioc.TypeReflectsToken);
	        actInjector
	            .setSingleton(IAdvisor.AdvisorToken, new Advisor_1.Advisor(reflects), Advisor_1.Advisor)
	            .setSingleton(IAdviceMatcher.AdviceMatcherToken, new AdviceMatcher_1.AdviceMatcher(reflects), AdviceMatcher_1.AdviceMatcher);
	        actInjector.regAction(ProceedingScope_1.ProceedingScope);
	        actInjector.getInstance(ioc.BeforeCtorScope)
	            .useBefore(aopActions.BeforeCtorAdviceAction);
	        actInjector.getInstance(ioc.AfterCtorScope)
	            // .use(ExetndsInstanceAction)
	            .use(aopActions.AfterCtorAdviceAction);
	        actInjector.getInstance(ioc.RuntimeMthScope)
	            .useBefore(aopActions.BindMthPointcutAction);
	        actInjector.getInstance(ioc.RuntimeLifeScope)
	            .useBefore(aopActions.MatchPointcutAction, ioc.CtorArgsAction);
	        actInjector.getInstance(ioc.DesignRegisterer)
	            .register(Aspect.Aspect, 'Class', ioc.TypeProviderAction, aopActions.RegistAspectAction);
	        actInjector.getInstance(ioc.RuntimeRegisterer)
	            .register(Aspect.Aspect, 'Class', ioc.RegSingletionAction);
	    };
	    tslib.__decorate([
	        tslib.__param(0, ioc.Inject(ioc.IocContainerToken)),
	        tslib.__metadata("design:type", Function),
	        tslib.__metadata("design:paramtypes", [Object]),
	        tslib.__metadata("design:returntype", void 0)
	    ], AopModule.prototype, "setup", null);
	    AopModule = tslib.__decorate([
	        ioc.IocExt(),
	        tslib.__metadata("design:paramtypes", [])
	    ], AopModule);
	    return AopModule;
	}());
	exports.AopModule = AopModule;


	});

	unwrapExports(AopModule_1);
	var AopModule_2 = AopModule_1.AopModule;

	var src = createCommonjsModule(function (module, exports) {
	Object.defineProperty(exports, "__esModule", { value: true });

	// decorators
	tslib.__exportStar(Advice, exports);
	tslib.__exportStar(Aspect, exports);
	tslib.__exportStar(After, exports);
	tslib.__exportStar(AfterReturning, exports);
	tslib.__exportStar(AfterThrowing, exports);
	tslib.__exportStar(Around, exports);
	tslib.__exportStar(Before, exports);
	tslib.__exportStar(Pointcut, exports);
	tslib.__exportStar(NonePointcut, exports);
	// joinpoints
	tslib.__exportStar(JoinpointState_1, exports);
	tslib.__exportStar(Joinpoint_1, exports);
	tslib.__exportStar(Advices, exports);
	tslib.__exportStar(ProceedingScope_1, exports);
	tslib.__exportStar(IAdvisor, exports);
	tslib.__exportStar(Advisor_1, exports);
	tslib.__exportStar(AdviceMatcher_1, exports);
	tslib.__exportStar(AopModule_1, exports);
	// actions
	tslib.__exportStar(aopActions, exports);


	});

	var index = unwrapExports(src);

	return index;

})));

});

unwrapExports(aop_umd);

var AuthenticatedVaildate_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




let AuthenticatedVaildate = class AuthenticatedVaildate {
    vaildate(ctx, authAnnotation, joinPoint) {
        if (!ioc.isFunction(ctx.isAuthenticated)) {
            return;
        }
        if (!ctx.isAuthenticated()) {
            throw new mvc.UnauthorizedError();
        }
    }
    static d0Ann() {
        return { "name": "AuthenticatedVaildate", "params": { "vaildate": ["ctx", "authAnnotation", "joinPoint"] } };
    }
};
tslib.__decorate([
    aop_umd.Before(mvc.AuthorizationPointcut, 'authAnnotation'),
    tslib.__param(0, ioc.Inject(mvc.ContextToken)),
    tslib.__metadata("design:type", Function),
    tslib.__metadata("design:paramtypes", [Object, Array, aop_umd.Joinpoint]),
    tslib.__metadata("design:returntype", void 0)
], AuthenticatedVaildate.prototype, "vaildate", null);
AuthenticatedVaildate = tslib.__decorate([
    aop_umd.Aspect()
], AuthenticatedVaildate);
exports.AuthenticatedVaildate = AuthenticatedVaildate;


});

unwrapExports(AuthenticatedVaildate_1);
var AuthenticatedVaildate_2 = AuthenticatedVaildate_1.AuthenticatedVaildate;

var RoleVaildate_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




let RoleVaildate = class RoleVaildate {
    vaildate(ctx, authAnnotation, joinPoint) {
        if (ioc.isFunction(ctx.hasRole) && authAnnotation && authAnnotation.length) {
            if (!ctx.hasRole(...authAnnotation.map(a => a.role).filter(a => a))) {
                throw new mvc.ForbiddenError();
            }
        }
    }
    static d0Ann() {
        return { "name": "RoleVaildate", "params": { "vaildate": ["ctx", "authAnnotation", "joinPoint"] } };
    }
};
tslib.__decorate([
    aop_umd.Before(mvc.AuthorizationPointcut, 'authAnnotation'),
    tslib.__param(0, ioc.Inject(mvc.ContextToken)),
    tslib.__metadata("design:type", Function),
    tslib.__metadata("design:paramtypes", [Object, Array, aop_umd.Joinpoint]),
    tslib.__metadata("design:returntype", void 0)
], RoleVaildate.prototype, "vaildate", null);
RoleVaildate = tslib.__decorate([
    aop_umd.Aspect()
], RoleVaildate);
exports.RoleVaildate = RoleVaildate;


});

unwrapExports(RoleVaildate_1);
var RoleVaildate_2 = RoleVaildate_1.RoleVaildate;

var vaildates = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(AuthenticatedVaildate_1, exports);
tslib.__exportStar(RoleVaildate_1, exports);


});

unwrapExports(vaildates);

var ControllerAuthRegisterAction = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


/**
 *  the routes need to auth.
 */
exports.AuthRoutesToken = new ioc.InjectToken('identify_auth_routes');
exports.ControllerAuthRegisterAction = (ctx, next) => {
    if (ioc.hasOwnClassMetadata(mvc.Authorization, ctx.type) || ioc.hasMethodMetadata(mvc.Authorization, ctx.type)) {
        let ctrlmetadatas = ioc.getTypeMetadata(mvc.Controller, ctx.type);
        let routers = ctx.injector.get(exports.AuthRoutesToken);
        ctrlmetadatas.forEach(ctlmeta => {
            if (!ctlmeta) {
                return;
            }
            let prefix = ctlmeta.routePrefix;
            if (prefix && !/^\//.test(prefix)) {
                prefix = '/' + prefix;
            }
            routers.add(prefix);
        });
    }
    next();
};


});

unwrapExports(ControllerAuthRegisterAction);
var ControllerAuthRegisterAction_1 = ControllerAuthRegisterAction.AuthRoutesToken;
var ControllerAuthRegisterAction_2 = ControllerAuthRegisterAction.ControllerAuthRegisterAction;

var IdentityStartupService_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });




let IdentityStartupService = class IdentityStartupService extends mvc.BeforeMidddlewareStartupService {
    async startup(ctx, middlewares) {
        let passport = ctx.injector.get(passports.AuthenticatorToken);
        let services = ctx.injector.getServices(passports.PassportBuildService);
        // config build first.
        let cfs = services.find(s => s instanceof passports.ConfigurePassportBuildService);
        if (cfs && services.indexOf(cfs) > 0) {
            services.splice(services.indexOf(cfs), 1);
            services.unshift(cfs);
        }
        await Promise.all(services.map(s => s.build(passport, ctx.getConfiguration())));
    }
    static d0Ann() {
        return { "name": "IdentityStartupService", "params": { "startup": ["ctx", "middlewares"] } };
    }
};
IdentityStartupService = tslib.__decorate([
    ioc.Singleton
], IdentityStartupService);
exports.IdentityStartupService = IdentityStartupService;


});

unwrapExports(IdentityStartupService_1);
var IdentityStartupService_2 = IdentityStartupService_1.IdentityStartupService;

var IdentityModule_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });











let IdentitySetupModule = class IdentitySetupModule {
    constructor() {
    }
    setup(container) {
        container.bindProvider(ControllerAuthRegisterAction.AuthRoutesToken, new Set());
        let actjtr = container.getInstance(ioc.ActionInjectorToken);
        actjtr.register(ControllerAuthRegisterAction.ControllerAuthRegisterAction);
        let dreger = actjtr.getInstance(ioc.DesignRegisterer);
        dreger.register(mvc.Controller, 'Class', ControllerAuthRegisterAction.ControllerAuthRegisterAction);
    }
    static d0Ann() {
        return { "name": "IdentitySetupModule", "params": { "constructor": [], "setup": ["container"] } };
    }
};
tslib.__decorate([
    tslib.__param(0, ioc.Inject(core.ContainerToken)),
    tslib.__metadata("design:type", Function),
    tslib.__metadata("design:paramtypes", [Object]),
    tslib.__metadata("design:returntype", void 0)
], IdentitySetupModule.prototype, "setup", null);
IdentitySetupModule = tslib.__decorate([
    ioc.IocExt(),
    tslib.__metadata("design:paramtypes", [])
], IdentitySetupModule);
let IdentityModule = class IdentityModule {
    static d0Ann() {
        return { "name": "IdentityModule", "params": {} };
    }
};
IdentityModule = tslib.__decorate([
    boot.DIModule({
        regIn: 'root',
        imports: [
            IdentitySetupModule,
            components.ComponentsModule,
            components.ElementModule
        ],
        providers: [
            IdentityStartupService_1.IdentityStartupService,
            [passports, vaildates, middlewares]
        ]
    })
], IdentityModule);
exports.IdentityModule = IdentityModule;


});

unwrapExports(IdentityModule_1);
var IdentityModule_2 = IdentityModule_1.IdentityModule;

var es2017 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(errors, exports);
tslib.__exportStar(middlewares, exports);
tslib.__exportStar(passports, exports);
tslib.__exportStar(stores, exports);
tslib.__exportStar(vaildates, exports);
tslib.__exportStar(IdentityModule_1, exports);
tslib.__exportStar(services, exports);
tslib.__exportStar(ControllerAuthRegisterAction, exports);


});

var index = unwrapExports(es2017);

module.exports = index;
//# sourceMappingURL=identity.js.map