@ug.software/opposer 3.0.10

package/lib/esm/server/security/middleware/permission.js

@@ -0,0 +1,133 @@
+import { Exception } from '../../helpers/index.js';
+import { HttpStatus } from '../../constants/index.js';
+import jwt from '../jwt/index.js';
+import system from '../../../system/index.js';
+import { getIsPublicMetadata, getIsPublicMethodMetadata } from '../../../server/decorators/index.js';
+import Session from '../models/se.js';
+import { Context } from '../../index.js';
+export default async (req, res, next) => {
+    const host = req.headers.host;
+    const referer = req.headers.referer;
+    // Bypass for playground or same domain requests
+    if (referer && host && referer.includes(host)) {
+        return next();
+    }
+    const request = req.body;
+    //skip session method
+    if (['login', 'register', 'refresh'].includes(request.method)) {
+        return next();
+    }
+    //skip for public models
+    if (request.model) {
+        const customModels = Context.get('models');
+        var allModels = await system.getAllModels(customModels);
+        var model = allModels.find((x) => x.name === request.model);
+        if (model) {
+            var isPublic = getIsPublicMetadata(model.entity);
+            if (isPublic) {
+                return next();
+            }
+        }
+    }
+    //skip for public methods
+    if (request.controller) {
+        const customControllers = Context.get('controllers');
+        const allControllers = await system.getAllControllers(customControllers);
+        var controller = allControllers.find((x) => x.name.toUpperCase() === request.controller?.toUpperCase());
+        if (controller) {
+            var methods = getIsPublicMethodMetadata(controller);
+            if (methods.some((x) => x.name === request.method)) {
+                return next();
+            }
+        }
+    }
+    const db = Context.get('db');
+    var decoded = null;
+    const authorization = req.headers.authorization || req.cookies.access_token;
+    if (authorization) {
+        var token = authorization.replace('Bearer ', '');
+        decoded = await jwt.validate.access(token);
+    }
+    if (typeof decoded === 'string' || !decoded || !authorization) {
+        const refresh = req.cookies.refresh_token;
+        if (!refresh) {
+            return res.status(HttpStatus[403].code).send(Exception({
+                ...HttpStatus[403],
+                message: "[autorization] - Don't authorized, verify data and try again.",
+            }));
+        }
+        if (!db) {
+            return res.status(HttpStatus[500].code).send(Exception({
+                ...HttpStatus[500],
+                message: '[database] - Database connection not found.',
+            }));
+        }
+        var sessionRepository = db.getRepository(Session);
+        var last = await sessionRepository.findOne({
+            where: { rt: refresh },
+        });
+        if (!last) {
+            return res.status(HttpStatus[401].code).send(Exception({
+                ...HttpStatus[401],
+                message: "Don't find session.",
+            }));
+        }
+        //cancel last session and update in database;
+        sessionRepository.update({ rt: last.rt }, {
+            ac: false,
+            lou: new Date(),
+        });
+        decoded = await jwt.validate.refresh(refresh);
+        if (!decoded || typeof decoded === 'string') {
+            return res.status(HttpStatus[401].code).send(Exception({
+                ...HttpStatus[401],
+                message: 'Invalid refresh token.',
+            }));
+        }
+        const { fn, id, lg, ln, rl } = decoded;
+        var revalidate = await jwt.sign({ fn, id, lg, ln, rl });
+        token = revalidate.token;
+        const current = new Date();
+        //seta os novos cookies
+        res.cookie('access_token', token, {
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            path: '/',
+            expires: new Date(current.getTime() + 15 * 60 * 1000), // 15 mim
+        });
+        res.cookie('refresh_token', revalidate.refresh, {
+            httpOnly: true,
+            secure: true,
+            sameSite: 'none',
+            path: '/',
+            expires: new Date(current.getTime() + 15 * 24 * 60 * 60 * 1000), // 15 dias
+        });
+        await sessionRepository.insert({
+            ac: true,
+            ag: last.ag,
+            ip: last.ip,
+            loi: new Date(),
+            rt: refresh,
+            usr: decoded.id,
+        });
+    }
+    if (typeof decoded !== 'string' && decoded !== undefined) {
+        //manager permission
+        if (decoded.rl.some((x) => x.mt === 'all' && x.sm === 'all')) {
+            return next();
+        }
+        //granular permission
+        if (!decoded.rl.some((x) => x.mt === request.method && x.sm === request.model)) {
+            return res.status(HttpStatus[403].code).send(Exception({
+                ...HttpStatus[403],
+                message: "[autorization] - Don't authorized, verify our permissions and try again.",
+            }));
+        }
+        return next();
+    }
+    return res.status(HttpStatus[403].code).send(Exception({
+        ...HttpStatus[403],
+        message: 'Unabled authorization key.',
+    }));
+};

