@ultrade/shared 1.0.0

package/dist/baseModel/base.model.d.ts

@@ -0,0 +1,26 @@
+import { DataSource } from 'typeorm';
+declare class BaseModel {
+    protected dataSource: DataSource;
+    tableName: string;
+    insertion: string;
+    selectCols: string;
+    selectWhere: string;
+    offsets: number;
+    limits: number;
+    orderBy: string;
+    orderIs: string;
+    fromDate: any;
+    toDate: any;
+    updation: string;
+    updateWhere: string;
+    insertPrimaryKey: string;
+    deleteWhere: string;
+    userId: string;
+    constructor(value: string, dataSource: DataSource);
+    SelectAssetData(): Promise<any>;
+    callQuery(query: string, args?: any[]): Promise<any>;
+    deleteFavRecord(): Promise<any>;
+    deleteAssetRecord(pairId: number, address: string): Promise<any>;
+    private resetSelectSettings;
+}
+export default BaseModel;

package/dist/baseModel/index.d.ts

@@ -0,0 +1,2 @@
+import BaseModel from './base.model';
+export default BaseModel;

package/dist/common/auth.helper.d.ts

@@ -0,0 +1,4 @@
+import algosdk from 'algosdk';
+export declare function encodeMessage(msg: string): Uint8Array<ArrayBufferLike>;
+export declare function generateTxnForSign(addr: string, note?: string, encoding?: BufferEncoding): algosdk.Transaction;
+export declare function signTxn(activeAddress: string, data: string, encoding: BufferEncoding, signTransactions: (transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>): Promise<Uint8Array>;

package/dist/common/auth.helper.js

@@ -0,0 +1,367 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("buffer"), require("algosdk"));
+	else if(typeof define === 'function' && define.amd)
+		define(["buffer", "algosdk"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("buffer"), require("algosdk")) : factory(root["buffer"], root["algosdk"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__18__, __WEBPACK_EXTERNAL_MODULE__9709__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 18:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__18__;
+
+/***/ }),
+
+/***/ 696:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.encodeMessage = encodeMessage;
+exports.generateTxnForSign = generateTxnForSign;
+exports.signTxn = signTxn;
+const algosdk_1 = __importDefault(__webpack_require__(9709));
+const Encoding_1 = __webpack_require__(8593);
+function encodeMessage(msg) {
+    return (0, Encoding_1.encodeString)(msg);
+    // removed by dead control flow
+
+    // removed by dead control flow
+
+}
+function generateTxnForSign(addr, note, encoding) {
+    return algosdk_1.default.makePaymentTxnWithSuggestedParamsFromObject({
+        from: addr,
+        to: addr,
+        amount: 0,
+        note: note && new Uint8Array(Buffer.from(note, encoding)),
+        suggestedParams: {
+            fee: 0,
+            firstRound: 1,
+            lastRound: 2,
+            genesisHash: 'SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=',
+            genesisID: 'testnet-v1.0',
+        },
+    });
+}
+function signTxn(activeAddress, data, encoding, signTransactions) {
+    return signTransaction(generateTxnForSign(activeAddress, data, encoding), signTransactions);
+}
+async function signTransaction(rawTxn, signTransactions) {
+    const encodedTransaction = algosdk_1.default.encodeUnsignedTransaction(rawTxn);
+    const signedTransactions = await signTransactions([encodedTransaction]);
+    const decodedTxns = algosdk_1.default.decodeSignedTransaction(signedTransactions[0]);
+    const signature = new Uint8Array(decodedTxns.sig);
+    return signature;
+}
+
+
+/***/ }),
+
+/***/ 8593:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.decodeAddress = exports.encodeAddress = void 0;
+exports.concatArrays = concatArrays;
+exports.packData = packData;
+exports.unpackData = unpackData;
+exports.encodeArgArray = encodeArgArray;
+exports.encodeString = encodeString;
+exports.decodeString = decodeString;
+exports.encode32Bytes = encode32Bytes;
+exports.encodeUint64 = encodeUint64;
+exports.decodeUint64 = decodeUint64;
+exports.encodeBase64 = encodeBase64;
+exports.decodeBase64 = decodeBase64;
+exports.compareArrays = compareArrays;
+exports.getDeltaUint = getDeltaUint;
+exports.getDeltaBytes = getDeltaBytes;
+exports.toUnix = toUnix;
+exports.fromUnix = fromUnix;
+const algosdk_1 = __importStar(__webpack_require__(9709));
+// import sha512 from "js-sha512"
+const buffer_1 = __webpack_require__(18);
+function concatArrays(arrays) {
+    return arrays.reduce((a, b) => Uint8Array.from([...a, ...b]));
+}
+function packData(value, format) {
+    const chunks = [];
+    for (const [name, type] of Object.entries(format)) {
+        const v = value[name];
+        if (v === undefined) {
+            throw new Error(`Key ${name} missing from value`);
+        }
+        switch (type.type) {
+            case 'address':
+                if (v instanceof Uint8Array && v.length == 32) {
+                    chunks.push(v);
+                    break;
+                }
+                else if (typeof v === 'string') {
+                    chunks.push((0, algosdk_1.decodeAddress)(v).publicKey);
+                }
+                else {
+                    throw new Error(`${name}: Expected address, got ${v}`);
+                }
+                break;
+            case 'bytes':
+                if (v instanceof Uint8Array) {
+                    if (v.length == type.size) {
+                        chunks.push(v);
+                        break;
+                    }
+                    else {
+                        throw new Error(`${name}: Bytes length is wrong, expected ${type.size}, got ${v.length}`);
+                    }
+                }
+                else {
+                    throw new Error(`${name}: Expected bytes[${type.size}], got ${v}`);
+                }
+            case 'double':
+                if (typeof v === 'number') {
+                    const bytes = new ArrayBuffer(8);
+                    buffer_1.Buffer.from(bytes).writeDoubleLE(v, 0);
+                    chunks.push(new Uint8Array(bytes));
+                    break;
+                }
+                else {
+                    throw new Error(`${name}: Expected double, got ${v}`);
+                }
+            case 'number':
+            case 'uint':
+                if (typeof v === 'bigint' || typeof v === 'number') {
+                    chunks.push(encodeUint64(v));
+                    break;
+                }
+                else {
+                    throw new Error(`${name}: Expected uint or number, got ${v}`);
+                }
+            case 'string':
+                if (typeof v === 'string') {
+                    const str = encodeString(v);
+                    if (str.length == type.size) {
+                        chunks.push(str);
+                        break;
+                    }
+                    else {
+                        throw new Error(`${name}: Expected string length ${type.size}, got string length ${str.length}`);
+                    }
+                }
+                else {
+                    throw new Error(`${name}: Expected string length ${type.size}, got ${v}`);
+                }
+        }
+    }
+    return concatArrays(chunks);
+}
+function unpackData(data, format) {
+    const result = new Map();
+    let index = 0;
+    for (const [name, type] of Object.entries(format)) {
+        if (index >= data.length) {
+            throw new Error('Array index out of bounds');
+        }
+        let value;
+        switch (type.type) {
+            case 'address':
+                value = (0, algosdk_1.encodeAddress)(data.slice(index, index + 32));
+                index += 32;
+                break;
+            case 'bytes':
+                value = data.slice(index, index + type.size);
+                index += type.size;
+                break;
+            case 'double':
+                value = buffer_1.Buffer.from(data.slice(index, index + 8)).readDoubleLE(0);
+                index += 8;
+                break;
+            case 'number':
+                value = Number(decodeUint64(data.slice(index, index + 8)));
+                index += 8;
+                break;
+            case 'uint':
+                value = decodeUint64(data.slice(index, index + 8));
+                index += 8;
+                break;
+            case 'string':
+                value = decodeString(data.slice(index, index + type.size));
+                index += type.size;
+                break;
+        }
+        result.set(name, value);
+    }
+    return Object.fromEntries(result);
+}
+function encodeArgArray(params) {
+    return params.map(param => {
+        if (param instanceof Uint8Array)
+            return new Uint8Array(param);
+        if (typeof param === "string")
+            return encodeString(param);
+        if (typeof param === "boolean")
+            param = BigInt(param ? 1 : 0);
+        if (typeof param === "number")
+            param = BigInt(param);
+        return encodeUint64(param);
+    });
+}
+function encodeString(value) {
+    return new Uint8Array(buffer_1.Buffer.from(value));
+}
+function decodeString(value) {
+    return buffer_1.Buffer.from(value).toString('utf-8');
+}
+function encode32Bytes(value) {
+    const valueButes = algosdk_1.default.encodeUint64(value);
+    return concatArrays([new Uint8Array(32 - valueButes.length), valueButes]);
+}
+function encodeUint64(value) {
+    const bytes = buffer_1.Buffer.alloc(8);
+    for (let index = 0; index < 8; index++)
+        bytes[7 - index] = Number((BigInt(value) >> BigInt(index * 8)) & BigInt(0xFF));
+    return new Uint8Array(bytes);
+}
+function decodeUint64(value) {
+    let num = BigInt(0);
+    for (let index = 0; index < 8 && value?.length; index++)
+        num = (num << BigInt(8)) | BigInt(value[index]);
+    return num;
+}
+function encodeBase64(value) {
+    return buffer_1.Buffer.from(value).toString('base64');
+}
+function decodeBase64(value) {
+    return buffer_1.Buffer.from(value, 'base64');
+}
+// export const sha256HashLength = 32
+// export function sha256Hash(arr: sha512.Message): Uint8Array {
+//     return new Uint8Array(sha512.sha512_256.arrayBuffer(arr))
+// }
+// export function encodeApplicationAddress(id: number): Address {
+//     const APP_ID_PREFIX = Buffer.from('appID');
+//     const toBeSigned = concatArrays([APP_ID_PREFIX, encodeUint64(BigInt(id))]);
+//     return encodeAddress(sha256Hash(toBeSigned));
+// }
+function compareArrays(a, b) {
+    return a.length === b.length && a.reduce((equal, item, index) => equal && item === b[index], true);
+}
+function getDelta(response, key) {
+    const delta = response['global-state-delta'].find((v) => v.key === key);
+    if (delta === undefined)
+        return undefined;
+    return delta['value'];
+}
+function getDeltaUint(response, key) {
+    const delta = getDelta(response, key);
+    if (delta === undefined)
+        return undefined;
+    return BigInt(delta['uint']);
+}
+function getDeltaBytes(response, key) {
+    const delta = getDelta(response, key);
+    if (delta === undefined)
+        return undefined;
+    return decodeBase64(delta['bytes']);
+}
+function toUnix(date) {
+    return Math.floor(date.getTime() / 1000);
+}
+function fromUnix(timestamp) {
+    return new Date(timestamp * 1000);
+}
+var algosdk_2 = __webpack_require__(9709);
+Object.defineProperty(exports, "encodeAddress", ({ enumerable: true, get: function () { return algosdk_2.encodeAddress; } }));
+Object.defineProperty(exports, "decodeAddress", ({ enumerable: true, get: function () { return algosdk_2.decodeAddress; } }));
+
+
+/***/ }),
+
+/***/ 9709:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__9709__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(696);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/awsKms.d.ts

