seller-base-service 0.0.1-security → 0.1.12

package/dist/notification/index.js

@@ -0,0 +1,2373 @@
+module.exports =
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "KBg6");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "6Xvj":
+/***/ (function(module, exports) {
+
+module.exports = require("seller-base");
+
+/***/ }),
+
+/***/ "KBg6":
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+
+// EXTERNAL MODULE: external "seller-base"
+var external_seller_base_ = __webpack_require__("6Xvj");
+
+// CONCATENATED MODULE: ./src/modules/notification/service.ts
+var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+
+
+class service_NotificationService extends external_seller_base_["ServiceModule"] {
+  constructor(service) {
+    super(service);
+    this.name = 'notification';
+    service_NotificationService.$instance = this;
+  }
+  /**
+   * 获取notification 列表
+   * @see https://api.seller.shopee.io/project/1288/interface/api/39488
+   * @param params NotificationRequest
+   */
+
+
+  getNotificationList(params, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.api.v1Request.get("/notification/list", {
+        params: external_seller_base_["Base"].Utility.snakeCaseKeys(params),
+        skipError: !!(config && config.skipError)
+      });
+    });
+  }
+  /**
+   * 标记所有为已读
+   * @see https://api.seller.shopee.io/project/1288/interface/api/39984
+   * @param data
+   */
+
+
+  markAllAsRead(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.api.v1Request.post("/notification/mark_all_as_read", data);
+    });
+  }
+  /**
+   * 更新notification状态
+   * @see https://api.seller.shopee.io/project/1288/interface/api/39504
+   * @param data  updateList: UpdateNotificationList[]
+   */
+
+
+  updateNotificationStatus(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+      return this.api.v1Request.post("/notification/status", data);
+    });
+  }
+  /**
+   * 获取notification未读消息，包括下面folder
+   * @see https://api.seller.shopee.io/project/1288/interface/api/39496
+   * @param params NotificationCountsRequest
+   */
+
+
+  getNotificationCounts(params, config) {
+    return this.api.v1Request.get("/notification/count", {
+      skipError: config.skipError,
+      params
+    });
+  }
+  /**
+   * 拉取最新notification未读消息数量
+   * @see https://api.seller.shopee.io/project/1288/interface/api/39992
+   */
+
+
+  pullNotificationStatus() {
+    return this.api.v1Request.get("/notification/poll_status", {
+      skipError: true
+    });
+  }
+  /**
+   * 获取group信息
+   * @see https://api.seller.shopee.io/project/1288/interface/api/40000
+   * @param params: NotificationGroupRequest
+   */
+
+
+  getNotificationGroup(params) {
+    return this.api.v1Request.get("/notification/group", {
+      params: external_seller_base_["Base"].Utility.snakeCaseKeys(params)
+    });
+  }
+  /**
+   * 获取有权限的folder信息
+   * @see https://api.seller.shopee.io/project/1288/interface/api/42018
+   */
+
+
+  getFolders(config) {
+    return this.api.v1Request.get("/notification/folder", {
+      skipError: config.skipError
+    });
+  }
+
+}
+// CONCATENATED MODULE: ./src/modules/notification/types.ts
+var Status;
+
+(function (Status) {
+  Status[Status["UNREAD"] = 1] = "UNREAD";
+  Status[Status["READ"] = 2] = "READ";
+  Status[Status["DELETE"] = 3] = "DELETE";
+})(Status || (Status = {}));
+// CONCATENATED MODULE: ./src/modules/notification/constants.ts
+const FoldersConfig = [{
+  to: '/portal/notification/',
+  folderKey: undefined,
+  type: null,
+  category: null,
+  transifyKey: 'sp_pc_notification_label_all_notification',
+  trackKey: 'all_notifications',
+  trackImpressionKey: 'all_notifications'
+}, {
+  to: '/portal/notification/order-updates/',
+  folderKey: 'order-updates',
+  type: 1,
+  category: [17, 26],
+  transifyKey: 'sp_pc_notification_label_order_updates',
+  trackKey: 'order_updates',
+  trackImpressionKey: 'order_updates'
+}, {
+  to: '/portal/notification/rating-updates/',
+  folderKey: 'rating-updates',
+  type: 2,
+  category: 18,
+  transifyKey: 'sp_pc_notification_label_rating_updates',
+  trackKey: 'rating',
+  trackImpressionKey: 'rating'
+}, {
+  to: '/portal/notification/return-refund/',
+  folderKey: 'return-refund',
+  type: 3,
+  category: 19,
+  transifyKey: 'sp_pc_notification_label_return_and_refund_updates',
+  trackKey: 'return_refund',
+  trackImpressionKey: 'return_refund'
+}, {
+  to: '/portal/notification/listing-updates/',
+  folderKey: 'listing-updates',
+  type: 4,
+  category: [20, 27],
+  transifyKey: 'sp_pc_notification_label_listing_updates',
+  trackKey: 'listing',
+  trackImpressionKey: 'listing'
+}, {
+  to: '/portal/notification/sbs-updates/',
+  folderKey: 'sbs-updates',
+  type: 9,
+  category: [15, 16],
+  transifyKey: 'sp_pc_notification_label_sbs_updates',
+  trackKey: 'sbs_updates',
+  trackImpressionKey: 'sbs_updates'
+}, {
+  to: '/portal/notification/wallet-updates/',
+  folderKey: 'wallet-updates',
+  type: 5,
+  category: [21, 28],
+  transifyKey: 'sp_pc_notification_label_wallet_updates',
+  trackKey: 'seller_wallet',
+  trackImpressionKey: 'seller_wallet'
+}, {
+  to: '/portal/notification/marketing-center/',
+  folderKey: 'marketing-center',
+  type: 6,
+  category: [9, 14, 22],
+  transifyKey: 'sp_pc_notification_label_marketing_centre_updates',
+  trackKey: 'marketing_center',
+  trackImpressionKey: 'marketing_center'
+}, {
+  to: '/portal/notification/performance/',
+  folderKey: 'performance',
+  type: 7,
+  category: [23, 29],
+  transifyKey: 'sp_pc_notification_label_performance_updates',
+  trackKey: 'perfomrance',
+  trackImpressionKey: 'perfomrance'
+}, {
+  to: '/portal/notification/shopee-updates/',
+  folderKey: 'shopee-updates',
+  type: 8,
+  category: [6, 24, 30, 31],
+  transifyKey: 'sp_pc_notification_label_shopee_updates',
+  trackKey: 'shopee_updates',
+  trackImpressionKey: 'shopee_updates'
+}];
+const ActionTypes = {
+  NEW_ORDER: 1,
+  OUT_STOCK: 2,
+  DUP_LOGIN: 3,
+  INVALID_ITEM: 4,
+  ORDER_PAID: 5,
+  ORDER_COMPLETE: 7,
+  CHAT_MSG: 8,
+  NEW_ACTIVITY: 11,
+  OFFER_STATUS: 12,
+  NEW_ITEM: 14,
+  ORDER_CANCEL: 15,
+  BAN_ITEM: 16,
+  ACCOUNT_BAN: 17,
+  CHECKOUT_PAID: 18,
+  RETURN_UPDATE: 19,
+  CHECKOUT_CANCEL: 20,
+  CHECKOUT_UPDATE: 21,
+  ORDER_UPDATE: 22,
+  EMAIL_VERIFIED: 23,
+  ORDER_TOSHIP: 24,
+  ORDER_TORECEIVE: 25,
+  CHECKOUT_TOSHIP: 26,
+  USERINFO_UPDATEED: 27,
+  NEW_FEED: 28,
+  SHOPINFO_UPDATED: 29,
+  OUT_STOCK_VARIATION: 30,
+  ACCOUNT_FROZEN: 31,
+  ACCOUNT_UNFROZEN: 32,
+  CHAT_UPDATE: 33,
+  CART_UPDATE: 34,
+  CHAT_CLEARED: 35,
+  ACTION_REQUIRE_REMOVED: 36,
+  CHAT_UNREAD: 37,
+  // System Message notifications
+  ACTION_SYSTEM_MESSAGE: 99,
+  SELLER_PAY_CONFIRM: 100,
+  BUYER_UNDERPAY: 101,
+  BUYER_PAYER_VERI_FAIL: 102,
+  BUYER_CHECKOUT_CANCEL_UNDERPAY: 103,
+  SELLER_ORDER_CANCEL_NOPAY: 104,
+  BUYER_CHECKOUT_CANCEL_PAY_VERI_FAIL: 105,
+  BUYER_ORDER_CANCEL_NOPAY: 106,
+  BUYER_BEFORE_ESCROW_RELEASE: 107,
+  SELLER_ESCROW_EXTEND: 108,
+  BUYER_ORDER_CONFIRM_REMINDER: 109,
+  BUYER_ORDER_CANCEL_BANK: 110,
+  BUYER_ORDER_CANCEL_CARD: 111,
+  BUYER_REFUND_BANK: 112,
+  BUYER_REFUND_CARD: 113,
+  SELLER_RETURN_REQUEST: 114,
+  SELLER_BEFORE_RELEASE_REFUND: 115,
+  BUYER_DISPUTE: 116,
+  NEED_PROOF: 117,
+  SELLER_MEDIATION_RESULT: 118,
+  BUYER_OVERPAID_BANK: 119,
+  BUYER_NONRECEIPT_DISPUTE: 120,
+  SELLER_BANK_INFO: 121,
+  BUYER_REFUND_CREATED_BANK: 122,
+  SELLER_ORDER_CANCEL_BY_BUYER: 123,
+  BUYER_ORDER_SHIPPED: 124,
+  BUYER_REFUND_CREATED_CARD: 125,
+  SELLER_BANK_INFO_REMINDER: 126,
+  BUYER_BANK_INFO_REMINDER: 127,
+  BUYER_RETURN_APPROVED: 128,
+  BUYER_PAY_CONFIRM: 129,
+  BUYER_UNDERPAY_REMINDER: 130,
+  BUYER_NOPAY_REMINDER: 131,
+  SELLER_NEW_ORDER_ESCROW: 132,
+  SELLER_NEW_ORDER_OFFLINE: 133,
+  BUYER_BANNED_ITEM: 134,
+  BUYER_BEFORE_ESCROW_RELEASE_EXTEND: 135,
+  ORDER_COMPLETE_BANK: 136,
+  ORDER_COMPLETE_NO_BANK: 137,
+  SELLER_BANKINFO_REJECTED: 138,
+  BUYER_BANKINFO_REJECTED: 139,
+  SELLER_NONRECEIPT_RETURN_REQUEST: 140,
+  BUYER_NONRECEIPT_RETURN_REQUEST: 141,
+  BUYER_MEDIATION_RESULT: 142,
+  BUYER_NOTRECEIVE_RETUERN_DISPUTE: 143,
+  SELLER_NOTRECEIVE_RETUERN_DISPUTE: 144,
+  BUYER_REFUND_CREATED_BT: 145,
+  SELLER_ORDER_COMPLETE_OFFLINE: 146,
+  PROMO_CODE_GENERATED: 147,
+  CUSTOMIZED_ACTION: 148,
+  USER_BANKINFO_REJECTED: 149,
+  ORDER_CHANGE_OFFLINE_TO_ESCROW: 150,
+  CUSTOMIZED_ACTION_PURE: 151,
+  CUSTOMIZED_PUSHNOTI_PURE: 152,
+  // add for logistics
+  SELLER_NEW_ORDER_COD: 153,
+  ORDER_CHANGE_OFFLINE_TO_COD: 154,
+  BUYER_ORDER_COD_APPROVE: 155,
+  SELLER_ORDER_COD_APPROVE: 156,
+  BUYER_ORDER_COD_REJECT: 157,
+  SELLER_ORDER_COD_REJECT: 158,
+  BUYER_REJECT_COD_DELIVERY: 159,
+  BUYER_ORDER_CANCEL_COD: 160,
+  LOGISTICS_CONFIRMED_DELIVERY_BUYER: 161,
+  LOGISTICS_CONFIRMED_DELIVERY_SELLER: 162,
+  PICKUP_DEADLINE: 163,
+  SELLER_ORDER_CANCEL_PICKUP_FAILED: 164,
+  SELLER_REJECT_COD_DELIVERY: 165,
+  BUYER_REJECT_NOCOD_DELIVERY: 166,
+  SELLER_REJECT_NOCOD_DELIVERY: 167,
+  PICKUP_REMINDER: 168,
+  PICKUP_24HOURS: 169,
+  PICKUP_THEDAY: 170,
+  PICKUP_RETRY_BEFOREDEADLINE: 171,
+  SHIPOUT_24HOUR: 172,
+  SHIPOUT_DEADLINE: 173,
+  BUYER_SHIPPINGFEE_REVISED: 174,
+  BUYER_PICKUP_SUCCEED: 175,
+  BUYER_ORDER_COD_CANCEL_PICKUP_FAILED: 176,
+  BUYER_ORDER_NOCOD_CANCEL_PICKUP_FAILED: 177,
+  PICKUP_ARRANGED: 178,
+  SELLER_ORDER_CANCEL_ARRANGEPICKUP_FAIL: 179,
+  BUYER_ORDER_CANCEL_ARRANGEPICKUP_FAIL: 180,
+  SELLER_ARRANGEPICKUP_EXT_REMINDER: 181,
+  SELLER_ARRANGEPICKUP_DEADLINE_REMINDER: 182,
+  SHOP_DESCRIPTION_BANNED: 183,
+  SHOP_COVERS_BANNED: 184,
+  SELLER_INACTIVE_FIRST: 185,
+  SELLER_INACTIVE_SECOND: 186,
+  SELLER_PICKUP_COUNTER_CLOSE: 187,
+  BUYER_TW711_DELIVERED_COUNTER: 188,
+  SELLER_PAY_NOBANK_CONFIRM: 189,
+  BUYER_TW711_DELIVERED_REMINDER: 190,
+  SELLER_TW_COLLECT_NOBUYER: 191,
+  BUYER_FM_DELIVERED_COUNTER: 192,
+  SELLER_ORDER_CANCEL_AFTER_ESCROW: 193,
+  BUYER_ORDER_CANCEL_AFTER_ESCROW: 194,
+  BUYER_INDO_JOBRESUBMIT_WAYBILL: 195,
+  SELLER_RESELECT_COUNTER_COMPLETED: 196,
+  SELLER_DELIVERY_CODE_EXPIRED: 197,
+  BUYER_DELIVERY_DELAYED_VOUCHER: 198,
+  BUYER_RETURN_APPROVED_CARD: 199,
+  CRM_SELLER_INACTIVE_SEVEN: 401,
+  CRM_SELLER_INACTIVE_ELEVEN: 402,
+  CRM_SELLER_INACTIVE_FORTEEN: 403,
+  CRM_CHAT_REMINDER: 404,
+  CRM_OFFER_REMINDER: 405,
+  CRM_ORDER_REMINDER: 406,
+  CRM_ORDER_COD_REMINDER: 407,
+  BUYER_ORDER_CANCEL_NO_BANK: 408,
+  BUYER_RETURN_APPROVED_NO_BA: 409,
+  BUYER_COD_BANNED: 410,
+  BUYER_COD_RELEASED: 411,
+  SELLER_TW_TO_SHIP: 412,
+  SELLER_TW_TO_DROP: 413,
+  BUYER_ORDER_CANCEL_BY_BUYER: 414,
+  SMART_GROUP_MESSAGE: 415,
+  SELLER_ORDER_COMPLETE_RATING: 416,
+  BUYER_ORDER_COMPLETE_RATING: 417,
+  SELLER_RATING_3DAY: 418,
+  BUYER_RATING_3DAY: 419,
+  SELLER_RATING_BUYER_RATED: 420,
+  BUYER_RATING_SELLER_RATED: 421,
+  SELLER_VIEW_BOTH_RATED: 422,
+  SELLER_VIEW_BUYER_RATED: 432,
+  SELLER_VIEW_BUYER_CHANGED: 433,
+  SELLER_CONFIRM_AUTO_REFUND: 434,
+  SELLER_BE_CANCELORDER_REMINDER: 435,
+  BUYER_REFUND_PAYOUT_CARD: 436,
+  LOGISTICS_DELIVERY_FAILED_BUYER: 437,
+  SELLER_RETURN_PICKUPCOUNTER_CLOSE: 438,
+  SELLER_BE_AUTO_CANCEL: 439,
+  DISPUTE_RATING_SUCC: 440,
+  RATING_DISPUTED: 441,
+  CRM_BUYER_CART: 442,
+  CRM_BUYER_CART_STOCK: 443,
+  CRM_BUYER_CART_DISCOUNT: 444,
+  SELLER_FIRST_LISTING_TW: 445,
+  HM_SELLER_ARRANGE_PICKUP: 446,
+  HM_ORDER_AUTO_CANCEL: 447,
+  HM_SELLER_REMINDER_TO_SHIP: 448,
+  SELLER_ESCROW_RELEASED_ID_DAYS: 449,
+  BUYER_PUSH_SELLER_SO_COD: 450,
+  BUYER_PUSH_SELLER_SO_NONCOD: 451,
+  BUYER_CAN_CANCEL_REMINDER_NONCOD: 452,
+  BUYER_CAN_CANCEL_REMINDER_COD: 453,
+  SELLER_RETURN_RESELECT_TW_711: 741,
+  // trigger email & sms
+  BUYER_OFFER_DECLINE: 200,
+  BUYER_OFFER_ACCEPT: 201,
+  SELLER_OFFER_NEW: 202,
+  BUYER_PAY_CONFIRM_CARD: 203,
+  BUYER_RETURN_REQUEST: 204,
+  BUYER_PAY_CONFIRM_BANK: 206,
+  ACCOUNT_DELETE: 207,
+  PASSWORD_CHANGED: 208,
+  BUYER_PAY_CHOOSE_BANK: 209,
+  SELLER_ESCROW_RELEASED: 210,
+  SELLER_OFFER_CANCEL: 211,
+  SELLER_DISPUTE: 212,
+  SELLER_NONRECEIPT_DISPUTE: 213,
+  SELLER_ORDER_CANCEL: 214,
+  SELLER_CONFIRM_RETURN: 215,
+  SELLER_CANCEL_RETURN: 216,
+  BUYER_PAY_CONFIRM_OFFLINE: 217,
+  SELLER_FIRST_LISTING: 218,
+  SELLER_PAY_CONFIRM_OFFLINE: 219,
+  WEB_REGISTRATION: 220,
+  SELLER_CONTACT_LOGISTICS_TW: 221,
+  SELLER_ESCROW_RELEASED_ID: 222,
+  ACTIVITY_FOLLOW_YOU: 300,
+  ACTIVITY_AT_YOU_IN_COMMENT: 301,
+  ACTIVITY_COMMENT_YOUR_ITEM: 302,
+  ACTIVITY_CONTACT_REGISTERED: 303,
+  ACTIVITY_ITEM_RATED: 304,
+  ACTIVITY_CUSTOMIZED_ACTIVITY: 305,
+  ACTIVITY_AT_YOU_IN_FEED_CMT: 306,
+  ACTIVITY_COMMENT_YOUR_FEED: 307,
+  // ACTIVITY_S_VIEW_BOTH_RATED: 308,
+  ACTIVITY_B_VIEW_BOTH_RATED: 309,
+  // ACTIVITY_S_VIEW_BUYER_RATED: 310,
+  ACTIVITY_B_VIEW_SELLER_RATED: 311,
+  // ACTIVITY_S_VIEW_BUYER_CHANGED: 312,
+  ACTIVITY_B_VIEW_SELLER_CHANGED: 313,
+  SELLER_PENALTY_POINT: 551,
+  SELLER_PENALTY_TIER: 552,
+  SELLER_PENALTY_POINT_REMOVE: 554,
+  SELLER_BUYERCANCEL_REQUESTED: 520,
+  SELLER_BUYERCANCEL_WITHDRAW: 521,
+  SELLER_BUYERCANCEL_ACCEPT: 522,
+  SHOP_FLASHSALE_CANCELLED: 1027,
+  SHOP_FLASHSALE_PRODUCT_PROMOTED: 1028,
+  SHOP_FLASHSALE_PRODUCT_REJECTED: 1029,
+  SHOP_FLASHSALE_SHOP_REJECTED: 1030,
+  SHOP_FLASHSALE_CANCELLED_SG: 1037,
+  SHOP_FLASHSALE_PRODUCT_PROMOTED_SG: 1038,
+  SHOP_FLASHSALE_PRODUCT_REJECTED_SG: 1039,
+  SHOP_FLASHSALE_SHOP_REJECTED_SG: 1040,
+  SHOP_FLASHSALE_CANCELLED_MY: 1041,
+  SHOP_FLASHSALE_PRODUCT_PROMOTED_MY: 1042,
+  SHOP_FLASHSALE_PRODUCT_REJECTED_MY: 1043,
+  SHOP_FLASHSALE_SHOP_REJECTED_MY: 1044,
+  BUYER_MEDIATION_RESULT_DRC: 1118,
+  SELLER_MEDIATION_RESULT_DRC: 1119
+};
+const ActionRedirectTypes = {
+  REDIRECT_NONE: 0,
+  REDIRECT_ORDERS_DETAIL: 1,
+  REDIRECT_MY_PRODUCTS: 2,
+  REDIRECT_MY_INCOME: 3,
+  REDIRECT_ORDERS_RETURNREFUND: 4,
+  REDIRECT_ORDERS_CANCEL: 5,
+  REDIRECT_OUTOF_STOCK: 6,
+  // REDIRECT_REFUND_SELLERCANCEL: 7,
+  REDIRECT_PURE_REFUND: 8,
+  REDIRECT_NEW_WEB_PAGE: 10,
+  REDIRECT_UPLOAD_RECEIPT_PAGE: 11,
+  REDIRECT_SHOPING_CART: 12,
+  REDIRECT_BUNCH_ORDERS_DETAIL: 13,
+  // REDIRECT_BUY_PAGE: 14,
+  // REDIRECT_CHAT_PAGE: 15,
+  REDIRECT_ORDER_CHAT_PAGE: 16,
+  // REDIRECT_PRODUCT_OFFER_CHAT_PAGE: 17,
+  REDIRECT_RELATED_PRODUCT_PAGE: 18,
+  REDIRECT_CREDIT_CARD_PAYMENT_PAGE: 19,
+  REDIRECT_MY_WALLET: 20,
+  REDIRECT_EDIT_SHOP_PROFILE: 21,
+  REDIRECT_APP_PATH: 22,
+  REDIRECT_MY_ACCOUNT: 23
+};
+const AppPath = {
+  CHAT_LIST: 'chatList',
+  MY_ACCOUNT: 'myAccount',
+  EDIT_PROFILE: 'editProfile',
+  SOCIAL_ACCOUNT: 'socialAccount',
+  SETTINGS: 'settings',
+  HOME_FEEDS: 'homeFeed',
+  HOME: 'home',
+  CHAT: 'chat',
+  INCOME: 'income',
+  SELLER_ASSISTANT: 'sellerAssistant',
+  NOTIFICATION: 'notification',
+  PENALTY: 'penalty'
+};
+const RedirectTypePreferred = [ActionRedirectTypes.REDIRECT_APP_PATH, ActionRedirectTypes.REDIRECT_BUNCH_ORDERS_DETAIL, ActionRedirectTypes.REDIRECT_PURE_REFUND];
+const ActionCategory = {
+  ORDER_UPDATES: [17, 26],
+  RATING: 18,
+  RETURN_AND_REFUND: 19,
+  LISTING_UPDATES: [20, 27],
+  SBS_UPDATES: [15, 16],
+  SELLER_WALLET: [21, 28],
+  MARKETING_CENTER: [9, 14, 22],
+  PERFORMANCE: [23, 29],
+  SHOPEE_UPDATES: [6, 24, 30, 31]
+};
+const FoldersType = {
+  ORDER_UPDATES: 1,
+  RATING: 2,
+  RETURN_AND_REFUND: 3,
+  LISTING_UPDATES: 4,
+  SELLER_WALLET: 5,
+  MARKETING_CENTER: 6,
+  PERFORMANCE: 7,
+  SHOPEE_UPDATES: 8,
+  SBS_UPDATES: 9
+};
+var NotiEventNames;
+
+(function (NotiEventNames) {
+  NotiEventNames["MarkAllHeaderNotiAsRead"] = "HeaderMarkAllAsRead";
+  NotiEventNames["MarkAllNotiAsRead"] = "NotiMarkAllAsRead";
+  NotiEventNames["MarkNotiAsRead"] = "MarkNotiAsRead";
+  NotiEventNames["MarkHeaderNotiAsRead"] = "MarkHeaderNotiAsRead";
+  NotiEventNames["NotiCountsChange"] = "NotiCountsChange";
+  NotiEventNames["HeaderNotiCountsChange"] = "HeaderNotiCountsChange";
+})(NotiEventNames || (NotiEventNames = {}));
+// EXTERNAL MODULE: ./node_modules/big-integer/BigInteger.js
+var BigInteger = __webpack_require__("dAlA");
+var BigInteger_default = /*#__PURE__*/__webpack_require__.n(BigInteger);
+
+// CONCATENATED MODULE: ./src/modules/notification/action.ts
+
+
+
+function replaceUrl(url, action) {
+  return url.replace('${PC_MALL_ORIGIN}', external_seller_base_["Base"].$instance.environment.pcMallOrigin).replace('${SELLER_ORIGIN}', external_seller_base_["Base"].$instance.environment.sellerOrigin).replace('${MALL_ORIGIN}', external_seller_base_["Base"].$instance.environment.mallOrigin).replace('${CHECKOUT_ID}', "".concat(action.idInfo.checkoutId)).replace('${ITEM_ID}', "".concat(action.idInfo.itemId)).replace('${BUYER_USER_ID}', "".concat(action.idInfo.userid)).replace('${ORDER_ID}', "".concat(action.idInfo.orderId)).replace('${SHOP_ID}', "".concat(action.idInfo.shopid)).replace('${RETURN_ID || REFUND_ID}', "".concat(action.idInfo.returnId || action.idInfo.refundId));
+}
+function clickable(action) {
+  if (!!action.pcRedirectUrl) {
+    return true;
+  }
+
+  const redirectType = action.actionRedirectType;
+
+  if (redirectType === ActionRedirectTypes.REDIRECT_NEW_WEB_PAGE) {
+    // special case: penalty redirection
+    if ([ActionTypes.SELLER_PENALTY_POINT, ActionTypes.SELLER_PENALTY_TIER, ActionTypes.SELLER_PENALTY_POINT_REMOVE].includes(action.actionType)) {
+      return clickableByActionType(action);
+    } // special case: bridge_cmd redirection
+
+
+    if (action.actionRedirectUrl && !action.actionRedirectUrl.includes('bridge_cmd')) {
+      return true;
+    }
+
+    return clickableByActionType(action);
+  }
+
+  if (RedirectTypePreferred.includes(redirectType)) {
+    return clickableByRedirectType(action);
+  }
+
+  let ret = clickableByActionType(action);
+
+  if (ret === false) {
+    ret = clickableByRedirectType(action);
+  }
+
+  return ret;
+}
+function clickableByActionType(action) {
+  if (action.actionTypeRedirectUrl) {
+    return true;
+  }
+
+  if (Object.values(ActionTypes).includes(action.actionType)) {
+    return;
+  }
+
+  return false;
+}
+function clickableByRedirectType(action) {
+  if (action.actionRedirectType === ActionRedirectTypes.REDIRECT_ORDER_CHAT_PAGE || action.redirectActionTypeRedirectUrl) {
+    return true;
+  } else if (action.actionRedirectType === ActionRedirectTypes.REDIRECT_APP_PATH) {
+    return clickableByAppPath(action);
+  }
+}
+function clickableByAppPath(action) {
+  if (action.actionAppPath === AppPath.CHAT || action.appPathRedirectUrl) {
+    return true;
+  }
+
+  return false;
+}
+
+const getRedirectURL = url => {
+  const isCB = external_seller_base_["Base"].$instance.environment.isCBSC || external_seller_base_["Base"].$instance.environment.isMainland;
+
+  if (!isCB) {
+    return url;
+  }
+
+  try {
+    const urlObject = new URL(url);
+    const env = '(test|uat|staging|live-test|test-stable)?\\.?';
+
+    if (new RegExp("^mall\\.".concat(env, "shopee\\.")).test(urlObject.hostname)) {
+      urlObject.hostname = new URL(external_seller_base_["Base"].$instance.environment.mallOrigin).hostname;
+    } else if (new RegExp("^".concat(env, "shopee\\.")).test(urlObject.hostname)) {
+      urlObject.hostname = new URL(external_seller_base_["Base"].$instance.environment.sellerOrigin).hostname;
+    } else if (new RegExp("^(seller|banhang)\\.".concat(env, "shopee\\.")).test(urlObject.hostname)) {
+      urlObject.hostname = new URL(external_seller_base_["Base"].$instance.environment.pcMallOrigin).hostname;
+    }
+
+    return urlObject.toString();
+  } catch (e) {
+    console.error('getRedirectURL', e);
+    return url;
+  }
+};
+
+function redirect(action, chatProxyService) {
+  if (!!action.pcRedirectUrl) {
+    const url = getRedirectURL(action.pcRedirectUrl);
+    window.open(url);
+    return;
+  }
+
+  const redirectType = action.actionRedirectType;
+
+  if (redirectType === ActionRedirectTypes.REDIRECT_NEW_WEB_PAGE) {
+    // special case: penalty redirection
+    if ([ActionTypes.SELLER_PENALTY_POINT, ActionTypes.SELLER_PENALTY_TIER, ActionTypes.SELLER_PENALTY_POINT_REMOVE].includes(action.actionType)) {
+      redirectByActionType(action);
+      return;
+    } // special case: bridge_cmd redirection
+
+
+    if (action.actionRedirectUrl && !action.actionRedirectUrl.includes('bridge_cmd')) {
+      const url = getRedirectURL(action.actionRedirectUrl);
+      window.open(url);
+      return;
+    } else {
+      if (action.actionTypeRedirectUrl) {
+        window.open(replaceUrl(action.actionTypeRedirectUrl, action));
+      }
+    }
+
+    return;
+  }
+
+  if (RedirectTypePreferred.includes(action.actionRedirectType)) {
+    return redirectByRedirectType(action, chatProxyService);
+  }
+
+  const ret = redirectByActionType(action);
+
+  if (ret === false) {
+    redirectByRedirectType(action, chatProxyService);
+  }
+}
+
+function redirectByActionType(action) {
+  if (action.actionTypeRedirectUrl) {
+    return window.open(replaceUrl(action.actionTypeRedirectUrl, action));
+  }
+
+  if (Object.values(ActionTypes).includes(action.actionType)) {
+    return;
+  }
+
+  return false;
+}
+
+function redirectByRedirectType(action, chatProxyService) {
+  const {
+    orderId,
+    shopid,
+    buyerId
+  } = action.idInfo;
+
+  if (action.actionRedirectType === ActionRedirectTypes.REDIRECT_ORDER_CHAT_PAGE) {
+    chatProxyService.startChatWithOrder(shopid, buyerId, orderId);
+  } else if (action.actionRedirectType === ActionRedirectTypes.REDIRECT_APP_PATH) {
+    redirectByAppPath(action, chatProxyService);
+  } else if (action.redirectActionTypeRedirectUrl) {
+    window.open(replaceUrl(action.redirectActionTypeRedirectUrl, action));
+  }
+}
+
+function redirectByAppPath(action, chatProxyService) {
+  if (action.actionAppPath === AppPath.CHAT) {
+    const {
+      shopid,
+      userid,
+      buyerId,
+      orderId
+    } = action.idInfo;
+    chatProxyService.startChatWithOrder(shopid, userid || buyerId, orderId);
+  } else if (action.appPathRedirectUrl) {
+    window.open(replaceUrl(action.appPathRedirectUrl, action));
+  }
+}
+
+function compileAction(action) {
+  return {
+    id: action.actionId,
+    title: action.title,
+    content: action.content,
+    images: action.images,
+    groupId: action.groupId,
+    groupCount: action.groupCount,
+    status: action.status,
+    type: action.type,
+    clickable: !!clickable(action),
+    idInfo: action.idInfo,
+    actionCate: action.actionCate,
+    actionType: action.actionType,
+    traceId: action.traceId,
+    timestamp: action.timestamp,
+    actionRedirectType: action.actionRedirectType,
+    actionRedirectUrl: action.actionRedirectUrl,
+    actionTypeRedirectUrl: action.actionTypeRedirectUrl,
+    appPathRedirectUrl: action.appPathRedirectUrl,
+    redirectActionTypeRedirectUrl: action.redirectActionTypeRedirectUrl,
+    pcRedirectUrl: action.pcRedirectUrl,
+    actionAppPath: action.actionAppPath,
+
+    action(action, chatProxyService) {
+      if (!ActionCategory.MARKETING_CENTER.includes(action.actionCate) || action.actionRedirectUrl) {
+        return redirect(action, chatProxyService);
+      }
+    }
+
+  };
+}
+function getMaxActionId(notificationList) {
+  const actionIds = notificationList.map(item => BigInteger_default()(item.id));
+  return actionIds.reduce((prev, next) => {
+    if (prev.compareTo(next) < 0) {
+      return next;
+    }
+
+    return prev;
+  });
+}
+// CONCATENATED MODULE: ./src/modules/notification/index.ts
+/* concated harmony reexport NotificationService */__webpack_require__.d(__webpack_exports__, "NotificationService", function() { return service_NotificationService; });
+/* concated harmony reexport CompiledNotification */__webpack_require__.d(__webpack_exports__, "CompiledNotification", function() { return /* Cannot get final name for export "CompiledNotification" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport Notification */__webpack_require__.d(__webpack_exports__, "Notification", function() { return /* Cannot get final name for export "Notification" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport Counts */__webpack_require__.d(__webpack_exports__, "Counts", function() { return /* Cannot get final name for export "Counts" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport Status */__webpack_require__.d(__webpack_exports__, "Status", function() { return Status; });
+/* concated harmony reexport NotificationGroupRequest */__webpack_require__.d(__webpack_exports__, "NotificationGroupRequest", function() { return /* Cannot get final name for export "NotificationGroupRequest" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport UpdateNotificationList */__webpack_require__.d(__webpack_exports__, "UpdateNotificationList", function() { return /* Cannot get final name for export "UpdateNotificationList" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport NotificationRequest */__webpack_require__.d(__webpack_exports__, "NotificationRequest", function() { return /* Cannot get final name for export "NotificationRequest" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport TrackData */__webpack_require__.d(__webpack_exports__, "TrackData", function() { return /* Cannot get final name for export "TrackData" in "./src/modules/notification/types.ts" (known exports: Status, known reexports: ) */ undefined; });
+/* concated harmony reexport FoldersConfig */__webpack_require__.d(__webpack_exports__, "FoldersConfig", function() { return FoldersConfig; });
+/* concated harmony reexport ActionCategory */__webpack_require__.d(__webpack_exports__, "ActionCategory", function() { return ActionCategory; });
+/* concated harmony reexport FoldersType */__webpack_require__.d(__webpack_exports__, "FoldersType", function() { return FoldersType; });
+/* concated harmony reexport NotiEventNames */__webpack_require__.d(__webpack_exports__, "NotiEventNames", function() { return NotiEventNames; });
+/* concated harmony reexport compileAction */__webpack_require__.d(__webpack_exports__, "compileAction", function() { return compileAction; });
+/* concated harmony reexport getMaxActionId */__webpack_require__.d(__webpack_exports__, "getMaxActionId", function() { return getMaxActionId; });
+
+
+
+
+
+/***/ }),
+
+/***/ "dAlA":
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(module) {var __WEBPACK_AMD_DEFINE_RESULT__;var bigInt = (function (undefined) {
+    "use strict";
+
+    var BASE = 1e7,
+        LOG_BASE = 7,
+        MAX_INT = 9007199254740992,
+        MAX_INT_ARR = smallToArray(MAX_INT),
+        DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+    var supportsNativeBigInt = typeof BigInt === "function";
+
+    function Integer(v, radix, alphabet, caseSensitive) {
+        if (typeof v === "undefined") return Integer[0];
+        if (typeof radix !== "undefined") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);
+        return parseValue(v);
+    }
+
+    function BigInteger(value, sign) {
+        this.value = value;
+        this.sign = sign;
+        this.isSmall = false;
+    }
+    BigInteger.prototype = Object.create(Integer.prototype);
+
+    function SmallInteger(value) {
+        this.value = value;
+        this.sign = value < 0;
+        this.isSmall = true;
+    }
+    SmallInteger.prototype = Object.create(Integer.prototype);
+
+    function NativeBigInt(value) {
+        this.value = value;
+    }
+    NativeBigInt.prototype = Object.create(Integer.prototype);
+
+    function isPrecise(n) {
+        return -MAX_INT < n && n < MAX_INT;
+    }
+
+    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes
+        if (n < 1e7)
+            return [n];
+        if (n < 1e14)
+            return [n % 1e7, Math.floor(n / 1e7)];
+        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
+    }
+
+    function arrayToSmall(arr) { // If BASE changes this function may need to change
+        trim(arr);
+        var length = arr.length;
+        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
+            switch (length) {
+                case 0: return 0;
+                case 1: return arr[0];
+                case 2: return arr[0] + arr[1] * BASE;
+                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
+            }
+        }
+        return arr;
+    }
+
+    function trim(v) {
+        var i = v.length;
+        while (v[--i] === 0);
+        v.length = i + 1;
+    }
+
+    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger
+        var x = new Array(length);
+        var i = -1;
+        while (++i < length) {
+            x[i] = 0;
+        }
+        return x;
+    }
+
+    function truncate(n) {
+        if (n > 0) return Math.floor(n);
+        return Math.ceil(n);
+    }
+
+    function add(a, b) { // assumes a and b are arrays with a.length >= b.length
+        var l_a = a.length,
+            l_b = b.length,
+            r = new Array(l_a),
+            carry = 0,
+            base = BASE,
+            sum, i;
+        for (i = 0; i < l_b; i++) {
+            sum = a[i] + b[i] + carry;
+            carry = sum >= base ? 1 : 0;
+            r[i] = sum - carry * base;
+        }
+        while (i < l_a) {
+            sum = a[i] + carry;
+            carry = sum === base ? 1 : 0;
+            r[i++] = sum - carry * base;
+        }
+        if (carry > 0) r.push(carry);
+        return r;
+    }
+
+    function addAny(a, b) {
+        if (a.length >= b.length) return add(a, b);
+        return add(b, a);
+    }
+
+    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT
+        var l = a.length,
+            r = new Array(l),
+            base = BASE,
+            sum, i;
+        for (i = 0; i < l; i++) {
+            sum = a[i] - base + carry;
+            carry = Math.floor(sum / base);
+            r[i] = sum - carry * base;
+            carry += 1;
+        }
+        while (carry > 0) {
+            r[i++] = carry % base;
+            carry = Math.floor(carry / base);
+        }
+        return r;
+    }
+
+    BigInteger.prototype.add = function (v) {
+        var n = parseValue(v);
+        if (this.sign !== n.sign) {
+            return this.subtract(n.negate());
+        }
+        var a = this.value, b = n.value;
+        if (n.isSmall) {
+            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
+        }
+        return new BigInteger(addAny(a, b), this.sign);
+    };
+    BigInteger.prototype.plus = BigInteger.prototype.add;
+
+    SmallInteger.prototype.add = function (v) {
+        var n = parseValue(v);
+        var a = this.value;
+        if (a < 0 !== n.sign) {
+            return this.subtract(n.negate());
+        }
+        var b = n.value;
+        if (n.isSmall) {
+            if (isPrecise(a + b)) return new SmallInteger(a + b);
+            b = smallToArray(Math.abs(b));
+        }
+        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
+    };
+    SmallInteger.prototype.plus = SmallInteger.prototype.add;
+
+    NativeBigInt.prototype.add = function (v) {
+        return new NativeBigInt(this.value + parseValue(v).value);
+    }
+    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;
+
+    function subtract(a, b) { // assumes a and b are arrays with a >= b
+        var a_l = a.length,
+            b_l = b.length,
+            r = new Array(a_l),
+            borrow = 0,
+            base = BASE,
+            i, difference;
+        for (i = 0; i < b_l; i++) {
+            difference = a[i] - borrow - b[i];
+            if (difference < 0) {
+                difference += base;
+                borrow = 1;
+            } else borrow = 0;
+            r[i] = difference;
+        }
+        for (i = b_l; i < a_l; i++) {
+            difference = a[i] - borrow;
+            if (difference < 0) difference += base;
+            else {
+                r[i++] = difference;
+                break;
+            }
+            r[i] = difference;
+        }
+        for (; i < a_l; i++) {
+            r[i] = a[i];
+        }
+        trim(r);
+        return r;
+    }
+
+    function subtractAny(a, b, sign) {
+        var value;
+        if (compareAbs(a, b) >= 0) {
+            value = subtract(a, b);
+        } else {
+            value = subtract(b, a);
+            sign = !sign;
+        }
+        value = arrayToSmall(value);
+        if (typeof value === "number") {
+            if (sign) value = -value;
+            return new SmallInteger(value);
+        }
+        return new BigInteger(value, sign);
+    }
+
+    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT
+        var l = a.length,
+            r = new Array(l),
+            carry = -b,
+            base = BASE,
+            i, difference;
+        for (i = 0; i < l; i++) {
+            difference = a[i] + carry;
+            carry = Math.floor(difference / base);
+            difference %= base;
+            r[i] = difference < 0 ? difference + base : difference;
+        }
+        r = arrayToSmall(r);
+        if (typeof r === "number") {
+            if (sign) r = -r;
+            return new SmallInteger(r);
+        } return new BigInteger(r, sign);
+    }
+
+    BigInteger.prototype.subtract = function (v) {
+        var n = parseValue(v);
+        if (this.sign !== n.sign) {
+            return this.add(n.negate());
+        }
+        var a = this.value, b = n.value;
+        if (n.isSmall)
+            return subtractSmall(a, Math.abs(b), this.sign);
+        return subtractAny(a, b, this.sign);
+    };
+    BigInteger.prototype.minus = BigInteger.prototype.subtract;
+
+    SmallInteger.prototype.subtract = function (v) {
+        var n = parseValue(v);
+        var a = this.value;
+        if (a < 0 !== n.sign) {
+            return this.add(n.negate());
+        }
+        var b = n.value;
+        if (n.isSmall) {
+            return new SmallInteger(a - b);
+        }
+        return subtractSmall(b, Math.abs(a), a >= 0);
+    };
+    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
+
+    NativeBigInt.prototype.subtract = function (v) {
+        return new NativeBigInt(this.value - parseValue(v).value);
+    }
+    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;
+
+    BigInteger.prototype.negate = function () {
+        return new BigInteger(this.value, !this.sign);
+    };
+    SmallInteger.prototype.negate = function () {
+        var sign = this.sign;
+        var small = new SmallInteger(-this.value);
+        small.sign = !sign;
+        return small;
+    };
+    NativeBigInt.prototype.negate = function () {
+        return new NativeBigInt(-this.value);
+    }
+
+    BigInteger.prototype.abs = function () {
+        return new BigInteger(this.value, false);
+    };
+    SmallInteger.prototype.abs = function () {
+        return new SmallInteger(Math.abs(this.value));
+    };
+    NativeBigInt.prototype.abs = function () {
+        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);
+    }
+
+
+    function multiplyLong(a, b) {
+        var a_l = a.length,
+            b_l = b.length,
+            l = a_l + b_l,
+            r = createArray(l),
+            base = BASE,
+            product, carry, i, a_i, b_j;
+        for (i = 0; i < a_l; ++i) {
+            a_i = a[i];
+            for (var j = 0; j < b_l; ++j) {
+                b_j = b[j];
+                product = a_i * b_j + r[i + j];
+                carry = Math.floor(product / base);
+                r[i + j] = product - carry * base;
+                r[i + j + 1] += carry;
+            }
+        }
+        trim(r);
+        return r;
+    }
+
+    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE
+        var l = a.length,
+            r = new Array(l),
+            base = BASE,
+            carry = 0,
+            product, i;
+        for (i = 0; i < l; i++) {
+            product = a[i] * b + carry;
+            carry = Math.floor(product / base);
+            r[i] = product - carry * base;
+        }
+        while (carry > 0) {
+            r[i++] = carry % base;
+            carry = Math.floor(carry / base);
+        }
+        return r;
+    }
+
+    function shiftLeft(x, n) {
+        var r = [];
+        while (n-- > 0) r.push(0);
+        return r.concat(x);
+    }
+
+    function multiplyKaratsuba(x, y) {
+        var n = Math.max(x.length, y.length);
+
+        if (n <= 30) return multiplyLong(x, y);
+        n = Math.ceil(n / 2);
+
+        var b = x.slice(n),
+            a = x.slice(0, n),
+            d = y.slice(n),
+            c = y.slice(0, n);
+
+        var ac = multiplyKaratsuba(a, c),
+            bd = multiplyKaratsuba(b, d),
+            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));
+
+        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));
+        trim(product);
+        return product;
+    }
+
+    // The following function is derived from a surface fit of a graph plotting the performance difference
+    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.
+    function useKaratsuba(l1, l2) {
+        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;
+    }
+
+    BigInteger.prototype.multiply = function (v) {
+        var n = parseValue(v),
+            a = this.value, b = n.value,
+            sign = this.sign !== n.sign,
+            abs;
+        if (n.isSmall) {
+            if (b === 0) return Integer[0];
+            if (b === 1) return this;
+            if (b === -1) return this.negate();
+            abs = Math.abs(b);
+            if (abs < BASE) {
+                return new BigInteger(multiplySmall(a, abs), sign);
+            }
+            b = smallToArray(abs);
+        }
+        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes
+            return new BigInteger(multiplyKaratsuba(a, b), sign);
+        return new BigInteger(multiplyLong(a, b), sign);
+    };
+
+    BigInteger.prototype.times = BigInteger.prototype.multiply;
+
+    function multiplySmallAndArray(a, b, sign) { // a >= 0
+        if (a < BASE) {
+            return new BigInteger(multiplySmall(b, a), sign);
+        }
+        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);
+    }
+    SmallInteger.prototype._multiplyBySmall = function (a) {
+        if (isPrecise(a.value * this.value)) {
+            return new SmallInteger(a.value * this.value);
+        }
+        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);
+    };
+    BigInteger.prototype._multiplyBySmall = function (a) {
+        if (a.value === 0) return Integer[0];
+        if (a.value === 1) return this;
+        if (a.value === -1) return this.negate();
+        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);
+    };
+    SmallInteger.prototype.multiply = function (v) {
+        return parseValue(v)._multiplyBySmall(this);
+    };
+    SmallInteger.prototype.times = SmallInteger.prototype.multiply;
+
+    NativeBigInt.prototype.multiply = function (v) {
+        return new NativeBigInt(this.value * parseValue(v).value);
+    }
+    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;
+
+    function square(a) {
+        //console.assert(2 * BASE * BASE < MAX_INT);
+        var l = a.length,
+            r = createArray(l + l),
+            base = BASE,
+            product, carry, i, a_i, a_j;
+        for (i = 0; i < l; i++) {
+            a_i = a[i];
+            carry = 0 - a_i * a_i;
+            for (var j = i; j < l; j++) {
+                a_j = a[j];
+                product = 2 * (a_i * a_j) + r[i + j] + carry;
+                carry = Math.floor(product / base);
+                r[i + j] = product - carry * base;
+            }
+            r[i + l] = carry;
+        }
+        trim(r);
+        return r;
+    }
+
+    BigInteger.prototype.square = function () {
+        return new BigInteger(square(this.value), false);
+    };
+
+    SmallInteger.prototype.square = function () {
+        var value = this.value * this.value;
+        if (isPrecise(value)) return new SmallInteger(value);
+        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
+    };
+
+    NativeBigInt.prototype.square = function (v) {
+        return new NativeBigInt(this.value * this.value);
+    }
+
+    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.
+        var a_l = a.length,
+            b_l = b.length,
+            base = BASE,
+            result = createArray(b.length),
+            divisorMostSignificantDigit = b[b_l - 1],
+            // normalization
+            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),
+            remainder = multiplySmall(a, lambda),
+            divisor = multiplySmall(b, lambda),
+            quotientDigit, shift, carry, borrow, i, l, q;
+        if (remainder.length <= a_l) remainder.push(0);
+        divisor.push(0);
+        divisorMostSignificantDigit = divisor[b_l - 1];
+        for (shift = a_l - b_l; shift >= 0; shift--) {
+            quotientDigit = base - 1;
+            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
+                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);
+            }
+            // quotientDigit <= base - 1
+            carry = 0;
+            borrow = 0;
+            l = divisor.length;
+            for (i = 0; i < l; i++) {
+                carry += quotientDigit * divisor[i];
+                q = Math.floor(carry / base);
+                borrow += remainder[shift + i] - (carry - q * base);
+                carry = q;
+                if (borrow < 0) {
+                    remainder[shift + i] = borrow + base;
+                    borrow = -1;
+                } else {
+                    remainder[shift + i] = borrow;
+                    borrow = 0;
+                }
+            }
+            while (borrow !== 0) {
+                quotientDigit -= 1;
+                carry = 0;
+                for (i = 0; i < l; i++) {
+                    carry += remainder[shift + i] - base + divisor[i];
+                    if (carry < 0) {
+                        remainder[shift + i] = carry + base;
+                        carry = 0;
+                    } else {
+                        remainder[shift + i] = carry;
+                        carry = 1;
+                    }
+                }
+                borrow += carry;
+            }
+            result[shift] = quotientDigit;
+        }
+        // denormalization
+        remainder = divModSmall(remainder, lambda)[0];
+        return [arrayToSmall(result), arrayToSmall(remainder)];
+    }
+
+    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/
+        // Performs faster than divMod1 on larger input sizes.
+        var a_l = a.length,
+            b_l = b.length,
+            result = [],
+            part = [],
+            base = BASE,
+            guess, xlen, highx, highy, check;
+        while (a_l) {
+            part.unshift(a[--a_l]);
+            trim(part);
+            if (compareAbs(part, b) < 0) {
+                result.push(0);
+                continue;
+            }
+            xlen = part.length;
+            highx = part[xlen - 1] * base + part[xlen - 2];
+            highy = b[b_l - 1] * base + b[b_l - 2];
+            if (xlen > b_l) {
+                highx = (highx + 1) * base;
+            }
+            guess = Math.ceil(highx / highy);
+            do {
+                check = multiplySmall(b, guess);
+                if (compareAbs(check, part) <= 0) break;
+                guess--;
+            } while (guess);
+            result.push(guess);
+            part = subtract(part, check);
+        }
+        result.reverse();
+        return [arrayToSmall(result), arrayToSmall(part)];
+    }
+
+    function divModSmall(value, lambda) {
+        var length = value.length,
+            quotient = createArray(length),
+            base = BASE,
+            i, q, remainder, divisor;
+        remainder = 0;
+        for (i = length - 1; i >= 0; --i) {
+            divisor = remainder * base + value[i];
+            q = truncate(divisor / lambda);
+            remainder = divisor - q * lambda;
+            quotient[i] = q | 0;
+        }
+        return [quotient, remainder | 0];
+    }
+
+    function divModAny(self, v) {
+        var value, n = parseValue(v);
+        if (supportsNativeBigInt) {
+            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];
+        }
+        var a = self.value, b = n.value;
+        var quotient;
+        if (b === 0) throw new Error("Cannot divide by zero");
+        if (self.isSmall) {
+            if (n.isSmall) {
+                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
+            }
+            return [Integer[0], self];
+        }
+        if (n.isSmall) {
+            if (b === 1) return [self, Integer[0]];
+            if (b == -1) return [self.negate(), Integer[0]];
+            var abs = Math.abs(b);
+            if (abs < BASE) {
+                value = divModSmall(a, abs);
+                quotient = arrayToSmall(value[0]);
+                var remainder = value[1];
+                if (self.sign) remainder = -remainder;
+                if (typeof quotient === "number") {
+                    if (self.sign !== n.sign) quotient = -quotient;
+                    return [new SmallInteger(quotient), new SmallInteger(remainder)];
+                }
+                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];
+            }
+            b = smallToArray(abs);
+        }
+        var comparison = compareAbs(a, b);
+        if (comparison === -1) return [Integer[0], self];
+        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];
+
+        // divMod1 is faster on smaller input sizes
+        if (a.length + b.length <= 200)
+            value = divMod1(a, b);
+        else value = divMod2(a, b);
+
+        quotient = value[0];
+        var qSign = self.sign !== n.sign,
+            mod = value[1],
+            mSign = self.sign;
+        if (typeof quotient === "number") {
+            if (qSign) quotient = -quotient;
+            quotient = new SmallInteger(quotient);
+        } else quotient = new BigInteger(quotient, qSign);
+        if (typeof mod === "number") {
+            if (mSign) mod = -mod;
+            mod = new SmallInteger(mod);
+        } else mod = new BigInteger(mod, mSign);
+        return [quotient, mod];
+    }
+
+    BigInteger.prototype.divmod = function (v) {
+        var result = divModAny(this, v);
+        return {
+            quotient: result[0],
+            remainder: result[1]
+        };
+    };
+    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;
+
+
+    BigInteger.prototype.divide = function (v) {
+        return divModAny(this, v)[0];
+    };
+    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {
+        return new NativeBigInt(this.value / parseValue(v).value);
+    };
+    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;
+
+    BigInteger.prototype.mod = function (v) {
+        return divModAny(this, v)[1];
+    };
+    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {
+        return new NativeBigInt(this.value % parseValue(v).value);
+    };
+    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;
+
+    BigInteger.prototype.pow = function (v) {
+        var n = parseValue(v),
+            a = this.value,
+            b = n.value,
+            value, x, y;
+        if (b === 0) return Integer[1];
+        if (a === 0) return Integer[0];
+        if (a === 1) return Integer[1];
+        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];
+        if (n.sign) {
+            return Integer[0];
+        }
+        if (!n.isSmall) throw new Error("The exponent " + n.toString() + " is too large.");
+        if (this.isSmall) {
+            if (isPrecise(value = Math.pow(a, b)))
+                return new SmallInteger(truncate(value));
+        }
+        x = this;
+        y = Integer[1];
+        while (true) {
+            if (b & 1 === 1) {
+                y = y.times(x);
+                --b;
+            }
+            if (b === 0) break;
+            b /= 2;
+            x = x.square();
+        }
+        return y;
+    };
+    SmallInteger.prototype.pow = BigInteger.prototype.pow;
+
+    NativeBigInt.prototype.pow = function (v) {
+        var n = parseValue(v);
+        var a = this.value, b = n.value;
+        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);
+        if (b === _0) return Integer[1];
+        if (a === _0) return Integer[0];
+        if (a === _1) return Integer[1];
+        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];
+        if (n.isNegative()) return new NativeBigInt(_0);
+        var x = this;
+        var y = Integer[1];
+        while (true) {
+            if ((b & _1) === _1) {
+                y = y.times(x);
+                --b;
+            }
+            if (b === _0) break;
+            b /= _2;
+            x = x.square();
+        }
+        return y;
+    }
+
+    BigInteger.prototype.modPow = function (exp, mod) {
+        exp = parseValue(exp);
+        mod = parseValue(mod);
+        if (mod.isZero()) throw new Error("Cannot take modPow with modulus 0");
+        var r = Integer[1],
+            base = this.mod(mod);
+        if (exp.isNegative()) {
+            exp = exp.multiply(Integer[-1]);
+            base = base.modInv(mod);
+        }
+        while (exp.isPositive()) {
+            if (base.isZero()) return Integer[0];
+            if (exp.isOdd()) r = r.multiply(base).mod(mod);
+            exp = exp.divide(2);
+            base = base.square().mod(mod);
+        }
+        return r;
+    };
+    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;
+
+    function compareAbs(a, b) {
+        if (a.length !== b.length) {
+            return a.length > b.length ? 1 : -1;
+        }
+        for (var i = a.length - 1; i >= 0; i--) {
+            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
+        }
+        return 0;
+    }
+
+    BigInteger.prototype.compareAbs = function (v) {
+        var n = parseValue(v),
+            a = this.value,
+            b = n.value;
+        if (n.isSmall) return 1;
+        return compareAbs(a, b);
+    };
+    SmallInteger.prototype.compareAbs = function (v) {
+        var n = parseValue(v),
+            a = Math.abs(this.value),
+            b = n.value;
+        if (n.isSmall) {
+            b = Math.abs(b);
+            return a === b ? 0 : a > b ? 1 : -1;
+        }
+        return -1;
+    };
+    NativeBigInt.prototype.compareAbs = function (v) {
+        var a = this.value;
+        var b = parseValue(v).value;
+        a = a >= 0 ? a : -a;
+        b = b >= 0 ? b : -b;
+        return a === b ? 0 : a > b ? 1 : -1;
+    }
+
+    BigInteger.prototype.compare = function (v) {
+        // See discussion about comparison with Infinity:
+        // https://github.com/peterolson/BigInteger.js/issues/61
+        if (v === Infinity) {
+            return -1;
+        }
+        if (v === -Infinity) {
+            return 1;
+        }
+
+        var n = parseValue(v),
+            a = this.value,
+            b = n.value;
+        if (this.sign !== n.sign) {
+            return n.sign ? 1 : -1;
+        }
+        if (n.isSmall) {
+            return this.sign ? -1 : 1;
+        }
+        return compareAbs(a, b) * (this.sign ? -1 : 1);
+    };
+    BigInteger.prototype.compareTo = BigInteger.prototype.compare;
+
+    SmallInteger.prototype.compare = function (v) {
+        if (v === Infinity) {
+            return -1;
+        }
+        if (v === -Infinity) {
+            return 1;
+        }
+
+        var n = parseValue(v),
+            a = this.value,
+            b = n.value;
+        if (n.isSmall) {
+            return a == b ? 0 : a > b ? 1 : -1;
+        }
+        if (a < 0 !== n.sign) {
+            return a < 0 ? -1 : 1;
+        }
+        return a < 0 ? 1 : -1;
+    };
+    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
+
+    NativeBigInt.prototype.compare = function (v) {
+        if (v === Infinity) {
+            return -1;
+        }
+        if (v === -Infinity) {
+            return 1;
+        }
+        var a = this.value;
+        var b = parseValue(v).value;
+        return a === b ? 0 : a > b ? 1 : -1;
+    }
+    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;
+
+    BigInteger.prototype.equals = function (v) {
+        return this.compare(v) === 0;
+    };
+    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;
+
+    BigInteger.prototype.notEquals = function (v) {
+        return this.compare(v) !== 0;
+    };
+    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;
+
+    BigInteger.prototype.greater = function (v) {
+        return this.compare(v) > 0;
+    };
+    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;
+
+    BigInteger.prototype.lesser = function (v) {
+        return this.compare(v) < 0;
+    };
+    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;
+
+    BigInteger.prototype.greaterOrEquals = function (v) {
+        return this.compare(v) >= 0;
+    };
+    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;
+
+    BigInteger.prototype.lesserOrEquals = function (v) {
+        return this.compare(v) <= 0;
+    };
+    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;
+
+    BigInteger.prototype.isEven = function () {
+        return (this.value[0] & 1) === 0;
+    };
+    SmallInteger.prototype.isEven = function () {
+        return (this.value & 1) === 0;
+    };
+    NativeBigInt.prototype.isEven = function () {
+        return (this.value & BigInt(1)) === BigInt(0);
+    }
+
+    BigInteger.prototype.isOdd = function () {
+        return (this.value[0] & 1) === 1;
+    };
+    SmallInteger.prototype.isOdd = function () {
+        return (this.value & 1) === 1;
+    };
+    NativeBigInt.prototype.isOdd = function () {
+        return (this.value & BigInt(1)) === BigInt(1);
+    }
+
+    BigInteger.prototype.isPositive = function () {
+        return !this.sign;
+    };
+    SmallInteger.prototype.isPositive = function () {
+        return this.value > 0;
+    };
+    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;
+
+    BigInteger.prototype.isNegative = function () {
+        return this.sign;
+    };
+    SmallInteger.prototype.isNegative = function () {
+        return this.value < 0;
+    };
+    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;
+
+    BigInteger.prototype.isUnit = function () {
+        return false;
+    };
+    SmallInteger.prototype.isUnit = function () {
+        return Math.abs(this.value) === 1;
+    };
+    NativeBigInt.prototype.isUnit = function () {
+        return this.abs().value === BigInt(1);
+    }
+
+    BigInteger.prototype.isZero = function () {
+        return false;
+    };
+    SmallInteger.prototype.isZero = function () {
+        return this.value === 0;
+    };
+    NativeBigInt.prototype.isZero = function () {
+        return this.value === BigInt(0);
+    }
+
+    BigInteger.prototype.isDivisibleBy = function (v) {
+        var n = parseValue(v);
+        if (n.isZero()) return false;
+        if (n.isUnit()) return true;
+        if (n.compareAbs(2) === 0) return this.isEven();
+        return this.mod(n).isZero();
+    };
+    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;
+
+    function isBasicPrime(v) {
+        var n = v.abs();
+        if (n.isUnit()) return false;
+        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;
+        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;
+        if (n.lesser(49)) return true;
+        // we don't know if it's prime: let the other functions figure it out
+    }
+
+    function millerRabinTest(n, a) {
+        var nPrev = n.prev(),
+            b = nPrev,
+            r = 0,
+            d, t, i, x;
+        while (b.isEven()) b = b.divide(2), r++;
+        next: for (i = 0; i < a.length; i++) {
+            if (n.lesser(a[i])) continue;
+            x = bigInt(a[i]).modPow(b, n);
+            if (x.isUnit() || x.equals(nPrev)) continue;
+            for (d = r - 1; d != 0; d--) {
+                x = x.square().mod(n);
+                if (x.isUnit()) return false;
+                if (x.equals(nPrev)) continue next;
+            }
+            return false;
+        }
+        return true;
+    }
+
+    // Set "strict" to true to force GRH-supported lower bound of 2*log(N)^2
+    BigInteger.prototype.isPrime = function (strict) {
+        var isPrime = isBasicPrime(this);
+        if (isPrime !== undefined) return isPrime;
+        var n = this.abs();
+        var bits = n.bitLength();
+        if (bits <= 64)
+            return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
+        var logN = Math.log(2) * bits.toJSNumber();
+        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);
+        for (var a = [], i = 0; i < t; i++) {
+            a.push(bigInt(i + 2));
+        }
+        return millerRabinTest(n, a);
+    };
+    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;
+
+    BigInteger.prototype.isProbablePrime = function (iterations, rng) {
+        var isPrime = isBasicPrime(this);
+        if (isPrime !== undefined) return isPrime;
+        var n = this.abs();
+        var t = iterations === undefined ? 5 : iterations;
+        for (var a = [], i = 0; i < t; i++) {
+            a.push(bigInt.randBetween(2, n.minus(2), rng));
+        }
+        return millerRabinTest(n, a);
+    };
+    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;
+
+    BigInteger.prototype.modInv = function (n) {
+        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;
+        while (!newR.isZero()) {
+            q = r.divide(newR);
+            lastT = t;
+            lastR = r;
+            t = newT;
+            r = newR;
+            newT = lastT.subtract(q.multiply(newT));
+            newR = lastR.subtract(q.multiply(newR));
+        }
+        if (!r.isUnit()) throw new Error(this.toString() + " and " + n.toString() + " are not co-prime");
+        if (t.compare(0) === -1) {
+            t = t.add(n);
+        }
+        if (this.isNegative()) {
+            return t.negate();
+        }
+        return t;
+    };
+
+    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;
+
+    BigInteger.prototype.next = function () {
+        var value = this.value;
+        if (this.sign) {
+            return subtractSmall(value, 1, this.sign);
+        }
+        return new BigInteger(addSmall(value, 1), this.sign);
+    };
+    SmallInteger.prototype.next = function () {
+        var value = this.value;
+        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);
+        return new BigInteger(MAX_INT_ARR, false);
+    };
+    NativeBigInt.prototype.next = function () {
+        return new NativeBigInt(this.value + BigInt(1));
+    }
+
+    BigInteger.prototype.prev = function () {
+        var value = this.value;
+        if (this.sign) {
+            return new BigInteger(addSmall(value, 1), true);
+        }
+        return subtractSmall(value, 1, this.sign);
+    };
+    SmallInteger.prototype.prev = function () {
+        var value = this.value;
+        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);
+        return new BigInteger(MAX_INT_ARR, true);
+    };
+    NativeBigInt.prototype.prev = function () {
+        return new NativeBigInt(this.value - BigInt(1));
+    }
+
+    var powersOfTwo = [1];
+    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
+    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];
+
+    function shift_isSmall(n) {
+        return Math.abs(n) <= BASE;
+    }
+
+    BigInteger.prototype.shiftLeft = function (v) {
+        var n = parseValue(v).toJSNumber();
+        if (!shift_isSmall(n)) {
+            throw new Error(String(n) + " is too large for shifting.");
+        }
+        if (n < 0) return this.shiftRight(-n);
+        var result = this;
+        if (result.isZero()) return result;
+        while (n >= powers2Length) {
+            result = result.multiply(highestPower2);
+            n -= powers2Length - 1;
+        }
+        return result.multiply(powersOfTwo[n]);
+    };
+    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;
+
+    BigInteger.prototype.shiftRight = function (v) {
+        var remQuo;
+        var n = parseValue(v).toJSNumber();
+        if (!shift_isSmall(n)) {
+            throw new Error(String(n) + " is too large for shifting.");
+        }
+        if (n < 0) return this.shiftLeft(-n);
+        var result = this;
+        while (n >= powers2Length) {
+            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;
+            remQuo = divModAny(result, highestPower2);
+            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
+            n -= powers2Length - 1;
+        }
+        remQuo = divModAny(result, powersOfTwo[n]);
+        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
+    };
+    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;
+
+    function bitwise(x, y, fn) {
+        y = parseValue(y);
+        var xSign = x.isNegative(), ySign = y.isNegative();
+        var xRem = xSign ? x.not() : x,
+            yRem = ySign ? y.not() : y;
+        var xDigit = 0, yDigit = 0;
+        var xDivMod = null, yDivMod = null;
+        var result = [];
+        while (!xRem.isZero() || !yRem.isZero()) {
+            xDivMod = divModAny(xRem, highestPower2);
+            xDigit = xDivMod[1].toJSNumber();
+            if (xSign) {
+                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers
+            }
+
+            yDivMod = divModAny(yRem, highestPower2);
+            yDigit = yDivMod[1].toJSNumber();
+            if (ySign) {
+                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers
+            }
+
+            xRem = xDivMod[0];
+            yRem = yDivMod[0];
+            result.push(fn(xDigit, yDigit));
+        }
+        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);
+        for (var i = result.length - 1; i >= 0; i -= 1) {
+            sum = sum.multiply(highestPower2).add(bigInt(result[i]));
+        }
+        return sum;
+    }
+
+    BigInteger.prototype.not = function () {
+        return this.negate().prev();
+    };
+    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;
+
+    BigInteger.prototype.and = function (n) {
+        return bitwise(this, n, function (a, b) { return a & b; });
+    };
+    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;
+
+    BigInteger.prototype.or = function (n) {
+        return bitwise(this, n, function (a, b) { return a | b; });
+    };
+    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;
+
+    BigInteger.prototype.xor = function (n) {
+        return bitwise(this, n, function (a, b) { return a ^ b; });
+    };
+    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;
+
+    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
+    function roughLOB(n) { // get lowestOneBit (rough)
+        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)
+        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]
+        var v = n.value,
+            x = typeof v === "number" ? v | LOBMASK_I :
+                typeof v === "bigint" ? v | BigInt(LOBMASK_I) :
+                    v[0] + v[1] * BASE | LOBMASK_BI;
+        return x & -x;
+    }
+
+    function integerLogarithm(value, base) {
+        if (base.compareTo(value) <= 0) {
+            var tmp = integerLogarithm(value, base.square(base));
+            var p = tmp.p;
+            var e = tmp.e;
+            var t = p.multiply(base);
+            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };
+        }
+        return { p: bigInt(1), e: 0 };
+    }
+
+    BigInteger.prototype.bitLength = function () {
+        var n = this;
+        if (n.compareTo(bigInt(0)) < 0) {
+            n = n.negate().subtract(bigInt(1));
+        }
+        if (n.compareTo(bigInt(0)) === 0) {
+            return bigInt(0);
+        }
+        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));
+    }
+    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;
+
+    function max(a, b) {
+        a = parseValue(a);
+        b = parseValue(b);
+        return a.greater(b) ? a : b;
+    }
+    function min(a, b) {
+        a = parseValue(a);
+        b = parseValue(b);
+        return a.lesser(b) ? a : b;
+    }
+    function gcd(a, b) {
+        a = parseValue(a).abs();
+        b = parseValue(b).abs();
+        if (a.equals(b)) return a;
+        if (a.isZero()) return b;
+        if (b.isZero()) return a;
+        var c = Integer[1], d, t;
+        while (a.isEven() && b.isEven()) {
+            d = min(roughLOB(a), roughLOB(b));
+            a = a.divide(d);
+            b = b.divide(d);
+            c = c.multiply(d);
+        }
+        while (a.isEven()) {
+            a = a.divide(roughLOB(a));
+        }
+        do {
+            while (b.isEven()) {
+                b = b.divide(roughLOB(b));
+            }
+            if (a.greater(b)) {
+                t = b; b = a; a = t;
+            }
+            b = b.subtract(a);
+        } while (!b.isZero());
+        return c.isUnit() ? a : a.multiply(c);
+    }
+    function lcm(a, b) {
+        a = parseValue(a).abs();
+        b = parseValue(b).abs();
+        return a.divide(gcd(a, b)).multiply(b);
+    }
+    function randBetween(a, b, rng) {
+        a = parseValue(a);
+        b = parseValue(b);
+        var usedRNG = rng || Math.random;
+        var low = min(a, b), high = max(a, b);
+        var range = high.subtract(low).add(1);
+        if (range.isSmall) return low.add(Math.floor(usedRNG() * range));
+        var digits = toBase(range, BASE).value;
+        var result = [], restricted = true;
+        for (var i = 0; i < digits.length; i++) {
+            var top = restricted ? digits[i] : BASE;
+            var digit = truncate(usedRNG() * top);
+            result.push(digit);
+            if (digit < top) restricted = false;
+        }
+        return low.add(Integer.fromArray(result, BASE, false));
+    }
+
+    var parseBase = function (text, base, alphabet, caseSensitive) {
+        alphabet = alphabet || DEFAULT_ALPHABET;
+        text = String(text);
+        if (!caseSensitive) {
+            text = text.toLowerCase();
+            alphabet = alphabet.toLowerCase();
+        }
+        var length = text.length;
+        var i;
+        var absBase = Math.abs(base);
+        var alphabetValues = {};
+        for (i = 0; i < alphabet.length; i++) {
+            alphabetValues[alphabet[i]] = i;
+        }
+        for (i = 0; i < length; i++) {
+            var c = text[i];
+            if (c === "-") continue;
+            if (c in alphabetValues) {
+                if (alphabetValues[c] >= absBase) {
+                    if (c === "1" && absBase === 1) continue;
+                    throw new Error(c + " is not a valid digit in base " + base + ".");
+                }
+            }
+        }
+        base = parseValue(base);
+        var digits = [];
+        var isNegative = text[0] === "-";
+        for (i = isNegative ? 1 : 0; i < text.length; i++) {
+            var c = text[i];
+            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));
+            else if (c === "<") {
+                var start = i;
+                do { i++; } while (text[i] !== ">" && i < text.length);
+                digits.push(parseValue(text.slice(start + 1, i)));
+            }
+            else throw new Error(c + " is not a valid character");
+        }
+        return parseBaseFromArray(digits, base, isNegative);
+    };
+
+    function parseBaseFromArray(digits, base, isNegative) {
+        var val = Integer[0], pow = Integer[1], i;
+        for (i = digits.length - 1; i >= 0; i--) {
+            val = val.add(digits[i].times(pow));
+            pow = pow.times(base);
+        }
+        return isNegative ? val.negate() : val;
+    }
+
+    function stringify(digit, alphabet) {
+        alphabet = alphabet || DEFAULT_ALPHABET;
+        if (digit < alphabet.length) {
+            return alphabet[digit];
+        }
+        return "<" + digit + ">";
+    }
+
+    function toBase(n, base) {
+        base = bigInt(base);
+        if (base.isZero()) {
+            if (n.isZero()) return { value: [0], isNegative: false };
+            throw new Error("Cannot convert nonzero numbers to base 0.");
+        }
+        if (base.equals(-1)) {
+            if (n.isZero()) return { value: [0], isNegative: false };
+            if (n.isNegative())
+                return {
+                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))
+                        .map(Array.prototype.valueOf, [1, 0])
+                    ),
+                    isNegative: false
+                };
+
+            var arr = Array.apply(null, Array(n.toJSNumber() - 1))
+                .map(Array.prototype.valueOf, [0, 1]);
+            arr.unshift([1]);
+            return {
+                value: [].concat.apply([], arr),
+                isNegative: false
+            };
+        }
+
+        var neg = false;
+        if (n.isNegative() && base.isPositive()) {
+            neg = true;
+            n = n.abs();
+        }
+        if (base.isUnit()) {
+            if (n.isZero()) return { value: [0], isNegative: false };
+
+            return {
+                value: Array.apply(null, Array(n.toJSNumber()))
+                    .map(Number.prototype.valueOf, 1),
+                isNegative: neg
+            };
+        }
+        var out = [];
+        var left = n, divmod;
+        while (left.isNegative() || left.compareAbs(base) >= 0) {
+            divmod = left.divmod(base);
+            left = divmod.quotient;
+            var digit = divmod.remainder;
+            if (digit.isNegative()) {
+                digit = base.minus(digit).abs();
+                left = left.next();
+            }
+            out.push(digit.toJSNumber());
+        }
+        out.push(left.toJSNumber());
+        return { value: out.reverse(), isNegative: neg };
+    }
+
+    function toBaseString(n, base, alphabet) {
+        var arr = toBase(n, base);
+        return (arr.isNegative ? "-" : "") + arr.value.map(function (x) {
+            return stringify(x, alphabet);
+        }).join('');
+    }
+
+    BigInteger.prototype.toArray = function (radix) {
+        return toBase(this, radix);
+    };
+
+    SmallInteger.prototype.toArray = function (radix) {
+        return toBase(this, radix);
+    };
+
+    NativeBigInt.prototype.toArray = function (radix) {
+        return toBase(this, radix);
+    };
+
+    BigInteger.prototype.toString = function (radix, alphabet) {
+        if (radix === undefined) radix = 10;
+        if (radix !== 10) return toBaseString(this, radix, alphabet);
+        var v = this.value, l = v.length, str = String(v[--l]), zeros = "0000000", digit;
+        while (--l >= 0) {
+            digit = String(v[l]);
+            str += zeros.slice(digit.length) + digit;
+        }
+        var sign = this.sign ? "-" : "";
+        return sign + str;
+    };
+
+    SmallInteger.prototype.toString = function (radix, alphabet) {
+        if (radix === undefined) radix = 10;
+        if (radix != 10) return toBaseString(this, radix, alphabet);
+        return String(this.value);
+    };
+
+    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;
+
+    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }
+
+    BigInteger.prototype.valueOf = function () {
+        return parseInt(this.toString(), 10);
+    };
+    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
+
+    SmallInteger.prototype.valueOf = function () {
+        return this.value;
+    };
+    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
+    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {
+        return parseInt(this.toString(), 10);
+    }
+
+    function parseStringValue(v) {
+        if (isPrecise(+v)) {
+            var x = +v;
+            if (x === truncate(x))
+                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);
+            throw new Error("Invalid integer: " + v);
+        }
+        var sign = v[0] === "-";
+        if (sign) v = v.slice(1);
+        var split = v.split(/e/i);
+        if (split.length > 2) throw new Error("Invalid integer: " + split.join("e"));
+        if (split.length === 2) {
+            var exp = split[1];
+            if (exp[0] === "+") exp = exp.slice(1);
+            exp = +exp;
+            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error("Invalid integer: " + exp + " is not a valid exponent.");
+            var text = split[0];
+            var decimalPlace = text.indexOf(".");
+            if (decimalPlace >= 0) {
+                exp -= text.length - decimalPlace - 1;
+                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
+            }
+            if (exp < 0) throw new Error("Cannot include negative exponent part for integers");
+            text += (new Array(exp + 1)).join("0");
+            v = text;
+        }
+        var isValid = /^([0-9][0-9]*)$/.test(v);
+        if (!isValid) throw new Error("Invalid integer: " + v);
+        if (supportsNativeBigInt) {
+            return new NativeBigInt(BigInt(sign ? "-" + v : v));
+        }
+        var r = [], max = v.length, l = LOG_BASE, min = max - l;
+        while (max > 0) {
+            r.push(+v.slice(min, max));
+            min -= l;
+            if (min < 0) min = 0;
+            max -= l;
+        }
+        trim(r);
+        return new BigInteger(r, sign);
+    }
+
+    function parseNumberValue(v) {
+        if (supportsNativeBigInt) {
+            return new NativeBigInt(BigInt(v));
+        }
+        if (isPrecise(v)) {
+            if (v !== truncate(v)) throw new Error(v + " is not an integer.");
+            return new SmallInteger(v);
+        }
+        return parseStringValue(v.toString());
+    }
+
+    function parseValue(v) {
+        if (typeof v === "number") {
+            return parseNumberValue(v);
+        }
+        if (typeof v === "string") {
+            return parseStringValue(v);
+        }
+        if (typeof v === "bigint") {
+            return new NativeBigInt(v);
+        }
+        return v;
+    }
+    // Pre-define numbers in range [-999,999]
+    for (var i = 0; i < 1000; i++) {
+        Integer[i] = parseValue(i);
+        if (i > 0) Integer[-i] = parseValue(-i);
+    }
+    // Backwards compatibility
+    Integer.one = Integer[1];
+    Integer.zero = Integer[0];
+    Integer.minusOne = Integer[-1];
+    Integer.max = max;
+    Integer.min = min;
+    Integer.gcd = gcd;
+    Integer.lcm = lcm;
+    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };
+    Integer.randBetween = randBetween;
+
+    Integer.fromArray = function (digits, base, isNegative) {
+        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);
+    };
+
+    return Integer;
+})();
+
+// Node.js check
+if ( true && module.hasOwnProperty("exports")) {
+    module.exports = bigInt;
+}
+
+//amd check
+if (true) {
+    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+        return bigInt;
+    }).call(exports, __webpack_require__, exports, module),
+				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+}
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("uAlt")(module)))
+
+/***/ }),
+
+/***/ "uAlt":
+/***/ (function(module, exports) {
+
+module.exports = function(module) {
+	if (!module.webpackPolyfill) {
+		module.deprecate = function() {};
+		module.paths = [];
+		// module.parent = undefined by default
+		if (!module.children) module.children = [];
+		Object.defineProperty(module, "loaded", {
+			enumerable: true,
+			get: function() {
+				return module.l;
+			}
+		});
+		Object.defineProperty(module, "id", {
+			enumerable: true,
+			get: function() {
+				return module.i;
+			}
+		});
+		module.webpackPolyfill = 1;
+	}
+	return module;
+};
+
+
+/***/ })
+
+/******/ });
+//# sourceMappingURL=index.js.map