package/lib/esm/server/security/models/crp.d.ts

@@ -0,0 +1,8 @@
+export default class ChangeRequestPassword {
+    id: string;
+    usr: string;
+    tk: string;
+    ex: Date;
+    ac: boolean;
+    ct: Date;
+}

package/lib/esm/server/security/models/crp.js

@@ -0,0 +1,40 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, CreateDateColumn, f } from "../../../orm/index.js";
+let ChangeRequestPassword = class ChangeRequestPassword {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], ChangeRequestPassword.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("usr is string.").required("usr is required.")),
+    __metadata("design:type", String)
+], ChangeRequestPassword.prototype, "usr", void 0);
+__decorate([
+    Field(() => f().string("tk is string.").required("tk is required.")),
+    __metadata("design:type", String)
+], ChangeRequestPassword.prototype, "tk", void 0);
+__decorate([
+    Field(() => f().date("ex is date.").required("ex is required.")),
+    __metadata("design:type", Date)
+], ChangeRequestPassword.prototype, "ex", void 0);
+__decorate([
+    Field(() => f().boolean("ac is boolean.").required("ac is required.")),
+    __metadata("design:type", Boolean)
+], ChangeRequestPassword.prototype, "ac", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], ChangeRequestPassword.prototype, "ct", void 0);
+ChangeRequestPassword = __decorate([
+    Entity("crp")
+], ChangeRequestPassword);
+export default ChangeRequestPassword;

package/lib/esm/server/security/models/ke.d.ts

@@ -0,0 +1,7 @@
+export default class Key {
+    id: string;
+    nm: string;
+    hs: string;
+    ex: Date;
+    ct: Date;
+}

package/lib/esm/server/security/models/ke.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, CreateDateColumn, f } from "../../../orm/index.js";
+let Key = class Key {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Key.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("nm is string.").required("nm is required.")),
+    __metadata("design:type", String)
+], Key.prototype, "nm", void 0);
+__decorate([
+    Field(() => f().string("hs is string.").required("hs is required.")),
+    __metadata("design:type", String)
+], Key.prototype, "hs", void 0);
+__decorate([
+    Field(() => f().date("ex is date.").required("ex is required.")),
+    __metadata("design:type", Date)
+], Key.prototype, "ex", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], Key.prototype, "ct", void 0);
+Key = __decorate([
+    Entity("ke")
+], Key);
+export default Key;

package/lib/esm/server/security/models/rl.d.ts

@@ -0,0 +1,9 @@
+import User from "./usr.js";
+export default class Role {
+    id: string;
+    sm: string;
+    mt: string;
+    ct: Date;
+    ut: Date;
+    usr: User;
+}

package/lib/esm/server/security/models/rl.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, Relation, CreateDateColumn, UpdateDateColumn, f } from "../../../orm/index.js";
+import User from "./usr.js";
+let Role = class Role {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Role.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("model is string.").required("model is required.")),
+    __metadata("design:type", String)
+], Role.prototype, "sm", void 0);
+__decorate([
+    Field(() => f().string("model is string.").required("model is required.")),
+    __metadata("design:type", String)
+], Role.prototype, "mt", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], Role.prototype, "ct", void 0);
+__decorate([
+    UpdateDateColumn(),
+    __metadata("design:type", Date)
+], Role.prototype, "ut", void 0);
+__decorate([
+    Relation({
+        type: "many-to-one",
+        target: () => User,
+        inverseSide: "rl"
+    }),
+    __metadata("design:type", User)
+], Role.prototype, "usr", void 0);
+Role = __decorate([
+    Entity("rl")
+], Role);
+export default Role;