@@ -0,0 +1,2 @@
+export declare const encrypt: (string: string) => Promise<string>;
+export declare const decrypt: (encryptedString: string) => Promise<string>;

package/dist/common/awsKms.js

@@ -0,0 +1,265 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@aws-sdk/client-kms"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@aws-sdk/client-kms"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@aws-sdk/client-kms")) : factory(root["@aws-sdk/client-kms"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__7818__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 298:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Logger = void 0;
+const node_process_1 = __webpack_require__(1708);
+class Logger {
+    constructor(prefix, disabled) {
+        this._timeLabels = new Map();
+        this._prefix = prefix;
+        this.disabled = disabled;
+    }
+    log(...args) {
+        if (this.disabled) {
+            return;
+        }
+        try {
+            this._prefix
+                ? console.log(this.prefixLabel(this._prefix), ...this.formatArgs(args))
+                : console.log(...this.formatArgs(args));
+        }
+        catch (error) {
+            console.log('Error on formating args', error);
+            console.log('Args =>', ...args);
+        }
+    }
+    logWarning(message) {
+        console.log(this.toYellow(message));
+    }
+    getUniqueTimeLabel(label) {
+        const timeLabel = `[${Math.random() * Math.pow(10, 18)}] ${label}`;
+        return timeLabel;
+    }
+    time(label) {
+        if (this._timeLabels.has(label)) {
+            console.warn(`Label '${label}' already exists for logger.time()`);
+            return;
+        }
+        const start = node_process_1.hrtime.bigint();
+        this._timeLabels.set(label, start);
+    }
+    timeEnd(label) {
+        if (!this._timeLabels.has(label)) {
+            console.warn(`Label '${label}' does not exist for logger.time()`);
+            return 0;
+        }
+        const start = this._timeLabels.get(label);
+        const end = node_process_1.hrtime.bigint();
+        const diff = +(Number(end - start) / 1000000).toFixed(2);
+        const color = process.env.LOGGING_OBJECT_INLINE !== "false"
+            ? this.noColor
+            : (diff > 100 ? this.toRed : this.toYellow);
+        // console.log(' ');
+        if (diff > 100 || (label.includes('update24hStat') && diff > 25)) {
+            this.log(`Benchmark took ${color(diff)} milliseconds for ${color(label)}`);
+        }
+        this._timeLabels.delete(label);
+        return +diff;
+    }
+    logRabbit(...args) {
+        this.log(...this.formatArgs(["[Rabbit]", ...args]));
+    }
+    logPair(...args) {
+        this.log(...this.formatArgs(args, "Pair"));
+    }
+    logPairTime(pair, label) {
+        this.time(`${this.prefixLabel("Pair", pair)} ${label}`);
+    }
+    logPairTimeEnd(pair, label) {
+        this.timeEnd(`${this.prefixLabel("Pair", pair)} ${label}`);
+    }
+    logOrder(...args) {
+        this.log(...this.formatArgs(args, "OrderID"));
+    }
+    logOrderTime(id, label) {
+        this.time(`${this.prefixLabel("OrderID", id)} ${label}`);
+    }
+    logOrderTimeEnd(id, label) {
+        this.timeEnd(`${this.prefixLabel("OrderID", id)} ${label}`);
+    }
+    logTrade(...args) {
+        this.log(...this.formatArgs(args, "TradeID"));
+    }
+    logCompany(...args) {
+        this.log(...this.formatArgs(args, "CompanyID"));
+    }
+    logTradeTime(id, label) {
+        this.time(`${this.prefixLabel("TradeID", id)} ${label}`);
+    }
+    logTradeTimeEnd(id, label) {
+        this.timeEnd(`${this.prefixLabel("TradeID", id)} ${label}`);
+    }
+    logOperation(...args) {
+        this.log(...this.formatArgs(args, "OperationID"));
+    }
+    logVaa(...args) {
+        this.log(...this.formatArgs(args, "VaaId"));
+    }
+    logRequest(event, maskFunction = (_, body) => body) {
+        const { httpMethod, path, queryStringParameters, body } = event;
+        this.log(httpMethod, path, { queryStringParameters, body: maskFunction(path, body) });
+    }
+    formatArgs(args, prefix = null) {
+        return args.map((value, index) => {
+            if (index === 0 && typeof value === "string" && prefix === "Pair") {
+                return `[${value}]`;
+            }
+            if (index === 0 && !!prefix) {
+                return this.prefixLabel(prefix, typeof value === "object" ? JSON.stringify(value) : value);
+            }
+            if (typeof value === "object" && process.env.LOGGING_OBJECT_INLINE !== "false") {
+                return JSON.stringify(value);
+            }
+            return value;
+        });
+    }
+    prefixLabel(prefix, value) {
+        return value ? `[${prefix}: ${value}]` : `[${prefix}]`;
+    }
+    toYellow(value) {
+        return `\x1b[33m${value}\x1b[0m`;
+    }
+    toRed(value) {
+        return `\x1b[31m${value}\x1b[0m`;
+    }
+    noColor(value) {
+        return value;
+    }
+}
+exports.Logger = Logger;
+exports["default"] = new Logger();
+
+
+/***/ }),
+
+/***/ 1708:
+/***/ ((module) => {
+
+module.exports = require("node:process");
+
+/***/ }),
+
+/***/ 7818:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__7818__;
+
+/***/ }),
+
+/***/ 8980:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.decrypt = exports.encrypt = void 0;
+const client_kms_1 = __webpack_require__(7818);
+const logger_1 = __importDefault(__webpack_require__(298));
+const encrypt = async (string) => {
+    if (process.env.ENVIRONMENT === 'LOCAL') {
+        logger_1.default.logWarning('WARNING: AWS KMS encryption is bypassed in local environment.');
+        return string;
+    }
+    const input = {
+        KeyId: process.env.SOCIAL_SECRET_KEY_ID,
+        Plaintext: Buffer.from(string),
+    };
+    const command = new client_kms_1.EncryptCommand(input);
+    const result = await sendKmsCommand(command);
+    return Buffer.from(result.CiphertextBlob).toString('base64');
+};
+exports.encrypt = encrypt;
+const decrypt = async (encryptedString) => {
+    if (process.env.ENVIRONMENT === 'LOCAL') {
+        logger_1.default.logWarning('WARNING: AWS KMS decryption is bypassed in local environment.');
+        return encryptedString;
+    }
+    const input = {
+        KeyId: process.env.SOCIAL_SECRET_KEY_ID,
+        CiphertextBlob: Buffer.from(encryptedString, 'base64'),
+    };
+    const command = new client_kms_1.DecryptCommand(input);
+    const result = await sendKmsCommand(command);
+    return new TextDecoder().decode(result.Plaintext);
+};
+exports.decrypt = decrypt;
+const sendKmsCommand = async (command) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const client = new client_kms_1.KMSClient({ region: 'us-east-1' });
+            client.send(command, (err, data) => {
+                if (err) {
+                    console.log('-----error in KMS operation---------', err);
+                    reject(err);
+                }
+                else {
+                    console.log('KMS command was successfully sent');
+                    resolve(data);
+                }
+            });
+        }
+        catch (error) {
+            console.log('KMSClient error', error);
+            reject(error);
+        }
+    });
+};
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(8980);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});