package/lib/esm/server/security/models/se.d.ts

@@ -0,0 +1,11 @@
+export default class Session {
+    id: string;
+    usr: string;
+    ip: string;
+    ag: string;
+    rt: string;
+    ac: boolean;
+    loi: Date;
+    lou?: Date;
+    ct: Date;
+}

package/lib/esm/server/security/models/se.js

@@ -0,0 +1,52 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, CreateDateColumn, f } from "../../../orm/index.js";
+let Session = class Session {
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], Session.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("usr is string.").required("usr is required.")),
+    __metadata("design:type", String)
+], Session.prototype, "usr", void 0);
+__decorate([
+    Field(() => f().string("ip is string.").required("ip is required.")),
+    __metadata("design:type", String)
+], Session.prototype, "ip", void 0);
+__decorate([
+    Field(() => f().string("ag is string.").required("ag is required.")),
+    __metadata("design:type", String)
+], Session.prototype, "ag", void 0);
+__decorate([
+    Field(() => f().string("rt is string.").required("rt is required.")),
+    __metadata("design:type", String)
+], Session.prototype, "rt", void 0);
+__decorate([
+    Field(() => f().boolean("ac is boolean.").required("ac is required.")),
+    __metadata("design:type", Boolean)
+], Session.prototype, "ac", void 0);
+__decorate([
+    Field(() => f().date("loi is date.").required("loi is required.")),
+    __metadata("design:type", Date)
+], Session.prototype, "loi", void 0);
+__decorate([
+    Field({ nullable: true, validation: () => f().date("lou is date.") }),
+    __metadata("design:type", Date)
+], Session.prototype, "lou", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], Session.prototype, "ct", void 0);
+Session = __decorate([
+    Entity("se")
+], Session);
+export default Session;

package/lib/esm/server/security/models/usr.d.ts

@@ -0,0 +1,14 @@
+import Role from "./rl.js";
+export default class User {
+    id: string;
+    fn: string;
+    ln: string;
+    lg: string;
+    ps: string;
+    ac: boolean;
+    ct: Date;
+    ut: Date;
+    rl: Role[];
+    hashPassword(): Promise<void>;
+    comparePassword(plainPassword: string): Promise<boolean>;
+}

package/lib/esm/server/security/models/usr.js

@@ -0,0 +1,77 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Entity, Field, PrimaryColumn, Relation, CreateDateColumn, UpdateDateColumn, BeforeInsert, BeforeUpdate, f, } from "../../../orm/index.js";
+import bcrypt from "bcrypt";
+import Role from "./rl.js";
+let User = class User {
+    async hashPassword() {
+        if (this.ps) {
+            const salt = await bcrypt.genSalt(10);
+            this.ps = await bcrypt.hash(this.ps, salt);
+        }
+    }
+    async comparePassword(plainPassword) {
+        return await bcrypt.compare(plainPassword, this.ps);
+    }
+};
+__decorate([
+    PrimaryColumn({ type: "uuid" }),
+    __metadata("design:type", String)
+], User.prototype, "id", void 0);
+__decorate([
+    Field(() => f().string("first name is string.").required("first name is required.")),
+    __metadata("design:type", String)
+], User.prototype, "fn", void 0);
+__decorate([
+    Field(() => f().string("last name is string.").required("last name is required.")),
+    __metadata("design:type", String)
+], User.prototype, "ln", void 0);
+__decorate([
+    Field(() => f().string("ln is string.").required("ln is required.")),
+    __metadata("design:type", String)
+], User.prototype, "lg", void 0);
+__decorate([
+    Field(() => f()
+        .string("password is string.")
+        .required("password is required.")
+        .match(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9])[^\s]{8,}$/, "password not security, for strong password is necessary upper words, numbers and special characters.")),
+    __metadata("design:type", String)
+], User.prototype, "ps", void 0);
+__decorate([
+    Field({ type: "boolean", default: true }),
+    __metadata("design:type", Boolean)
+], User.prototype, "ac", void 0);
+__decorate([
+    CreateDateColumn(),
+    __metadata("design:type", Date)
+], User.prototype, "ct", void 0);
+__decorate([
+    UpdateDateColumn(),
+    __metadata("design:type", Date)
+], User.prototype, "ut", void 0);
+__decorate([
+    Relation({
+        type: "one-to-many",
+        target: () => Role,
+        inverseSide: "usr",
+    }),
+    __metadata("design:type", Array)
+], User.prototype, "rl", void 0);
+__decorate([
+    BeforeInsert(),
+    BeforeUpdate(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], User.prototype, "hashPassword", null);
+User = __decorate([
+    Entity("usr")
+], User);
+export default User;

package/lib/esm/server/services/delete.d.ts

@@ -0,0 +1,13 @@
+import { HandleDeleteProps } from '../../interfaces/controller.js';
+declare const _default: (props: HandleDeleteProps) => Promise<{
+    readonly success: true;
+    readonly data: any;
+} | {
+    readonly success: false;
+    readonly error: {
+        name: string;
+        code: number;
+        message: any;
+    };
+}>;
+export default _default;

package/lib/esm/server/services/delete.js

@@ -0,0 +1,44 @@
+import { HttpStatus } from '../constants/index.js';
+import { Exception, Success } from '../helpers/index.js';
+import system from '../../system/index.js';
+import { Context } from '../index.js';
+export default async (props) => {
+    const customModels = Context.get('models');
+    const allModels = await system.getAllModels(customModels);
+    const model = allModels.find((x) => x.name === props.model);
+    const db = Context.get('db');
+    if (!db) {
+        return Exception({
+            name: HttpStatus[500].name,
+            code: HttpStatus[500].code,
+            message: 'Database not connected.',
+        });
+    }
+    if (model) {
+        const repository = db.getRepository(model.entity);
+        if (!props.filter || Object.keys(props.filter).length === 0) {
+            return Exception({
+                ...HttpStatus[400],
+                message: 'Necessary to set query params for delete items.',
+            });
+        }
+        try {
+            await repository.delete(props.filter);
+            return Success({
+                message: 'Success removing item',
+            });
+        }
+        catch (err) {
+            return Exception({
+                name: HttpStatus[500].name,
+                code: HttpStatus[500].code,
+                message: err.message,
+            });
+        }
+    }
+    return Exception({
+        name: HttpStatus[400].name,
+        code: HttpStatus[400].code,
+        message: 'Unable to identify Model.',
+    });
+};

package/lib/esm/server/services/get.d.ts

@@ -0,0 +1,4 @@
+import { HandleGetProps } from '../../interfaces/controller.js';
+import { HandleRequestResult } from '../../interfaces/request.js';
+declare const _default: (props: HandleGetProps) => Promise<HandleRequestResult<unknown>>;
+export default _default;

package/lib/esm/server/services/get.js

@@ -0,0 +1,140 @@
+import { Exception, Success } from '../helpers/index.js';
+import { HttpStatus } from '../constants/index.js';
+import system from '../../system/index.js';
+import { Context } from '../index.js';
+export default async (props) => {
+    const customModels = Context.get('models');
+    const allModels = await system.getAllModels(customModels);
+    const model = allModels.find((x) => {
+        return x.name.toLowerCase() === props.model.toLowerCase();
+    });
+    if (!model) {
+        return Exception({
+            name: HttpStatus[400].name,
+            code: HttpStatus[400].code,
+            message: 'Unable to identify Model.',
+        });
+    }
+    const db = Context.get('db');
+    if (!db) {
+        return Exception({
+            name: HttpStatus[500].name,
+            code: HttpStatus[500].code,
+            message: 'Database not connected.',
+        });
+    }
+    if (!props.query) {
+        return Exception({
+            name: HttpStatus[400].name,
+            code: HttpStatus[400].code,
+            message: 'Search parameters missing.',
+        });
+    }
+    const repository = db.getRepository(model.entity);
+    const queryKeys = ['filter', 'find', 'count', 'exists', 'aggregate', 'distinct', 'group'];
+    const presentKeys = queryKeys.filter((k) => {
+        return k in props.query;
+    });
+    if (presentKeys.length > 1) {
+        return Exception({
+            name: HttpStatus[400].name,
+            code: HttpStatus[400].code,
+            message: `Conflicting search parameters: multiple types provided (${presentKeys.join(', ')}).`,
+        });
+    }
+    let type = props.query.type;
+    if (presentKeys.length === 1) {
+        type = presentKeys[0];
+    }
+    if (!type) {
+        return Exception({
+            name: HttpStatus[400].name,
+            code: HttpStatus[400].code,
+            message: 'Search type not identified. Please provide one of: ' + queryKeys.join(', '),
+        });
+    }
+    try {
+        switch (type) {
+            case 'filter': {
+                const filter = props.query.filter || {};
+                const select = props.query.select || [];
+                const relation = props.query.relation || [];
+                const pagination = props.pagination;
+                const items = await repository.find({
+                    where: filter,
+                    select,
+                    relation,
+                    pagination,
+                });
+                if (props.pagination) {
+                    const totalItems = await repository.count(filter);
+                    const totalPages = Math.ceil(totalItems / (props.pagination.take || 10));
+                    return Success({
+                        items,
+                        totalItems,
+                        totalPages: totalPages > 0 ? totalPages : 0,
+                    });
+                }
+                return Success(items);
+            }
+            case 'find': {
+                const find = props.query.find || {};
+                const select = props.query.select || [];
+                const relation = props.query.relation || [];
+                const result = await repository.findOne({
+                    where: find,
+                    select,
+                    relation,
+                });
+                return Success(result);
+            }
+            case 'count': {
+                const count = props.query.count || {};
+                const result = await repository.count(count);
+                return Success({ count: result });
+            }
+            case 'exists': {
+                const exists = props.query.exists || {};
+                const result = await repository.exists(exists);
+                return Success({ exists: result });
+            }
+            case 'aggregate': {
+                const aggregate = props.query.aggregate;
+                if (!aggregate) {
+                    throw new Error('Aggregate configuration missing.');
+                }
+                const result = await repository.aggregate(aggregate);
+                return Success(result);
+            }
+            case 'distinct': {
+                const distinct = props.query.distinct;
+                if (!distinct) {
+                    throw new Error('Distinct configuration missing.');
+                }
+                const result = await repository.distinct(distinct);
+                return Success(result);
+            }
+            case 'group': {
+                const group = props.query.group;
+                if (!group) {
+                    throw new Error('Group configuration missing.');
+                }
+                const result = await repository.group(group);
+                return Success(result);
+            }
+            default:
+                return Exception({
+                    name: HttpStatus[400].name,
+                    code: HttpStatus[400].code,
+                    message: `Search type '${type}' not understood.`,
+                });
+        }
+    }
+    catch (err) {
+        return Exception({
+            name: HttpStatus[400].name,
+            code: HttpStatus[400].code,
+            message: err.message,
+        });
+    }
+};

package/lib/esm/server/services/insert.d.ts

@@ -0,0 +1,13 @@
+import { HandleInsertProps } from '../../interfaces/controller.js';
+declare const _default: (props: HandleInsertProps) => Promise<{
+    readonly success: true;
+    readonly data: any;
+} | {
+    readonly success: false;
+    readonly error: {
+        name: string;
+        code: number;
+        message: any;
+    };
+}>;
+export default _default;