/*!
 * Ripple Client v1.1.32-bugfix-2-ge152297-dirty
 * Copyright (c) 2015 Ripple Labs, Inc.
 * Licensed under the ISC license.
 */
/******/ (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] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = 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;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	var types = __webpack_require__(2);

	// Enable Copy-Paste on MacOs
	var gui = __webpack_require__(1);
	if (process.platform === "darwin") {
	  var mb = new gui.Menu({type: 'menubar'});
	  mb.createMacBuiltin('RippleClient', {
	    hideEdit: false,
	  });
	  gui.Window.get().menu = mb;
	}


	// Moment.js
	moment = __webpack_require__(46);

	// Load app modules
	__webpack_require__(3);
	__webpack_require__(4);
	__webpack_require__(5);
	__webpack_require__(6);
	__webpack_require__(7);
	__webpack_require__(8);
	__webpack_require__(9);
	__webpack_require__(10);
	__webpack_require__(11);
	__webpack_require__(12);
	__webpack_require__(13);
	__webpack_require__(14);
	__webpack_require__(15);
	__webpack_require__(16);
	__webpack_require__(17);
	__webpack_require__(18);
	__webpack_require__(19);
	__webpack_require__(20);
	__webpack_require__(21);
	__webpack_require__(22);
	__webpack_require__(23);
	__webpack_require__(24);
	__webpack_require__(25);
	__webpack_require__(26);
	__webpack_require__(27);
	__webpack_require__(28);
	__webpack_require__(29);

	// Angular module dependencies
	var appDependencies = [
	  'ng',
	  'ngRoute',
	  // Controllers
	  'app',
	  'navbar',
	  // Services
	  'id',
	  'filedialog',
	  // Directives
	  'charts',
	  'effects',
	  'events',
	  'fields',
	  'formatters',
	  'directives',
	  'validators',
	  'datalinks',
	  'errors',
	  // Filters
	  'filters',
	  'ui.bootstrap',
	  'ui.sortable'
	];

	// Load tabs
	var tabdefs = [
	  __webpack_require__(30),
	  __webpack_require__(31),
	  __webpack_require__(32),
	  __webpack_require__(33),
	  __webpack_require__(34),
	  __webpack_require__(35),
	  __webpack_require__(36),
	  __webpack_require__(37),
	  __webpack_require__(38),
	  __webpack_require__(39),
	  __webpack_require__(40),
	  __webpack_require__(41),
	  __webpack_require__(42),
	  __webpack_require__(43),
	  __webpack_require__(44),
	  __webpack_require__(45)
	];

	// Prepare tab modules
	var tabs = tabdefs.map(function (Tab) {
	  var tab = new Tab();

	  if (tab.angular) {
	    var module = angular.module(tab.tabName, tab.angularDeps);
	    tab.angular(module);
	    appDependencies.push(tab.tabName);
	  }

	  return tab;
	});

	var app = angular.module('rp', appDependencies);

	// Global reference for debugging only (!)
	var rippleclient = window.rippleclient = {};
	rippleclient.app = app;
	rippleclient.types = types;

	// Install basic page template
	angular.element('body').prepend(__webpack_require__(53)());

	app.config(['$routeProvider', function ($routeProvider) {
	  // Set up routing for tabs
	  _.each(tabs, function (tab) {
	    if ("function" === typeof tab.generateHtml) {
	      var template = tab.generateHtml();

	      var config = {
	        tabName: tab.tabName,
	        tabClass: 't-'+tab.tabName,
	        pageMode: 'pm-'+tab.pageMode,
	        mainMenu: tab.mainMenu,
	        template: template
	      };

	      $routeProvider.when('/'+tab.tabName, config);
	    }
	  });

	  // Language switcher
	  $routeProvider.when('/lang/:language', {
	    redirectTo: function(routeParams, path, search){
	      lang = routeParams.language;

	      if (!store.disabled) {
	        store.set('ripple_language',lang ? lang : '');
	      }

	      // problem?
	      // reload will not work, as some pages are also available for guests.
	      // Logout will show the same page instead of showing login page.
	      // This line redirects user to root (login) page
	      var port = location.port.length > 0 ? ":" + location.port : "";
	      location.href = location.protocol + '//' + location.hostname  + port + location.pathname;
	    }
	  });

	  $routeProvider.otherwise({redirectTo: '/balance'});
	}]);

	app.run(['$rootScope', '$route', '$routeParams',
	  function ($rootScope, $route, $routeParams)
	  {
	    // This is the desktop client
	    $rootScope.productName = 'Ripple';

	    // Global reference for debugging only (!)
	    if ("object" === typeof rippleclient) {
	      rippleclient.$scope = $rootScope;
	      rippleclient.version = $rootScope.version =
	        angular.element('#version').text();
	    }

	    // Helper for detecting empty object enumerations
	    $rootScope.isEmpty = function (obj) {
	      return angular.equals({},obj);
	    };

	    var scope = $rootScope;
	    $rootScope.$route = $route;
	    $rootScope.$routeParams = $routeParams;
	    $('#main').data('$scope', scope);

	    // Once the app controller has been instantiated
	    // XXX ST: I think this should be an event instead of a watch
	    scope.$watch("app_loaded", function on_app_loaded(oldval, newval) {
	      $('nav a').click(function() {
	        if (location.hash == this.hash) {
	          scope.$apply(function () {
	            $route.reload();
	          });
	        }
	      });
	    });
	  }]);

	if ("function" === typeof angular.resumeBootstrap) angular.resumeBootstrap();


/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = require("nw.gui");

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	var Base58Utils = __webpack_require__(50);

	var RippleAddress = (function () {
	  function append_int(a, i) {
	    return [].concat(a, i >> 24, (i >> 16) & 0xff, (i >> 8) & 0xff, i & 0xff)
	  }

	  function firstHalfOfSHA512(bytes) {
	    return sjcl.bitArray.bitSlice(
	      sjcl.hash.sha512.hash(sjcl.codec.bytes.toBits(bytes)),
	      0, 256
	    );
	  }

	  function SHA256_RIPEMD160(bits) {
	    return sjcl.hash.ripemd160.hash(sjcl.hash.sha256.hash(bits));
	  }

	  return function (seed) {
	    this.seed = Base58Utils.decode_base_check(33, seed);

	    if (!this.seed) {
	      throw "Invalid seed."
	    }

	    this.getAddress = function (seq) {
	      seq = seq || 0;

	      var private_gen, public_gen, i = 0;
	      do {
	        private_gen = sjcl.bn.fromBits(firstHalfOfSHA512(append_int(this.seed, i)));
	        i++;
	      } while (!sjcl.ecc.curves.c256.r.greaterEquals(private_gen));

	      public_gen = sjcl.ecc.curves.c256.G.mult(private_gen);

	      var sec;
	      i = 0;
	      do {
	        sec = sjcl.bn.fromBits(firstHalfOfSHA512(append_int(append_int(public_gen.toBytesCompressed(), seq), i)));
	        i++;
	      } while (!sjcl.ecc.curves.c256.r.greaterEquals(sec));

	      var pubKey = sjcl.ecc.curves.c256.G.mult(sec).toJac().add(public_gen).toAffine();

	      return Base58Utils.encode_base_check(0, sjcl.codec.bytes.fromBits(SHA256_RIPEMD160(sjcl.codec.bytes.toBits(pubKey.toBytesCompressed()))));
	    };
	  };
	})();

	exports.RippleAddress = RippleAddress;



/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * APP
	 *
	 * The app controller manages the global scope.
	 */

	var util = __webpack_require__(47),
	    events = __webpack_require__(48),
	    rewriter = __webpack_require__(54),
	    genericUtils = __webpack_require__(55),
	    Amount = ripple.Amount;

	var module = angular.module('app', []);

	module.controller('AppCtrl', ['$rootScope', '$compile', 'rpId', 'rpNetwork',
	                              'rpKeychain', '$location', '$timeout',
	                              function ($scope, $compile, $id, $net,
	                                        keychain, $location, $timeout)
	{
	  reset();

	  var account;

	  // For announcement banner

	  $scope.showAnnouncement = store.get('announcement');

	  if('undefined' === typeof $scope.showAnnouncement) $scope.showAnnouncement = true;

	  $scope.dismissBanner = function() {
	    store.set('announcement', false);
	    $scope.showAnnouncement = store.get('announcement');
	  }

	  // Global reference for debugging only (!)
	  if ("object" === typeof rippleclient) {
	    rippleclient.id = $id;
	    rippleclient.net = $net;
	    rippleclient.keychain = keychain;
	  }

	  function reset()
	  {
	    $scope.account = {};
	    $scope.lines = {};
	    $scope.offers = {};
	    $scope.events = [];
	    $scope.history = [];
	    $scope.balances = {};
	    $scope.loadState = [];
	    $scope.unseenNotifications = {
	      count: 0
	    };
	  }

	  // Load notification modal
	  $scope.load_notification = function(status) {
	    if (typeof status !== 'string') {
	      console.log("You must pass in a string for the status");
	      return;
	    }

	    $scope.notif = status;

	    $timeout(function() {
	      $scope.notif = "clear";
	    }, 7000);
	  }

	  // TODO fix this
	  $scope.reset = function(){
	    reset();
	  }

	  var myHandleAccountEvent;
	  var myHandleAccountEntry;

	  function handleAccountLoad(e, data)
	  {
	    var remote = $net.remote;

	    account = data.account;

	    reset();

	    var accountObj = remote.account(data.account);

	    // We need a reference to these functions after they're bound, so we can
	    // unregister them if the account is unloaded.
	    myHandleAccountEvent = handleAccountEvent;
	    myHandleAccountEntry = handleAccountEntry;
	    $scope.loadingAccount = true;

	    accountObj.on('transaction', myHandleAccountEvent);
	    accountObj.on('entry', function(data){
	      $scope.$apply(function () {
	        $scope.loadingAccount = false;
	        myHandleAccountEntry(data);
	      });
	    });

	    accountObj.entry(function (err, entry) {
	      if (err) {
	        $scope.loadingAccount = false;
	        $scope.loadState['account'] = true;
	      }
	    });

	    // Ripple credit lines
	    remote.requestAccountLines({account: data.account})
	      .on('success', handleRippleLines)
	      .on('error', handleRippleLinesError).request();

	    // Transactions
	    remote.requestAccountTransactions({
	      account: data.account,
	      ledger_index_min: -1,
	      descending: true,
	      limit: Options.transactions_per_page
	    })
	      .on('success', handleAccountTx)
	      .on('error', handleAccountTxError).request();

	    // Outstanding offers
	    remote.requestAccountOffers({ account: data.account})
	      .on('success', handleOffers)
	      .on('error', handleOffersError).request();
	  }

	  function handleAccountUnload(e, data)
	  {
	    if (myHandleAccountEvent && myHandleAccountEntry) {
	      var remote = $net.remote;
	      var accountObj = remote.account(data.account);
	      accountObj.removeListener('transaction', myHandleAccountEvent);
	      accountObj.removeListener('entry', myHandleAccountEntry);
	    }
	  }

	  function handleRippleLines(data)
	  {
	    $scope.$apply(function () {
	      $scope.lines = {};

	      for (var n=0, l=data.lines.length; n<l; n++) {
	        var line = data.lines[n];

	        // XXX: This reinterpretation of the server response should be in the
	        //      library upstream.
	        line = $.extend({}, line, {
	          limit: ripple.Amount.from_json({value: line.limit, currency: line.currency, issuer: line.account}),
	          limit_peer: ripple.Amount.from_json({value: line.limit_peer, currency: line.currency, issuer: account}),
	          balance: ripple.Amount.from_json({value: line.balance, currency: line.currency, issuer: account})
	        });

	        $scope.lines[line.account+line.currency] = line;
	        updateRippleBalance(line.currency, line.account, line.balance);
	        if(line.account == "rrh7rf1gV2pXAoqA8oYbpHd8TKv5ZQeo67"){
	          store.set('gbi_connected', true);
	        }
	      }
	      console.log('lines updated:', $scope.lines);

	      $scope.$broadcast('$balancesUpdate');

	      $scope.loadState['lines'] = true;
	    });
	  }

	  function handleRippleLinesError(data)
	  {
	    $scope.$apply(function () {
	      $scope.loadState['lines'] = true;
	    });
	  }

	  function handleOffers(data)
	  {
	    $scope.$apply(function () {
	      data.offers.forEach(function (offerData) {
	        var offer = {
	          seq: +offerData.seq,
	          gets: ripple.Amount.from_json(offerData.taker_gets),
	          pays: ripple.Amount.from_json(offerData.taker_pays),
	          flags: offerData.flags
	        };

	        updateOffer(offer);
	      });
	      console.log('offers updated:', $scope.offers);
	      $scope.$broadcast('$offersUpdate');

	      $scope.loadState['offers'] = true;
	    });
	  }

	  function handleOffersError(data)
	  {
	    $scope.$apply(function () {
	      $scope.loadState['offers'] = true;
	    });
	  }

	  function handleAccountEntry(data)
	  {
	    var remote = $net.remote;
	    $scope.account = data;

	    // XXX Shouldn't be using private methods
	    var server = remote._getServer();

	    // As per json wire format convention, real ledger entries are CamelCase,
	    // e.g. OwnerCount, additional convenience fields are lower case, e.g.
	    // reserve, max_spend.
	    var ownerCount  = $scope.account.OwnerCount || 0;
	    $scope.account.reserve_base = server._reserve(0);
	    $scope.account.reserve = server._reserve(ownerCount);
	    $scope.account.reserve_to_add_trust = server._reserve(ownerCount+1);
	    $scope.account.reserve_low_balance = $scope.account.reserve.product_human(2);

	    // Maximum amount user can spend
	    var bal = Amount.from_json(data.Balance);
	    $scope.account.max_spend = bal.subtract($scope.account.reserve);

	    $scope.loadState['account'] = true;
	  }

	  function handleAccountTx(data)
	  {
	    $scope.$apply(function () {
	      $scope.tx_marker = data.marker;

	      if (data.transactions) {
	        data.transactions.reverse().forEach(function (e, key) {
	          processTxn(e.tx, e.meta, true);
	        });

	        $scope.$broadcast('$eventsUpdate');
	      }

	      $scope.loadState['transactions'] = true;
	    });
	  }

	  function handleAccountTxError(data)
	  {
	    $scope.$apply(function () {
	      $scope.loadState['transactions'] = true;
	    });
	  }

	  function handleAccountEvent(e)
	  {
	    $scope.$apply(function () {
	      processTxn(e.transaction, e.meta);
	      $scope.$broadcast('$eventsUpdate');
	    });
	  }

	  /**
	   * Process a transaction and add it to the history table.
	   */
	  function processTxn(tx, meta, is_historic)
	  {
	    var processedTxn = rewriter.processTxn(tx, meta, account);

	    if (processedTxn && processedTxn.error) {
	      var err = processedTxn.error;
	      console.error('Error processing transaction '+processedTxn.transaction.hash+'\n',
	                    err && 'object' === typeof err && err.stack ? err.stack : err);

	      // Add to history only
	      $scope.history.unshift(processedTxn);
	    } else if (processedTxn) {
	      var transaction = processedTxn.transaction;

	      // Update account
	      if (processedTxn.accountRoot) {
	        handleAccountEntry(processedTxn.accountRoot);
	      }

	      // Show status notification
	      if (processedTxn.tx_result === "tesSUCCESS" &&
	          transaction &&
	          !is_historic) {

	        $scope.$broadcast('$appTxNotification', {
	          hash:tx.hash,
	          tx: transaction
	        });
	      }

	      // Add to recent notifications
	      if (processedTxn.tx_result === "tesSUCCESS" &&
	          transaction) {

	        var effects = [];
	        // Only show specific transactions
	        switch (transaction.type) {
	          case 'offernew':
	          case 'exchange':
	            var funded = false;
	            processedTxn.effects.some(function(effect) {
	              if (_.contains(['offer_bought','offer_funded','offer_partially_funded'], effect.type)) {
	                funded = true;
	                effects.push(effect);
	                return true;
	              }
	            });

	            // Only show trades/exchanges which are at least partially funded
	            if (!funded) {
	              break;
	            }
	            /* falls through */
	          case 'received':

	            // Is it unseen?
	            if (processedTxn.date > ($scope.userBlob.data.lastSeenTxDate || 0)) {
	              processedTxn.unseen = true;
	              $scope.unseenNotifications.count++;
	            }

	            processedTxn.showEffects = effects;
	            $scope.events.unshift(processedTxn);
	        }
	      }

	      // Add to history
	      $scope.history.unshift(processedTxn);

	      // Update Ripple lines
	      if (processedTxn.effects && !is_historic) {
	        updateLines(processedTxn.effects);
	      }

	      // Update my offers
	      if (processedTxn.effects && !is_historic) {
	        // Iterate on each effect to find offers
	        processedTxn.effects.forEach(function (effect) {
	          // Only these types are offers
	          if (_.contains([
	            'offer_created',
	            'offer_funded',
	            'offer_partially_funded',
	            'offer_cancelled'], effect.type))
	          {
	            var offer = {
	              seq: +effect.seq,
	              gets: effect.gets,
	              pays: effect.pays,
	              deleted: effect.deleted,
	              flags: effect.flags
	            };

	            updateOffer(offer);
	          }
	        });

	        $scope.$broadcast('$offersUpdate');
	      }
	    }
	  }

	  function updateOffer(offer)
	  {
	    if (offer.flags && offer.flags === ripple.Remote.flags.offer.Sell) {
	      offer.type = 'sell';
	      offer.first = offer.gets;
	      offer.second = offer.pays;
	    } else {
	      offer.type = 'buy';
	      offer.first = offer.pays;
	      offer.second = offer.gets;
	    }

	    if (!offer.deleted) {
	      $scope.offers[""+offer.seq] = offer;
	    } else {
	      delete $scope.offers[""+offer.seq];
	    }
	  }

	  function updateLines(effects)
	  {
	    if (!$.isArray(effects)) return;

	    var balancesUpdated;

	    $.each(effects, function () {
	      if (_.contains([
	        'trust_create_local',
	        'trust_create_remote',
	        'trust_change_local',
	        'trust_change_remote',
	        'trust_change_balance',
	        'trust_change_no_ripple'], this.type))
	      {
	        var effect = this,
	            line = {},
	            index = effect.counterparty + effect.currency;

	        line.currency = effect.currency;
	        line.account = effect.counterparty;
	        line.flags = effect.flags;
	        line.no_ripple = !!effect.noRipple; // Force Boolean

	        if (effect.balance) {
	          line.balance = effect.balance;
	          updateRippleBalance(effect.currency,
	                                    effect.counterparty,
	                                    effect.balance);
	          balancesUpdated = true;
	        }

	        if (effect.deleted) {
	          delete $scope.lines[index];
	          return;
	        }

	        if (effect.limit) {
	          line.limit = effect.limit;
	        }

	        if (effect.limit_peer) {
	          line.limit_peer = effect.limit_peer;
	        }

	        $scope.lines[index] = $.extend($scope.lines[index], line);
	      }
	    });

	    if (balancesUpdated) $scope.$broadcast('$balancesUpdate');
	  }

	  function updateRippleBalance(currency, new_account, new_balance)
	  {
	    // Ensure the balances entry exists first
	    if (!$scope.balances[currency]) {
	      $scope.balances[currency] = {components: {}, total: null};
	    }

	    var balance = $scope.balances[currency];

	    if (new_account) {
	      balance.components[new_account] = new_balance;
	    }

	    $(balance.components).sort(function(a,b){
	      return a.compareTo(b);
	    });

	    balance.total = null;
	    for (var counterparty in balance.components) {
	      var amount = balance.components[counterparty];
	      balance.total = balance.total ? balance.total.add(amount) : amount;
	    }
	  }

	  $scope.currencies_all = __webpack_require__(57);

	  // prefer currency full_names over whatever the local storage has saved
	  var storeCurrenciesAll = store.get('ripple_currencies_all') || [];

	  // run through all currencies
	  _.each($scope.currencies_all, function(currency) {

	    // find the currency in the local storage
	    var allCurrencyHit = _.where(storeCurrenciesAll, {value: currency.value})[0];

	    // if the currency already exists in local storage, updated only the name
	    if (allCurrencyHit) {
	      allCurrencyHit.name = currency.name;
	    } else {
	      // else append the currency to the storeCurrenciesAll array
	      storeCurrenciesAll.push(currency);
	    }
	  });

	  $scope.currencies_all = storeCurrenciesAll;

	  // Personalized default pair set
	  if (!store.disabled && !store.get('ripple_pairs_all')) {
	    store.set('ripple_pairs_all',__webpack_require__(58));
	  }

	  var pairs_all = store.get('ripple_pairs_all');
	  var pairs_default = __webpack_require__(58);
	  $scope.pairs_all = genericUtils.uniqueObjArray(pairs_all, pairs_default, 'name');

	  function compare(a, b) {
	    if (a.order < b.order) return 1;
	    if (a.order > b.order) return -1;
	    return 0;
	  }

	  // sort currencies and pairs by order
	  $scope.currencies_all.sort(compare);

	  function compare_last_used(a, b) {
	    var time_a = a.last_used || a.order || 0;
	    var time_b = b.last_used || b.order || 0;
	    if (time_a < time_b) return 1;
	    if (time_a > time_b) return -1;
	    return 0;
	  }
	  $scope.pairs_all.sort(compare_last_used);

	  $scope.currencies_all_keyed = {};
	  _.each($scope.currencies_all, function(currency){
	    $scope.currencies_all_keyed[currency.value] = currency;
	  });

	  $scope.$watch('currencies_all', function(){
	    if (!store.disabled) {
	      store.set('ripple_currencies_all',$scope.currencies_all);
	    }
	  }, true);

	  $scope.$watch('pairs_all', function(){
	    if (!store.disabled) {
	      store.set('ripple_pairs_all',$scope.pairs_all);
	    }
	  }, true);

	  $scope.pairs = $scope.pairs_all.slice(1);

	  $scope.app_loaded = true;

	  // Moved this to the run block
	  // Nav links same page click fix
	  // $('nav a').click(function(){
	  //   if (location.hash == this.hash) {
	  //     location.href="#/";
	  //     location.href=this.href;
	  //   }
	  // });

	  $scope.$on('$idAccountLoad', function (e, data) {
	    // fix blob if wrong
	    if (_.isArray($scope.userBlob.data.clients)) {
	      $scope.userBlob.unset('/clients');
	    }

	    // Server is connected
	    if ($scope.connected) {
	      handleAccountLoad(e, data);
	    }

	    // Server is not connected yet. Handle account load after server response.
	    $scope.$on('$netConnected', function(){
	      if ($.isEmptyObject($scope.account)) {
	        $scope.$broadcast('$idAccountUnload', {account: $scope.account});
	        handleAccountLoad(e, data);
	      }
	    });
	  });

	  $scope.$on('$idAccountUnload', handleAccountUnload);

	  // XXX: The app also needs to handle updating its data when the connection is
	  //      lost and later re-established. (... or will the Ripple lib do that for us?)
	  var removeFirstConnectionListener =
	        $scope.$on('$netConnected', handleFirstConnection);
	  function handleFirstConnection() {
	    removeFirstConnectionListener();
	  }

	  $net.listenId($id);
	  $net.init();
	  $id.init();

	  $scope.logout = function () {
	    $id.logout();
	    location.reload();
	  };

	  $scope.$on('$idRemoteLogout', handleRemoteLogout);
	  function handleRemoteLogout()
	  {
	    location.reload();
	  }

	  // Generate an array of source currencies for path finding.
	  // This will generate currencies for every issuers.
	  // It will also generate a self-issue currency for currencies which have multi issuers.
	  //
	  // Example balances for account rEXAMPLE:
	  //   CNY: rCNY1
	  //        rCNY2
	  //   BTC: rBTC
	  // Will generate:
	  //   CNY/rEXAMPLE
	  //   CNY/rCNY1
	  //   CNY/rCNY2
	  //   BTC/rBTC
	  $scope.generate_src_currencies = function () {
	    var src_currencies = [];
	    var balances = $scope.balances;
	    var isIssuer = $scope.generate_issuer_currencies();
	    src_currencies.push({ currency: "XRP" });
	    for (var currency_name in balances) {
	      if (!balances.hasOwnProperty(currency_name)) continue;

	      var currency = balances[currency_name];
	      var currency_hex = currency.total.currency().to_hex();
	      var result = [];
	      for (var issuer_name in currency.components)
	      {
	        if (!currency.components.hasOwnProperty(issuer_name)) continue;
	        var component = currency.components[issuer_name];
	        if (component.is_positive())
	          result.push({ currency: currency_hex, issuer: issuer_name});
	      }

	      if (result.length > 1 || isIssuer[currency_hex] || result.length === 0)
	        result.unshift({ currency: currency_hex });

	      src_currencies = src_currencies.concat(result);
	    }
	    return src_currencies;
	  };

	  $scope.generate_issuer_currencies = function () {
	    var isIssuer = {};
	    _.each($scope.lines, function(line){
	      if (line.limit_peer.is_positive()) {
	        isIssuer[line.balance.currency().to_hex()] = true;
	      }
	    });
	    return isIssuer;
	  };

	  /**
	   * Testing hooks
	   */
	  this.reset                  =  reset;
	  this.handleAccountLoad      =  handleAccountLoad;
	  this.handleAccountUnload    =  handleAccountUnload;
	  this.handleRemoteLogout     =  handleRemoteLogout;
	  this.handleRippleLines      =  handleRippleLines;
	  this.handleRippleLinesError =  handleRippleLinesError;
	  this.handleOffers           =  handleOffers;
	  this.handleOffersError      =  handleOffersError;
	  this.handleAccountEntry     =  handleAccountEntry;
	  this.handleAccountTx        =  handleAccountTx;
	  this.handleAccountTxError   =  handleAccountTxError;
	  this.handleAccountEvent     =  handleAccountEvent;
	  this.processTxn             =  processTxn;
	  this.updateOffer            =  updateOffer;
	  this.updateLines            =  updateLines;
	  this.updateRippleBalance    =  updateRippleBalance;
	  this.compare                =  compare;
	  this.handleFirstConnection  =  handleFirstConnection;
	}]);


/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * NAVBAR
	 *
	 * The navbar controller manages the bar at the top of the screen.
	 */

	var Amount = ripple.Amount,
	    rewriter = __webpack_require__(54);

	var module = angular.module('navbar', []);

	module.controller('NavbarCtrl', ['$scope', '$element', '$compile', 'rpId',
	                                 'rpNetwork', '$location',
	                                 function ($scope, el, $compile, $id,
	                                           network, $location)
	{
	  var queue = [];
	  var tickInterval = 4000;
	  var tickUpcoming = false;

	  var tplAccount = __webpack_require__(59);

	  // Activate #status panel
	  $scope.toggle_secondary = function () {
	    $scope.show_secondary = !$scope.show_secondary;
	  };

	  function serverStatusUpdate() {
	    $scope.fee = network.remote.createTransaction()._computeFee();

	    if (!$scope.connected && $scope.userCredentials.username) {
	      $scope.serverStatus = 'disconnected';
	    }
	    else if ($scope.connected && $scope.fee) {
	      if ((parseFloat(ripple.Amount.from_json($scope.fee).to_human()) > parseFloat(Options.low_load_threshold)) && (parseFloat($scope.fee) < parseFloat(Options.max_tx_network_fee))) {
	        $scope.serverLoad = 'mediumLoad';
	        $scope.serverStatus = 'mediumLoad';
	      } else if (parseFloat($scope.fee) >= parseFloat(Options.max_tx_network_fee)) {
	        $scope.serverLoad = 'highLoad';
	        $scope.serverStatus = 'highLoad';
	      } else {
	        $scope.serverLoad = '';
	        $scope.serverStatus = 'lowLoad';
	      }
	    }
	    else {
	      $scope.serverStatus = 'connected';
	    }
	  }

	  $scope.$watch('connected', serverStatusUpdate, true);

	  // Username
	  $scope.$watch('userCredentials', serverStatusUpdate, true);

	  $scope.$on('$netConnected', function(e) {
	    setConnectionStatus(true);
	  });

	  $scope.$on('$netDisconnected', function(e) {
	    setConnectionStatus(false);
	  });

	  var updateNotifications = function() {
	    if ($scope.events) {
	      $scope.notifications = $scope.events.slice(0,10);
	    }
	  };

	  $scope.$on('$eventsUpdate', updateNotifications);

	  /**
	   * Marks all the notifications as seen.
	   */
	  $scope.read = function() {
	    // don't do anything if account is unfunded
	    if (!$scope.notifications.length)
	      return;

	    var lastTxDate = $scope.notifications[0].date;

	    if ($scope.unseen > 0) {
	      $scope.unseen = 0;
	    }

	    if (($scope.userBlob.data.lastSeenTxDate || 0) < lastTxDate) {
	      // Remember last seen date
	      $scope.userBlob.set("/lastSeenTxDate", lastTxDate);

	      // Reset the counter
	      $scope.unseen = $scope.unseenNotifications.count;
	      $scope.unseenNotifications.count = 0;

	      // Set seen for all the events
	//      _.each($scope.events, function(event){
	//        event.unseen = false;
	//      })
	    }
	  };

	  /**
	   * Graphically display a network-related notifications.
	   *
	   * This function does no filtering - we assume that any transaction that makes
	   * it here is ready to be rendered by the notification area.
	   *
	   * @param {Object} e Angular event object
	   * @param {Object} tx Transaction info, returned from JsonRewriter#processTxn
	   */

	// VH: Hiding this for now.
	//  $scope.$on('$appTxNotification', function (e, tx) {
	//    var $localScope = $scope.$new();
	//    $localScope.tx = tx.tx;
	//
	//    var html = tplAccount($localScope);
	//
	//    if (html.length) {
	//      var msg = $compile(html)($localScope);
	//      enqueue(msg);
	//    }
	//  });

	  function setConnectionStatus(connected) {
	    $scope.connected = !!connected;
	  }

	  // A notification might have been queued already before the app was fully
	  // initialized. If so, we display it now.
	  if (queue.length) tick();

	  var notifyEl = $('<div>').attr('id', 'notification').insertAfter(el);

	  // Default to disconnected
	  setTimeout(function() {
	    setConnectionStatus($scope.connected);
	  }, 1000 * 3);

	  /**
	   * Add the status message to the queue.
	   */
	  function enqueue(msg)
	  {
	    queue.push(msg);
	    if (!tickUpcoming) {
	      setImmediate(tick);
	    }
	  }

	  /**
	   * Proceed to next notification.
	   */
	  var prevEl = null;
	  function tick()
	  {
	    if (prevEl) {
	      // Hide notification box
	      prevEl.removeClass('active');
	      var prevElRef = prevEl;
	      setTimeout(function () {
	        prevElRef.remove();
	      }, 1000);
	      prevEl = null;
	    }

	    tickUpcoming = false;
	    if (queue.length) {
	      // Ensure secondary currencies pulldown is closed
	      $scope.$apply(function() {
	        $scope.show_secondary = false;
	      });

	      // Show next status message
	      var next = queue.shift();

	      var el = $(next);
	      el.addClass('notification');
	      el.appendTo(notifyEl);
	      setImmediate(function () {
	        el.addClass('active');
	      });

	      prevEl = el;

	      tickUpcoming = true;
	      setTimeout(tick, tickInterval);
	    }
	  }

	  updateNotifications();

	  // Testing Hooks
	  this.setConnectionStatus = setConnectionStatus;
	  this.enqueue             = enqueue;
	  this.tick                = tick;
	}]);


/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * CHARTS
	 *
	 * Charts and data visualization directives go into this file.
	 */

	var module = angular.module('charts', []);

	/**
	 * Trust line graph. (Similar to small box plot.)
	 */
	module.directive('rpTrustLine', ['$filter', function($filter) {
	  function redraw(ctx, data) {
	    // Axis distance to left and right edges
	    var axisMargin = 30;
	    // Tick length away from axis
	    var tickLen    = 5;
	    // Thickness of bars
	    var barWidth   = 6;
	    // Offset for text below axis
	    var lowText    = 16;
	    // Offset for text above bar
	    var highText   = -10;

	    // Fetch size of canvas
	    var width      = ctx.canvas.width;
	    var height     = ctx.canvas.height;
	    var axisLen    = width - axisMargin * 2;
	    var axisY      = Math.floor(height/2);

	    // Clear canvas
	    ctx.clearRect(0, 0, width, height);

	    // Parse input data
	    var trust_l, trust_r, balance;
	    try {
	      trust_l = -data.limit_peer.to_number();
	      trust_r = data.limit.to_number();
	      balance = data.balance.to_number();
	    } catch (e) {
	      // In case of invalid input data we simply skip drawing the chart.
	      return;
	    }

	    // Calculate minimum and maximum logical point
	    var min        = Math.min(balance, trust_l);
	    var max        = Math.max(balance, trust_r);
	    var scale      = axisLen / (max - min);

	    ctx.lineWidth = 2;
	    ctx.strokeStyle = '#333';

	    // Draw balance
	    if (balance > 0) {
	      ctx.beginPath();
	      ctx.rect(f(0), axisY-barWidth, f(balance)-f(0), barWidth);
	      ctx.fillStyle = 'green';
	      ctx.fill();
	    } else {
	      ctx.beginPath();
	      ctx.rect(f(balance), axisY, f(0)-f(balance), barWidth);
	      ctx.fillStyle = balance === 0 ? 'black' : 'red';
	      ctx.fill();
	    }

	    ctx.beginPath();
	    // Draw axis
	    ctx.moveTo(f(trust_l), axisY);
	    ctx.lineTo(f(trust_r), axisY);
	    // Left end tick
	    ctx.moveTo(f(trust_l), axisY-tickLen);
	    ctx.lineTo(f(trust_l), axisY+tickLen);
	    // Right end tick
	    ctx.moveTo(f(trust_r), axisY-tickLen);
	    ctx.lineTo(f(trust_r), axisY+tickLen);
	    // Origin tick
	    ctx.moveTo(f(0),       axisY-tickLen);
	    ctx.lineTo(f(0),       axisY+tickLen);
	    ctx.stroke();

	    // Draw labels
	    var rpamount = $filter('rpamount');
	    var fmt = {rel_precision: 0};
	    ctx.font = "11px sans-serif";
	    ctx.textAlign = 'center';
	    ctx.fillText(rpamount(data.balance, fmt), f(balance), axisY+highText);
	    ctx.fillStyle = '#333';

	    var lAmount = rpamount(data.limit_peer, fmt);

	    if (0 !== trust_l)
	      lAmount = "-"+lAmount;

	    if (trust_l === trust_r && 0 === trust_l) {
	      lAmount = "0 / 0";
	    } else {
	      ctx.fillText(rpamount(data.limit, fmt), f(trust_r), axisY+lowText);
	    }

	    ctx.fillText(lAmount, f(trust_l), axisY+lowText);

	    // Exchange a value to a pixel position
	    function f(val)
	    {
	      // Enforce limits
	      val = Math.min(val, max);
	      val = Math.max(val, min);
	      return Math.round((val - min) * scale + axisMargin);
	    }
	  }

	  return {
	    restrict: 'E',
	    template: '<canvas width="140" height="50">',
	    scope: {
	      data: '=rpLineData'
	    },
	    link: function(scope, elm, attrs) {
	      var ctx = elm.find('canvas')[0].getContext('2d');

	      redraw(ctx, scope.data);

	      scope.$watch('data', function () {
	        redraw(ctx, scope.data);
	      }, true);
	    }
	  };
	}]);



	/**
	 * Balance pie chart
	 */
	module.directive('rpPieChart', ['$filter', function($filter) {
	  var rpcurrency = $filter('rpcurrency');
	  var rpcontactname = $filter('rpcontactname');
	  function contactButNotXrp(x) {
	    return x==="XRP" ? "XRP" : rpcontactname(x);
	  }

	  // Create a pie chart in the element, using the data on the scope.
	  function pieChart(element, scope) {
	    
	    var SIZE = parseInt(scope.size, 10);
	    
	    // Main function
	    function drawPieChart(container, exchangeRates, drops, ious) {
	      
	      if (!(drops && exchangeRates && Object.keys(exchangeRates).length)) {
	        return;
	      }
	      
	      var xrpAsSuch = parseInt(drops,10) / 1000000;      
	      
	      // We construct an array of "pieces", which each correspond to one piece of the pie,
	      // containing information that will be extracted to calculate the appearance of each sector.
	      var pieces = [{
	        issuerSubshares: [{
	          issuer: "XRP",
	          subbalance: xrpAsSuch
	        }],
	        amountForCurrency: "0"
	      }];
	        
	      function descendingBy(key) {
	        return function(a,b) {
	          return b[key] - a[key];
	        };
	      }
	        
	      var totalAsXrp = xrpAsSuch;
	      for (var cur in ious) {if (ious.hasOwnProperty(cur)){
	        var components = ious[cur].components;
	        var issuerSubshares = [];
	        var issuer;
	        for (issuer in components) {if (components.hasOwnProperty(issuer)){
	          var amount = components[issuer].to_number();
	          // The chart ignores negative balances. The user should be notified (separately) of this omission.
	          if (amount > 0) {
	            var subbalanceAsXrp = amount * (exchangeRates[cur+":"+issuer] || 0);
	            totalAsXrp += subbalanceAsXrp;
	            issuerSubshares.push({
	              issuer: contactButNotXrp(issuer),
	              subbalance: subbalanceAsXrp
	            });
	          }
	        }}
	        issuerSubshares.sort(descendingBy("subbalance"));
	        pieces.push({
	          issuerSubshares: issuerSubshares,
	          amountForCurrency: components[issuer]
	        });
	      }}
	      
	      // Now, go through the list of pieces and do the following for each:
	      // -Divide all the subbalances by totalAsXrp, inserting the result as "subshare"s
	      // -Insert the sum of the "subshare"s as "share"
	      // -Insert "currency" by translating "amountForCurrency" into a currency
	      var i, j, piece;
	      for (i=0; i<pieces.length; i++) {
	        piece = pieces[i];
	        var share = 0;
	        for (j=0; j<piece.issuerSubshares.length; j++) {
	          var is = piece.issuerSubshares[j];
	          is.subshare = is.subbalance / totalAsXrp;
	          share += is.subshare;
	        }
	        piece.share = share;
	        piece.currency = rpcurrency(piece.amountForCurrency);
	      }
	      
	      pieces.sort(descendingBy("share"));
	      
	      
	      // Reset the container
	      container.find('*').remove()
	      container.append('<svg></svg>');
	      
	      // Draw the subsectors          
	      function selectValue(name) {
	        return function(o) {
	          return o[name];
	        }
	      }
	      var p, offset=0, broken=false;
	      for (p=0; p<pieces.length; p++) {
	        piece = pieces[p];
	        if (p>0) {
	          offset += pieces[p-1].share;
	        }
	        if (offset < 0.97) {
	          drawSectors(
	            container,
	            piece.issuerSubshares.map(selectValue("subshare")),
	            piece.issuerSubshares.map(selectValue("issuer")),
	            "sub",
	            piece.currency,
	            offset
	          );
	        } else if (offset < 0.999999999999) { // (to account for floating-point errors)
	          // We've come to the limit, and so we'll lump the rest in under "other".
	          broken = true;
	          drawSectors(container, [1 - offset], ["other"], "sub", "other", offset);
	          break;
	        }
	      }
	      if (broken) {
	        pieces.length = p;
	        pieces.push({
	          share: 1 - offset,
	          currency: "other" // We are trusting here that no actual currency will ever be called "other".
	        });
	      }

	      // Draw the main sectors.
	      // This must come last, so that the onMouseOver works.
	      drawSectors(
	        container,
	        pieces.map(selectValue("share")),
	        pieces.map(selectValue("currency")),
	        "main",
	        pieces.map(selectValue("currency"))
	      );
	      
	      // Draw the hole in the middle
	      $('<circle></circle>').appendTo(container.find('svg')).attr({
	        "class": "hole",
	        cx:   SIZE/2,
	        cy:   SIZE/2,
	        r:    SIZE/6
	      });
	      
	      // Refresh the DOM (because JQuery and SVG don't play nice)
	      container.html(container.html());
	      
	      // Center text elements
	      container.find("text").each(function(){
	        var width = $(this)[0].getBBox().width;
	        var x = $(this).attr("x");
	        $(this).attr("x",x - width/2);
	      });
	      
	      // Resolve collisions and adjust viewBox
	      var extremeBounds = resolveCollisions(container);
	      var PADDING = 5
	      container.find('svg')[0].setAttribute("viewBox", [
	        (extremeBounds.left-PADDING),
	        (extremeBounds.top-PADDING),
	        (extremeBounds.right-extremeBounds.left+PADDING*2),
	        (extremeBounds.bottom-extremeBounds.top+PADDING*2)
	      ].join(" "));
	      
	      // Define hovering behavior
	      container.find("path.main").on("mouseover", function(){
	        var group = $(this).attr("group");
	        container.find(".main text").css("opacity",0);
	        container.find(".main path").css("opacity",0.125);
	        $(this).css("opacity",0);
	        container.find(".sub[group='"+group+"']").css("opacity",1);
	      }).on("mouseout", function(){
	        container.find(".main").css("opacity",1);
	        container.find(".sub").css("opacity",0);
	      });
	      
	    }
	    
	    // Given a container, and parallel arrays "shares" and "labels",
	    // draw sectors on the container's SVG element, with the given "cssClass" and "grouping".
	    // Off-set the whole thing by "offset" turns.
	    function drawSectors(container, shares, labels, cssClass, grouping, offset) {
	      var TAU = Math.PI*2;
	      if (shares.length && shares[0] === 1) {
	        shares[0] = 0.9999;
	      }
	      if (offset) {
	        shares.unshift(offset);
	        labels.unshift("!!!"); // If you see this in the view, something's wrong.
	      }
	      
	      
	      var boundaries = [];
	      var sum = 0;
	      var i;
	      for (i=0; i<shares.length; i++) {
	        boundaries.push(shares[i]+sum);
	        sum += shares[i];
	      }
	      var boundaryAngles = boundaries.map(function(x){return x*TAU;});
	      
	      var midpoints = [];
	      for (i=0; i<shares.length; i++) {
	        midpoints.push((boundaries[i-1]||0) + shares[i]/2);
	      }
	      var midpointAngles = midpoints.map(function(x){return x*TAU;});
	      
	      var center = [SIZE/2,SIZE/2];
	      var circleRadius = SIZE/2;
	      
	      var polarToRect = function(radius, angle) {
	        return [
	          center[0]+radius*Math.sin(angle), 
	          center[1]-radius*Math.cos(angle)
	        ];
	      };
	      
	      
	      var sectors = [];
	      for ((offset ? i=1 : i=0); i<shares.length; i++) {
	        var share = shares[i];
	        if (share !== 0) {
	          var pointA = polarToRect(circleRadius, boundaryAngles[i-1]||0);
	          var pointB = polarToRect(circleRadius, boundaryAngles[i]);
	          var labelCoords = polarToRect(circleRadius+20, midpointAngles[i]);
	          var labelPosition = {
	            x: labelCoords[0],
	            y: labelCoords[1]
	          };
	          
	          sectors.push({
	            path: "M "+center.join(",")+
	              " L "+pointA.join(",")+
	              " A "+circleRadius+","+circleRadius+
	              " 0,"+(shares[i]>0.5?"1":"0")+",1 "+
	              pointB.join(",")+" Z",
	            labelPosition: labelPosition,
	            labelText: labels[i],
	            group: "string"===typeof(grouping) ? grouping : grouping[i],
	            share: share
	          });
	        }
	      }

	      var svg = container.find('svg').attr({
	        width: "100%",
	        height: SIZE*19/12,
	        "xmlns:svg": "http://www.w3.org/2000/svg",
	        "xmlns":     "http://www.w3.org/2000/svg"
	      });
	      
	      var sector, g;
	      for (i=0; i<sectors.length; i++) {
	        sector = sectors[i];
	        
	        var colorClass = sector.group.toLowerCase();
	        if (!({
	          xrp: true,
	          usd: true,
	          btc: true,
	          eur: true,
	          cny: true,
	          jpy: true,
	          cad: true, // If we add any more specific currency colors, add them to this list also.
	          other: true
	        }).hasOwnProperty(colorClass)) {
	          colorClass = "generic" + (i%2 + 1);
	        }
	        g = $('<g></g>').appendTo(svg).attr({
	          "class": cssClass + " " + colorClass,
	          group: sector.group
	        });
	        
	        $('<path></path>').appendTo(g).attr({
	          d: sector.path,
	          "class": cssClass,
	          group: sector.group
	        });
	      }

	      for (i=0; i<sectors.length; i++) {
	        sector = sectors[i];
	        
	        g = $('<g></g>').appendTo(svg).attr({
	          "class": cssClass + " pielabel",
	          group: sector.group
	        });
	        
	        $('<text></text>').appendTo(g).text(sector.labelText).attr({
	          x: sector.labelPosition.x,
	          y: sector.labelPosition.y,
	          "class": cssClass,
	          group: sector.group
	        });
	        
	        var percentage = Math.round(sector.share*100);
	        if (percentage === 0 && sector.share > 0) {
	          percentage = "<1";
	        }
	        
	        $('<text></text>').appendTo(g).text(percentage+"%").attr({
	          "class": cssClass + " percentage",
	          x: sector.labelPosition.x,
	          y: sector.labelPosition.y+14,
	          group: sector.group
	        });
	      }
	    }

	    // Move the labels around until they don't overlap, and return the extreme bounding box.
	    // (The adjustment is only done a finite number of times, to avoid an infinite loop.)
	    function resolveCollisions(container) {
	      var svg = container.find('svg');
	      var bounds = [];

	      var iterations=0, mainBounds, changed, temp;
	      do {
	        temp = resolveCollisionsInSelection(svg.find("g.main.pielabel"));
	        mainBounds = temp[0];
	        changed = temp[1];
	        iterations++;
	      } while (changed && iterations<10);
	      bounds.push(mainBounds);
	      
	      var groups = {};
	      svg.find("g.sub.pielabel").each(function(){
	        groups[$(this).attr("group")] = true;
	      });
	      var okg = Object.keys(groups);
	      var i;
	      var groupBounds;
	      for (i=0; i<okg.length; i++) {
	        var group = okg[i];
	        var selection = svg.find("g.sub.pielabel[group='"+group+"']");
	        iterations = 0;
	        do {
	          temp = resolveCollisionsInSelection(selection);
	          groupBounds = temp[0];
	          changed = temp[1];
	          iterations++;
	        } while (changed && iterations<10);
	        bounds.push(groupBounds);
	      }
	      return findExtremeBounds(bounds);
	    }
	    
	    // Given a list of "bounds" objects, find the smallest bound that contains them all.
	    function findExtremeBounds(bounds) {
	      var extrema = {
	        left:    0,
	        right:  SIZE,
	        top:     0,
	        bottom: SIZE
	      };
	      
	      for (var i=0; i<bounds.length; i++) {
	        var bound = bounds[i];
	        extrema = {
	          left:   Math.min(extrema.left, bound.left),
	          right:  Math.max(extrema.right, bound.right),
	          top:    Math.min(extrema.top, bound.top),
	          bottom: Math.max(extrema.bottom, bound.bottom)
	        };
	      }
	      return extrema;
	    }
	    
	    // Given a selection, move the labels around if they collide.
	    // Returns an array: [
	    //   The extreme bounds after moving the labels, and
	    //   true/false whether anything was moved.
	    // ]
	    function resolveCollisionsInSelection(selection) {
	      var bounds = [];
	      selection.each(function(){
	        var bbox = $(this)[0].getBBox();
	        bounds.push({
	          left:   bbox.x,
	          right:  bbox.x+bbox.width,
	          top:    bbox.y,
	          bottom: bbox.y+bbox.height
	        });
	      });
	      var collisions = {};
	      var collider, collidee;
	      for (collider=0; collider<bounds.length; collider++) {
	        var colliderBounds = bounds[collider];
	        for (collidee=0; collidee<bounds.length; collidee++) { if (collider !== collidee) {
	          var collideeBounds = bounds[collidee];
	          var collisionLR = colliderBounds.right - collideeBounds.left;
	          var collisionRL = colliderBounds.left - collideeBounds.right;
	          var collisionTB = colliderBounds.bottom - collideeBounds.top;
	          var collisionBT = colliderBounds.top - collideeBounds.bottom;
	          
	          if (collisionLR > 0 && collisionRL < 0 && collisionTB > 0 && collisionBT < 0) {
	            if (!collisions[collider]) {
	              collisions[collider] = {};
	            }
	            if (!collisions[collider][collidee]) {
	              collisions[collider][collidee] = {};
	            }
	            collisions[collider][collidee] = {
	              x: (collisionLR > -collisionRL ? collisionRL : collisionLR),
	              y: (collisionTB > -collisionBT ? collisionBT : collisionTB)
	            };
	          }
	        }}
	      }
	      
	      function adjustBy(collision, coordinate) {
	        return function() {
	          var t = $(this).attr(coordinate);
	          var adjustment = collision[coordinate];
	          $(this).attr(coordinate,t-adjustment/1.9);
	        }
	      }
	      
	      for (collider in collisions) {if (collisions.hasOwnProperty(collider)) {
	        var collidingWith = collisions[collider];
	        for (collidee in collidingWith) {if (collidingWith.hasOwnProperty(collidee)) {
	          var collision = collidingWith[collidee];
	          var g = $(selection[collider]);
	          if (Math.abs(collision.x) < Math.abs(collision.y)) {
	            g.find("text").each(adjustBy(collision,"x"));
	          } else {
	            g.find("text").each(adjustBy(collision,"y"));
	          }
	        }}
	      }}
	            
	      return [
	        findExtremeBounds(bounds),
	        !!(Object.keys(collisions).length)
	      ];
	    }
	    
	    
	    // Finally, call the main function.
	    drawPieChart(element, scope.exchangeRates, scope.drops, scope.ious);
	  }
	  
	  return {
	    restrict: 'E',
	    scope: {
	      drops: '=rpDrops',
	      ious: '=rpIous',
	      exchangeRates: '=rpExchangeRates',
	      size: '@rpSize'
	    },
	    link: function(scope, element, attributes) {
	      pieChart(element, scope),
	      scope.$watch('drops', function() {
	        pieChart(element, scope);
	      });
	      
	      scope.$on('$balancesUpdate', function() {
	        pieChart(element, scope);
	      });
	      
	      scope.$watch('exchangeRates', function() {
	        pieChart(element, scope);
	      }, true);
	    }
	  };
	}]); 





/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * FIELDS
	 *
	 * Angular-powered input components go into this file.
	 */

	var webutil = __webpack_require__(51);

	var module = angular.module('fields', []);

	/**
	 * Combobox input element.
	 *
	 * Adds a autocomplete-like dropdown to an input element.
	 *
	 * @param {string} rpCombobox Pass a function that takes a string and returns
	 *   the matching autocompletions.
	 */
	module.directive('rpCombobox', [function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, el, attrs, ngModel) {
	      var keyCursor = -1;

	      el.wrap('<div class="rp-combobox">');
	      el.attr('autocomplete', 'off');
	      var cplEl = $('<ul class="completions"></ul>').hide();
	      el.parent().append(cplEl);

	      // Explicit select button
	      if (attrs.rpComboboxSelect) {
	        var selectEl = $('<div>').appendTo(el.parent());
	        selectEl.addClass('select');
	        selectEl.mousedown(function (e) {
	          e.preventDefault();
	        });
	        selectEl.click(function () {
	          var complFn = scope.$eval(attrs.rpCombobox);
	          if ("function" !== typeof complFn) {
	            var options = complFn;
	            complFn = webutil.queryFromOptions(complFn);
	            scope.$watch(options, function(value) {
	              setCompletions(complFn());
	            });
	          }
	          setCompletions(complFn());
	          if (cplEl.is(':visible')) {
	            el.blur();
	          } else {
	            setCompletions(complFn());
	            el.focus();
	          }
	        });
	      }

	      // Listen for keyboard keydown events
	      el.keydown(function (e) {
	        // "Up/Down" key press
	        if (e.which === 38 || e.which === 40) {
	          if (!cplEl.children().length) {
	            updateCompletions();
	          }
	          e.preventDefault();

	          // Move cursor (highlighted option) up/down
	          if (e.which === 38) keyCursor--;
	          else keyCursor++;

	          updateKeyCursor();
	        }

	        // "Enter" key press (select the option)
	        else if (e.which === 13) {
	          var curEl = cplEl.find('li.cursor');
	          if (cplEl.is(':visible')) {
	            e.preventDefault();
	          }
	          if (cplEl.find('li').length === 1) {
	            // Only one completion, we'll assume that's the one they want
	            selectCompletion(cplEl.find('li'));
	          } else if (curEl.length === 1) {
	            selectCompletion(curEl);
	          }
	        }

	        // "ESC" key press
	        else if (e.which === 27) {
	          // Hide the options list
	          setVisible(false);
	        }
	      });

	      // Listen for keyboard keyup events to enable binding
	      el.keyup(function(e) {
	        // Ignore Left, up, right, down
	        if (e.which >= 37 && e.which <= 40) return;
	        // Ignore Enter, Esc
	        if (e.which === 13 || e.which === 27) return;

	        // Any other keypress should update completions list
	        updateCompletions();
	      });

	      el.focus(function() {
	        keyCursor = -1;
	        triggerCompletions();
	      });

	      el.blur(function() {
	        setVisible(false);
	      });

	      cplEl.mousedown(function (e) {
	        e.preventDefault();
	      });

	      function setVisible(to) {
	        el.parent()[to ? 'addClass' : 'removeClass']('active');
	        cplEl[to ? 'fadeIn' : 'fadeOut']('fast');
	      }

	      /**
	       * Update completions list
	       */
	      function updateCompletions() {
	        var match = ngModel.$viewValue, // Input value
	            completions = [], re = null,
	            complFn, valueOption;

	        // Query function. This should return the full options list
	        complFn = scope.$eval(attrs.rpCombobox);

	        // Uses the default query function, if it's not defined
	        if ("function" !== typeof complFn) {
	          complFn = webutil.queryFromOptions(complFn);
	        }

	        if ("string" === typeof match && match.length) {
	          // Escape field value
	          var escaped = webutil.escapeRegExp(match);
	          // Build the regex for completion list lookup
	          re = new RegExp('('+escaped+')', 'i');

	          completions = complFn(match, re);
	        }

	        // Value as option
	        if (attrs.rpComboboxValueAsOption && match.length) {
	          var prefix = attrs.rpComboboxValueAsOptionPrefix;

	          valueOption = (prefix && 0 !== match.indexOf(prefix))
	            ? prefix + match
	            : match;

	          completions.push(valueOption);
	        }

	        // By fading out without updating the completions we get a smoother effect
	        if (!completions.length) {
	          setVisible(false);
	          return;
	        }

	        setCompletions(completions, re);
	        triggerCompletions();
	      }

	      function setCompletions(completions, re) {
	        cplEl.empty();
	        keyCursor = -1;
	        completions.forEach(function (completion) {
	          var additional = '';

	          if ("string" === typeof completion) {
	            val = completion;
	          } else {
	            val = completion.name;

	            if (completion.additional) {
	              additional = '<span class="additional">' + completion.additional + '</span>';
	            }
	          }

	          if (re) val = val.replace(re, '<u>$1</u>');
	          var completionHtml = $('<li><span class="val">' + val + '</span>' + additional + '</li>');
	          el.parent().find('.completions').append(completionHtml);
	        });
	      }

	      function triggerCompletions() {
	        var cplEls = cplEl.children();
	        var visible = !!cplEls.length;
	        if (cplEls.length === 1 &&
	            cplEls.eq(0).text() === el.val()) {
	          visible = false;
	        }
	        setVisible(visible);
	      }

	      // Update the cursor (highlight selected option)
	      function updateKeyCursor() {
	        var opts = cplEl.find('li');
	        keyCursor = Math.max(keyCursor, 0);
	        keyCursor = Math.min(keyCursor, opts.length - 1);
	        opts.removeClass('cursor');
	        opts.eq(keyCursor).addClass('cursor');
	      }

	      function selectCompletion(liEl) {
	        var val = $(liEl).find('.val').text();
	        scope.$apply(function () {
	          el.val(val);
	          ngModel.$setViewValue(val);
	          setVisible(false);
	        });
	      }

	      function escape(str) {
	        return str
	          .replace(/&/g, '&amp;')
	          .replace(/</g, '&lt;')
	          .replace(/>/g, '&gt;')
	          .replace(/"/g, '&quot;')
	          .replace(/'/g, '&apos;');
	      }

	      cplEl.on('click', 'li', function () {
	        selectCompletion(this);
	      });
	    }
	  };
	}]);

	/**
	 * Datepicker
	 */
	module.directive('rpDatepicker', [function() {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function(scope, element, attr, ngModel) {
	      attr.$observe('rpDatepicker', function() {
	        var dp = $(element).datepicker();
	        dp.on('changeDate', function(e) {
	          scope.$apply(function () {
	            ngModel.$setViewValue(e.date.getMonth() ? e.date : new Date(e.date));
	          });
	        });
	        scope.$watch(attr.ngModel,function() {
	          var update = ngModel.$viewValue;

	          function falsy(v) {return v == '0' || v == 'false'; }

	          if (!falsy(attr.ignoreInvalidUpdate) &&
	               (update == null ||
	                 (update instanceof Date && isNaN(update.getYear())) )) {
	              return;
	            } else {
	              dp.datepicker('setValue', update)
	                .datepicker('update');
	            }
	        });
	      });
	    }
	  };
	}]);

	module.directive('fileUploadButton', function() {
	  return {
	    require: '^ngModel',
	    link: function(scope, element, attributes) {
	      var el = angular.element(element);

	      var button = el.children()[0];

	      el.css({
	        'position': 'relative',
	        'margin-bottom': 14
	      });

	      var fileInput = angular.element('<input type="file" ng-model="walletfile" nwsaveas="wallet.txt" />');

	      fileInput.bind('change', function () {
	          scope.$apply(attributes.fileUploadButton);
	      });

	      fileInput.css({
	        position: 'absolute',
	        top: 0,
	        left: 0,
	        'z-index': '2',
	        width: '100%',
	        height: '100%',
	        opacity: '0',
	        cursor: 'pointer'
	      });

	      el.append(fileInput);
	    }
	  }
	});



/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * EFFECTS
	 *
	 * Angular-powered animation and visual effects directives go into this file.
	 */

	var module = angular.module('effects', []);

	/**
	 * Animate element creation
	 */
	module.directive('rpAnimate', function() {
	  return {
	    restrict: 'A',
	    link: function(scope, elm, attrs) {
	      if (attrs.rpAnimate !== "rp-animate" && !scope.$eval(attrs.rpAnimate)) return;
	      elm = jQuery(elm);
	      elm.hide();
	      elm.fadeIn(600);
	      elm.css('background-color', '#E2F5E4');
	      elm.addClass('rp-animate-during rp-animate');
	      elm.animate({
	        'background-color': '#fff'
	      }, {
	        duration: 600,
	        complete: function () {
	          elm.removeClass('rp-animate-during').addClass('rp-animate-after');
	        }
	      });
	    }
	  };
	});


/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * VALIDATORS
	 *
	 * Form validation directives go into this file.
	 */

	var webutil = __webpack_require__(51),
	    Base = ripple.Base,
	    Amount = ripple.Amount,
	    Currency = ripple.Currency;

	var module = angular.module('validators', []);

	/**
	 * Secret Account Key validator
	 */
	module.directive('rpMasterKey', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        if (value && !Base.decode_check(33, value)) {
	          ctrl.$setValidity('rpMasterKey', false);
	          return;
	        }

	        ctrl.$setValidity('rpMasterKey', true);
	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpMasterKey', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	/**
	 * Validate a payment destination.
	 *
	 * You can set this validator and one or more of the type attributes:
	 *
	 * - rp-dest-address     - If set, allows Ripple addresses as destinations.
	 * - rp-dest-contact     - If set, allows address book contacts.
	 * - rp-dest-model       - If set, updates the model with the resolved ripple address.
	 * - rp-dest-email            - If set, allows federation/email addresses.
	 * - rp-dest-check-federation - If set, check federation address for validity.
	 * - rp-dest-ripple-name      - If set, allows Existing ripple name as destination.
	 *
	 * If the input can be validly interpreted as one of these types, the validation
	 * will succeed.
	 */
	module.directive('rpDest', ['$timeout', '$parse', 'rpFederation', function ($timeout, $parse, federation) {
	  var emailRegex = /^\S+@\S+\.[^\s.]+$/;
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var getter = null,
	          currentCheckTimeout = null;

	      function setDestModelValue(value) {
	        if (attr.rpDestModel) {
	          getter = $parse(attr.rpDestModel);
	          getter.assign(scope, value);
	        }
	      }
	      
	      function showLoading(doShow) {
	        if (attr.rpDestLoading) {
	          var getterL = $parse(attr.rpDestLoading);
	          getterL.assign(scope,doShow);
	        }
	      }


	      var validator = function(value) {
	        var strippedValue = webutil.stripRippleAddress(value);
	        var address = ripple.UInt160.from_json(strippedValue);
	        
	        if (typeof strippedValue !== 'string'
	          || (strippedValue.length && strippedValue[0] !== 'r')) {
	            address = ripple.UInt160.from_json();
	        }
	        
	        ctrl.rpDestType = null;

	        $timeout.cancel(currentCheckTimeout);
	        currentCheckTimeout = null;


	        if (attr.rpDestFederationModel) {
	          getter = $parse(attr.rpDestFederationModel);
	          getter.assign(scope, null);
	        }

	        if (attr.rpDestAddress && address.is_valid()) {
	          ctrl.rpDestType = "address";
	          ctrl.$setValidity('rpDest', true);

	          setDestModelValue(value);

	          return value;
	        }

	        if (attr.rpDestContact && scope.userBlob &&
	            webutil.getContact(scope.userBlob.data.contacts,strippedValue)) {
	          ctrl.rpDestType = "contact";
	          ctrl.$setValidity('rpDest', true);

	          setDestModelValue(webutil.getContact(scope.userBlob.data.contacts,strippedValue).address);

	          return value;
	        }

	        // server-side validation
	        if (attr.rpDestEmail && emailRegex.test(strippedValue)) {
	          ctrl.rpDestType = 'email';
	          if (attr.rpDestCheckFederation) {
	            return federation.check_email(value)
	              .then(function(result) {
	                // Check if this request is still current, exit if not
	                if (value != ctrl.$viewValue) return;

	                setDestModelValue(value);

	                if (attr.rpDestFederationModel) {
	                  getter = $parse(attr.rpDestFederationModel);
	                  getter.assign(scope, result);
	                }
	                return true;
	              }, function() {
	                return false;
	              });
	          } else {
	            setDestModelValue(value);

	            // return $q.when(true);
	            ctrl.$setValidity('rpDest', true);
	            return value;
	          }
	        }

	        if (((attr.rpDestRippleName && webutil.isRippleName(value)) ||
	          (attr.rpDestRippleNameNoTilde && value && value[0] !== '~' && webutil.isRippleName('~' + value)))) { // TODO Don't do a client check in validators
	          ctrl.rpDestType = "rippleName";

	          currentCheckTimeout = $timeout(function() {
	            showLoading(true);
	            currentCheckTimeout = null;

	            ripple.AuthInfo.get(Options.domain, value, function(err, info) {
	              showLoading(false)              ;
	              // Check if this request is still current, exit if not
	              if (value != ctrl.$viewValue) return;
	              scope.$apply(function(){
	                if (info && info.exists) {
	                  ctrl.$setValidity('rpDest', true);
	                  setDestModelValue(info.address);
	                } else {
	                  ctrl.$setValidity('rpDest', false);
	                }
	              });
	            });
	          }, 500);
	          return value;
	        }

	        ctrl.$setValidity('rpDest', false);
	        return;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpDest', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	}]);

	/**
	 * Source and destination tags validator
	 *
	 * Integer in the range 0 to 2^32-1
	 */
	module.directive('rpStdt', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        if (!value || (!isNaN(parseFloat(value)) && isFinite(value) && value >= 0 && value < Math.pow(2,32) - 1)) {
	          ctrl.$setValidity('rpStdt', true);
	          return value;
	        } else {
	          ctrl.$setValidity('rpStdt', false);
	          return;
	        }
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpStdt', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	module.directive('rpNotMe', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        var contact = webutil.getContact(scope.userBlob.data.contacts,value);

	        if (value) {
	          if ((contact && contact.address === scope.userBlob.data.account_id) || scope.userBlob.data.account_id === value) {
	            ctrl.$setValidity('rpNotMe', false);
	            return;
	          }
	        }

	        ctrl.$setValidity('rpNotMe', true);
	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpNotMe', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	module.directive('rpIssuer', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        if(!value){
	          ctrl.$setValidity('rpIssuer', false);
	          return;
	        }

	        var shortValue = value.slice(0, 3).toUpperCase();

	        if ( (shortValue==="XRP") || webutil.findIssuer(scope.lines,shortValue))
	        {
	          ctrl.$setValidity('rpIssuer', true);
	          return value;
	        } else {
	          ctrl.$setValidity('rpIssuer', false);
	          return;
	        }
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpIssuer', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	/**
	 * Verify a set of inputs have the same value.
	 *
	 * For example you could use this as a password repeat validator.
	 *
	 * @example
	 *   <input name=password type=password rp-same-in-set="passwordSet">
	 *   <input name=password2 type=password rp-same-in-set="passwordSet">
	 */
	module.directive('rpSameInSet', [function() {
	  return {
	    require: 'ngModel',
	    link: function(scope, elm, attrs, ctrl) {
	      var set = scope.$eval(attrs.rpSameInSet);

	      function validator(value) {
	        var oldValue = value !== ctrl.$modelValue
	            ? ctrl.$modelValue
	            : (value !== ctrl.$viewValue ? ctrl.$viewValue : value);
	        if (value !== oldValue) {
	          set[oldValue] = (set[oldValue] || 1) - 1;
	          if (set[oldValue] === 0) {
	            delete set[oldValue];
	          }
	          if (value) {
	            set[value] = (set[value] || 0) + 1;
	          }
	        }
	        return value;
	      }

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.push(validator);

	      scope.$watch(
	          function() {
	            return _.size(set) === 1;
	          },
	          function(value){
	            ctrl.$setValidity('rpSameInSet', value);
	          }
	      );
	    }
	  }
	}]);

	/**
	 * Field uniqueness validator.
	 *
	 * @param {array=} rpUnique Array of strings which are disallowed values.
	 * @param {string=} rpUniqueField If set, rpUnique will be interpreted as an
	 *   array of objects and we compare the value with the field named
	 *   rpUniqueField inside of those objects.
	 * @param {string=} rpUniqueOrig You can set this to the original value to
	 *   ensure this value is always allowed.
	 * @param {string=} rpUniqueGroup @ref rpUniqueScope
	 *
	 * @example
	 *   <input ng-model="name" rp-unique="addressbook" rp-unique-field="name">
	 */
	module.directive('rpUnique', function() {
	  var globalGroups = {};
	  var bind = function(callback) {
	    return function(args) {
	      return callback.apply(this, args);
	    };
	  }
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function ($scope, elm, attr, ctrl) {
	      if (!ctrl) return;
	      var group;
	      if (attr.rpUniqueGroup) {
	        var groups;
	        groups = elm.inheritedData(RP_UNIQUE_SCOPE) || globalGroups;
	        if (!groups[attr.rpUniqueGroup]) groups[attr.rpUniqueGroup] = [];
	        group = groups[attr.rpUniqueGroup];
	        group.push([$scope, elm, attr, ctrl]);
	      } else {
	        group = [[$scope, elm, attr, ctrl]];
	      }

	      var setResult = function(result) {
	        _.forEach(group, bind(function($scope, elm, attr, ctrl){
	          ctrl.$setValidity('rpUnique', result);
	        }));
	      };

	      // makes undefined == ''
	      var checkValue = function(a, b) {
	        if (a === b) return true;
	        if ((a === null || a === undefined || a === '') &&
	            (b === null || b === undefined || b === '')) return true;
	        return false
	      };

	      var validator = function(value) {
	        var thisCtrl = ctrl;
	        var pool = $scope.$eval(attr.rpUnique) || [];
	        var orig = _.every(group, bind(function($scope, elm, attr, ctrl){
	          return attr.rpUniqueOrig && checkValue(ctrl === thisCtrl ? value : ctrl.$viewValue, $scope.$eval(attr.rpUniqueOrig));
	        }));
	        if (orig) {
	          // Original value is always allowed
	          setResult(true);
	        } else if (attr.rpUniqueField) {
	          var check = function (i){
	            return _.every(group, bind(function($scope, elm, attr, ctrl){
	              return checkValue(pool[i][attr.rpUniqueField], ctrl === thisCtrl ? value : ctrl.$viewValue);
	            }));
	          };
	          for (i = 0, l = pool.length; i < l; i++) {
	            if (check(i)) {
	              setResult(false);
	              return value;
	            }
	            setResult(true);
	          }
	        } else {
	          ctrl.$setValidity('rpUnique', pool.indexOf(value) === -1);
	        }

	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      $scope.$watch(attr.rpUnique, function () {
	        validator(ctrl.$viewValue);
	      }, true);
	    }
	  };
	});

	/**
	 * Field uniqueness validator scope for group mode. rpUniqueField must be present.
	 *
	 * @example
	 *   <div rp-unique-scope>
	 *     <input ng-model="name" rp-unique="addressbook" rp-unique-field="name"> // this will not join the group
	 *     <input ng-model="address" rp-unique="addressbook" rp-unique-field="address" rp-unique-group="address-dt">
	 *     <input ng-model="dt" rp-unique="addressbook" rp-unique-field="dt" rp-unique-group="address-dt">
	 *   </div>
	 */
	var RP_UNIQUE_SCOPE = "rp-unique-scope";
	module.directive('rpUniqueScope', function() {
	  return {
	    restrict: 'EA',
	    link: {
	      pre: function ($scope, elm) {
	        elm.data(RP_UNIQUE_SCOPE, {});
	      }
	    }
	  };
	});

	/**
	 * Password strength validator
	 */
	module.directive('rpStrongPassword', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(password) {
	        var score = 0;
	        var username = ""+scope.username;

	        if (!password) {
	          scope.strength = '';
	          return password;
	        }

	        // password < 6
	        if (password.length < 6 ) {
	          ctrl.$setValidity('rpStrongPassword', false);
	          scope.strength = 'weak';
	          return;
	        }

	        // password == user name
	        if (password.toLowerCase() === username.toLowerCase()) {
	          ctrl.$setValidity('rpStrongPassword', false);
	          scope.strength = 'match';
	          return;
	        }

	        checkRepetition = function (pLen, str) {
	          var res = "";
	          for (var i = 0; i < str.length; i++ ) {
	            var repeated = true;

	            for (var j = 0; j < pLen && (j+i+pLen) < str.length; j++) {
	              repeated = repeated && (str.charAt(j+i) === str.charAt(j+i+pLen));
	            }
	            if (j<pLen) {
	              repeated = false;
	            }

	            if (repeated) {
	              i += pLen-1;
	              repeated = false;
	            } else {
	              res += str.charAt(i);
	            }
	          }
	          return res;
	        };

	        // password length
	        score += password.length * 4;
	        score += ( checkRepetition(1, password).length - password.length ) * 1;
	        score += ( checkRepetition(2, password).length - password.length ) * 1;
	        score += ( checkRepetition(3, password).length - password.length ) * 1;
	        score += ( checkRepetition(4, password).length - password.length ) * 1;

	        // password has 3 numbers
	        if (password.match(/(.*[0-9].*[0-9].*[0-9])/)) {
	          score += 5;
	        }

	        // password has 2 symbols
	        if (password.match(/(.*[!,@,#,$,%,&,*,?,_,~].*[!,@,#,$,%,&,*,?,_,~])/)) {
	          score += 5;
	        }

	        // password has Upper and Lower chars
	        if (password.match(/([a-z].*[A-Z])|([A-Z].*[a-z])/)){
	          score += 10;
	        }

	        // password has number and chars
	        if (password.match(/([a-zA-Z])/) && password.match(/([0-9])/)) {
	          score += 15;
	        }

	        //password has number and symbol
	        if (password.match(/([!,@,#,$,%,&,*,?,_,~])/) && password.match(/([0-9])/)) {
	          score += 15;
	        }

	        // password has char and symbol
	        if (password.match(/([!,@,#,$,%,&,*,?,_,~])/) && password.match(/([a-zA-Z])/)) {
	          score += 15;
	        }

	        // password is just a numbers or chars
	        if (password.match(/^\w+$/) || password.match(/^\d+$/) ) {
	          score -= 10;
	        }

	        // verifying 0 < score < 100
	        if (score < 0) { score = 0; }
	        if (score > 100) { score = 100; }

	        if (score < 34) {
	          ctrl.$setValidity('rpStrongPassword', false);
	          scope.strength = 'weak';
	          return;
	        }

	        ctrl.$setValidity('rpStrongPassword', true);

	        if (score < 68) {
	          scope.strength = 'medium';
	          return password;
	        }

	        scope.strength = 'strong';
	        return password;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpStrongPassword', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	module.directive('rpAmount', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        if (value && value.toString().indexOf(",") != -1) {
	          value = value.split(",").join("");
	        }

	        var test = /^(([0-9]*?\.\d+)|([1-9]\d*))$/.test(value);

	        if (test && value[0] == '.') {
	          value = '0' + value;
	        }

	        // check for valid amount
	        ctrl.$setValidity('rpAmount', test);

	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);
	    }
	  };
	});

	module.directive('rpAmountPositive', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      // We don't use parseAmount here, assuming that you also use rpAmount validator
	      var validator = function(value) {
	        // check for positive amount
	        ctrl.$setValidity('rpAmountPositive', value > 0);

	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);
	    }
	  };
	});

	module.directive('rpAmountXrpLimit', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      // We don't use parseAmount here, assuming that you also use rpAmount validator
	      var validator = function(value) {
	        var currency = Currency.from_json(attr.rpAmountXrpLimitCurrency);

	        // If XRP, ensure amount is less than 100 billion and is at least one drop
	        if (currency.is_valid() && currency.is_native()) {
	          ctrl.$setValidity('rpAmountXrpLimit', value <= 100000000000 && value >= 0.000001);
	        } else {
	          ctrl.$setValidity('rpAmountXrpLimit', true);
	        }

	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpAmountXrpLimitCurrency', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	/**
	 * Limit currencies to be entered
	 */
	module.directive('rpRestrictCurrencies', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        var match = /^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})\b/.exec(value);

	        if (attr.rpRestrictCurrencies) {
	          if (match) {
	            ctrl.$setValidity('rpRestrictCurrencies',
	              attr.rpRestrictCurrencies.indexOf(match[1]) != -1
	                ? true
	                : value === 'XRP'
	            );
	          } else {
	            ctrl.$setValidity('rpRestrictCurrencies', false);
	          }
	        }
	        else {
	          ctrl.$setValidity('rpRestrictCurrencies', true);
	        }

	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);
	    }
	  };
	});

	/**
	 * Port number validator
	 */
	module.directive('rpPortNumber', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        ctrl.$setValidity('rpPortNumber', (parseInt(value,10) == value && value >= 1 && value <= 65535));
	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpPortNumber', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	/**
	 * Hostname validator
	 * IPv4, IPv6 and hostname
	 */
	module.directive('rpHostname', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      function validate(str) {
	        var test = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$|^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-_]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$|^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/.test(str);
	        //var test = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$|^(([a-zA-Z]|[a-zA-Z][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z]|[A-Za-z][A-Za-z0-9\-]*[A-Za-z0-9])$|^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$/.test(str);
	        return test;
	      }

	      var validator = function(value) {
	        ctrl.$setValidity('rpHostname', validate(value));
	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpHostname', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	/**
	 * Used for currency selectors
	 */
	module.directive('rpNotXrp', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var validator = function(value) {
	        ctrl.$setValidity('rpNotXrp', !value || value.toLowerCase() !== 'xrp');
	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpNotXrp', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});

	/**
	 * Email address validation
	 */
	module.directive('rpEmail', function () {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function (scope, elm, attr, ctrl) {
	      if (!ctrl) return;

	      var emailRegex = /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;

	      var validator = function(value) {
	        ctrl.$setValidity('rpEmail', emailRegex.test(value));
	        return value;
	      };

	      ctrl.$formatters.push(validator);
	      ctrl.$parsers.unshift(validator);

	      attr.$observe('rpEmail', function() {
	        validator(ctrl.$viewValue);
	      });
	    }
	  };
	});



/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * EVENTS
	 *
	 * Angular-powered event handling directives go into this file.
	 */

	var module = angular.module('events', []);

	/**
	 * Handle ENTER key press.
	 */
	module.directive('ngEnter', function() {
	  return function(scope, elm, attrs) {
	    elm.bind('keypress', function(e) {
	      if (e.charCode === 13) scope.$apply(attrs.ngEnter);
	    });
	  };
	});


/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * FORMATTERS
	 *
	 * Formatters are directives that simply display a value. Normally we do this
	 * via filters, however if the value needs HTML (rather than just text) it's
	 * better to use a directive.
	 */

	var webutil = __webpack_require__(51),
	    Amount = ripple.Amount,
	    Currency = ripple.Currency;

	var module = angular.module('formatters', ['domainalias']);

	module.directive('rpPrettyIssuer', ['rpDomainAlias', function(aliasService) {
	  return {
	    restrict: 'EA',
	    scope: {
	      issuer: '=rpPrettyIssuer',
	      contacts: '=rpPrettyIssuerContacts'
	    },
	    template: '{{alias || name || issuer}}',
	    compile: function (element, attr, linker) {
	      return function (scope, element, attr) {
	        function update() {
	          if (!scope.issuer) {
	            scope.alias = attr.rpPrettyIssuerDefault ? attr.rpPrettyIssuerDefault : '???';
	            return;
	          }
	          var aliasPromise = aliasService.getAliasForAddress(scope.issuer);
	          scope.alias = null;
	          aliasPromise.then(function(result) {
	            scope.alias = result;
	          });

	          scope.name = null;
	          if (scope.contacts) {
	            scope.name = webutil.isContact(scope.contacts, scope.issuer);
	          }

	          if (!scope.name && attr.rpPrettyIssuerOrShort) {
	            scope.name = "" + scope.issuer.substring(0,7) + "…";
	          }
	        }

	        scope.$watch('issuer', update);
	        scope.$watch('contacts', update, true);
	        update();
	      };
	    }
	  };
	}]);

	var RP_PRETTY_AMOUNT_DATE = 'rp-pretty-amount-date';

	module.directive('rpPrettyAmount', [function () {
	  return {
	    restrict: 'EA',
	    scope: {
	      amount: '=rpPrettyAmount'
	    },
	    template: '<span class="value">{{amount | rpamount:{reference_date:date} }}</span> ' +
	              '<span class="currency" rp-currency="amount"></span>',
	    compile: function (element, attr, linker) {
	      return function (scope, element, attr) {
	        scope.date = scope.date || element.inheritedData(RP_PRETTY_AMOUNT_DATE);
	      };
	    }
	  };
	}]);

	/**
	 * Set the reference date for rpPrettyAmount.
	 *
	 * You can set this on the same element that uses rpPrettyAmount or on any
	 * parent element.
	 *
	 * The reference date is used to calculate demurrage/interest correctly.
	 */
	module.directive('rpPrettyAmountDate', [function () {
	  return {
	    restrict: 'EA',
	    compile: function (element, attr, linker) {
	      return function (scope, element, attr) {
	        element.data(RP_PRETTY_AMOUNT_DATE, scope.$eval(attr.rpPrettyAmountDate));
	      };
	    }
	  };
	}]);

	module.directive('rpPrettyIdentity', ['$timeout', function ($timeout) {
	  var popupDelay = 800;
	  var hideDelay = 1500;

	  return {
	    restrict: 'EA',
	    scope: {
	      identity: '=rpPrettyIdentity'
	    },
	    template: '{{identity | rpcontactnamefull | rpripplename:{tilde:true} }}',
	    compile: function (element, attr, linker) {
	      if (attr.rpPrettyIdentityFilters) {
	        element.text('{{identity | ' + attr.rpPrettyIdentityFilters + ' }}');
	      }
	      return function (scope, element, attr) {
	        var cancelHidePopoverTimeout;
	        var cancelShowPopoverTimeout;
	        var tip;
	        var shown = false;

	        function hidePopover() {
	          if (!cancelHidePopoverTimeout) {
	            cancelHidePopoverTimeout = $timeout( function() {
	              element.popover('hide');
	              shown = false;
	            }, hideDelay, false );
	            cancelHidePopoverTimeout.finally(function() { cancelHidePopoverTimeout = null; });
	          }
	        }

	        function onPopoverEnter() {
	          if (cancelShowPopoverTimeout) {
	            $timeout.cancel( cancelShowPopoverTimeout );
	            cancelShowPopoverTimeout = null;
	          }
	          if (cancelHidePopoverTimeout) {
	            $timeout.cancel( cancelHidePopoverTimeout );
	            cancelHidePopoverTimeout = null;
	          }
	        }

	        function onPopoverLeave() {
	          hidePopover();
	        }

	        function onElemEnter() {
	          if (cancelHidePopoverTimeout) {
	            $timeout.cancel( cancelHidePopoverTimeout );
	            cancelHidePopoverTimeout = null;
	          } else if (!cancelShowPopoverTimeout) {
	            cancelShowPopoverTimeout = $timeout( function() {
	              element.popover('show'); 
	              shown = true;
	            }, popupDelay, false );
	            cancelShowPopoverTimeout.finally(function() { cancelShowPopoverTimeout = null; });
	          }
	        }

	        function onElemLeave() {
	          if (cancelShowPopoverTimeout) {
	            $timeout.cancel( cancelShowPopoverTimeout );
	            cancelShowPopoverTimeout = null;
	          } else if (shown) {
	            hidePopover();
	          }
	        }

	        function unbindHanlders() {
	          element.unbind('mouseenter', onElemEnter);
	          element.unbind('mouseleave', onElemLeave);
	          tip.unbind('mouseenter', onPopoverEnter);
	          tip.bind('mouseleave', onPopoverLeave);
	        }
	        // XXX Set title to identity
	        // console.log(element);

	        element.popover('destroy');
	        var content = 'Ripple address ' + scope.identity;
	        var options = {  content: content,
	          trigger: 'manual', placement: 'top',
	          container: 'body',
	          template: '<div class="popover"><div class="arrow"></div><div class="popover-inner"><div class="popover-content" ></div></div></div>'
	        };
	        var popover = element.popover(options);
	        tip = element.data('popover').tip();
	        element.bind('mouseenter', onElemEnter);
	        element.bind('mouseleave', onElemLeave);
	        tip.bind('mouseenter', onPopoverEnter);
	        tip.bind('mouseleave', onPopoverLeave);
	        // Make sure popover is destroyed and removed.
	        scope.$on('$destroy', function onDestroyPopover() {
	          $timeout.cancel( cancelHidePopoverTimeout );
	          $timeout.cancel( cancelShowPopoverTimeout );
	          unbindHanlders();
	          if (tip) {
	            tip.remove();
	            tip = null;
	          }
	        });
	      };
	    }
	  };
	}]);

	module.directive('rpRippleName', ['rpId', function(id) {
	  return {
	    restrict: 'EA',
	    scope: {
	      address: '=rpRippleName'
	    },
	    template: '{{name || address}}',
	    compile: function (element, attr, linker) {
	      return function (scope, element, attr) {
	        function update() {
	          id.resolveName(scope.address, { tilde: true }).then(function(name) {
	            scope.name = name;
	          });
	        }
	        scope.$watch('address', update);
	        update();
	      };
	    }
	  };
	}]);

	module.directive('rpBindColorAmount', function () {
	  return {
	    restrict: 'A',
	    compile: function (element, attr, linker) {
	      return function (scope, element, attr) {
	        scope.$watch(attr.rpBindColorAmount, function(value){
	          if (value) {
	            var parts = value.split(".");

	            if (parts.length === 2) { // you never know
	              var decimalPart = parts[1].replace(/0(0+)$/, '0<span class="insig">$1</span>');

	              element[0].innerHTML = decimalPart.length > 0 ? parts[0] + "." + decimalPart : parts[0];
	            }
	          }
	        });
	      };
	    }
	  };
	});

	module.directive('rpCurrency', function () {
	  return {
	    restrict: 'A',
	    compile: function (element, attr, linker) {
	      return function (scope, element, attr) {
	        scope.$watch(attr.rpCurrency, function (input) {
	          var currency;
	          if (input instanceof Currency) {
	            currency = input;
	          } else {
	            var amount = Amount.from_json(input);
	            currency = amount.currency();
	          }

	          var mainText = currency.to_human();

	          // Should we look for a full name like "USD - US Dollar"?
	          if (attr.rpCurrencyFull) {
	            var currencyInfo = $.grep(scope.currencies_all, function(e){ return e.value == mainText; })[0];
	            if (currencyInfo) mainText = currencyInfo.name;
	          }

	          if (currency.has_interest()) {
	            // Get yearly interest rate
	            var referenceDate = currency._interest_start + 3600 * 24 * 365;
	            var interestRate = currency.get_interest_at(referenceDate);

	            // Convert to percent and round to two decimal places
	            interestRate = Math.round(interestRate * 10000 - 10000) / 100;

	            var helpText;
	            if (interestRate > 0) {
	              // Positive interest
	              helpText = "Interest: "+interestRate+" %/yr";
	            } else {
	              // Fee
	              helpText = "Fee: "+(-interestRate)+"%/yr";
	            }

	            var el = $('<abbr></abbr>')
	                  .attr('title', helpText)
	                  .text(mainText);
	            element.empty().append(el);
	          } else {
	            element.empty().text(mainText);
	          }
	        });
	      };
	    }
	  };
	});


/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * DIRECTIVES
	 *
	 * Miscellaneous directives go in this file.
	 */

	var module = angular.module('directives', ['popup']);

	/**
	 * Inline edit
	 */
	module.directive('inlineEdit', function() {
	  var previewTemplate = '<span ng-hide="mode">{{model}}</span>';
	  var editTemplate = '<input ng-show="mode" ng-model="model" />';

	  return {
	    restrict: 'E',
	    scope: {
	      model: '=',
	      mode: '='
	    },
	    template: previewTemplate + editTemplate
	  };
	});

	/**
	 * Group of validation errors for a form field.
	 *
	 * @example
	 *   <input name=send_destination ng-model=recipient>
	 *   <div rp-errors=send_destination>
	 *     <div rp-error-on=required>This field is required.</div>
	 *     <div rp-error-valid>{{recipient}} is a valid destination.</div>
	 *   </div>
	 */
	var RP_ERRORS = 'rp-errors';
	module.directive('rpErrors', [function() {
	  return {
	    restrict: 'EA',
	    compile: function(el, attr, linker) {
	      var fieldName = attr.rpErrors || attr.on,
	        errs = {};

	      el.data(RP_ERRORS, errs);
	      return function(scope, el) {
	        var formController = el.inheritedData('$formController');
	        var formName = formController.$name,
	          selectedTransclude,
	          selectedElement,
	          selectedScope;

	        function updateErrorTransclude() {
	          var field = formController[fieldName];

	          if (!field) return;

	          var $error = field && field.$error;

	          if (selectedElement) {
	            selectedScope.$destroy();
	            selectedElement.remove();
	            selectedElement = selectedScope = null;
	          }

	          // Pristine fields should show neither success nor failure messages
	          if (field.$pristine) return;

	          // Find any error messages defined for current errors
	          selectedTransclude = false;
	          $.each(errs, function(validator, transclude) {
	            if (validator.length <= 1) return;
	            if ($error && $error[validator.slice(1)]) {
	              selectedTransclude = transclude;
	              return false;
	            }
	          });

	          // Show message for valid fields
	          if (!selectedTransclude && errs['+'] && field.$valid) {
	            selectedTransclude = errs['+'];
	          }

	          // Generic message for invalid fields when there is no specific msg
	          if (!selectedTransclude && errs['?'] && field.$invalid) {
	            selectedTransclude = errs['?'];
	          }

	          if (selectedTransclude) {
	            scope.$eval(attr.change);
	            selectedScope = scope.$new();
	            selectedTransclude(selectedScope, function(errElement) {
	              selectedElement = errElement;
	              el.append(errElement);
	            });
	          }
	        }

	        scope.$watch(formName + '.' + fieldName + '.$error', updateErrorTransclude, true);
	        scope.$watch(formName + '.' + fieldName + '.$pristine', updateErrorTransclude);
	      };
	    }
	  };
	}]);

	/**
	 * Error message for validator failure.
	 *
	 * Use this directive within a rp-errors block to show a message for a specific
	 * validation failing.
	 *
	 * @example
	 *   <div rp-errors=send_destination>
	 *     <div rp-error-on=required>This field is required.</div>
	 *   </div>
	 */
	module.directive('rpErrorOn', [function() {
	  return {
	    transclude: 'element',
	    priority: 500,
	    compile: function(element, attrs, transclude) {
	      var errs = element.inheritedData(RP_ERRORS);
	      if (!errs) return;
	      errs['!' + attrs.rpErrorOn] = transclude;
	    }
	  };
	}]);

	/**
	 * Message for no matched validator failures.
	 *
	 * Use this directive within a rp-errors block to show a message if the field is
	 * invalid, but there was no error message defined for any of the failing
	 * validators.
	 *
	 * @example
	 *   <div rp-errors=send_destination>
	 *     <div rp-error-on=required>This field is required.</div>
	 *     <div rp-error-unknown>Invalid value.</div>
	 *   </div>
	 */
	module.directive('rpErrorUnknown', [function() {
	  return {
	    transclude: 'element',
	    priority: 500,
	    compile: function(element, attrs, transclude) {
	      var errs = element.inheritedData(RP_ERRORS);
	      if (!errs) return;
	      errs['?'] = transclude;
	    }
	  };
	}]);

	/**
	 * Message for field valid.
	 *
	 * Use this directive within a rp-errors block to show a message if the field is
	 * valid.
	 */
	module.directive('rpErrorValid', [function() {
	  return {
	    transclude: 'element',
	    priority: 500,
	    compile: function(element, attrs, transclude) {
	      var errs = element.inheritedData(RP_ERRORS);
	      if (!errs) return;
	      errs['+'] = transclude;
	    }
	  };
	}]);

	module.directive('rpConfirm', ['rpPopup', function(popup) {
	  return {
	    restrict: 'E',
	    link: function postLink(scope, element, attrs) {
	      // Could have custom or bootstrap modal options here
	      var popupOptions = {};
	      element.find('a,button').click(function(e) {
	        e.preventDefault();

	        popup.confirm(attrs["title"], attrs["actionText"],
	          attrs["actionButtonText"], attrs["actionFunction"], attrs["actionButtonCss"],
	          attrs["cancelButtonText"], attrs["cancelFunction"], attrs["cancelButtonCss"],
	          scope, popupOptions);
	      });
	    }
	  };
	}]);

	module.directive('rpPopup', ['rpPopup', '$parse', function(popup, $parse) {
	  return {
	    restrict: 'E',
	    link: function postLink(scope, element, attrs) {
	      var a = element.find('a[rp-popup-link]');
	      a.click(function(e) {
	        e.preventDefault();

	        // onShow action
	        if (attrs.rpPopupOnOpen) {
	          $parse(attrs.rpPopupOnOpen)(scope);
	        }

	        var content = element.find('[rp-popup-content]');
	        xml = new XMLSerializer().serializeToString(content[0]);

	        popup.blank(xml, scope);
	        if (attrs.onopen && scope[attrs.onopen]) {
	          scope[attrs.onopen]();
	        }
	      });
	    }
	  };
	}]);

	/*
	 * Adds download functionality to an element.
	 */
	module.directive('rpDownload', [function() {
	  return {
	    restrict: 'A',
	    scope: {
	      data: '=rpDownload',
	      filename: '@rpDownloadFilename',
	      isCsv: '@rpDownloadCsv',
	      clickHandler: '@ngClick'
	    },
	    compile: function(element, attr, linker) {
	      return function(scope, element, attr) {
	        var trigger = element.find('[rp-download-trigger]');
	        if (!trigger.length) trigger = element;

	        if ("download" in document.createElement("a")) {
	          scope.$watch('data', function(data) {
	            if (scope.isCsv) trigger.attr('href', data ? "data:text/csv;charset=utf-8," + escape(data) : "");
	            else trigger.attr('href', "data:text/plain," + data);
	          });
	          scope.$watch('filename', function(filename) {
	            trigger.attr('download', filename);
	          });
	        } else if (swfobject.hasFlashPlayerVersion("10.0.0")) {
	          element.css('position', 'relative');

	          setImmediate(function() {
	            var width = trigger.innerWidth();
	            var height = trigger.innerHeight();
	            var offsetTrigger = trigger.offset();
	            var offsetElement = element.offset();
	            var topOffset = offsetTrigger.top - offsetElement.top;
	            var leftOffset = offsetTrigger.left - offsetElement.left;
	            var dl = Downloadify.create(element[0], {
	              filename: function() {
	                return scope.filename;
	              },
	              data: function() {
	                // If there was a click handler in the element Downloadify hides, then trigger it now
	                if (scope.clickHandler) trigger.trigger('click');
	                return scope.data;
	              },
	              transparent: true,
	              swf: 'swf/downloadify.swf',
	              downloadImage: 'img/transparent_l.gif',
	              width: width,
	              height: height,
	              append: true
	            });

	            var id = dl.flashContainer.id;
	            $('#' + id).css({
	              position: 'absolute',
	              top: topOffset + 'px',
	              left: leftOffset + 'px'
	            });
	          });
	        } else {
	          // XXX Should provide some alternative or error
	        }
	      };
	    }
	  };
	}]);

	/**
	 * Tooltips
	 */
	module.directive('rpTooltip', [function() {
	  return function(scope, element, attr) {
	    attr.$observe('rpTooltip', function(value) {
	      // Title
	      var options = {'title': value};

	      // Placement
	      if (attr.rpTooltipPlacement)
	        options.placement = attr.rpTooltipPlacement;

	      $(element).tooltip('destroy');
	      $(element).tooltip(options);
	    });
	  };
	}]);

	/**
	 * Popovers
	 */
	module.directive('rpPopover', ['$interpolate', function($interpolate) {
	  return function(scope, element, attr) {
	    var interpolateContent = function () {
	      return $interpolate(attr.rpPopoverContent)(scope);
	    };

	    if (!attr.rpPopoverTrigger) attr.rpPopoverTrigger = 'click';

	    var options = {
	      html: true,
	      placement: attr.rpPopoverPlacement,
	      trigger: attr.rpPopoverTrigger
	    };
	    if (attr.rpPopoverTitle) {
	      options.title = attr.rpPopoverTitle;
	    }
	    else {
	      options.template = '<div class="popover"><div class="arrow"></div><div class="popover-inner"><div class="popover-content" ></div></div></div>';
	    }
	    if (attr.rpPopoverContent) {
	      options.content = interpolateContent;
	    }
	    if (attr.rpPopoverDelay) {
	      var delay = attr.rpPopoverDelay;
	      if (typeof delay !== 'number') {
	        delay = 500;
	      }
	      options.delay = {
	        show: delay,
	        hide: 1000
	      };
	    }
	    $(element).popover(options);

	    $('html').click(function() {
	      $(element).popover('hide');
	    });

	    $(element).click(function(event){
	      event.stopPropagation();
	    });
	  };
	}]);

	module.directive('rpAutofill', ['$parse', function($parse) {
	  return {
	    restrict: 'A',
	    require: '?ngModel',
	    link: function($scope, element, attr, ctrl) {
	      if (!ctrl) return;

	      $scope.$watch(attr.rpAutofill, function(value) {
	        if (value) {
	          // Normalize amount
	          if (attr.rpAutofillAmount || attr.rpAutofillCurrency) {
	            // 1 XRP will be interpreted as 1 XRP, not 1 base unit
	            if (value === ("" + parseInt(value, 10))) {
	              value = value + '.0';
	            }

	            var convertCurrency = function(currencyObj) {
	              if (attr.rpAutofillCurrencyFullname) {
	                if ($scope.currencies_all_keyed[currencyObj.get_iso()]) {
	                  return currencyObj.to_human({full_name:$scope.currencies_all_keyed[currencyObj.get_iso()].name});
	                } else {
	                  return currencyObj.to_human();
	                }
	              } else {
	                return currencyObj.to_json();
	              }
	            };

	            // Is it an amount?
	            var amount = ripple.Amount.from_json(value);
	            if (amount.is_valid()) {
	              if (attr.rpAutofillAmount) {
	                value = amount.to_human({
	                  group_sep: false
	                });
	              } else {
	                value = convertCurrency(amount.currency());
	              }
	            }
	            // Maybe a currency?
	            else {
	              var currency = ripple.Currency.from_json(value);
	              if (!currency.is_valid()) return;

	              value = convertCurrency(currency);
	            }
	          }

	          element.val(value);
	          ctrl.$setViewValue(value);
	          $scope.$eval(attr.rpAutofillOn);
	        }
	      }, true);
	    }
	  };
	}]);

	module.directive('rpSelectEl', [function() {
	  return {
	    restrict: 'A',
	    scope: {
	      target: '@rpSelectEl'
	    },
	    link: function($scope, element, attr) {
	      element.click(function() {
	        var doc = document;
	        var text = doc.getElementById($scope.target);

	        if (doc.body.createTextRange) { // ms
	          var range = doc.body.createTextRange();
	          range.moveToElementText(text);
	          range.select();
	        } else if (window.getSelection) { // moz, opera, webkit
	          var selection = window.getSelection();
	          var srange = doc.createRange();
	          srange.selectNodeContents(text);
	          selection.removeAllRanges();
	          selection.addRange(srange);
	        }
	      });
	    }
	  };
	}]);

	module.directive('rpNoPropagate', [function() {
	  return {
	    restrict: 'A',
	    link: function($scope, element, attr) {
	      element.click(function(e) {
	        e.stopPropagation();
	      });
	    }
	  };
	}]);

	/**
	 * Spinner
	 */
	module.directive('rpSpinner', [function() {
	  return {
	    restrict: 'A',
	    link: function(scope, element, attr) {
	      var spinner = null;
	      attr.$observe('rpSpinner', function(value) {
	        element.removeClass('spinner');
	        if (spinner) {
	          spinner.stop();
	          spinner = null;
	        }

	        if (value > 0) {
	          spinner = new Spinner({
	            lines: 9, // The number of lines to draw
	            length: 3, // The length of each line
	            width: 2, // The line thickness
	            radius: value, // The radius of the inner circle
	            className: 'spinnerInner'
	          });

	          // Spinner for input field
	          if (element.is('input')) {
	            element.after('<div class="inputSpinner"></div>');
	            spinner.spin(element.parent().find('.inputSpinner')[0]);
	          }

	          // Spinner for everything else
	          else {
	            element.addClass('spinner');
	            spinner.spin(element[0]);
	          }
	        }
	      });
	    }
	  };
	}]);


	// Version 0.2.0
	// AngularJS simple file upload directive
	// this directive uses an iframe as a target
	// to enable the uploading of files without
	// losing focus in the ng-app.
	//
	// <div ng-app="app">
	//   <div ng-controller="mainCtrl">
	//    <form action="/uploads" ng-upload="results()">
	//      <input type="file" name="avatar"></input>
	//      <input type="submit" value="Upload"></input>
	//    </form>
	//  </div>
	// </div>
	//
	//  angular.module('app', ['ngUpload'])
	//    .controller('mainCtrl', function($scope) {
	//      $scope.results = function(content) {
	//        console.log(content);
	//      }
	//  });
	//
	//
	module.directive('ngUpload', function() {
	  return {
	    restrict: 'A',
	    link: function(scope, element, attrs) {

	      // Options (just 1 for now)
	      // Each option should be prefixed with 'upload-Options-' or 'uploadOptions'
	      // {
	      //    // specify whether to enable the submit button when uploading forms
	      //    enableControls: bool
	      // }
	      var options = {};
	      options.enableControls = attrs['uploadOptionsEnableControls'];

	      // get scope function to execute on successful form upload
	      if (attrs['ngUpload']) {

	        element.attr("target", "upload_iframe");
	        element.attr("method", "post");

	        // Append a timestamp field to the url to prevent browser caching results
	        element.attr("action", element.attr("action") + "?_t=" + new Date().getTime());

	        element.attr("enctype", "multipart/form-data");
	        element.attr("encoding", "multipart/form-data");

	        // Retrieve the callback function
	        var fn = attrs['ngUpload'].split('(')[0];
	        var callbackFn = scope.$eval(fn);
	        if (callbackFn === null || callbackFn === undefined || !angular.isFunction(callbackFn)) {
	          var message = "The expression on the ngUpload directive does not point to a valid function.";
	          // console.error(message);
	          throw message + "\n";
	        }

	        // Helper function to create new iframe for each form submission
	        var addNewDisposableIframe = function(submitControl) {
	          // create a new iframe
	          var iframe = $("<iframe id='upload_iframe' name='upload_iframe' border='0' width='0' height='0' style='width: 0px; height: 0px; border: none; display: none' />");

	          // attach function to load event of the iframe
	          iframe.bind('load', function() {

	            // get content - requires jQuery
	            var content = iframe.contents().find('body').text();

	            // execute the upload response function in the active scope
	            scope.$apply(function() {
	              callbackFn(content, content !== "" /* upload completed */ );
	            });

	            // remove iframe
	            if (content !== "") // Fixes a bug in Google Chrome that dispose the iframe before content is ready.
	              setTimeout(function() {
	                iframe.remove();
	              }, 250);

	            //if (options.enableControls == null || !(options.enableControls.length >= 0))
	            submitControl.attr('disabled', null);
	            submitControl.attr('title', 'Click to start upload.');
	          });

	          // add the new iframe to application
	          element.parent().append(iframe);
	        };

	        // 1) get the upload submit control(s) on the form (submitters must be decorated with the 'ng-upload-submit' class)
	        // 2) attach a handler to the controls' click event
	        $('.upload-submit', element).click(

	          function() {

	            addNewDisposableIframe($(this) /* pass the submit control */ );

	            scope.$apply(function() {
	              callbackFn("Please wait...", false /* upload not completed */ );
	            });

	            //console.log(angular.toJson(options));

	            var enabled = true;
	            if (options.enableControls === null || options.enableControls === undefined || options.enableControls.length >= 0) {
	              // disable the submit control on click
	              $(this).attr('disabled', 'disabled');
	              enabled = false;
	            }

	            $(this).attr('title', (enabled ? '[ENABLED]: ' : '[DISABLED]: ') + 'Uploading, please wait...');

	            // submit the form
	            $(element).submit();
	          }).attr('title', 'Click to start upload.');
	      } else console.log("No callback function found on the ngUpload directive.");
	    }
	  };
	});

	/**
	 * Focus element on render
	 */
	module.directive('rpFocus', ['$timeout', function($timeout) {
	  return function($scope, element) {
	    $timeout(function(){
	      $scope.$watch(function () {return element.is(':visible')}, function(newValue) {
	        if (newValue === true)
	          element.focus();
	      })
	    })
	  }
	}]);

	module.directive('rpOffCanvasMenu', function() {
	  return {
	    restrict: 'A',
	    link: function(scope, element, attrs) {
	      element.find('h2').click(function () {
	        element.parent().toggleClass('off-canvas-nav-expand');
	      });
	    }
	  };
	});

	module.directive('rpSnapper', ['rpId', function($id) {
	  return function($scope) {
	    // Initialize snapper only if user is logged in.
	    var watcher = $scope.$watch(function(){return $id.loginStatus}, function(){
	      var snapper;

	      if ($id.loginStatus) {
	        setImmediate(function(){
	          snapper = new Snap({
	            element: document.getElementById('wrapper'),
	            disable: 'right'
	          });

	          // Check
	          checkSize();

	          // Snapper toggle button
	          $('.snapper-toggle').click(function(){
	            snapper.state().state == 'closed' ? snapper.open('left') : snapper.close()
	          });

	          $('.mobile-nav').find('a').click(function(){
	            snapper.close();
	          });
	        });

	        // Activate if resized to mobile size
	        $(window).resize(function(){
	          checkSize();
	        });

	        var checkSize = function(){
	          // screen-xs-max
	          if ('object' === typeof snapper) {
	            if ($(window).width() > 767) {
	              snapper.close();
	              snapper.disable();
	            } else {
	              $('.mobile-nav').show();
	              snapper.enable();
	            }
	          }
	        };

	        // Remove watcher
	        watcher();
	      }
	    });
	  }
	}]);

	/**
	 * Adds spacing around span tags.
	 */
	module.directive('rpSpanSpacing', [function () {
	  return {
	    restrict: 'EA',
	    compile: function (element, attr, linker) {
	      element.find('> span').before(' ').after(' ');
	    }
	  };
	}]);


/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * DATALINKS
	 *
	 * Data-centric links for things like transactions, accounts etc.
	 */

	var module = angular.module('datalinks', []);

	module.directive('rpLinkTx', ['$location', function ($location) {
	  return {
	    restrict: 'A',
	    link: function ($scope, element, attr) {
	      var url;
	      $scope.$watch(attr.rpLinkTx, function (hash) {
	        url = "/tx?id="+hash;
	      });
	      element.click(function () {
	        $scope.$apply(function () {
	          if (url) $location.url(url);
	        });
	      });
	    }
	  };
	}]);


/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * ERRORS
	 *
	 * Directives related to errors and error messages.
	 */

	var module = angular.module('errors', []);

	/**
	 * Trust line graph. (Similar to small box plot.)
	 */
	module.directive('rpTransactionStatus', function() {
	  return {
	    restrict: 'E',
	    template: __webpack_require__(61),
	    scope: {
	      engine_result: '@rpEngineResult',
	      engine_result_message: '@rpEngineResultMessage',
	      accepted: '@rpAccepted'
	    },
	    link: function(scope, elm, attrs) {
	    }
	  };
	});


/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * QR
	 *
	 * Directive to render a QR code.
	 */

	var module = angular.module('qr', []);

	/**
	 * angular-qrcode v3.1.0
	 * (c) 2013 Monospaced http://monospaced.com
	 * License: MIT
	 */
	module.directive('rpQrcode', ['$window', function($window) {
	  var canvas2D = !!$window.CanvasRenderingContext2D,
	      levels = {
	        'L': 'Low',
	        'M': 'Medium',
	        'Q': 'Quartile',
	        'H': 'High'
	      },
	      draw = function(context, qr, modules, tile) {
	        for (var row = 0; row < modules; row++) {
	          for (var col = 0; col < modules; col++) {
	            var w = (Math.ceil((col + 1) * tile) - Math.floor(col * tile)),
	                h = (Math.ceil((row + 1) * tile) - Math.floor(row * tile));

	            context.fillStyle = qr.isDark(row, col) ? '#000' : '#fff';
	            context.fillRect(Math.round(col * tile),
	                             Math.round(row * tile), w, h);
	          }
	        }
	      };

	  return {
	    restrict: 'E',
	    template: '<canvas></canvas>',
	    link: function(scope, element, attrs) {
	      var domElement = element[0],
	          canvas = element.find('canvas')[0],
	          context = canvas2D ? canvas.getContext('2d') : null,
	          trim = /^\s+|\s+$/g,
	          error,
	          version,
	          errorCorrectionLevel,
	          data,
	          size,
	          modules,
	          tile,
	          qr,
	          setVersion = function(value) {
	            version = Math.max(1, Math.min(parseInt(value, 10), 10)) || 4;
	          },
	          setErrorCorrectionLevel = function(value) {
	            errorCorrectionLevel = value in levels ? value : 'M';
	          },
	          setData = function(value) {
	            if (!value) {
	              return;
	            }

	            data = value.replace(trim, '');
	            qr = qrcode(version, errorCorrectionLevel);
	            qr.addData(data);

	            try {
	              qr.make();
	            } catch(e) {
	              error = e.message;
	              return;
	            }

	            error = false;
	            modules = qr.getModuleCount();
	          },
	          setSize = function(value) {
	            size = parseInt(value, 10) || modules * 2;
	            tile = size / modules;
	            canvas.width = canvas.height = size;
	          },
	          render = function() {
	            if (!qr) {
	              return;
	            }

	            if (error) {
	              if (!canvas2D) {
	                domElement.innerHTML = '<img src width="' + size + '"' +
	                  'height="' + size + '">';
	              }
	              scope.$emit('qrcode:error', error);
	              return;
	            }

	            if (canvas2D) {
	              draw(context, qr, modules, tile);
	            } else {
	              domElement.innerHTML = qr.createImgTag(tile, 0);
	            }
	          };

	      setVersion(attrs.version);
	      setErrorCorrectionLevel(attrs.errorCorrectionLevel);
	      setSize(attrs.size);

	      attrs.$observe('version', function(value) {
	        if (!value) {
	          return;
	        }

	        setVersion(value);
	        setData(data);
	        setSize(size);
	        render();
	      });

	      attrs.$observe('errorCorrectionLevel', function(value) {
	        if (!value) {
	          return;
	        }

	        setErrorCorrectionLevel(value);
	        setData(data);
	        setSize(size);
	        render();
	      });

	      attrs.$observe('data', function(value) {
	        if (!value) {
	          return;
	        }

	        setData(value);
	        setSize(size);
	        render();
	      });

	      attrs.$observe('size', function(value) {
	        if (!value) {
	          return;
	        }

	        setSize(value);
	        render();
	      });
	    }
	  };
	}]);


/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {

	var module = angular.module('filters', []),
	    webutil = __webpack_require__(51),
	    Amount = ripple.Amount,
	    Currency = ripple.Currency,
	    Base = ripple.Base;

	var iso4217 = __webpack_require__(60);

	/**
	 * Format a ripple.Amount.
	 *
	 * If the parameter is a number, the number is treated the relative
	 */
	module.filter('rpamount', function () {
	  return function (input, options) {
	    var opts = jQuery.extend(true, {}, options);

	    if ("number" === typeof opts) {
	      opts = {
	        rel_min_precision: opts
	      };
	    } else if ("object" !== typeof opts) {
	      opts = {};
	    }

	    if (!input) return "n/a";

	    if (opts.xrp_human && input === ("" + parseInt(input, 10))) {
	      input = input + ".0";
	    }

	    // Reference date
	    // XXX Should maybe use last ledger close time instead
	    if (!opts.reference_date && !opts.no_interest) {
	      opts.reference_date = new Date();
	    }

	    var amount = Amount.from_json(input);
	    if (!amount.is_valid()) return "n/a";

	    // Currency default precision
	    var currency = iso4217[amount.currency().to_human()];
	    var cdp = ("undefined" !== typeof currency) ? currency[1] : 4;

	    // Certain formatting options are relative to the currency default precision
	    if ("number" === typeof opts.rel_precision) {
	      opts.precision = cdp + opts.rel_precision;
	    }
	    if ("number" === typeof opts.rel_min_precision) {
	      opts.min_precision = cdp + opts.rel_min_precision;
	    }

	    // If no precision is given, we'll default to max precision.
	    if ("number" !== typeof opts.precision) {
	      opts.precision = 16;
	    }

	    // But we will cut off after five significant decimals
	    if ("number" !== typeof opts.max_sig_digits) {
	      opts.max_sig_digits = 5;
	    }

	    var out = amount.to_human(opts);

	    // If amount is very small and only has zeros (ex. 0.0000), raise precision
	    // to make it useful.
	    if (out.length > 1 && 0 === +out && !opts.hard_precision) {
	      opts.precision = 5;

	      out = amount.to_human(opts);
	    }

	    return out;
	  };
	});

	/**
	 * Get the currency from an Amount or Currency object.
	 *
	 * If the input is neither an Amount or Currency object it will be passed to
	 * Amount#from_json to try to interpret it.
	 */
	module.filter('rpcurrency', function () {
	  return function (input) {
	    if (!input) return "";

	    var currency;
	    if (input instanceof Currency) {
	      currency = input;
	    } else {
	      var amount = Amount.from_json(input);
	      currency = amount.currency();
	    }

	    return currency.to_human();
	  };
	});

	/**
	 * Get the currency issuer.
	 */
	module.filter('rpissuer', function () {
	  return function (input) {
	    if (!input) return "";

	    var amount = Amount.from_json(input);
	    return amount.issuer().to_json();
	  };
	});

	/**
	 * Get the full currency name from an Amount.
	 */
	module.filter('rpcurrencyfull', ['$rootScope', function ($scope) {
	  return function (input) {
	    if (!input) return "";

	    var amount = Amount.from_json(input);
	    var currency = $.grep($scope.currencies_all, function(e){ return e.value == amount.currency().to_human(); })[0];

	    if (currency) {
	      return currency.name;
	    } else {
	      return amount.currency().to_human();
	    }
	  };
	}]);

	/**
	 * Calculate a ratio of two Amounts.
	 */
	module.filter('rpamountratio', function () {
	  return function (numerator, denominator) {
	    try {
	      return Amount.from_json(numerator).ratio_human(denominator, {reference_date: new Date()});
	    } catch (err) {
	      return Amount.NaN();
	    }
	  };
	});

	/**
	 * Calculate the sum of two Amounts.
	 */
	module.filter('rpamountadd', function () {
	  return function (a, b) {
	    try {
	      b = Amount.from_json(b);
	      if (b.is_zero()) return a;
	      return Amount.from_json(a).add(b);
	    } catch (err) {
	      return Amount.NaN();
	    }
	  };
	});
	/**
	 * Calculate the difference of two Amounts.
	 */
	module.filter('rpamountsubtract', function () {
	  return function (a, b) {
	    try {
	      return Amount.from_json(a).subtract(b);
	    } catch (err) {
	      return Amount.NaN();
	    }
	  };
	});

	/**
	 * Angular filter for Moment.js.
	 *
	 * Displays a timestamp as "x minutes ago".
	 */
	var momentCache = {};

	module.filter('rpfromnow', function () {
	  return function (input) {
	    // This is an expensive function, cache it
	    if (!momentCache[input]) momentCache[input] = moment(input).fromNow();

	    return momentCache[input];
	  };
	});

	/**
	 * Show contact name or short address
	 */
	module.filter('rpcontactname', ['$rootScope', function ($scope) {
	  return function (address) {
	    address = address ? ""+address : "";

	    var contact = webutil.getContact($scope.userBlob.data.contacts, address);

	    if (!contact) {
	      //return "" + address.substring(0,7) + "…";
	      return address;
	    }

	    return contact.name;
	  };
	}]);

	module.filter('rpcontactnamefull', ['$rootScope', function ($scope) {
	  return function (address) {
	    address = address ? ""+address : "";
	    var contact = webutil.getContact($scope.userBlob.data.contacts, address);

	    if (!contact) {
	      return "" + address;
	    }

	    return contact.name;
	  };
	}]);

	module.filter('rponlycontactname', ['$rootScope', function ($scope) {
	  return function (address) {
	    address = address ? ""+address : "";

	    var contact = webutil.getContact($scope.userBlob.data.contacts, address);

	    if (contact) {
	      return contact.name;
	    }
	  };
	}]);

	/**
	 * Masks a string like so: •••••.
	 *
	 * The number of the bullets will correspond to the length of the string.
	 */
	module.filter('rpmask', function () {
	  return function (pass) {
	    pass = ""+pass;
	    return Array(pass.length+1).join("•");
	  };
	});

	/**
	 * Crops a string to len characters
	 *
	 * The number of the bullets will correspond to the length of the string.
	 */
	module.filter('rptruncate', function () {
	  return function (str, len) {
	    return str ? str.slice(0, len) : '';
	  };
	});

	/**
	 * Format a file size.
	 *
	 * Based on code by aioobe @ StackOverflow.
	 * @see http://stackoverflow.com/questions/3758606
	 */
	module.filter('rpfilesize', function () {
	  function number_format( number, decimals, dec_point, thousands_sep ) {
	    // http://kevin.vanzonneveld.net
	    // +   original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
	    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
	    // +     bugfix by: Michael White (http://crestidg.com)
	    // +     bugfix by: Benjamin Lupton
	    // +     bugfix by: Allan Jensen (http://www.winternet.no)
	    // +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
	    // *     example 1: number_format(1234.5678, 2, '.', '');
	    // *     returns 1: 1234.57

	    var n = number, c = isNaN(decimals = Math.abs(decimals)) ? 2 : decimals;
	    var d = dec_point === undefined ? "," : dec_point;
	    var t = thousands_sep === undefined ? "." : thousands_sep, s = n < 0 ? "-" : "";
	    var i = parseInt(n = Math.abs(+n || 0).toFixed(c), 10) + "", j = (j = i.length) > 3 ? j % 3 : 0;

	    return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "");
	  }

	  // SI (International System of Units)
	  // e.g. 1000 bytes = 1 kB
	  var unit = 1000;
	  var prefixes = "kMGTPE";
	  var common = "B";

	  // Binary system
	  // e.g. 1024 bytes = 1 KiB
	  //var unit = 1024
	  //var prefixes = "KMGTPE";
	  //var common = "iB";

	  return function (str) {
	    var bytes = +str;
	    if (bytes < unit) return bytes + " B";
	    var exp = Math.floor(Math.log(bytes) / Math.log(unit));
	    var pre = " "+prefixes[exp-1] + common;
	    return number_format(bytes / Math.pow(unit, exp), 2, '.', '')+pre;
	  };
	});

	/**
	 * Uppercase the first letter.
	 */
	module.filter('rpucfirst', function () {
	  return function (str) {
	    str = ""+str;
	    return str.charAt(0).toUpperCase() + str.slice(1);
	  };
	});

	/**
	 * Something similar to javascript for loop
	 *
	 * Usage
	 * Example1 : ng-repeat="n in [20] | rprange"
	 * Example2 : ng-repeat="n in [10, 35] | rprange"
	 */
	module.filter('rprange', function() {
	  return function(input) {
	    var lowBound, highBound;
	    switch (input.length) {
	      case 1:
	        lowBound = 0;
	        highBound = parseInt(input[0], 10) - 1;
	        break;
	      case 2:
	        lowBound = parseInt(input[0], 10);
	        highBound = parseInt(input[1], 10);
	        break;
	      default:
	        return input;
	    }
	    var result = [];
	    for (var i = lowBound; i <= highBound; i++)
	      result.push(i);
	    return result;
	  };
	});

	module.filter('rpaddressorigin', function() {
	  return function(recipient) {
	    return !isNaN(Base.decode_check([0, 5], recipient, 'bitcoin')) ? 'bitcoin' : 'ripple';
	  };
	});

	module.filter('rpheavynormalize', function () {
	  return function (value, maxLength) {
	    return String(value)
	      // Remove non-printable and non-ASCII characters
	      .replace(/[^ -~]/g, '')
	      // Enforce character limit
	      .substr(0, maxLength || 160)
	      // Remove leading whitespace
	      .replace(/^\s+/g, '')
	      // Remove trailing whitespace
	      .replace(/\s+$/g, '')
	      // Normalize all other whitespace
	      .replace(/\s+/g, ' ');
	  };
	});

	/**
	 * Show Ripple Name
	 *
	 * Shows a ripple name for a given ripple address
	 */
	module.filter("rpripplename", ['rpId', function(id) {
	  return function(address, options) {
	    var ripplename = id.resolveNameSync(address, options);
	    if (ripplename !== address) {
	      return ripplename;
	    }
	    if (address.length > 21) {
	      return address.substring(0, 7) + "…";
	    }
	    return address;
	  }
	}]);


/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

	var globals = angular.module('app.globals', []);

	/*
	We want to be able to inject mocks into tests with dependencies on these globals
	*/

	// deps/js/store.js
	globals.constant('store', store);
	// config.js
	globals.constant('Options', Options);


/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * ID
	 *
	 * The id service is used for user identification and authorization.
	 */

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    Base58Utils = __webpack_require__(50),
	    RippleAddress = __webpack_require__(2).RippleAddress;

	var module = angular.module('id', ['authflow', 'blob', 'rippletxt']);

	module.factory('rpId', ['$rootScope', '$location', '$route', '$routeParams', '$timeout',
	                        'rpAuthFlow', 'rpBlob', '$q', 'rpRippleTxt', '$http',
	                        function($scope, $location, $route, $routeParams, $timeout,
	                                 $authflow, $blob, $q, txt, $http)
	{
	  /**
	   * Identity manager
	   *
	   * This class manages the encrypted blob and all user-specific state.
	   */
	  var Id = function() {
	    this.account = null;
	    this.loginStatus = false;
	    this.resolvedNames = [];
	    this.serviceInvoked = [];
	  };

	  // This object defines the minimum structure of the blob.
	  //
	  // This is used to ensure that the blob we get from the server has at least
	  // these fields and that they are of the right types.
	  Id.minimumBlob = {
	    data: {
	      contacts: [],
	      preferred_issuer: {},
	      preferred_second_issuer: {}
	    },
	    meta: []
	  };

	  // The default blob is the blob that a new user gets.
	  //
	  // Right now this is equal to the minimum blob, but we may define certain
	  // default values here in the future.
	  Id.defaultBlob = Id.minimumBlob;

	  /**
	   * Reduce username to standardized form.
	   *
	   * This creates the version of the username that is displayed in the UI.
	   */
	  Id.normalizeUsernameForDisplay = function (username) {
	    username = ""+username;

	    // Strips whitespace at beginning and end.
	    username = username.trim();

	    return username;
	  };

	  /**
	   * Reduce username to standardized form.
	   *
	   * This version is used in the login system and it's the version sent to
	   * servers.
	   */
	  Id.normalizeUsernameForInternals = function (username) {
	    username = ""+username;

	    // Strips whitespace at beginning and end.
	    username = username.trim();

	    // Remove hyphens
	    username = username.replace(/-/g, '');

	    // All lowercase
	    username = username.toLowerCase();

	    return username;
	  };

	  /**
	   * Reduce password to standardized form.
	   *
	   * Strips whitespace at beginning and end.
	   */
	  Id.normalizePassword = function (password) {
	    password = ""+password;
	    password = password.trim();
	    return password;
	  };

	  Id.prototype.init = function ()
	  {
	    var self = this;

	    // Initializing sjcl.random doesn't really belong here, but there is no other
	    // good place for it yet.
	    for (var i = 0; i < 8; i++) {
	      sjcl.random.addEntropy(Math.random(), 32, "Math.random()");
	    }

	    $scope.userBlob = Id.defaultBlob;
	    $scope.userCredentials = {};

	    $scope.$watch('userBlob',function(){
	      // XXX Maybe the blob service should handle this stuff?
	      $scope.$broadcast('$blobUpdate');

	      // XXX What's the equivalent in the new login API?
	      /*
	      if (self.username && self.password) {
	        $oldblob.set(...,
	                  self.username.toLowerCase(), self.password,
	                  $scope.userBlob,function(){
	                    $scope.$broadcast('$blobSave');
	                  });
	      }
	      */
	    },true);

	    $scope.$on('$blobUpdate', function(){
	      // Account address
	      if (!$scope.address && $scope.userBlob.data.account_id) {
	        $scope.address = $scope.userBlob.data.account_id;
	      }
	    });

	    if (!!store.get('ripple_auth')) {
	      
	      self.relogin(function(err, blob) {
	        if (!blob) {
	          self.logout();  
	          $location.path('/login');
	        }
	      });
	    }

	    $(window).bind('storage', function (e) {
	      // http://stackoverflow.com/questions/18476564/ie-localstorage-event-misfired
	      if (document.hasFocus()) return;

	      if (e.originalEvent.key == 'ripple_auth' && e.originalEvent.oldValue && !e.originalEvent.newValue) {
	        $timeout(function(){ $scope.$broadcast('$idRemoteLogout'); }, 0);
	      }

	      if (e.originalEvent.key == 'ripple_auth' && !e.originalEvent.oldValue && e.originalEvent.newValue) {
	        $timeout(function(){ $scope.$broadcast('$idRemoteLogin'); }, 0);
	      }
	    });
	  };

	  Id.prototype.setUsername = function (username)
	  {
	    this.username = username;
	    $scope.userCredentials.username = username;
	    $scope.$broadcast('$idUserChange', {username: username});
	  };

	  Id.prototype.setAccount = function (accId)
	  {
	    if (this.account !== null) {
	      $scope.$broadcast('$idAccountUnload', {account: accId});
	    }
	    this.account = accId;
	    $scope.userCredentials.account = accId;
	    $scope.$broadcast('$idAccountLoad', {account: accId});
	  };

	  Id.prototype.setLoginKeys = function (keys)
	  {
	    this.keys = keys;
	  };

	  Id.prototype.isReturning = function ()
	  {
	    return !!store.get('ripple_known');
	  };

	  Id.prototype.isLoggedIn = function ()
	  {
	    return this.loginStatus;
	  };

	  Id.prototype.storeLoginKeys = function (url, username, keys)
	  {
	    store.set('ripple_auth', {url:url, username: username, keys: keys});
	  };

	  Id.prototype.verify = function (opts, callback) {
	    $authflow.verify(opts, callback);
	  };

	  Id.prototype.resendEmail = function (opts, callback) {
	    $authflow.resendEmail(opts, callback);
	  };

	  Id.prototype.rename = function (opts, callback) {
	    opts.blob = $scope.userBlob;
	    opts.url = $scope.userBlob.url;
	    opts.username = this.username;

	    $authflow.rename(opts, callback);
	  };

	  Id.prototype.register = function (opts, callback)
	  {
	    var self = this;

	    // If account master key is not present, generate one
	    var masterkey = !!opts.masterkey
	      ? opts.masterkey
	      : Base58Utils.encode_base_check(33, sjcl.codec.bytes.fromBits(sjcl.random.randomWords(4)));

	    // Callback is optional
	    if ("function" !== typeof callback) callback = $.noop;

	    // Username is empty for the desktop client
	    if (!opts.username) opts.username = 'local';

	    // Blob data
	    var username = Id.normalizeUsernameForDisplay(opts.username);
	    var password = Id.normalizePassword(opts.password);
	    var account  = (new RippleAddress(masterkey)).getAddress();

	    $authflow.register({
	      'username': username,
	      'password': password,
	      'account': account,
	      'email': opts.email,
	      'masterkey': masterkey,
	      'oldUserBlob': opts.oldUserBlob,
	      'walletfile': opts.walletfile
	    },
	    function (err, blob, keys) {
	      if (err) {
	        console.log("client: id: registration failed:", (err && err.stack) ? err.stack : err);
	        callback(err);
	        return;
	      }

	      $scope.userBlob = blob;

	      self.setUsername(username);

	//      self.setAccount(blob.data.account_id);
	//      self.setLoginKeys(keys);
	//      self.storeLoginKeys(username, keys);
	//      self.loginStatus = true;
	//      $scope.$broadcast('$blobUpdate');

	      self.setAccount(blob.data.account_id);
	      self.loginStatus = true;
	      $scope.$broadcast('$blobUpdate');

	      store.set('ripple_known', true);
	      callback(null, masterkey);
	    });
	  };

	  Id.prototype.exists = function (username, password, callback)
	  {
	    var self = this;

	    username = Id.normalizeUsernameForDisplay(username);
	    password = Id.normalizePassword(password);

	    $authflow.exists(Id.normalizeUsernameForInternals(username), password, function (err, data) {
	      if (!err && data) {
	        // Blob found, new auth method
	        callback(null, true);
	      } else {
	        // No blob found
	        callback(null, false);
	      }
	    });
	  };

	  Id.prototype.login = function (opts, callback)
	  {
	    var self = this;

	    // Callback is optional
	    if ("function" !== typeof callback) callback = $.noop;

	    var username = Id.normalizeUsernameForDisplay(opts.username);
	    var password = Id.normalizePassword(opts.password);
	    var deviceID = opts.device_id || store.get('device_id');

	    $authflow.login({
	      'username': Id.normalizeUsernameForInternals(username),
	      'password': password,
	      'walletfile': opts.walletfile
	    }, function (err, blob, keys, actualUsername) {

	      if (err) {
	        // login failed and no fallback configured
	        callback(err);
	      } else {
	        // Ensure certain properties exist
	        $.extend(true, blob, Id.minimumBlob);

	        // Ripple's username system persists the capitalization of the username,
	        // even though usernames are case-insensitive. That's why we want to use
	        // the "actualUsername" that the server returned.
	        //
	        // However, we want this to never be a source for problems, so we'll
	        // ensure the actualUsername returned is equivalent to what we expected
	        // and fall back to what the user entered otherwise.
	        if ("string" !== typeof actualUsername ||
	            Id.normalizeUsernameForInternals(actualUsername) !== Id.normalizeUsernameForInternals(username)) {
	          actualUsername = username;
	        }

	        $scope.userBlob = blob;
	        self.setUsername(actualUsername);


	        self.setAccount(blob.data.account_id);
	        self.setLoginKeys(keys);
	        self.storeLoginKeys(blob.url, actualUsername, keys);
	        store.set('device_id', blob.device_id);
	        self.loginStatus = true;
	        $scope.$broadcast('$blobUpdate');
	        store.set('ripple_known', true);

	        if (blob.data.account_id) {
	          // Success
	          callback(null);
	        } else {
	          // Invalid blob
	          callback(new Error("Blob format unrecognized!"));
	        }
	      }
	    });
	  };
	  
	  Id.prototype.relogin = function (callback) {
	    var self     = this;
	    var auth     = store.get('ripple_auth');
	    var deviceID = store.get('device_id');
	    if (!auth || !auth.keys) {
	      return callback(new Error('Missing authentication keys'));
	    }
	    
	    // XXX This is technically not correct, since we don't know yet whether
	    //     the login will succeed. But we need to set it now, because the page
	    //     controller will likely query it long before we get a response from
	    //     the login system.
	    //
	    //     Will work fine as long as any relogin error triggers a logout and
	    //     logouts trigger a full page reload.
	    self.loginStatus = true;    
	    
	    $authflow.relogin(auth.url, auth.keys, deviceID, function (err, blob) {
	      
	      if (err) {
	        
	        // Failed to relogin
	        console.log("client: id: failed to relogin:", err.message || err.toString());
	        callback(err);        
	        
	      } else {
	        // Ensure certain properties exist
	        $.extend(true, blob, Id.minimumBlob);

	        $scope.userBlob = blob;
	        self.setUsername(auth.username);
	        self.setAccount(blob.data.account_id);
	        self.setLoginKeys(auth.keys);
	        self.loginStatus = true;
	        $scope.$broadcast('$blobUpdate');
	        store.set('ripple_known', true);
	        callback(null, blob);
	      }
	    });    
	  };

	  Id.prototype.verifyToken = function (options, callback) {
	    store.set('remember_me', options.remember_me);
	    $authflow.verifyToken(options, callback);    
	  }; 
	  
	  Id.prototype.changePassword = function (options, callback) {
	    var self = this;
	    
	    $authflow.changePassword(options, function(err, resp) {  
	      
	      if (err) {
	        return callback(err);
	      }
	      
	      //NOTE: the section below changed so that you can recover with 2FA enabled
	      //We should be checking attestation statuses here also.
	      
	      //perform login, so that the email verification is checked
	      //and the username, blob, and keys get stored.
	      //self.login(options, callback); 
	      
	      var keys = {id:options.blob.id,crypt:options.blob.key};
	      
	      $scope.userBlob = options.blob;
	      self.setUsername(options.username);
	      self.setAccount(options.blob.data.account_id);
	      self.setLoginKeys(keys);
	      self.storeLoginKeys(options.blob.url, options.username, keys);
	      store.set('device_id', options.blob.device_id);
	      self.loginStatus = true;
	      $scope.$broadcast('$blobUpdate');
	      store.set('ripple_known', true);  
	      callback();          
	    });
	  };
	  
	  Id.prototype.logout = function ()
	  {
	    store.remove('ripple_auth');

	    //remove deviceID if remember me is not set
	    if (!store.get('remember_me')) {
	      store.remove('device_id');  
	    }
	    
	    // TODO make it better
	    this.account = '';
	    this.keys = {};
	    this.loginStatus = false;
	    this.username = '';

	    $scope.address = '';
	//    $location.path('/login');

	    // problem?
	    // reload will not work, as some pages are also available for guests.
	    // Logout will show the same page instead of showing login page.
	    // This line redirects user to root (login) page
	//    var port = location.port.length > 0 ? ":" + location.port : "";
	//    location.href = location.protocol + '//' + location.hostname  + port + location.pathname;
	  };

	  Id.prototype.unlock = function (username, password, callback)
	  {
	    var self = this;

	    // Callback is optional
	    if ("function" !== typeof callback) callback = $.noop;

	    //username = Id.normalizeUsernameForDisplay(username);
	    //password = Id.normalizePassword(password);

	    $authflow.unlock(username, password, function (err, resp) {
	      if (err) {
	        callback(err);
	        return;
	      }
	    
	      callback(null, resp.secret);
	    });
	  };

	  /**
	   * Go to an identity page.
	   *
	   * Redirects the user to a page where they can identify. This could be the
	   * login or register tab most likely.
	   */
	  Id.prototype.goId = function () {
	    if (!this.isLoggedIn()) {
	      if (_.size($routeParams)) {
	        var tab = $route.current.tabName;
	        $location.search('tab', tab);
	        $location.path('/login');
	        return;
	      }

	      if (this.isReturning()) {
	        $location.path('/login');
	      } else {
	        $location.path('/register');
	      }
	    }
	  };

	  /**
	   * Find Ripple Name
	   *
	   * Find a ripple name for a given ripple address
	   */
	  Id.prototype.resolveNameSync = function(address, options) {
	    if (!this.resolvedNames[address]) {
	      if (!this.serviceInvoked[address]) {
	        this.resolveName(address, options);
	      }
	      return address;
	    }
	    return this.resolvedNames[address];
	  };

	  /**
	   *
	   */
	  Id.prototype.addressDontHaveName = function(address) {
	    return this.resolvedNames[address] === address;
	  };

	  /**
	   * Find Ripple Name
	   *
	   * Find a ripple name for a given ripple address
	   */
	  Id.prototype.resolveName = function(address, options) {
	    var self = this;
	    var deferred = $q.defer();
	    var strippedValue = webutil.stripRippleAddress(address);
	    var rpAddress = ripple.UInt160.from_json(strippedValue);
	    if (!rpAddress.is_valid()) {
	      deferred.resolve(address);
	      return deferred.promise;
	    }

	    var opts = jQuery.extend(true, {}, options);

	    if (!this.resolvedNames[address]) {
	      if (!this.serviceInvoked[address]) {
	        this.serviceInvoked[address] = deferred;

	        // Get the blobvault url
	        txt
	          .get(Options.domain)
	          .then(
	            function(txtData) {
	              if (!txtData.authinfo_url) {
	                deferred.reject(new Error('Authentication is not supported on ' + Options.domain));
	              } else {
	                var url = Array.isArray(txtData.authinfo_url) ? txtData.authinfo_url[0] : txtData.authinfo_url;
	                url += '?username=' + address;
	                $http.get(url)
	                  .success(function(data) {
	                    if (data.username) {
	                      
	                        self.resolvedNames[address] = data.username;
	                      
	                    } else {
	                      // Show the ripple address if there's no name associated with it
	                      self.resolvedNames[address] = address;
	                    }

	                    self.serviceInvoked[address] = true;
	                     var result = (self.resolvedNames[address] !== address && opts.tilde) ? '~'.concat(self.resolvedNames[address]) : self.resolvedNames[address];
	                     deferred.resolve(result);
	                    
	                  }).error(function(error, status) {
	                    self.serviceInvoked[address] = false;
	                    deferred.reject(new Error(error));
	                  });
	              }
	            },
	            function(error) {
	              self.serviceInvoked[address] = false;
	              deferred.reject(new Error(error));
	            }
	          );
	      } else {
	        if (!_.isBoolean(this.serviceInvoked[address]) && _.isFunction(this.serviceInvoked[address].resolve)) {
	          return this.serviceInvoked[address].promise;
	        } else {
	          deferred.resolve(address);
	        }
	      }
	    } else {
	      var result = (self.resolvedNames[address] !== address && opts.tilde) ? '~'.concat(self.resolvedNames[address]) : self.resolvedNames[address];
	      deferred.resolve(result);
	    }
	    return deferred.promise;
	  };

	  return new Id();
	}]);




/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * BLOB
	 *
	 * User blob storage for desktop client
	 */

	// TODO build a blobPrototype.
	// There's currently a code repetition between blobLocal and blobRemote..

	var fs = __webpack_require__(49);

	var module = angular.module('blob', []);

	module.factory('rpBlob', ['$rootScope', function ($scope)
	{
	  var cryptConfig = {
	    // key size
	    ks: 256,
	    // iterations (key derivation)
	    iter: 1000
	  };

	  var BlobObj = function (password, walletfile)
	  {
	    this.password = password;
	    this.walletfile = walletfile;
	    this.data = {};
	  };

	  // Blob operations
	  // Do NOT change the mapping of existing ops
	  BlobObj.ops = {
	    // Special
	    "noop": 0,

	    // Simple ops
	    "set": 16,
	    "unset": 17,
	    "extend": 18,

	    // Meta ops
	    "push": 32,
	    "pop": 33,
	    "shift": 34,
	    "unshift": 35,
	    "filter": 36
	  };

	  BlobObj.opsReverseMap = [];
	  $.each(BlobObj.ops, function (name, code) {
	    BlobObj.opsReverseMap[code] = name;
	  });

	  /**
	   * Attempts to retrieve the blob.
	   */
	  BlobObj.get = function(walletfile, callback)
	  {
	    fs.readFile(walletfile, 'utf8', function(err, data){
	      if (err) {
	        callback(err);
	        return;
	      }

	      callback(null, data);
	    });
	  };

	  /**
	   * Attempts to retrieve and decrypt the blob.
	   */
	  BlobObj.init = function(walletfile, password, callback)
	  {
	    BlobObj.get(walletfile, function (err, data) {
	      if (err) {
	        callback(err);
	        return;
	      }

	      var blob = new BlobObj(password, walletfile);
	      var decryptedBlob = blob.decrypt(data);

	      if (!decryptedBlob) {
	        callback(new Error("Error while decrypting blob"));
	        return;
	      }

	      callback(null, decryptedBlob);
	    });
	  };

	  /**
	   * Create a blob object
	   *
	   * @param {object} opts
	   * @param {string} opts.url
	   * @param {string} opts.id
	   * @param opts.crypt
	   * @param opts.unlock
	   * @param {string} opts.username
	   * @param {string} opts.account
	   * @param {string} opts.masterkey
	   * @param {object=} opts.oldUserBlob
	   * @param {function} callback
	   */
	  BlobObj.create = function (opts, callback)
	  {
	    var blob = new BlobObj(opts.password, opts.walletfile);
	    blob.data = {
	      masterkey: opts.masterkey,
	      account_id: opts.account,
	      contacts: [],
	      created: (new Date()).toJSON()
	    };

	    blob.persist(callback);
	  };

	  // Store blob in a file
	  BlobObj.prototype.persist = function(callback)
	  {
	    var blob = this;

	    fs.writeFile(this.walletfile, this.encrypt(), function(){
	      callback(null, blob);
	    });
	  };

	  BlobObj.prototype.encrypt = function()
	  {
	    // Filter Angular metadata before encryption
	    if ('object' === typeof this.data &&
	        'object' === typeof this.data.contacts)
	      this.data.contacts = angular.fromJson(angular.toJson(this.data.contacts));

	    // Encryption
	    return btoa(sjcl.encrypt(""+this.password.length+'|'+this.password,
	      JSON.stringify(this.data), {
	        ks: cryptConfig.ks,
	        iter: cryptConfig.iter
	      }
	    ));
	  };

	  BlobObj.prototype.decrypt = function (data)
	  {
	    var blob = this;

	    try {
	      function decrypt(priv, ciphertext)
	      {
	        blob.data = JSON.parse(sjcl.decrypt(priv, ciphertext));
	        return blob;
	      }

	      return decrypt(""+this.password.length+'|'+this.password, atob(data));
	    } catch (e) {
	      console.log("client: blob: decryption failed", e.toString());
	      console.log(e.stack);
	      return false;
	    }
	  };

	  BlobObj.escapeToken = function (token) {
	    return token.replace(/[~\/]/g, function (key) { return key === "~" ? "~0" : "~1"; });
	  };
	  BlobObj.prototype.escapeToken = BlobObj.escapeToken;

	  var unescapeToken = function(str) {
	    return str.replace(/~./g, function(m) {
	      switch (m) {
	      case "~0":
	        return "~";
	      case "~1":
	        return "/";
	      }
	      throw("Invalid tilde escape: " + m);
	    });
	  };

	  BlobObj.prototype.applyUpdate = function(op, path, params, callback) {
	    // Exchange from numeric op code to string
	    if ("number" === typeof op) {
	      op = BlobObj.opsReverseMap[op];
	    }
	    if ("string" !== typeof op) {
	      throw new Error("Blob update op code must be a number or a valid op id string");
	    }

	    // Separate each step in the "pointer"
	    var pointer = path.split("/");

	    var first = pointer.shift();
	    if (first !== "") {
	      throw new Error("Invalid JSON pointer: "+path);
	    }

	    this._traverse(this.data, pointer, path, op, params);

	    this.persist(function(err, data) {
	      console.log('Blob saved');
	      if (typeof callback === 'function') {
	        callback(err, data);
	      }
	    });
	  };

	  BlobObj.prototype._traverse = function (context, pointer,
	                                          originalPointer, op, params) {
	    var _this = this;
	    var part = unescapeToken(pointer.shift());

	    if (Array.isArray(context)) {
	      if (part === '-') {
	        part = context.length;
	      } else if (part % 1 !== 0 || part < 0) {
	        throw new Error("Invalid pointer, array element segments must be " +
	                        "a positive integer, zero or '-'");
	      }
	    } else if ("object" !== typeof context) {
	      return null;
	    } else if (!context.hasOwnProperty(part)) {
	      // Some opcodes create the path as they're going along
	      if (op === "set") {
	        context[part] = {};
	      } else if (op === "unshift") {
	        // this is not last element in path, and next is not array pointer
	        // so create object, not array
	        if (pointer.length !== 0 && pointer[0] !== '-' &&
	            (pointer[0] % 1 !== 0 || pointer[0] < 0)) {
	          context[part] = {};
	        } else {
	          context[part] = [];
	        }
	      } else {
	        return null;
	      }
	    }

	    if (pointer.length !== 0) {
	      return this._traverse(context[part], pointer,
	                            originalPointer, op, params);
	    }

	    switch (op) {
	    case "set":
	      context[part] = params[0];
	      break;
	    case "unset":
	      if (Array.isArray(context)) {
	        context.splice(part, 1);
	      } else {
	        delete context[part];
	      }
	      break;
	    case "extend":
	      if ("object" !== typeof context[part]) {
	        throw new Error("Tried to extend a non-object");
	      }
	      $.extend(context[part], params[0]);
	      break;
	    case "unshift":
	      if ("undefined" === typeof context[part]) {
	        context[part] = [];
	      } else if (!Array.isArray(context[part])) {
	        throw new Error("Operator 'unshift' must be applied to an array.");
	      }
	      context[part].unshift(params[0]);
	      break;
	    case "filter":
	      if (Array.isArray(context[part])) {
	        context[part].forEach(function (element, i) {
	          if ("object" === typeof element &&
	              element.hasOwnProperty(params[0]) &&
	              element[params[0]] === params[1]) {
	            var subpointer = originalPointer+"/"+i;
	            var subcommands = normalizeSubcommands(params.slice(2));

	            subcommands.forEach(function (subcommand) {
	              var op = subcommand[0];
	              var pointer = subpointer+subcommand[1];
	              _this.applyUpdate(op, pointer, subcommand.slice(2));
	            });
	          }
	        });
	      }
	      break;
	    default:
	      throw new Error("Unsupported op "+op);
	    }
	  };

	  BlobObj.prototype.set = function (pointer, value, callback) {
	    this.applyUpdate('set', pointer, [value]);
	    };

	  BlobObj.prototype.unset = function (pointer, callback) {
	    this.applyUpdate('unset', pointer, []);
	    };

	  BlobObj.prototype.extend = function (pointer, value, callback) {
	    this.applyUpdate('extend', pointer, [value]);
	    };

	  /**
	   * Prepend an entry to an array.
	   *
	   * This method adds an entry to the beginning of an array.
	   */
	  BlobObj.prototype.unshift = function (pointer, value, callback) {
	    this.applyUpdate('unshift', pointer, [value], callback);
	  };

	  function normalizeSubcommands(subcommands, compress) {
	    // Normalize parameter structure
	    if ("number" === typeof subcommands[0] ||
	        "string" === typeof subcommands[0]) {
	      // Case 1: Single subcommand inline
	      subcommands = [subcommands];
	    } else if (subcommands.length === 1 &&
	               Array.isArray(subcommands[0]) &&
	               ("number" === typeof subcommands[0][0] ||
	                "string" === typeof subcommands[0][0])) {
	      // Case 2: Single subcommand as array
	      // (nothing to do)
	    } else if (Array.isArray(subcommands[0])) {
	      // Case 3: Multiple subcommands as array of arrays
	      subcommands = subcommands[0];
	    }

	    // Normalize op name and convert strings to numeric codes
	    subcommands = subcommands.map(function (subcommand) {
	      if ("string" === typeof subcommand[0]) {
	        subcommand[0] = BlobObj.ops[subcommand[0]];
	      }
	      if ("number" !== typeof subcommand[0]) {
	        throw new Error("Invalid op in subcommand");
	      }
	      if ("string" !== typeof subcommand[1]) {
	        throw new Error("Invalid path in subcommand");
	      }
	      return subcommand;
	    });

	    if (compress) {
	      // Convert to the minimal possible format
	      if (subcommands.length === 1) {
	        return subcommands[0];
	      } else {
	        return [subcommands];
	      }
	    } else {
	      return subcommands;
	    }
	  }

	  /**
	   * Filter the row(s) from an array.
	   *
	   * This method will find any entries from the array stored under `pointer` and
	   * apply the `subcommands` to each of them.
	   *
	   * The subcommands can be any commands with the pointer parameter left out.
	   */
	  BlobObj.prototype.filter = function (pointer, field, value, subcommands, callback) {
	    var params = Array.prototype.slice.apply(arguments);
	    if ("function" === typeof params[params.length-1]) {
	      callback = params.pop();
	    }
	    params.shift();

	    // Normalize subcommands to minimize the patch size
	    params = params.slice(0, 2).concat(normalizeSubcommands(params.slice(2), true));

	    this.applyUpdate('filter', pointer, params);
	  };

	  function BlobError(message, backend) {
	    this.name = "BlobError";
	    this.message = message || "";
	    this.backend = backend || "generic";
	  }

	  BlobError.prototype = Error.prototype;

	  BlobObj.BlobError = BlobError;

	  return BlobObj;
	}]);


/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * AUTH FLOW
	 *
	 * This auth flow service manages the login and registration procedures for the desktop client.
	 */

	var module = angular.module('authflow', []);

	module.factory('rpAuthFlow', ['$rootScope', 'rpBlob',
	  function ($scope, $blob)
	  {
	    var AuthFlow = {};

	    /**
	     * Login
	     *
	     * @param {object} opts
	     * @param {string} opts.password
	     * @param {string} opts.walletfile
	     * @param {function} callback
	     */
	    AuthFlow.login = function (opts, callback) {
	      var password = opts.password;

	      $blob.init(opts.walletfile, password, function (err, blob) {
	        if (err) {
	          callback(err);
	          return;
	        }

	        console.log("client: authflow: login succeeded", blob);
	        callback(null, blob, '', 'local');
	      });
	    };

	    /**
	     * Register an account
	     *
	     * @param {object} opts
	     * @param {string} opts.password
	     * @param {string} opts.account
	     * @param {string} opts.masterkey
	     * @param {string} opts.walletfile
	     * @param {function} callback
	     */
	    AuthFlow.register = function (opts, callback) {
	      $blob.create({
	        'account': opts.account,
	        'password': opts.password,
	        'masterkey': opts.masterkey,
	        'walletfile': opts.walletfile
	      },
	      function (err, blob) {
	        if (err) {
	          callback(err);
	          return;
	        }

	        console.log("client: authflow: registration succeeded", blob);
	        callback(null, blob, 'local');
	      });
	    };

	    AuthFlow.relogin = function (username, keys, callback) {
	      callback('err');
	    };

	    return AuthFlow;
	  }]);


/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * KEYCHAIN
	 *
	 * Manages the actual signing keys for the account.
	 *
	 * The account is locked by default. When a transaction is requested, the user
	 * can enter their password to unlock their account for a certain period of
	 * time. This class manages the timeout when the account will be re-locked.
	 */

	var webutil = __webpack_require__(51),
	    log = __webpack_require__(52);

	var module = angular.module('keychain', ['popup']);

	module.factory('rpKeychain', ['$rootScope', '$timeout', 'rpPopup', 'rpId',
	                              function ($scope, $timeout, popup, id)
	{
	  var Keychain = function ()
	  {
	    var _this = this;
	    this.secrets = {};

	    // Unlock the Desktop client right away
	    var keychain = this;
	    var watcher = $scope.$watch('userBlob', function(){
	      if ($scope.userBlob.data && $scope.userBlob.data.account_id) {
	        keychain.secrets[$scope.userBlob.data.account_id] = {
	          masterkey: $scope.userBlob.data.masterkey
	        };
	        watcher();
	      }
	    }, true);
	  };

	  // Default unlock duration is 5 minutes
	  Keychain.unlockDuration = 5 * 60 * 1000;

	  Keychain.prototype.isUnlocked = function (account) {
	    return !!this.secrets[account];
	  };

	  /**
	   * Getting a secret for an account with default UI.
	   *
	   * This function will immediatly callback if the wallet is already unlocked.
	   * Otherwise, it will automatically handle the unlock process using a modal
	   * popover.
	   *
	   * If the user cancels the operation, the method will call the callback with
	   * an error.
	   */
	  Keychain.prototype.requestSecret = function (account, username, purpose, callback) {
	    var _this = this;

	    if ("function" === typeof purpose) {
	      callback = purpose;
	      purpose = null;
	    }

	    // Handle already unlocked accounts
	    if (this.secrets[account]) {
	      // Keep the secret in a closure in case it happens to get locked
	      // between now and when $timeout calls back.
	      var secret = this.secrets[account].masterkey;
	      $timeout(function () {
	        callback(null, secret);
	      });
	      return;
	    }

	    var popupScope = $scope.$new();
	    var unlock = popupScope.unlock = {
	      isConfirming: false,
	      password: '',
	      purpose: purpose
	    };
	    popupScope.confirm = function () {
	      unlock.isConfirming = true;

	      function handleSecret(err, secret) {
	        if (err) {
	          // XXX More fine-grained error handling would be good. Can we detect
	          //     server down?
	          unlock.isConfirming = false;
	          unlock.error = "password";
	        } else {
	          popup.close();

	          callback(null, secret);
	        }
	      }

	      _this.getSecret(account, username, popupScope.unlock.password,
	                      handleSecret);
	    };
	    popupScope.cancel = function () {
	      callback("canceled"); //need this for setting password protection
	      popup.close();
	    };
	    popup.blank(__webpack_require__(62)(), popupScope);
	  };

	  /**
	   * Getting a secret for an account with custom UI.
	   *
	   * The difference between this method and Keychain#requestSecret is that to
	   * call this function you have to request the password from the user yourself.
	   */
	  Keychain.prototype.getSecret = function (account, username, password, callback) {
	    var _this = this;

	    // Handle already unlocked accounts
	    if (this.secrets[account] && this.secrets[account].password === password) {
	      // Keep the secret in a closure in case it happens to get locked
	      // between now and when $timeout calls back.
	      var secret = this.secrets[account].masterkey;
	      $timeout(function () {
	        callback(null, secret);
	      });
	      return;
	    }

	    id.unlock(username, password, function (err, secret) {
	      if (err) {
	        callback(err);
	        return;
	      }

	      // Cache secret for unlock period
	      _this.secrets[account] = {
	        masterkey: secret,
	        password: password
	      };

	      _this.expireSecret(account);
	      callback(null, secret);
	    });
	  };

	  /**
	   * Synchronous way to acquire secret.
	   *
	   * This function will only work if the account is already unlocked. Throws an
	   * error otherwise.
	   */
	  Keychain.prototype.getUnlockedSecret = function (account) {
	    if (!this.isUnlocked) {
	      throw new Error("Keychain: Tried to get secret for locked account synchronously.");
	    }

	    return this.secrets[account].masterkey;
	  };


	 /**
	  * setPasswordProtection
	  * @param {Object} protect
	  * @param {Object} callback
	  */
	  Keychain.prototype.setPasswordProtection = function (requirePassword, callback) {
	    var _this   = this;

	    if (requirePassword === false) {
	      this.requestSecret(id.account, id.username, function(err, secret) {
	        if (err) {
	          return callback(err);            
	        }
	        
	        setPasswordProtection(requirePassword, secret, callback);
	      });
	                       
	    } else {
	      setPasswordProtection(requirePassword, null, callback);
	    }
	    
	    function setPasswordProtection (requirePassword, secret, callback) {
	      
	      $scope.userBlob.set('/persistUnlock', !requirePassword, function(err, resp) {
	        if (err) {
	          return callback(err);
	        }
	        
	        if (requirePassword) {
	          _this.expireSecret(id.account);
	        }
	        
	      });
	    }
	  };
	  
	  Keychain.prototype.expireSecret = function (account) {
	    var _this = this;
	    $timeout(function(){
	      if (_this.secrets[account] && !$scope.userBlob.data.persistUnlock) {
	        delete _this.secrets[account];  
	      }  
	    }, Keychain.unlockDuration);  
	  }
	  
	  return new Keychain();
	}]);


/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * NETWORK
	 *
	 * The network service is used to communicate with the Ripple network.
	 *
	 * It encapsulates a ripple.Remote instance.
	 */

	var module = angular.module('network', []);

	module.factory('rpNetwork', ['$rootScope', function($scope)
	{
	  /**
	   * Manage network state.
	   *
	   * This class is intended to manage the connection status to the
	   * Ripple network.
	   *
	   * Note that code in other places *is allowed* to call the Ripple
	   * library directly. This is not to be intended to be an abstraction
	   * layer on top of an abstraction layer.
	   */
	  var Network = function() {
	    this.remote = new ripple.Remote(Options.server, true);
	    this.remote.on('connected', this.handleConnect.bind(this));
	    this.remote.on('disconnected', this.handleDisconnect.bind(this));

	    // Set network max transaction fee from Options, or default to 12 drops of XRP
	    this.remote.max_fee = Options.max_tx_network_fee || 12;

	    this.connected = false;
	  };

	  Network.prototype.init = function() {
	    try {
	      this.remote.connect();
	    } catch (e) {
	      console.warn(e);
	      // fallback to default servers
	      Options.server.servers = Options.defaultServers;
	      this.remote = new ripple.Remote(Options.server, true);
	      this.remote.on('connected', this.handleConnect.bind(this));
	      this.remote.on('disconnected', this.handleDisconnect.bind(this));
	      this.remote.connect();
	    }
	  };

	  /**
	   * Setup listeners for identity state.
	   *
	   * This function causes the network object to start listening to
	   * changes in the identity state and automatically subscribe to
	   * accounts accordingly.
	   */
	  Network.prototype.listenId = function (id)
	  {
	    var self = this;
	  };

	  Network.prototype.handleConnect = function (e)
	  {
	    var self = this;
	    $scope.$apply(function () {
	      self.connected = true;
	      $scope.connected = true;
	      $scope.$broadcast('$netConnected');
	    });
	  };

	  Network.prototype.handleDisconnect = function (e)
	  {
	    var self = this;
	    $scope.$apply(function () {
	      self.connected = false;
	      $scope.connected = false;
	      $scope.$broadcast('$netDisconnected');
	    });
	  };

	  return new Network();
	}]);



/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * BOOKS
	 *
	 * The books service is used to keep track of orderbooks.
	 */

	var module = angular.module('books', ['network']);
	var Amount = ripple.Amount;


	module.factory('rpBooks', ['rpNetwork', '$q', '$rootScope', '$filter', 'rpId',
	function(net, $q, $scope, $filter, $id) {

	  var rowCount;

	  function loadBook(gets, pays, taker) {
	    return net.remote.book(gets.currency, gets.issuer,
	    pays.currency, pays.issuer,
	    taker);
	  }

	  function filterRedundantPrices(data, action, combine) {
	    var max_rows = Options.orderbook_max_rows || 100;

	    var price;
	    var lastprice;
	    var current;
	    var rpamount = $filter('rpamount');
	    var newData = jQuery.extend(true, {}, data);

	    rowCount = 0;
	    newData = _.values(_.compact(_.map(newData, function(d, i) {

	      // This check is redundant, but saves the CPU some work
	      if (rowCount > max_rows) return;

	      // rippled has a bug where it shows some unfunded offers
	      // We're ignoring them
	      if (d.taker_gets_funded === "0" || d.taker_pays_funded === "0")
	        return;

	      if (d.TakerGets.value) {
	        d.TakerGets.value = d.taker_gets_funded;
	      } else {
	        d.TakerGets = parseInt(Number(d.taker_gets_funded), 10);
	      }

	      if (d.TakerPays.value) {
	        d.TakerPays.value = d.taker_pays_funded;
	      } else {
	        d.TakerPays = parseInt(Number(d.taker_pays_funded), 10);
	      }

	      d.TakerGets = Amount.from_json(d.TakerGets);
	      d.TakerPays = Amount.from_json(d.TakerPays);

	      // You never know
	      if (!d.TakerGets.is_valid() || !d.TakerPays.is_valid())
	        return;

	      if (action === "asks") {
	        d.price = Amount.from_quality(d.BookDirectory,
	                                      d.TakerPays.currency(),
	                                      d.TakerPays.issuer(), {
	          base_currency: d.TakerGets.currency(),
	          reference_date: new Date()
	        });
	      } else {
	        d.price = Amount.from_quality(d.BookDirectory,
	                                      d.TakerGets.currency(),
	                                      d.TakerGets.issuer(), {
	          inverse: true,
	          base_currency: d.TakerPays.currency(),
	          reference_date: new Date()
	        });
	      }

	      var price = rpamount(d.price, {
	        rel_precision: 4,
	        rel_min_precision: 2
	      });

	      // Don't combine current user's orders.
	      if (d.Account == $id.account) {
	        d.my = true;
	      }

	      if (lastprice === price && !d.my) {
	        if (combine) {
	          newData[current].TakerPays = Amount.from_json(newData[current].TakerPays).add(d.TakerPays);
	          newData[current].TakerGets = Amount.from_json(newData[current].TakerGets).add(d.TakerGets);
	        }
	        d = false;
	      } else current = i;

	      if (!d.my)
	        lastprice = price;

	      if (d) rowCount++;

	      if (rowCount > max_rows) return false;

	      return d;
	    })));

	    var key = action === "asks" ? "TakerGets" : "TakerPays";
	    var sum;
	    _.each(newData, function (order, i) {
	      if (sum) sum = order.sum = sum.add(order[key]);
	      else sum = order.sum = order[key];
	    });

	    return newData;
	  }

	  return {
	    get: function(first, second, taker) {
	      var asks = loadBook(first, second, taker);
	      var bids = loadBook(second, first, taker);
	     
	      asks._shouldSubscribe = true;
	      bids._shouldSubscribe = true;
	      
	      var model = {
	        asks: filterRedundantPrices(asks.offersSync(), 'asks', true),
	        bids: filterRedundantPrices(bids.offersSync(), 'bids', true)
	      };

	      function handleAskModel(offers) {
	        $scope.$apply(function () {
	          model.asks = filterRedundantPrices(offers, 'asks', true);
	          model.updated = true;
	        });
	      }

	      function handleAskTrade(gets, pays) {
	        $scope.$apply(function () {
	          model.last_price = gets.ratio_human(pays);
	          model.updated = true;
	        });
	      }
	      asks.on('model', handleAskModel);
	      asks.on('trade', handleAskTrade);

	      function handleBidModel(offers) {
	        $scope.$apply(function () {
	          model.bids = filterRedundantPrices(offers, 'bids', true);
	          model.updated = true;
	        });
	      }

	      function handleBidTrade(gets, pays) {
	        $scope.$apply(function () {
	          model.last_price = pays.ratio_human(gets);
	          model.updated = true;
	        });
	      }
	      bids.on('model', handleBidModel);
	      bids.on('trade', handleBidTrade);

	      model.unsubscribe = function() {
	        asks.removeListener('model', handleAskModel);
	        asks.removeListener('trade', handleAskTrade);
	        bids.removeListener('model', handleBidModel);
	        bids.removeListener('trade', handleBidTrade);
	      };

	      return model;
	    },

	    getLength: function() {
	      return rowCount;
	    }
	  };
	}]);


/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * TRANSACTIONS
	 *
	 * The transactions service is used to listen to all Ripple network
	 * transactions.
	 *
	 * This obviously won't scale, but it'll do long enough for us (or somebody
	 * else) to come up with something better.
	 */

	var module = angular.module('transactions', ['network']);

	module.factory('rpTransactions', ['$rootScope', 'rpNetwork',
	                                  function($scope, net) {
	  var listeners = [],
	      subscribed = false;

	  function subscribe() {
	    if (subscribed) return;
	    net.remote.requestSubscribe("transactions").request();
	    subscribed = true;
	  }

	  function handleTransaction(msg) {
	    $scope.$apply(function () {
	      listeners.forEach(function (fn) {
	        fn(msg);
	      });
	    });
	  }

	  net.remote.on('net_transaction', handleTransaction);

	  return {
	    addListener: function (fn) {
	      listeners.push(fn);
	      subscribe();
	    },
	    removeListener: function (fn) {
	      var position = -1;
	      for (var i = 0, l = listeners.length; i < l; i++) {
	        if (listeners[i] === fn) {
	          position = i;
	        }
	      }
	      if (position < 0) return;
	      listeners.splice(position, 1);
	    }
	  };
	}]);


/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * LEDGER
	 *
	 * The ledger service is used to provide information that requires watching the
	 * entire ledger.
	 *
	 * This obviously won't scale, but it'll do long enough for us (or somebody
	 * else) to come up with something better.
	 */

	var module = angular.module('ledger', ['network', 'transactions']);

	module.factory('rpLedger', ['$q', '$rootScope', 'rpNetwork', 'rpTransactions',
	                            function($q, $rootScope, net, transactions)
	{

	  var offerPromise = $q.defer();
	  var tickerPromise = $q.defer();
	  var requested = false;

	  var ledger = {
	    offers: offerPromise.promise,
	    tickers: tickerPromise.promise,
	    getOrders: getOrders
	  };

	  function filterOrder(buyCurrency, sellCurrency, buyIssuer, sellIssuer,
	                       pays, gets) {
	    if (buyCurrency !== gets.currency || sellCurrency !== pays.currency) {
	      return false;
	    }

	    if (buyCurrency !== 'XRP' && buyIssuer && gets.issuer !== buyIssuer) {
	      return false;
	    }

	    if (sellCurrency !== 'XRP' && sellIssuer && pays.issuer !== sellIssuer) {
	      return false;
	    }

	    return true;
	  }

	  function getOrders(buyCurrency, sellCurrency, buyIssuer, sellIssuer) {
	    var obj = {
	      asks: [],
	      bids: []
	    };

	    if (!Array.isArray(ledger.offers)) return obj;

	    ledger.offers.forEach(function (node) {
	      var gets = rewriteAmount(node.TakerGets);
	      var pays = rewriteAmount(node.TakerPays);

	      if (filterOrder(buyCurrency, sellCurrency, buyIssuer, sellIssuer, pays, gets)) {
	        obj.asks.push({i: gets, o: pays});

	        // A bid can't also be an ask
	        return;
	      }

	      if (filterOrder(buyCurrency, sellCurrency, buyIssuer, sellIssuer, gets, pays)) {
	        obj.bids.push({i: pays, o: gets});
	      }
	    });

	    obj.asks.sort(function (a, b) {
	      var aRatio = a.o.amount.ratio_human(a.i.amount, {reference_date: new Date()});
	      var bRatio = b.o.amount.ratio_human(b.i.amount, {reference_date: new Date()});
	      return aRatio.compareTo(bRatio);
	    });

	    obj.bids.sort(function (a, b) {
	      var aRatio = a.o.amount.ratio_human(a.i.amount, {reference_date: new Date()});
	      var bRatio = b.o.amount.ratio_human(b.i.amount, {reference_date: new Date()});
	      return bRatio.compareTo(aRatio);
	    });

	    fillSum(obj.asks, 'i');
	    fillSum(obj.bids, 'i');

	    return obj;
	  }

	  function rewriteAmount(amountJson) {
	    var amount = ripple.Amount.from_json(amountJson);
	    return {
	      amount: amount,
	      // Pretty dirty hack, but to_text for native values gives 1m * value...
	      // In the future we will likely remove this field altogether (and use
	      // Amount class math instead), so it's ok.
	      num: +amount.to_human({group_sep: false}),
	      currency: amount.currency().to_human(),
	      issuer: amount.issuer().to_json()
	    };
	  }

	  /**
	   * Fill out the sum field in the bid or ask orders array.
	   */
	  function fillSum(array, field) {
	    var sum = null;
	    for (var i = 0, l = array.length; i<l; i++) {
	      if (sum === null) {
	        sum = array[i][field].amount;
	      } else {
	        sum = sum.add(array[i][field].amount);
	      }
	      array[i].sum = sum;
	    }
	  }

	  if(net.connected) {
	    doRequest();
	  }

	  net.on('connected', function(){
	    doRequest();
	  });

	  function doRequest()
	  {
	    if (requested) return;

	    net.remote.requestLedger("ledger_closed", "full")
	        .on('success', handleLedger)
	        .request();

	    transactions.addListener(handleTransaction);

	    requested = true;
	  }

	  function handleTransaction(msg)
	  {
	    // XXX: Update the ledger state using this transaction's metadata
	  }

	  function handleLedger(e)
	  {
	    $rootScope.$apply(function(){
	      var offers = e.ledger.accountState.filter(function (node) {
	        return node.LedgerEntryType === "Offer";
	      });

	      offerPromise.resolve(offers);
	      ledger.offers = offers;
	    });
	  }

	  return ledger;
	}]);


/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * POPUP
	 *
	 * The popup service is used to provide modals, alerts, and confirmation screens
	 */

	var module = angular.module('popup', []);

	module.factory('rpPopup', ['$compile',
	                           function ($compile)
	{
	  var popupService = {};

	  // Get the popup
	  popupService.getPopup = function(create)
	  {
	    if (!popupService.popupElement && create)
	    {
	      popupService.popupElement = $( '<div class="modal fade"></div>' );
	      popupService.popupElement.appendTo( 'BODY' );
	    }

	    return popupService.popupElement;
	  };

	  popupService.compileAndRunPopup = function (popup, scope, options) {
	    $compile(popup)(scope);
	    popup.modal(options);
	  };

	  popupService.blank = function(content,scope) {
	    var popup = popupService.getPopup(true);

	    var html = '<div class="modal-dialog"><div class="modal-content">';
	    html += content;
	    html += '</div></div>';

	    popup.html(html);

	    popupService.compileAndRunPopup(popup, scope);
	  };

	  popupService.confirm = function(title, actionText, actionButtonText, actionFunction, actionButtonCss, cancelButtonText, cancelFunction, cancelButtonCss, scope, options) {
	    actionText = (actionText) ? actionText : "Are you sure?";
	    actionButtonText = (actionButtonText) ? actionButtonText : "Ok";
	    actionButtonCss = (actionButtonCss) ? actionButtonCss : "btn btn-info";
	    cancelButtonText = (cancelButtonText) ? cancelButtonText : "Cancel";
	    cancelButtonCss = (cancelButtonCss) ? cancelButtonCss : "";

	    var popup = popupService.getPopup(true);
	    var confirmHTML = '<div class="modal-dialog"><div class="modal-content">';

	    if (title) {
	      confirmHTML += "<div class=\"modal-header\"><h1>"+title+"</h1></div>";
	    }

	    confirmHTML += "<div class=\"modal-body\"><p class=\"question\">"+actionText+"</p>"
	        +    "<div class=\"actions\">";

	    if (actionFunction) {
	      confirmHTML += "<button class=\"" + actionButtonCss + " \" ng-click=\""+actionFunction+"\">"+actionButtonText+"</button>";
	    }
	    else {
	      confirmHTML += "<button class=\"" + actionButtonCss + " \">"+actionButtonText+"</button>";
	    }

	    if (cancelFunction) {
	      confirmHTML += "<button class=\"" + cancelButtonCss + " btn-cancel\" ng-click=\""+cancelFunction+"\">"+cancelButtonText+"</button>";
	    }
	    else {
	      confirmHTML += "<button class=\"" + cancelButtonCss + " btn-cancel\">"+cancelButtonText+"</button>";
	    }

	    confirmHTML += "</div></div></div></div>";

	    popup.html(confirmHTML);

	    popup.find(".btn").click(function () {
	      popupService.close();
	    });

	    popupService.compileAndRunPopup(popup, scope, options);
	  };

	  popupService.close = function()
	  {
	    var popup = popupService.getPopup();
	    if (popup) {
	      popup.modal('hide');
	    }
	  };

	  return popupService;
	}]);


/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * RIPPLE.TXT
	 *
	 * The ripple.txt service looks up and caches ripple.txt files.
	 *
	 * These files are used to do DNS-based verifications autonomously on the
	 * client-side. Quite neat when you think about it and a decent solution until
	 * we have a network-internal nickname system.
	 */

	var module = angular.module('rippletxt', []);

	module.factory('rpRippleTxt', ['$q', '$rootScope', '$http', function ($q, $scope, $http) {
	  var promises = {};

	  function get(domain) {
	    if (promises[domain]) {
	      return promises[domain];
	    }

	    var txtPromise = $q.defer();

	    // TODO at some point we should only allow one of these
	    var urls = [
	      'https://www.' + domain + '/ripple.txt',
	      'https://' + domain + '/ripple.txt',
	      'https://ripple.' + domain + '/ripple.txt'
	    ].reverse();

	    var next = function () {
	      if (!urls.length) {
	        txtPromise.reject(new Error("No ripple.txt found"));
	        return;
	      }

	      var url = urls.pop();

	      $http.get(url)
	        .success(function(data) {
	          txtPromise.resolve(parse(data));
	        })
	        .error(next);
	    };

	    next();

	    return promises[domain] = txtPromise.promise;
	  }

	  function parse(txt) {
	    txt = txt.replace('\r\n', '\n');
	    txt = txt.replace('\r', '\n');
	    txt = txt.split('\n');

	    var currentSection = "", sections = {};
	    for (var i = 0, l = txt.length; i < l; i++) {
	      var line = txt[i];
	      if (!line.length || line[0] === '#') {
	        continue;
	      }
	      else if (line[0] === '[' && line[line.length - 1] === ']') {
	        currentSection = line.slice(1, line.length - 1);
	        sections[currentSection] = [];
	      }
	      else {
	        line = line.replace(/^\s+|\s+$/g, '');
	        if (sections[currentSection]) {
	          sections[currentSection].push(line);
	        }
	      }
	    }

	    return sections;
	  }

	  return {
	    get: get,
	    parse: parse
	  };
	}]);


/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * FEDERATION
	 *
	 * The federation service looks up and caches federation queries.
	 *
	 * These files are used to do DNS-based verifications autonomously on the
	 * client-side. Quite neat when you think about it and a decent solution until
	 * we have a network-internal nickname system.
	 */

	(function () {
	'use strict';

	/* global ripple: false, angular: false, _: false, jQuery: false, store: false, Options: false */

	var module = angular
	  .module('federation', ['rippletxt'])
	  .factory('rpFederation', rpFederation);

	rpFederation.$inject = ['$q', '$rootScope', 'rpRippleTxt'];

	function rpFederation($q, $scope, $txt) {
	  var txts = {};

	  return {
	    check_email: checkEmail
	  };

	  function checkEmail(email) {
	    var federationPromise = $q.defer();

	    var tmp = email.split('@');
	    var domain = tmp.pop();
	    var user = tmp.join('@');

	    var txtPromise = $txt.get(domain);

	    if (txtPromise) {
	      if ('function' === typeof txtPromise.then) {
	        txtPromise.then(processTxt, handleNoTxt);
	      } else {
	        processTxt(txtPromise);
	      }
	    } else {
	      handleNoTxt();
	    }

	    return federationPromise.promise;

	    function handleNoTxt() {
	      federationPromise.reject({
	        result: 'error',
	        error: 'noRippleTxt',
	        error_message: 'Ripple.txt not available for the requested domain.'
	      });
	    }

	    function processTxt(txt) {
	      if (txt.federation_url) {
	        $.ajax({
	          url: txt.federation_url[0],
	          dataType: 'json',
	          data: {
	            type: 'federation',
	            domain: domain,
	            destination: user,
	            // DEPRECATED 'destination' is a more neutral name for this field
	            //   than 'user'
	            user: user
	          },
	          error: function () {
	            $scope.$apply(function() {
	              federationPromise.reject({
	                result: 'error',
	                error: 'down',
	                error_message: 'Federation gateway did not respond.',
	                url: txt.federation_url[0]
	              });
	            });
	          },
	          success: function (data) {
	            $scope.$apply(function() {
	              if ('object' === typeof data &&
	                  'object' === typeof data.federation_json &&
	                  data.federation_json.type === 'federation_record' &&
	                  (data.federation_json.user === user ||
	                   data.federation_json.destination === user) &&
	                  data.federation_json.domain === domain) {
	                federationPromise.resolve(data.federation_json);
	              } else if ('string' === typeof data.error) {
	                federationPromise.reject({
	                  result: 'error',
	                  error: 'remote',
	                  error_remote: data.error,
	                  error_message: data.error_message
	                    ? 'Service error: ' + data.error_message
	                    : 'Unknown remote service error.'
	                });
	              } else {
	                federationPromise.reject({
	                  result: 'error',
	                  error: 'unavailable',
	                  error_message: 'Federation gateway\'s response was invalid.'
	                });
	              }
	            });
	          }
	        });
	      } else {
	        federationPromise.reject({
	          result: 'error',
	          error: 'noFederation',
	          error_message: 'Federation is not available on the requested domain.'
	        });
	      }
	    }
	  }
	}
	})();


/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * DOMAIN ALIAS
	 *
	 * The domain alias service resolves ripple address to domains.
	 *
	 * In the AccountRoot entry of any ripple account users can provide a reference
	 * to a domain they own. Ownership of the domain is verified via the ripple.txt
	 * magic file.
	 *
	 * This service provides both the lookup in the ledger and the subsequent
	 * verification via ripple.txt.
	 */

	var module = angular.module('domainalias', ['network', 'rippletxt']);

	module.factory('rpDomainAlias', ['$q', '$rootScope', 'rpNetwork', 'rpRippleTxt',
	                                 function ($q, $scope, net, txt)
	{
	  var promises = {};

	  /**
	   * Validates a domain against an object parsed from ripple.txt data.
	   *
	   * @private
	   */
	  function validateDomain(domain, address, data)
	  {
	    // Validate domain
	    if (!data.domain ||
	        data.domain.length !== 1 ||
	        data.domain[0] !== domain) {
	      return false;
	    }

	    // Validate address
	    if (!data.accounts) {
	      return false;
	    }
	    for (var i = 0, l = data.accounts.length; i < l; i++) {
	      if (data.accounts[i] === address) {
	        return true;
	      }
	    }

	    return false;
	  }

	  function getAliasForAddress(address)
	  {
	    if (promises[address]) {
	      return promises[address];
	    }

	    var aliasPromise = $q.defer();

	    net.remote.requestAccountInfo({account: address})
	      .on('success', function (data) {
	        if (data.account_data.Domain) {
	          $scope.$apply(function () {
	            var domain = sjcl.codec.utf8String.fromBits(sjcl.codec.hex.toBits(data.account_data.Domain));

	            txt
	              .get(domain)
	              .then(
	                function (data) {
	                  if (validateDomain(domain, address, data)) {
	                    aliasPromise.resolve(domain);
	                  }
	                  else {
	                    aliasPromise.reject(new Error("Invalid domain"));
	                  }
	                },
	                function (error) {
	                  aliasPromise.reject(new Error(error));
	                }
	              );
	          });
	        }
	        else {
	          aliasPromise.reject(new Error("No domain found"));
	        }
	      })
	      .on('error', function () {
	        aliasPromise.reject(new Error("No domain found"));
	      })
	      .request();

	    return promises[address] = aliasPromise.promise;
	  }

	  return {
	    getAliasForAddress: getAliasForAddress
	  };
	}]);


/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

	/* Taken from https://github.com/DWand/nw-fileDialog */

	var module = angular.module('filedialog', []);

	module.factory('rpFileDialog', ['$rootScope', function($scope){
	  var callDialog = function(dialog, callback) {
	    dialog.addEventListener('change', function() {
	      var result = dialog.value;
	      callback(result);
	    }, false);
	    dialog.click();
	  };

	  var dialogs = {};
	  
	  dialogs.saveAs = function(callback, defaultFilename, acceptTypes) {
	    var dialog = document.createElement('input');
	    dialog.type = 'file';
	    dialog.nwsaveas = defaultFilename || '';
	    if (angular.isArray(acceptTypes)) {
	      dialog.accept = acceptTypes.join(',');
	    } else if (angular.isString(acceptTypes)) {
	      dialog.accept = acceptTypes;
	    }
	    callDialog(dialog, callback);
	  };
	  
	  dialogs.openFile = function(callback, multiple, acceptTypes) {
	    var dialog = document.createElement('input');
	    dialog.type = 'file';
	    if (multiple === true) {
	      dialog.multiple = 'multiple';
	    }
	    if (angular.isArray(acceptTypes)) {
	      dialog.accept = acceptTypes.join(',');
	    } else if (angular.isString(acceptTypes)) {
	      dialog.accept = acceptTypes;
	    }
	    callDialog(dialog, callback);
	  };
	  
	  dialogs.openDir = function(callback) {
	    var dialog = document.createElement('input');
	    dialog.type = 'file';
	    dialog.nwdirectory = 'nwdirectory';
	    callDialog(dialog, callback);
	  };
	  
	  return dialogs;
	}]);

/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var Tab = __webpack_require__(63).Tab;

	var RegisterTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(RegisterTab, Tab);

	RegisterTab.prototype.tabName = 'register';
	RegisterTab.prototype.pageMode = 'single';
	RegisterTab.prototype.parent = 'main';

	RegisterTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(64)();
	};

	RegisterTab.prototype.angular = function (module) {

	  module.controller('RegisterCtrl', ['$scope', '$location', '$element',
	                                     '$timeout', 'rpId', 'rpFileDialog',
	                                     function ($scope, $location, $element,
	                                               $timeout, $id, filedialog)
	  {
	    if ($id.loginStatus) {
	      $location.path('/balance');
	      return;
	    }
	    $scope.goTo = function(url){
	      $location.path(url);
	    };

	    $scope.reset = function()
	    {
	      $scope.password = '';
	      $scope.passwordSet = {};
	      $scope.password1 = '';
	      $scope.password2 = '';
	      $scope.master = '';
	      $scope.key = '';
	      $scope.mode = 'register_new_account';
	      //$scope.mode = 'register_empty_wallet1';
	      $scope.showMasterKeyInput = false;
	      $scope.submitLoading = false;

	      if ($scope.registerForm) $scope.registerForm.$setPristine(true);
	    };

	    $scope.fileInputClick = function() {
	      filedialog.saveAs(function(filename) {
	        $scope.$apply(function() {
	          $scope.walletfile = filename;
	          $scope.mode = 'register_empty_wallet';
	        });
	      }, 'wallet.txt');
	    };

	    $scope.submitSecretKeyForm = function(){
	      $scope.masterkey = $scope.secretKey;
	      $scope.fileInputClick();
	    };

	    $scope.register = function()
	    {
	      $id.register({
	        'username': 'local',
	        'password': $scope.password1,
	        'masterkey': $scope.masterkey,
	        'walletfile': $scope.walletfile
	      },
	      function(err, key){
	        if (err) {
	          $scope.mode = "failed";
	          $scope.error_detail = err.message;
	          return;
	        }
	        $scope.password = new Array($scope.password1.length+1).join("*");
	        $scope.keyOpen = key;
	        $scope.key = $scope.keyOpen[0] + new Array($scope.keyOpen.length).join("*");

	        $scope.$apply(function(){
	          $scope.mode = 'welcome';
	        });

	      });
	    };

	    $scope.submitForm = function()
	    {
	      $scope.register();
	    };

	    $scope.goToFund = function()
	    {
	      $scope.mode = 'register_empty_wallet';
	      $scope.reset();

	      $location.path('/xrp');
	    };

	    $scope.reset();

	  }]);
	};

	module.exports = RegisterTab;


/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var Tab = __webpack_require__(63).Tab;

	var LoginTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(LoginTab, Tab);

	LoginTab.prototype.tabName = 'login';
	LoginTab.prototype.pageMode = 'single';
	LoginTab.prototype.parent = 'main';

	LoginTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(65)();
	};

	LoginTab.prototype.angular = function (module) {
	  module.controller('LoginCtrl', ['$scope', '$element', '$routeParams',
	                                  '$location', 'rpId', '$rootScope',
	                                  'rpPopup', '$timeout', 'rpFileDialog',
	                                  function ($scope, $element, $routeParams,
	                                            $location, $id, $rootScope,
	                                            popup, $timeout, filedialog)
	  {
	    if ($id.loginStatus) {
	      $location.path('/balance');
	      return;
	    }

	    $scope.fileInputClick = function(element){
	      filedialog.openFile(function(evt) {
	        $scope.$apply(function() {
	          $scope.walletfile = evt;
	        });
	      }, false);
	    };

	    $scope.error = '';
	    $scope.username = '';
	    $scope.password = '';
	    $scope.loginForm && $scope.loginForm.$setPristine(true);
	    $scope.backendMessages = [];

	    // Autofill fix
	    $timeout(function(){
	      $scope.$apply(function () {
	        $scope.username = $element.find('input[name="login_username"]').val();
	        $scope.password = $element.find('input[name="login_password"]').val();
	      });
	    }, 1000);

	    $rootScope.$on("$blobError", function (e, err) {
	      console.log("BLOB ERROR", arguments);
	      $scope.backendMessages.push({'backend': err.backend, 'message': err.message});
	    });

	    var updateFormFields = function(){
	      var username;
	      var password;

	      // There are multiple login forms due to the Ripple URI login feature.
	      // But only one of them should be visible and that's the one we want.
	      username = $element.find('input[name="login_username"]:visible').eq(0).val();
	      password = $element.find('input[name="login_password"]:visible').eq(0).val();

	      if ("string" === typeof username) {
	        $scope.loginForm.login_username.$setViewValue(username);
	      }
	      if ("string" === typeof password) {
	        $scope.loginForm.login_password.$setViewValue(password);
	      }
	    };

	    // Issues #1024, #1060
	    $scope.$watch('username',function(){
	      $timeout(function(){
	        $scope.$apply(function () {
	         updateFormFields();
	        })
	      }, 50);
	    });

	    // Ok, now try to remove this line and then go write "a" for wallet name, and "a" for passphrase.
	    // "Open wallet" is still disabled hah? no worries, just enter anything else and it will be activated.
	    // Probably this is an AngularJS issue. Had no time to check it yet.
	    $scope.$watch('password');

	    $scope.submitForm = function()
	    {
	      if ($scope.ajax_loading) return;

	      if (!$scope.walletfile) {
	        $scope.ajax_loading = false;
	        $scope.error = 'Please select a wallet file.';
	        return;
	      }

	      $scope.backendMessages = [];

	      // Issue #36: Password managers may change the form values without
	      // triggering the events Angular.js listens for. So we simply force
	      // an update of Angular's model when the form is submitted.
	      updateFormFields();

	      setImmediate(function () {
	        $id.login({
	          username: 'local',
	          password: $scope.password,
	          walletfile: $scope.walletfile
	        }, function (err, blob) {
	          $scope.$apply(function(){
	            $scope.ajax_loading = false;
	            $scope.status = '';

	            if (err) {
	              $scope.error = 'Login failed: Wallet file or password is wrong.';

	              return;
	            };

	            $location.path('/balance');
	          });
	        });
	      });

	      $scope.ajax_loading = true;
	      $scope.error = '';
	      $scope.status = 'Fetching wallet...';
	    };
	  }]);

	  /**
	   * Focus on username input only if it's empty. Otherwise focus on password field
	   * This directive will not be used anywhere else, that's why it's here.
	   */
	  module.directive('rpFocusOnEmpty', ['$timeout', function($timeout) {
	    return function($scope, element) {
	      $timeout(function(){
	        $scope.$watch(function () {return element.is(':visible')}, function(newValue) {
	          if (newValue === true && !element.val())
	            element.focus();
	        })
	      }, 200)
	    }
	  }]);
	};



	module.exports = LoginTab;


/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    Tab = __webpack_require__(63).Tab,
	    Amount = ripple.Amount,
	    rewriter = __webpack_require__(54);

	var BalanceTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(BalanceTab, Tab);

	BalanceTab.prototype.tabName = 'balance';
	BalanceTab.prototype.mainMenu = 'wallet';

	BalanceTab.prototype.angularDeps = Tab.prototype.angularDeps.concat(['qr']);

	BalanceTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(66)();
	};

	BalanceTab.prototype.angular = function (module)
	{
	  

	  module.controller('BalanceCtrl', ['$rootScope', 'rpId',
	                                     function ($scope, $id)
	  {
	    if (!$id.loginStatus) return $id.goId();
	  }]);
	};

	module.exports = BalanceTab;


/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    webUtil = __webpack_require__(51),
	    Tab = __webpack_require__(63).Tab,
	    rewriter = __webpack_require__(54),
	    Amount = ripple.Amount;

	var HistoryTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(HistoryTab, Tab);

	HistoryTab.prototype.tabName = 'history';
	HistoryTab.prototype.mainMenu = 'wallet';

	HistoryTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(68)();
	};

	HistoryTab.prototype.angular = function (module) {
	  module.controller('HistoryCtrl', ['$scope', 'rpId', 'rpNetwork',
	                                     function ($scope, $id, $network)
	  {
	    if (!$id.loginStatus) return $id.goId();

	    var history = [];

	    // Latest transaction
	    var latest;

	    // History collection
	    $scope.historyShow = [];
	    $scope.historyCsv = '';

	    // History states
	    $scope.$watch('loadState.transactions',function(){
	      $scope.historyState = !$scope.loadState.transactions ? 'loading' : 'ready';
	    });

	    // Open/close states of individual history items
	    $scope.details = [];

	    //$scope.typeUsage = [];
	    //$scope.currencyUsage = [];

	    // Currencies from history
	    var historyCurrencies = [];

	    $scope.types = {
	      sent: {
	        'types': ['sent'],
	        'checked': true
	      },
	      received: {
	        'types': ['received'],
	        'checked': true
	      },
	      gateways: {
	        'types': ['trusting','trusted'],
	        'checked': true
	      },
	      trades: {
	        'types': ['offernew','exchange'],
	        'checked': true
	      },
	      orders: {
	        'types': ['offernew','offercancel','exchange'],
	        'checked': true
	      },
	      other: {
	        'types': ['accountset','failed','rippling'],
	        'checked': true
	      }
	    };

	    $scope.advanced_feature_switch = Options.advanced_feature_switch;

	    $scope.orderedTypes = ['sent','received','gateways','trades','orders','other'];

	    if (store.get('ripple_history_type_selections')) {
	      $scope.types = $.extend(true,$scope.types,store.get('ripple_history_type_selections'));
	    }

	    // Filters
	    if (store.get('ripple_history_filters')) {
	      $scope.filters = store.get('ripple_history_filters');
	    } else {
	      $scope.filters = {
	        'currencies_is_active': false, // we do the currency filter only if this is true, which happens when at least one currency is off
	        'currencies': {},
	        'types': ['sent','received','exchange','trusting','trusted','offernew','offercancel','rippling'],
	        'minimumAmount': 0.000001
	      };
	    }

	    var getDateRangeHistory = function(dateMin,dateMax,callback)
	    {
	      var completed = false;
	      var history = [];

	      var params = {
	        account: $id.account,
	        ledger_index_min: -1,
	        limit: 200
	      };

	      var getTx = function(){
	        $network.remote.requestAccountTransactions(params)
	        .on('success', function(data) {
	          if (data.transactions.length) {
	            for(var i=0;i<data.transactions.length;i++) {
	              var date = ripple.utils.toTimestamp(data.transactions[i].tx.date);

	              if(date < dateMin.getTime()) {
	                completed = true;
	                break;
	              }

	              if(date > dateMax.getTime())
	                continue;

	              // Push
	              var tx = rewriter.processTxn(data.transactions[i].tx, data.transactions[i].meta, $id.account);
	              if (tx) history.push(tx);
	            }

	            if (data.marker) {
	              params.marker = data.marker;
	              $scope.tx_marker = params.marker;
	            }
	            else {
	              // Received all transactions since a marker was not returned
	              completed = true;
	            }

	            if (completed)
	              callback(history);
	            else
	              getTx();
	          } else {
	            callback(history);
	          }
	        }).request();
	      };

	      getTx(0);
	    };

	    // DateRange filter form
	    $scope.submitDateRangeForm = function() {
	      $scope.dateMaxView.setDate($scope.dateMaxView.getDate() + 1); // Including last date
	      changeDateRange($scope.dateMinView,$scope.dateMaxView);
	    };

	    $scope.submitMinimumAmountForm = function() {
	      updateHistory();
	    };

	    var changeDateRange = function(dateMin,dateMax) {
	      history = [];
	      $scope.historyState = 'loading';

	      getDateRangeHistory(dateMin,dateMax,function(hist){
	        $scope.$apply(function () {
	          history = hist;
	          $scope.historyState = 'ready';
	          updateHistory();
	        })
	      })
	    };

	    // All the currencies
	    $scope.$watch('balances', function(){
	      updateCurrencies();
	    });

	    // Types filter has been changed
	    $scope.$watch('types', function(){
	      var arr = [];
	      var checked = {};
	      _.each($scope.types, function(type,index){
	        if (type.checked) {
	          arr = arr.concat(type.types);
	        }

	        checked[index] = {
	          checked: !!type.checked
	        };
	      });
	      $scope.filters.types = arr;

	      if (!store.disabled) {
	        store.set('ripple_history_type_selections', checked);
	      }
	    }, true);

	    if (!store.disabled) {
	      $scope.$watch('filters', function(){
	        store.set('ripple_history_filters', $scope.filters);
	      }, true);
	    }

	    $scope.$watch('filters.types', function(){
	      updateHistory();
	    }, true);

	    // Currency filter has been changed
	    $scope.$watch('filters.currencies', function(){
	      updateCurrencies();
	      updateHistory();
	    }, true);

	    // New transactions
	    $scope.$watchCollection('history',function(){
	      history = $scope.history;

	      updateHistory();

	      // Update currencies
	      if (history.length)
	        updateCurrencies();
	    },true);

	    // Updates the history collection
	    var updateHistory = function (){

	      //$scope.typeUsage = [];
	      //$scope.currencyUsage = [];
	      $scope.historyShow = [];

	      if (history.length) {
	        var dateMin, dateMax;

	        $scope.minLedger = 0;

	        var currencies = _.map($scope.filters.currencies,function(obj,key){return obj.checked ? key : false});
	        history.forEach(function(event)
	        {

	          // Calculate dateMin/dateMax. Used in date filter view
	          if (!$scope.dateMinView) {
	            if (!dateMin || dateMin > event.date)
	              dateMin = event.date;

	            if (!dateMax || dateMax < event.date)
	              dateMax = event.date;
	          }

	          var affectedCurrencies = _.map(event.affected_currencies, function (currencyCode) {
	            return ripple.Currency.from_json(currencyCode).to_human();
	          });

	          // Update currencies
	          historyCurrencies = _.union(historyCurrencies, affectedCurrencies); // TODO put in one large array, then union outside of foreach

	          // Calculate min ledger. Used in "load more"
	          if (!$scope.minLedger || $scope.minLedger > event.ledger_index)
	            $scope.minLedger = event.ledger_index;

	          // Type filter
	          if (event.transaction && event.transaction.type === 'error') ; // Always show errors
	          else if (event.transaction && !_.contains($scope.filters.types,event.transaction.type))
	            return;

	          // Some events don't have transactions.. this is a temporary fix for filtering offers
	          else if (!event.transaction && !_.contains($scope.filters.types,'offernew'))
	            return;

	          // Currency filter
	          //if ($scope.filters.currencies_is_active && _.intersection(currencies,event.affected_currencies).length <= 0)
	          //  return;

	          var effects = [];
	          var isFundedTrade = false; // Partially/fully funded
	          var isCancellation = false;

	          if (event.effects) {
	            // Show effects
	            $.each(event.effects, function(){
	              var effect = this;
	              switch (effect.type) {
	                case 'offer_funded':
	                case 'offer_partially_funded':
	                case 'offer_bought':
	                  isFundedTrade = true;
	                  /* falls through */
	                case 'offer_cancelled':
	                  if (effect.type === 'offer_cancelled') {
	                    isCancellation = true;
	                    if (event.transaction && event.transaction.type === 'offercancel')
	                      return;
	                  }
	                  effects.push(effect);
	                  break;
	              }
	            });

	            event.showEffects = effects;

	            // Trade filter - remove open orders that haven't been filled/partially filled
	            if (_.contains($scope.filters.types,'exchange') && !_.contains($scope.filters.types,'offercancel')) {
	              if ((event.transaction && event.transaction.type === 'offernew' && !isFundedTrade) || isCancellation)
	                return
	            }

	            effects = [ ];

	            var amount, maxAmount;
	            var minimumAmount = $scope.filters.minimumAmount;

	            // Balance changer effects
	            $.each(event.effects, function(){
	              var effect = this;
	              switch (effect.type) {
	                case 'fee':
	                case 'balance_change':
	                case 'trust_change_balance':
	                  effects.push(effect);

	                  // Minimum amount filter
	                  if (effect.type === 'balance_change' || effect.type === 'trust_change_balance') {
	                    amount = effect.amount.abs().is_native()
	                      ? effect.amount.abs().to_number() / 1000000
	                      : effect.amount.abs().to_number();

	                    if (!maxAmount || amount > maxAmount)
	                      maxAmount = amount;
	                    }
	                  break;
	              }
	            });

	            // Minimum amount filter
	            if (maxAmount && minimumAmount > maxAmount)
	              return;

	            event.balanceEffects = effects;
	          }

	          // Don't show sequence update events
	          if (event.effects && 1 === event.effects.length && event.effects[0].type == 'fee')
	            return;

	          // Push events to history collection
	          $scope.historyShow.push(event);

	          // Type and currency usages
	          // TODO offers/trusts
	          //if (event.transaction)
	          //  $scope.typeUsage[event.transaction.type] = $scope.typeUsage[event.transaction.type] ? $scope.typeUsage[event.transaction.type]+1 : 1;

	          //event.affected_currencies.forEach(function(currency){
	          //  $scope.currencyUsage[currency] = $scope.currencyUsage[currency]? $scope.currencyUsage[currency]+1 : 1;
	          //});
	        });

	        if ($scope.historyShow.length && !$scope.dateMinView) {
	          setValidDateOnScopeOrNullify('dateMinView', dateMin);
	          setValidDateOnScopeOrNullify('dateMaxView', dateMax);
	        }
	      }
	    };

	    // Update the currency list
	    var updateCurrencies = function (){
	      if (!$.isEmptyObject($scope.balances)) {
	        var currencies = _.union(
	          ['XRP'],
	          _.map($scope.balances,function(obj,key){return obj.total.currency().to_human();}),
	          historyCurrencies
	        );

	        var objCurrencies = {};

	        var firstProcess = $.isEmptyObject($scope.filters.currencies);

	        $scope.filters.currencies_is_active = false;

	        _.each(currencies, function(currency){
	          var checked = ($scope.filters.currencies[currency] && $scope.filters.currencies[currency].checked) || firstProcess;
	          objCurrencies[currency] = {'checked':checked};

	          if (!checked)
	            $scope.filters.currencies_is_active = true;
	        });

	        $scope.filters.currencies = objCurrencies;
	      }
	    };

	    var setValidDateOnScopeOrNullify = function(key, value) {
	      if (isNaN(value) || value == null) {
	        $scope[key] = null;
	      } else {
	        $scope[key] = new Date(value);
	      }
	    };

	    $scope.loadMore = function () {
	      var dateMin = $scope.dateMinView;
	      var dateMax = $scope.dateMaxView;

	      $scope.historyState = 'loading';

	      var limit = 100; // TODO why 100?

	      var params = {
	        account: $id.account,
	        ledger_index_min: -1,
	        limit: limit,
	        marker: $scope.tx_marker
	      };

	      $network.remote.requestAccountTransactions(params)
	      .on('success', function(data) {
	        $scope.$apply(function () {
	          if (data.transactions.length < limit) {

	          }

	          $scope.tx_marker = data.marker;

	          if (data.transactions) {
	            var transactions = [];

	            data.transactions.forEach(function (e) {
	              var tx = rewriter.processTxn(e.tx, e.meta, $id.account);
	              if (tx) {
	                var date = ripple.utils.toTimestamp(tx.date);

	                if (dateMin && dateMax) {
	                  if (date < dateMin.getTime() || date > dateMax.getTime())
	                    return;
	                } else if (dateMax && date > dateMax.getTime()) {
	                  return;
	                } else if (dateMin && date < dateMin.getTime()) {
	                  return;
	                }
	                transactions.push(tx);
	              }
	            });

	            var newHistory = _.uniq(history.concat(transactions),false,function(ev){return ev.hash});

	            $scope.historyState = (history.length === newHistory.length) ? 'full' : 'ready';
	            history = newHistory;
	            updateHistory();
	          }
	        });
	      }).request();
	    }

	    var exists = function(pty) {
	      return typeof pty !== 'undefined';
	    };

	    // Change first letter of string to uppercase or lowercase
	    var capFirst = function(str, caps) {
	      var first = str.charAt(0);
	      return (caps ? first.toUpperCase() : first.toLowerCase()) + str.slice(1);
	    };

	    var issuerToString = function(issuer) {
	      var iss = issuer.to_json();
	      return typeof iss === 'number' && isNaN(iss) ? '' : iss;
	    };

	    // Convert Amount value to human-readable format
	    var formatAmount = function(amount) {
	      var formatted = '';

	      if (amount instanceof Amount) {
	        formatted = amount.to_human({group_sep: false, precision: 2});

	        // If amount is very small and only has zeros (ex. 0.0000), raise precision
	        if (formatted.length > 1 && 0 === +formatted) {
	          formatted = amount.to_human({group_sep: false, precision: 20, max_sig_digits: 5});
	        }
	      }

	      return formatted;
	    };

	    $scope.exportCsv = function() {

	      // Header (1st line) of CSV with name of each field
	      // Ensure that the field values for each row added in addLineToCsvToCsv() correspond in this order
	      var csv = 'Date,Time,Ledger Number,Transaction Type,Trust address,' +
	        'Address sent from,Amount sent/sold,Currency sent/sold,Issuer of sent/sold ccy,' +
	        'Address sent to,Amount received,Currency received,Issuer of received ccy,' +
	        'Executed Price,Network Fee paid,Transaction Hash\r\n';

	      var addLineToCsv = function(line) {
	        // Ensure that the fields match the CSV header initialized in var csv
	        csv += [ line['Date'], line['Time'], line['LedgerNum'], line['TransType'], line['TrustAddr'], 
	          line['FromAddr'], line['SentAmount'], line['SentCcy'], line['SentIssuer'], 
	          line['ToAddr'], line['RecvAmount'], line['RecvCcy'], line['RecvIssuer'], 
	          line['ExecPrice'], line['Fee'], line['TransHash']
	          ].join(',') + '\r\n';
	      }

	      // Convert the fields of interest in buy & sell Amounts to strings in Key/Value pairs
	      var getOrderDetails = function(keyVal, buy, sell) {
	        if (buy !== null && buy instanceof Amount) {
	          keyVal['SentAmount'] = formatAmount(buy);
	          keyVal['SentCcy'] = buy.currency().get_iso();
	          keyVal['SentIssuer'] = issuerToString(buy.issuer());
	        }

	        if (sell !== null && sell instanceof Amount) {
	          keyVal['RecvAmount'] = formatAmount(sell);
	          keyVal['RecvCcy'] = sell.currency().get_iso();
	          keyVal['RecvIssuer'] = issuerToString(sell.issuer());
	        }
	      }

	      // Construct a CSV string by:
	      // 1) Iterating over each line item in the *displayed* Transaction History
	      // 2) If the type of Transaction is in scope, convert the relevant fields to strings in Key/Value pairs
	      // 3) Concatenate the strings extracted in (2) in a comma-delimited line and append this line to the CSV
	      for (var i = 0; i < $scope.historyShow.length; i++) {
	        var  histLine = $scope.historyShow[i],
	          transaction = histLine.transaction,
	          type = histLine.tx_type,
	          dateTime = moment(histLine.date),
	          na = 'NA',
	          line = {},
	          lineTemplate = {},
	          lineTrust = {},
	          linePayment = {},
	          lineOffer = {},
	          sent;

	        // Unsuccessful transactions are excluded from the export
	        var transType = exists(transaction) ? transaction.type : null;
	        if (transType === 'failed' || histLine.tx_result !== 'tesSUCCESS') continue;

	        // Fields common to all Transaction types
	        lineTemplate['Date'] = dateTime.format('YYYY-MM-DD');
	        lineTemplate['Time'] = dateTime.format('HH:mm:ss');
	        lineTemplate['LedgerNum'] = histLine.ledger_index;
	        lineTemplate['Fee'] = formatAmount(Amount.from_json(histLine.fee));
	        lineTemplate['TransHash'] = histLine.hash;

	        // Default type-specific fields to NA, they will be overridden later if applicable
	        lineTemplate['TrustAddr'] = lineTemplate['FromAddr'] = lineTemplate['ToAddr'] = na;
	        lineTemplate['RecvAmount'] = lineTemplate['RecvCcy'] = lineTemplate['ExecPrice'] = na;

	        // Include if Payment, Trust, Offer. Otherwise Exclude.
	        if (type === 'TrustSet') {
	          // Trust Line (Incoming / Outgoing)
	          var trust = '';

	          if (transType === 'trusted') trust = 'Incoming ';
	          else if (transType === 'trusting') trust = 'Outgoing ';
	          else continue;  // unrecognised trust type

	          lineTrust['TransType'] = trust + 'trust line';
	          lineTrust['TrustAddr'] = transaction.counterparty;

	          lineTrust['SentAmount'] = formatAmount(transaction.amount);
	          lineTrust['SentCcy'] = transaction.currency; //transaction.amount.currency().get_iso();

	          lineTrust['SentIssuer'] = lineTrust['RecvIssuer'] = na;

	          line = $.extend({}, lineTemplate, lineTrust);
	          addLineToCsv(line);
	        }
	        else if (type === 'Payment' && transType !== null) {
	          // Payment (Sent / Received)
	          if (transType === 'sent') sent = true;
	          else if (transType === 'received') sent = false;
	          else continue;  // unrecognised payment type

	          linePayment['TransType'] = capFirst(transType, true) + ' ' + capFirst(type, false);

	          if (sent) {
	            // If sent, counterparty is Address To
	            linePayment['ToAddr'] = transaction.counterparty;
	            linePayment['FromAddr'] = $id.account;
	          }
	          else {
	            // If received, counterparty is Address From
	            linePayment['FromAddr'] = transaction.counterparty;
	            linePayment['ToAddr'] = $id.account;
	          }

	          if (exists(transaction.amountSent)) {
	            amtSent = transaction.amountSent;
	            linePayment['SentAmount'] = exists(amtSent.value) ? amtSent.value : formatAmount(Amount.from_json(amtSent));
	            linePayment['SentCcy'] = exists(amtSent.currency) ? amtSent.currency : 'XRP';
	            if (exists(transaction.sendMax)) linePayment['SentIssuer'] = transaction.sendMax.issuer;
	          }

	          linePayment['RecvAmount'] = formatAmount(transaction.amount);
	          linePayment['RecvCcy'] = transaction.currency;
	          linePayment['RecvIssuer'] = issuerToString(transaction.amount.issuer());

	          line = $.extend({}, lineTemplate, linePayment);
	          addLineToCsv(line);
	        }
	        else if (type === 'Payment' || type === 'OfferCreate' || type === 'OfferCancel') {
	          // Offers (Created / Cancelled / Executed)
	          var effect;

	          if (transType === 'offernew') {
	            getOrderDetails(lineOffer, transaction.gets, transaction.pays);
	            lineOffer['TransType'] = 'Offer Created';

	            line = $.extend({}, lineTemplate, lineOffer);
	            addLineToCsv(line);
	          }
	          else if (transType === 'offercancel') {
	            for (var e = 0; e < histLine.effects.length; e++) {
	              effect = histLine.effects[e];

	              if (effect.type === 'offer_cancelled') {
	                getOrderDetails(lineOffer, effect.gets, effect.pays);
	                lineOffer['TransType'] = 'Offer Cancelled';

	                line = $.extend({}, lineTemplate, lineOffer);
	                addLineToCsv(line);

	                break;
	              }
	            }
	          }

	          for (var s = 0; s < histLine.showEffects.length; s++) {
	            effect = histLine.showEffects[s],
	              buy = null,
	              sell = null;
	            lineOffer = {};

	            switch (effect.type) {
	            case 'offer_bought':
	            case 'offer_funded':
	            case 'offer_partially_funded':
	              // Order fills (partial or full)

	              if (effect.type === 'offer_bought') {
	                buy = exists(effect.paid) ? effect.paid : effect.pays;
	                sell = exists(effect.got) ? effect.got : effect.gets;
	              }
	              else {
	                buy = exists(effect.got) ? effect.got : effect.gets;
	                sell = exists(effect.paid) ? effect.paid : effect.pays;
	              }

	              getOrderDetails(lineOffer, buy, sell);
	              lineOffer['TransType'] = 'Executed offer';
	              lineOffer['ExecPrice'] = formatAmount(effect.price);

	              line = $.extend({}, lineTemplate, lineOffer);
	              if (s > 0) line['Fee'] = '';  // Fee only applies once
	              addLineToCsv(line);

	            break;  // end case
	            }
	          }
	        }
	        // else unrecognised Transaction type hence ignored
	      }

	      // Ensure that historyCsv is set to empty string if there is nothing to download,
	      // otherwise the file download will be a single line with header and no data
	      $scope.historyCsv = $scope.historyShow.length ? csv : '';
	    };

	  }]);
	};

	module.exports = HistoryTab;


/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	var util      = __webpack_require__(47);
	var webutil   = __webpack_require__(51);
	var Tab       = __webpack_require__(63).Tab;

	var ContactsTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(ContactsTab, Tab);

	ContactsTab.prototype.tabName = 'contacts';
	ContactsTab.prototype.mainMenu = 'wallet';

	// /contact is the way it appears in Ripple URIs
	ContactsTab.prototype.aliases = ['contact'];

	ContactsTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(67)();
	};

	ContactsTab.prototype.angular = function (module) {
	  module.controller('ContactsCtrl', ['$scope', 'rpId',
	    function ($scope, $id)
	  {
	    if (!$id.loginStatus) return $id.goId();

	    $scope.reset_form = function() {
	      $scope.contact = {
	        name: '',
	        view: '',
	        address: '',
	        federation: null
	      };
	      if ($scope.addForm) $scope.addForm.$setPristine();
	    };

	    $scope.reset_form();

	    /**
	     * Toggle "add contact" form
	     */
	    $scope.toggle_form = function() {
	      $scope.addform_visible = !$scope.addform_visible;
	      $scope.reset_form();
	    };

	    /**
	     * Create contact
	     */
	    $scope.create = function() {
	      var contact = {
	        name: $scope.contact.name,
	        view: $scope.contact.view,
	        address: $scope.contact.address
	      };

	      if ($scope.contact.dt && !$scope.contact.federation) {
	        contact.dt = $scope.contact.dt;
	      }

	      // Enable the animation
	      $scope.enable_highlight = true;

	      // Add an element
	      $scope.userBlob.unshift("/contacts", contact);

	      // Hide the form
	      $scope.toggle_form();

	      // Clear form
	      $scope.reset_form();
	    };
	  }]);

	  module.controller('ContactRowCtrl', ['$scope', '$location',
	    function ($scope, $location) {
	      $scope.editing = false;

	      /**
	       * Switch to edit mode
	       *
	       * @param index
	       */
	      $scope.edit = function(index) {
	        $scope.editing = true;
	        $scope.editname = $scope.entry.name;
	        $scope.editaddress = $scope.entry.address;
	        $scope.editview = $scope.entry.view || $scope.entry.address;
	        $scope.editdt = $scope.entry.dt;
	      };

	      /**
	       * Update contact
	       *
	       * @param index
	       */
	      $scope.update = function(index) {
	        if (!$scope.inlineAddress.editaddress.$error.rpUnique
	            && !$scope.inlineAddress.editaddress.$error.rpDest
	            && !$scope.inlineName.editname.$error.rpUnique) {

	          var entry = {
	            name: $scope.editname,
	            view: $scope.editview,
	            address: $scope.editaddress
	          };

	          if ($scope.editdt  && !$scope.contact.federation) {
	            entry.dt = $scope.editdt;
	          }

	          // Update blob
	          $scope.userBlob.filter('/contacts', 'name', $scope.entry.name,
	                                 'extend', '', entry);
	          // delete destination tag
	          if (!$scope.editdt && $scope.entry.dt) {
	            $scope.userBlob.filter('/contacts', 'name', $scope.entry.name,
	                                   'unset', '/dt');
	          }

	          $scope.editing = false;
	        }
	      };

	      /**
	       * Remove contact
	       *
	       * @param index
	       */
	      $scope.remove = function(index) {
	        // Update blob
	        if (!$scope.entry.name) {
	          // there was bug that allowed to create contact without name
	          $scope.userBlob.unset('/contacts/' + index);
	        } else {
	          $scope.userBlob.filter('/contacts', 'name', $scope.entry.name,
	                                 'unset', '');
	        }
	      };

	      /**
	       * Cancel contact edit
	       *
	       * @param index
	       */
	      $scope.cancel = function(index) {
	        $scope.editing = false;
	      };

	      $scope.send = function(index) {
	        var search = {to: $scope.entry.name};

	        $location.path('/send');
	        $location.search(search);
	      };
	    }]);
	};

	module.exports = ContactsTab;


/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    Tab = __webpack_require__(63).Tab,
	    Amount = ripple.Amount,
	    Base = ripple.Base,
	    Currency = ripple.Currency;

	var ExchangeTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(ExchangeTab, Tab);

	ExchangeTab.prototype.tabName = 'exchange';
	ExchangeTab.prototype.mainMenu = 'exchange';

	ExchangeTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(69)();
	};

	ExchangeTab.prototype.angular = function (module)
	{
	  module.controller('ExchangeCtrl', ['$scope', '$timeout', '$routeParams',
	    'rpId', 'rpNetwork', 'rpKeychain', '$rootScope',
	    function ($scope, $timeout, $routeParams, $id, $network, keychain, $rootScope)
	    {
	      if (!$id.loginStatus) return $id.goId();

	      var timer, pf;

	      // Remember user preference on Convert vs. Trade
	      $rootScope.ripple_exchange_selection_trade = false;

	      var xrpCurrency = Currency.from_json("XRP");

	      $scope.xrp = {
	        name: xrpCurrency.to_human({full_name:$scope.currencies_all_keyed["XRP"].name}),
	        code: xrpCurrency.get_iso(),
	        currency: xrpCurrency
	      };

	      $scope.$watch('exchange.amount', function () {
	        $scope.update_exchange();
	      }, true);

	      $scope.$watch('exchange.currency_name', function () {
	        var exchange = $scope.exchange;
	        var currency = Currency.from_human($scope.exchange.currency_name ? $scope.exchange.currency_name : "XRP");
	        exchange.currency_obj = currency;
	        exchange.currency_code = currency.get_iso();
	        exchange.currency_name = currency.to_human({
	          full_name: $scope.currencies_all_keyed[currency.get_iso()] ? $scope.currencies_all_keyed[currency.get_iso()].name : null
	        });
	        $scope.update_exchange();
	      }, true);


	      $scope.reset_paths = function () {
	        var exchange = $scope.exchange;

	        exchange.alternatives = [];
	      };

	      var pathUpdateTimeout;
	      $scope.update_exchange = function () {
	        var exchange = $scope.exchange;
	        var currency = ripple.Currency.from_human(exchange.currency_name);

	        $scope.reset_paths();

	        // if formatted or money to exchange is 0 then don't calculate paths or offer to exchange
	        if (parseFloat(exchange.amount) === 0 || !exchange.currency_name)
	        {
	          $scope.error_type = 'required';
	          return false;
	        }

	        else {
	          $scope.error_type = '';
	        }

	        var matchedCurrency = currency.has_interest() ? currency.to_hex() : currency.get_iso();
	        var match = /^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})\b/.exec(matchedCurrency);

	        if (!match) {
	          // Currency code not recognized, should have been caught by
	          // form validator.
	          return;
	        }

	        // Demurrage: Get a reference date five minutes in the future
	        //
	        // Normally, when using demurrage currencies, we would immediately round
	        // down (e.g. 0.99999 instead of 1) as demurrage occurs continuously. Not
	        // a good user experience.
	        //
	        // By choosing a date in the future, this gives us a time window before
	        // this rounding down occurs. Note that for positive interest currencies
	        // this actually *causes* the same odd rounding problem, so in the future
	        // we'll want a better solution, but for right now this does what we need.
	        var refDate = new Date(new Date().getTime() + 5 * 60000);

	        exchange.amount_feedback = Amount.from_human('' + exchange.amount + ' ' + matchedCurrency, { reference_date: refDate });
	        exchange.amount_feedback.set_issuer($id.account);

	        if (exchange.amount_feedback.is_valid() && exchange.amount_feedback.is_positive()) {
	          exchange.path_status = 'pending';
	          exchange.alt = null;

	          if (pathUpdateTimeout) clearTimeout(pathUpdateTimeout);
	          pathUpdateTimeout = $timeout($scope.update_paths, 500);
	        } else {
	          exchange.path_status = 'waiting';
	        }
	      };

	      $scope.update_paths = function () {
	        $scope.$apply(function () {
	          $scope.exchange.path_status = 'pending';
	          var amount = $scope.exchange.amount_feedback;

	          if (amount.is_zero()) return;

	          // Start path find
	          pf = $network.remote.pathFind($id.account,
	              $id.account,
	              amount);
	              // $scope.generate_src_currencies());
	              // XXX: Roll back pathfinding changes temporarily
	          var isIssuer = $scope.generate_issuer_currencies();

	          var lastUpdate;

	          pf.on('update', function (upd) {
	            $scope.$apply(function () {
	              lastUpdate = new Date();

	              clearInterval(timer);
	              timer = setInterval(function(){
	                $scope.$apply(function(){
	                  var seconds = Math.round((new Date() - lastUpdate)/1000);
	                  $scope.lastUpdate = seconds ? seconds : 0;
	                })
	              }, 1000);

	              if (!upd.alternatives || !upd.alternatives.length) {
	                $scope.exchange.path_status  = "no-path";
	                $scope.exchange.alternatives = [];
	              } else {
	                var currencies = {};
	                $scope.exchange.path_status  = "done";
	                $scope.exchange.alternatives = _.filter(_.map(upd.alternatives, function (raw) {
	                  var alt = {};
	                  alt.amount   = Amount.from_json(raw.source_amount);
	                  alt.rate     = alt.amount.ratio_human(amount);
	                  alt.send_max = alt.amount.product_human(Amount.from_json('1.01'));
	                  alt.paths    = raw.paths_computed
	                      ? raw.paths_computed
	                      : raw.paths_canonical;

	                  if (alt.amount.issuer().to_json() != $scope.address && !isIssuer[alt.amount.currency().to_hex()]) {
	                    currencies[alt.amount.currency().to_hex()] = true
	                  }

	                  return alt;
	                }), function(alt) {
	                  // XXX: Roll back pathfinding changes temporarily
	                  /* if (currencies[alt.amount.currency().to_hex()]) {
	                    return alt.amount.issuer().to_json() != $scope.address;
	                  } */
	                  return true;
	                });
	              }
	            });
	          });
	        });
	      };

	      var updateCurrencyOptions = function(){
	        // create a list of currency codes from the trust line objects
	        var currencies = _.uniq(_.map($scope.lines, function (line) {
	          return line.currency;
	        }));

	        // add XRP
	        currencies.unshift('XRP');

	        // create a currency object for each of the currency codes
	        for (var i=0; i < currencies.length; i++) {
	          currencies[i] = ripple.Currency.from_json(currencies[i]);
	        }

	        // create the display version of the currencies
	        currencies = _.map(currencies, function (currency) {
	          if ($scope.currencies_all_keyed[currency.get_iso()]) {
	            return currency.to_human({full_name:$scope.currencies_all_keyed[currency.get_iso()].name});
	          }

	          return currency.get_iso();
	        });

	        $scope.currency_choices = currencies;
	      };

	      $scope.$on('$balancesUpdate', updateCurrencyOptions);

	      $scope.reset = function () {
	        $scope.mode = "form";

	        // XXX Most of these variables should be properties of $scope.exchange.
	        //     The Angular devs recommend that models be objects due to the way
	        //     scope inheritance works.
	        $scope.exchange = {
	          amount: '',
	          currency_name: $scope.xrp.name,
	          currency_code: $scope.xrp.code,
	          currency_obj: $scope.xrp.currency,
	          path_status: 'waiting',
	          fund_status: 'none'
	        };
	        $scope.nickname = '';
	        $scope.error_type = '';
	        if ($scope.exchangeForm) $scope.exchangeForm.$setPristine(true);
	      };

	      $scope.cancelConfirm = function () {
	        $scope.mode = "form";
	        $scope.exchange.alt = null;
	      };

	      $scope.reset_goto = function (tabName) {
	        $scope.reset();

	        // TODO do something clever instead of document.location
	        // because goToTab does $scope.$digest() which we don't need
	        document.location = '#' + tabName;
	      };

	      /**
	       * N3. Confirmation page
	       */
	      $scope.exchange_prepared = function () {
	        $scope.confirm_wait = true;
	        $timeout(function () {
	          $scope.confirm_wait = false;
	        }, 1000, true);

	        $scope.mode = "confirm";
	      };

	      /**
	       * N4. Waiting for transaction result page
	       */
	      $scope.exchange_confirmed = function () {

	        // parse the currency name and extract the iso
	        var currency = Currency.from_human($scope.exchange.currency_name);
	        currency = currency.has_interest() ? currency.to_hex() : currency.get_iso();
	        var amount = Amount.from_human(""+$scope.exchange.amount+" "+currency);

	        amount.set_issuer($id.account);

	        var tx = $network.remote.transaction();

	        // Add memo to tx
	        tx.addMemo('client', 'rt' + $rootScope.version);

	        // Destination tag
	        tx.destination_tag(webutil.getDestTagFromAddress($id.account));
	        tx.payment($id.account, $id.account, amount.to_json());
	        tx.send_max($scope.exchange.alt.send_max);
	        tx.paths($scope.exchange.alt.paths);

	        if ($scope.exchange.secret) {
	          tx.secret($scope.exchange.secret);
	        } else {
	          // Get secret asynchronously
	          keychain.requestSecret($id.account, $id.username,
	            function (err, secret) {
	              if (err) {
	                console.log("client: exchange tab: error while " +
	                  "unlocking wallet: ", err);
	                $scope.mode = "error";
	                $scope.error_type = "unlockFailed";

	                return;
	              }

	              $scope.exchange.secret = secret;
	              $scope.exchange_confirmed();
	            });
	          return;
	        }

	        tx.on('proposed', function (res) {
	          $scope.$apply(function () {
	            setEngineStatus(res, false);
	            $scope.exchanged(tx.hash);

	            // Remember currency and increase order
	            var found;

	            for (var i = 0; i < $scope.currencies_all.length; i++) {
	              if ($scope.currencies_all[i].value.toLowerCase() === $scope.exchange.amount_feedback.currency().get_iso().toLowerCase()) {
	                $scope.currencies_all[i].order++;
	                found = true;
	                break;
	              }
	            }

	            // // Removed feature until a permanent fix
	            // if (!found) {
	            //   $scope.currencies_all.push({
	            //     "name": $scope.exchange.amount_feedback.currency().to_human().toUpperCase(),
	            //     "value": $scope.exchange.amount_feedback.currency().to_human().toUpperCase(),
	            //     "order": 1
	            //   });
	            // }
	          });
	        });
	        tx.on('success',function(res){
	          setEngineStatus(res, true);
	        });
	        tx.on('error', function (res) {
	          setImmediate(function () {
	            $scope.$apply(function () {
	              $scope.mode = "error";

	              if (res.result === "tejMaxFeeExceeded") {
	                $scope.error_type = "maxFeeExceeded";
	              }

	              if (res.error === 'remoteError' &&
	                  res.remote.error === 'noPath') {
	                $scope.mode = "status";
	                $scope.tx_result = "noPath";
	              }
	            });
	          });
	        });
	        tx.submit();

	        $scope.mode = "sending";
	      };

	      /**
	       * N6. exchanged page
	       */
	      $scope.exchanged = function (hash) {
	        $scope.mode = "status";
	        $network.remote.on('transaction', handleAccountEvent);

	        function handleAccountEvent(e) {
	          $scope.$apply(function () {
	            if (e.transaction.hash === hash) {
	              setEngineStatus(e, true);
	              $network.remote.removeListener('transaction', handleAccountEvent);
	            }
	          });
	        }
	      };

	      function setEngineStatus(res, accepted) {
	        $scope.engine_result = res.engine_result;
	        $scope.engine_result_message = res.engine_result_message;
	        switch (res.engine_result.slice(0, 3)) {
	          case 'tes':
	            $scope.tx_result = accepted ? "cleared" : "pending";
	            break;
	          case 'tem':
	            $scope.tx_result = "malformed";
	            break;
	          case 'ter':
	            $scope.tx_result = "failed";
	            break;
	          case 'tep':
	            $scope.tx_result = "partial";
	            break;
	          case 'tec':
	            $scope.tx_result = "claim";
	            break;
	          case 'tef':
	            $scope.tx_result = "failure";
	            break;
	          case 'tel':
	            $scope.tx_result = "local";
	            break;
	          default:
	            console.warn("Unhandled engine status encountered!");
	        }
	      }

	      $scope.reset();

	      updateCurrencyOptions();

	      // Stop the pathfinding when leaving the page
	      $scope.$on('$destroy', function(){
	        if (pf && "function" === typeof pf.close) {
	          pf.close();
	        }
	      });
	    }]);

	  /**
	   * Contact name and address uniqueness validator
	   */
	    // TODO move to global directives
	  module.directive('unique', function() {
	    return {
	      restrict: 'A',
	      require: '?ngModel',
	      link: function ($scope, elm, attr, ctrl) {
	        if (!ctrl) return;

	        var validator = function(value) {
	          var unique = !webutil.getContact($scope.userBlob.data.contacts,value);
	          ctrl.$setValidity('unique', unique);
	          if (unique) return value;
	        };

	        ctrl.$formatters.push(validator);
	        ctrl.$parsers.unshift(validator);

	        attr.$observe('unique', function() {
	          validator(ctrl.$viewValue);
	        });
	      }
	    };
	  });
	};

	module.exports = ExchangeTab;


/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var webutil = __webpack_require__(51);
	var Tab = __webpack_require__(63).Tab;
	var Amount = ripple.Amount;
	var Currency = ripple.Currency;

	var TrustTab = function ()
	{
	  Tab.call(this);

	};

	util.inherits(TrustTab, Tab);

	TrustTab.prototype.tabName = 'trust';
	TrustTab.prototype.mainMenu = 'fund';

	TrustTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(70)();
	};

	TrustTab.prototype.angular = function (module)
	{
	  module.controller('TrustCtrl', ['$scope', 'rpBooks', '$timeout', '$routeParams', 'rpId',
	                                  '$filter', 'rpNetwork', 'rpKeychain',
	                                  function ($scope, books, $timeout, $routeParams, id,
	                                            $filter, $network, keychain)
	  {
	    if (!id.loginStatus) return id.goId();

	    var RemoteFalagDefaultRipple = 0x00800000;

	    $scope.advanced_feature_switch = Options.advanced_feature_switch;
	    $scope.trust = {};

	    // Trust line sorting
	    $scope.sorting = {
	      predicate: 'balance',
	      reverse: true,
	      sort: function(line){
	        return $scope.sorting.predicate === 'currency' ? line.currency : line.balance.to_number();
	      }
	    };

	    $scope.validation_pattern = /^0*(([1-9][0-9]*.?[0-9]*)|(.0*[1-9][0-9]*))$/; //Don't allow zero for new trust lines.

	    $scope.reset = function () {
	      $scope.mode = 'main';
	      var usdCurrency = Currency.from_human('USD');
	      $scope.currency = usdCurrency.to_human({full_name:$scope.currencies_all_keyed[usdCurrency.get_iso()].name});
	      $scope.addform_visible = false;
	      $scope.edituser = '';
	      $scope.amount = '';
	      $scope.allowrippling = false;
	      $scope.counterparty = '';
	      $scope.counterparty_view = '';
	      $scope.counterparty_address = '';
	      $scope.saveAddressName = '';
	      $scope.error_account_reserve = false;
	    };

	    $scope.toggle_form = function () {

	      if($scope.addform_visible) {
	        $scope.reset();
	      } else {
	        $scope.addform_visible = true;
	      }
	    };


	    // User should not even be able to try granting a trust if the reserve is insufficient
	    $scope.$watch('account', function() {
	      $scope.acctDefaultRippleFlag = ($scope.account.Flags & RemoteFalagDefaultRipple);

	      $scope.can_add_trust = false;
	      if ($scope.account.Balance && $scope.account.reserve_to_add_trust) {
	        if (!$scope.account.reserve_to_add_trust.subtract($scope.account.Balance).is_positive()
	          || $.isEmptyObject($scope.lines))
	        {
	          $scope.can_add_trust = true;
	        }
	      }
	    }, true);

	    $scope.$watch('counterparty', function() {
	      $scope.error_account_reserve = false;
	      $scope.contact = webutil.getContact($scope.userBlob.data.contacts,$scope.counterparty);
	      if ($scope.contact) {
	        $scope.counterparty_name = $scope.contact.name;
	        $scope.counterparty_address = $scope.contact.address;
	      } else {
	        $scope.counterparty_name = '';
	        $scope.counterparty_address = $scope.counterparty;
	      }
	    }, true);

	    /**

	     * N2. Confirmation page
	     */
	    $scope.grant = function ()
	    {
	      // set variable to show throbber
	      $scope.verifying = true;
	      $scope.error_account_reserve = false;
	      // test if account is valid
	      $network.remote.requestAccountInfo({ account: $scope.counterparty_address })
	        // if account is valid then just to confirm page
	        .on('success', function (m) {
	          $scope.$apply(function(){
	            // hide throbber
	            $scope.verifying = false;

	            $scope.lineCurrencyObj = Currency.from_human($scope.currency);
	            var matchedCurrency = $scope.lineCurrencyObj.has_interest() ? $scope.lineCurrencyObj.to_hex() : $scope.lineCurrencyObj.get_iso();
	            var match = /^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})\b/.exec(matchedCurrency);

	            if (!match) {
	              // Currency code not recognized, should have been caught by
	              // form validator.
	              console.error('Currency code:', match, 'is not recognized');
	              return;
	            }

	            if ($scope.advanced_feature_switch === false || $scope.amount === '') {
	              // $scope.amount = Number(ripple.Amount.consts.max_value);
	              $scope.amount = Options.gateway_max_limit;
	            }

	            var amount = ripple.Amount.from_human('' + $scope.amount + ' ' + $scope.lineCurrencyObj.to_hex(), {reference_date: new Date(+new Date() + 5*60000)});

	            amount.set_issuer($scope.counterparty_address);
	            if (!amount.is_valid()) {
	              // Invalid amount. Indicates a bug in one of the validators.
	              return;
	            }

	            $scope.amount_feedback = amount;

	            $scope.confirm_wait = true;
	            $timeout(function () {
	              $scope.confirm_wait = false;
	            }, 1000, true);

	            $scope.mode = 'confirm';

	            /**
	             * Warning messages
	             *
	             * - firstIssuer
	             * - sameIssuer
	             * - multipleIssuers
	             */
	            currency = amount.currency().to_human({full_name:$scope.currencies_all_keyed[amount.currency().get_iso()].name});
	            var balance = $scope.balances[currency];
	            $scope.currencyWarning = false;

	            // New trust on a currency or no rippling enabled
	            // if (!balance || !$scope.allowrippling) {
	            //   $scope.currencyWarning = 'firstIssuer';
	            // }
	            // else {
	              // Trust limit change
	              // for (var counterparty in balance.components) {
	              //   if (counterparty === $scope.counterparty_address)
	              //     $scope.currencyWarning = 'sameIssuer';
	              // }

	              // Multiple trusts on a same currency
	              // if (!$scope.currencyWarning)
	              //   $scope.currencyWarning = 'multipleIssuers';
	            // }
	          });
	        })
	        .on('error', function (m) {
	          setImmediate(function () {
	            $scope.$apply(function(){
	              $scope.verifying = false;
	              $scope.error_account_reserve = true;
	            });
	          });
	        })
	        .request();
	    };

	    /**
	     * N3. Waiting for grant result page
	     */
	    $scope.grant_confirmed = function () {
	      var amount = $scope.amount_feedback.to_json();
	      var tx = $network.remote.transaction();

	      // Add memo to tx
	      tx.addMemo('client', 'rt' + $scope.version);


	      // Flags
	      tx
	        .rippleLineSet(id.account, amount)
	        .setFlags($scope.allowrippling ? 'ClearNoRipple' : 'NoRipple')
	        .on('proposed', function(res){
	          $scope.$apply(function () {
	            setEngineStatus(res, false);
	            $scope.granted(tx.hash);

	            // Remember currency and increase order
	            var found;

	            for (var i = 0; i < $scope.currencies_all.length; i++) {
	              if ($scope.currencies_all[i].value.toLowerCase() === $scope.amount_feedback.currency().get_iso().toLowerCase()) {
	                $scope.currencies_all[i].order++;
	                found = true;
	                break;
	              }
	            }

	            // // Removed feature until a permanent fix
	            // if (!found) {
	            //   $scope.currencies_all.push({
	            //     'name': currency,
	            //     'value': currency,
	            //     'order': 1
	            //   });
	            // }
	          });
	        })
	        .on('success', function(res) {
	          $scope.$apply(function() {
	            setEngineStatus(res, true);
	          });
	        })
	        .on('error', function(res) {
	          setImmediate(function () {
	            $scope.$apply(function() {
	              $scope.mode = 'error';
	              $scope.trust.loading = false;
	              var notification = res.result === 'tejMaxFeeExceeded' ? 'max_fee' : 'error';
	              $scope.load_notification(notification);
	            });
	          });
	        })
	      ;

	      keychain.requestSecret(id.account, id.username, function(err, secret) {
	        // XXX Error handling
	        if (err) return;

	        $scope.mode = 'granting';

	        tx.secret(secret);
	        tx.submit();
	        if(tx.tx_json.LimitAmount.issuer == 'rrh7rf1gV2pXAoqA8oYbpHd8TKv5ZQeo67') {
	          store.set('gbi_connected', true);
	        }
	      });
	      
	      $scope.toggle_form();
	    };

	    /**
	     * N5. Granted page
	     */
	    $scope.granted = function (hash) {
	      $scope.mode = 'granted';
	      $network.remote.on('transaction', handleAccountEvent);

	      function handleAccountEvent(e) {
	        $scope.$apply(function () {
	          if (e.transaction.hash === hash) {
	            setEngineStatus(e, true);
	            $network.remote.removeListener('transaction', handleAccountEvent);
	          }
	        });
	      }

	      $timeout(function(){
	        $scope.mode = 'main';
	      }, 10000);
	    };

	    function setEngineStatus(res, accepted) {
	      $scope.engine_result = res.engine_result;
	      $scope.engine_result_message = res.engine_result_message;

	      switch (res.engine_result.slice(0, 3)) {
	        case 'tes':
	          $scope.tx_result = accepted ? 'cleared' : 'pending';
	          break;
	        case 'tem':
	          $scope.tx_result = 'malformed';
	          break;
	        case 'ter':
	          $scope.tx_result = 'failed';
	          break;
	        case 'tec':
	          $scope.tx_result = 'failed';
	          break;
	        case 'tel':
	          $scope.tx_result = "local";
	          break;
	        case 'tep':
	          console.warn('Unhandled engine status encountered!');
	      }
	    }

	    $scope.edit_line = function ()
	    {
	      var line = this.component;
	      var filterAddress = $filter('rpcontactnamefull');
	      var contact = filterAddress(line.issuer);
	      $scope.line = this.component;
	      $scope.edituser = (contact) ? contact : 'User';
	      $scope.validation_pattern = contact ? /^[0-9.]+$/ : /^0*(([1-9][0-9]*.?[0-9]*)|(.0*[1-9][0-9]*))$/;

	      var lineCurrency = Currency.from_json(line.currency);
	      var formatOpts;
	      if ($scope.currencies_all_keyed[lineCurrency.get_iso()]) {
	        formatOpts = {
	          full_name:$scope.currencies_all_keyed[lineCurrency.get_iso()].name
	        }
	      }

	      $scope.lineCurrencyObj = lineCurrency;
	      $scope.currency = lineCurrency.to_human(formatOpts);
	      $scope.balance = line.balance.to_human();
	      $scope.balanceAmount = line.balance;
	      $scope.counterparty = line.issuer;
	      $scope.counterparty_view = contact;

	      $scope.amount = line.max.currency().has_interest()
	        ? +Math.round(line.max.applyInterest(new Date()).to_text())
	        : +line.max.to_text()

	      $scope.allowrippling = line.rippling;

	      // Close/open form. Triggers focus on input.
	      $scope.addform_visible = false;

	      $scope.load_orderbook();
	    };

	    $scope.$watch('userBlob.data.contacts', function (contacts) {
	      $scope.counterparty_query = webutil.queryFromContacts(contacts);
	    }, true);

	    $scope.currency_query = webutil.queryFromOptionsIncludingKeys($scope.currencies_all);

	    $scope.reset();

	    var updateAccountLines = function() {
	      var obj = {};

	      _.each($scope.lines, function(line){
	        if (!obj[line.currency]) {
	          obj[line.currency] = { components: [] };
	        }

	        obj[line.currency].components.push(line);
	        if(line.account == 'rrh7rf1gV2pXAoqA8oYbpHd8TKv5ZQeo67'){
	          store.set('gbi_connected', true);
	        }
	      })

	      $scope.accountLines = obj;
	      return;
	    }

	    $scope.$on('$balancesUpdate', function(){
	      updateAccountLines();
	    })

	    updateAccountLines();
	  }]);

	  module.controller('AccountRowCtrl', ['$scope', 'rpBooks', 'rpNetwork', 'rpId', 'rpKeychain', '$timeout',
	    function ($scope, books, $network, id, keychain, $timeout) {

	      $scope.validation_pattern = /^0*(([0-9]*.?[0-9]*)|(.0*[1-9][0-9]*))$/;

	      $scope.cancel = function () {
	        $scope.editing = false;
	      }


	      $scope.edit_account = function() {
	        $scope.editing = true;

	        $scope.trust = {};
	        // edit as string because Chrome shows tiny numbers in e-notation
	        $scope.trust.limit = String($scope.component.limit.to_json().value);
	        $scope.trust.rippling = !$scope.component.no_ripple;
	        $scope.trust.limit_peer = Number($scope.component.limit_peer.to_json().value);
	        $scope.trust.balance = String($scope.component.balance.to_json().value);
	        $scope.trust.balanceAmount = $scope.component.balance;

	        var currency = Currency.from_human($scope.component.currency);

	        currency.to_human({full_name:$scope.currencies_all_keyed[currency.get_iso()]})
	          ? $scope.trust.currency = currency.to_human({full_name:$scope.currencies_all_keyed[currency]})
	          : $scope.trust.currency = currency.to_human({full_name:$scope.currencies_all_keyed[currency.get_iso()].name});

	        // $scope.trust.currency = currency.to_human({full_name:$scope.currencies_all_keyed[currency.get_iso()].name});
	        $scope.trust.counterparty = $scope.component.account;

	        $scope.load_orderbook();
	      };

	      $scope.delete_account = function()
	      {
	        $scope.trust.loading = true;
	        $scope.load_notification('remove_gateway');

	        var setSecretAndSubmit = function(tx) {
	          keychain.requestSecret(id.account, id.username, function (err, secret) {
	            if (err) {
	              $scope.mode = 'error';
	              console.log('Error on requestSecret: ', err);
	              $scope.trust.loading = false;
	              $scope.load_notification('error');
	              return;
	            }

	            tx.secret(secret);

	            tx.submit(function(err, res) {
	              if (err) {
	                $scope.mode = 'error';
	                $scope.trust.loading = false;
	                var notification = err.result === 'tejMaxFeeExceeded' ? 'max_fee' : 'error';
	                $scope.load_notification(notification);

	                return;
	              }

	              console.log('Transaction has been submitted with response:', res);
	              $scope.trust.loading = false;
	              $scope.load_notification('gateway_removed');
	            });

	          });
	        }

	        var nullifyTrustLine = function(idAccount, lineCurrency, lineAccount) {
	          var tx = $network.remote.transaction();

	          // Add memo to tx
	          tx.addMemo('client', 'rt' + $scope.version);

	          tx.trustSet(idAccount, '0' + '/' + lineCurrency + '/' + lineAccount);
	          $scope.acctDefaultRippleFlag ? tx.setFlags('ClearNoRipple') : tx.setFlags('NoRipple');

	          setSecretAndSubmit(tx);
	        };

	        var clearBalance = function(selfAddress, issuerAddress, curr, amountObject, callback) {

	          // Decision tree: two paths
	          // 1) There is a market -> send back balance to user as XRP
	          // 2) There is no market -> send back balance to issuer

	          var sendBalanceToSelf = function() {
	            var tx = $network.remote.transaction();

	            // Add memo to tx
	            tx.addMemo('client', 'rt' + $scope.version);

	            var payment = tx.payment(selfAddress, selfAddress, '100000000000');

	            payment.setFlags('PartialPayment');
	            payment.sendMax(amountObject.to_human() + '/' + curr + '/' + issuerAddress);

	            return tx;
	          };

	          var sendBalanceToIssuer = function() {
	            var tx = $network.remote.transaction();

	            // Add memo to tx
	            tx.addMemo('client', 'rt' + $scope.version);

	            var amount = amountObject.clone();
	            var newAmount = amount.set_issuer(issuerAddress);
	            var payment = tx.payment(selfAddress, issuerAddress, newAmount);

	            return tx;
	          };

	          var tx = ($scope.orderbookStatus === 'exists') ? sendBalanceToSelf() : sendBalanceToIssuer();

	          setSecretAndSubmit(tx);

	          tx.once('proposed', callback);
	        };

	        // $scope.counterparty inside the clearBalance callback function does not have counterparty in its scope, therefore, we need an immediate function to capture it.

	        if ($scope.trust.balance !== '0') {
	          (function (counterparty) {
	            clearBalance(id.account, $scope.trust.counterparty, $scope.trust.currency, $scope.trust.balanceAmount, function(res) {
	              nullifyTrustLine(id.account, $scope.trust.currency, counterparty);
	            });
	          })($scope.trust.counterparty);
	          if($scope.trust.counterparty == 'rrh7rf1gV2pXAoqA8oYbpHd8TKv5ZQeo67') {
	            store.set('gbi_connected', false);
	          }
	        }

	        else {
	          nullifyTrustLine(id.account, $scope.trust.currency, $scope.trust.counterparty);
	          if($scope.trust.counterparty == 'rrh7rf1gV2pXAoqA8oYbpHd8TKv5ZQeo67') {
	            store.set('gbi_connected', false);
	          }
	        }

	      };

	      $scope.load_orderbook = function() {
	        $scope.orderbookStatus = false;

	        if ($scope.book) {
	          $scope.book.unsubscribe();
	        }

	        $scope.book = books.get({
	          currency: $scope.trust.currency,
	          issuer: $scope.trust.counterparty
	        }, {

	          currency: 'XRP',
	          issuer: undefined
	        });

	        $scope.$watchCollection('book', function () {
	          if (!$scope.book.updated) return;

	          if ($scope.book.asks.length !== 0 && $scope.book.bids.length !== 0) {
	            $scope.orderbookStatus = 'exists';
	          } else {
	            $scope.orderbookStatus = 'not';
	          }
	        });

	      };

	      $scope.save_account = function () {

	        $scope.trust.loading = true;

	        $scope.load_notification('loading');

	        var amount = ripple.Amount.from_human(
	          $scope.trust.limit + ' ' + $scope.component.currency,
	          {reference_date: new Date(+new Date() + 5*60000)}
	        );

	        amount.set_issuer($scope.component.account);

	        if (!amount.is_valid()) {
	          // Invalid amount. Indicates a bug in one of the validators.
	          console.log('Invalid amount');
	          return;
	        }

	        var tx = $network.remote.transaction();

	        // Add memo to tx
	        tx.addMemo('client', 'rt' + $scope.version);

	        // Flags
	        tx
	          .rippleLineSet(id.account, amount)
	          .setFlags($scope.trust.rippling ? 'ClearNoRipple' : 'NoRipple')
	          .on('success', function(res) {
	            $scope.$apply(function () {
	              setEngineStatus(res, true);

	              $scope.trust.loading = false
	              $scope.load_notification('success');
	              $scope.editing = false;
	            });
	          })
	          .on('error', function(res) {
	            setImmediate(function() {
	              $scope.$apply(function() {
	                $scope.mode = 'error';

	                var notification = res.result === 'tejMaxFeeExceeded' ? 'max_fee' : 'error';
	                $scope.load_notification(notification);

	                $scope.trust.loading = false;
	                $scope.editing = false;
	              });
	            });
	          });

	        function setEngineStatus(res, accepted) {
	          $scope.engine_result = res.engine_result;
	          $scope.engine_result_message = res.engine_result_message;

	          switch (res.engine_result.slice(0, 3)) {
	            case 'tes':
	              $scope.tx_result = accepted ? 'cleared' : 'pending';
	              break;
	            case 'tem':
	              $scope.tx_result = 'malformed';
	              break;
	            case 'ter':
	              $scope.tx_result = 'failed';
	              break;
	            case 'tec':
	              $scope.tx_result = 'failed';
	              break;
	            case 'tel':
	              $scope.tx_result = 'local';
	              break;
	            case 'tep':
	              console.warn('Unhandled engine status encountered!');
	          }
	        }

	        keychain.requestSecret(id.account, id.username, function (err, secret) {
	          // XXX Error handling
	          if (err) {
	            $scope.trust.loading = false;
	            $scope.load_notification('error');

	            return;
	          }

	          $scope.mode = 'granting';

	          tx.secret(secret);
	          tx.submit();
	        });
	      };

	    }]);

	};



	module.exports = TrustTab;


/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    Tab = __webpack_require__(63).Tab,
	    Amount = ripple.Amount,
	    Currency = ripple.Currency,
	    Base = ripple.Base,
	    RippleError = ripple.RippleError;

	var SendTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(SendTab, Tab);

	SendTab.prototype.tabName = 'send';
	SendTab.prototype.mainMenu = 'send';

	SendTab.prototype.angularDeps = Tab.prototype.angularDeps.concat(['federation', 'keychain']);

	SendTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(71)();
	};

	SendTab.prototype.angular = function(module)
	{
	  module.controller('SendCtrl', ['$scope', '$timeout', '$routeParams', 'rpId',
	                                 'rpNetwork', 'rpKeychain', 'rpFederation',
	                                 function ($scope, $timeout, $routeParams, $id,
	                                           $network, keychain, federation)
	  {
	    if (!$id.loginStatus) return $id.goId();

	    var timer, destUpdateTimeout;

	    // XRP currency object.
	    // {name: "XRP - Ripples", order: 146, value: "XRP"}
	    var xrpCurrency = Currency.from_json('XRP');

	    $scope.xrp = {
	      name: xrpCurrency.to_human({full_name:$scope.currencies_all_keyed.XRP.name}),
	      code: xrpCurrency.get_iso(),
	      currency: xrpCurrency
	    };

	    $scope.$watch('send.recipient', function(rec){
	      if (!rec) return;
	      // raw address without any parameters
	      var address = webutil.stripRippleAddress($scope.send.recipient);

	      $scope.contact = webutil.getContact($scope.userBlob.data.contacts, address);

	      // Sets
	      // send.recipient, send.recipient_name, send.recipient_address, send.dt.
	      if ($scope.contact) {
	        if ($scope.send.recipient === $scope.contact.address) {
	          $scope.send.recipient = $scope.contact.name;
	        }
	        $scope.send.recipient_name = $scope.contact.name;
	        $scope.send.recipient_address = $scope.contact.address;

	        if ($scope.contact.dt) {
	          $scope.send.dt = $scope.contact.dt;
	        }
	      }
	      else {
	        $scope.send.recipient_name = '';
	        $scope.send.recipient_address = address;
	      }

	      $scope.update_destination();
	    }, true);

	    $scope.$watch('send.currency', function () {
	      var currency = ripple.Currency.from_json($scope.send.currency);
	      if ($scope.send.currency !== '' && currency.is_valid()) {
	        $scope.send.currency_code = currency.to_human().toUpperCase();
	      } else {
	        $scope.send.currency_code = '';
	      }
	      $scope.update_currency();
	    }, true);

	    $scope.$watch('send.amount', function () {
	      $scope.update_amount();
	    }, true);

	    $scope.$watch('send.extra_fields', function () {
	      $scope.update_amount();
	    }, true);

	    // When the send form is invalid, path finding won't trigger. So if the form
	    // is changed by one of the update_* handlers and becomes valid during the
	    // next digest, we need to manually trigger another update_amount.
	    $scope.$watch('sendForm.$valid', function(v) {
	      if (v) {
	        $scope.update_amount();
	      } else {
	        clearInterval(timer);
	        $scope.send.last_recipient = null;
	        $scope.send.path_status = 'waiting';
	        $scope.send.fund_status = 'none';

	        if ($scope.send.pathfind) {
	          $scope.send.pathfind.close();
	          delete $scope.send.pathfind;
	        }
	        if (pathUpdateTimeout) {
	          $timeout.cancel(pathUpdateTimeout);
	          pathUpdateTimeout = null;
	        }
	        $scope.reset_paths();
	      }
	    });


	    // Reset everything that depends on the destination
	    $scope.reset_destination_deps = function() {
	      var send = $scope.send;
	      send.self = false;
	      send.quote_url = false;
	      send.federation = false;
	      send.fund_status = 'none';
	      send.extra_fields = [];

	      // Reset federation address validity status
	      if ($scope.sendForm && $scope.sendForm.send_destination) {
	        $scope.sendForm.send_destination.$setValidity('federation', true);
	        $scope.sendForm.send_destination.$setValidity('federationDown', true);
	        $scope.sendForm.send_destination.$setValidity('btcBridgeWrong', true);
	      }

	      // Now starting to work on resolving the recipient
	      send.recipient_resolved = false;
	      send.recipient_actual = void(0);
	      send.amount_actual = void(0);

	      $scope.reset_currency_deps();
	    };

	    $scope.check_dt_visibility = function() {
	      var send = $scope.send;

	      send.show_dt_field =
	          ($routeParams.dt
	          || send.dt
	          || (send.recipient_info &&
	          'object' === typeof send.recipient_info &&
	          send.recipient_info.dest_tag_required))
	          && (!send.federation || (send.federation_record && !send.federation_record.dt));
	    };

	    $scope.update_destination = function() {
	      var send = $scope.send;
	      var recipient = send.recipient_address;

	      if (recipient === send.last_recipient) return;

	      send.toBitcoin = false;
	      // Trying to send to a Bitcoin address
	      if (!isNaN(Base.decode_check([0, 5], recipient, 'bitcoin'))) {
	        if (Options.bridge.out.bitcoin) { // And there is a default bridge
	          recipient += '@' + Options.bridge.out.bitcoin;
	          send.recipient_address = recipient;
	          send.toBitcoin = true;
	        }
	      }

	      send.last_recipient = recipient;

	      $scope.reset_destination_deps();

	      // Trying to send XRP to self.
	      // This is used to disable 'Send XRP' button
	      send.self = recipient === $scope.address;


	      // Trying to send to a Ripple name
	      send.rippleName = webutil.isRippleName(recipient);

	      // Trying to send to an email/federation address
	      send.federation = ('string' === typeof recipient) && ~recipient.indexOf('@');

	      // Check destination tag visibility
	      $scope.check_dt_visibility();

	      if (destUpdateTimeout) $timeout.cancel(destUpdateTimeout);
	      destUpdateTimeout = $timeout($scope.update_destination_remote, 500);
	    };

	    $scope.update_destination_remote = function() {
	      var send = $scope.send;
	      var recipient = send.recipient_address;
	      var strippedRecipient = webutil.stripRippleAddress(send.recipient);
	      var isRecipientValidAddress = ripple.UInt160.is_valid(strippedRecipient);

	      // Reset federation address validity status
	      if ($scope.sendForm && $scope.sendForm.send_destination) {
	        $scope.sendForm.send_destination.$setValidity('federation', true);
	        $scope.sendForm.send_destination.$setValidity('federationDown', true);
	        $scope.sendForm.send_destination.$setValidity('btcBridgeWrong', true);
	      }

	      // If there was a previous federation request, we need to clean it up here.
	      if (send.federation_record) {
	        send.federation_record = null;
	        send.dt = null;
	      }

	      if (send.federation) {
	        send.path_status = 'fed-check';
	        federation.check_email(recipient)
	          .then(function(result) {
	            // Check if this request is still current, exit if not
	            var now_recipient = send.recipient_address;
	            if (recipient !== now_recipient) return;

	            send.federation_record = result;

	            if (result.extra_fields) {
	              send.extra_fields = result.extra_fields;
	            }

	            send.dt = ('number' === typeof result.dt) ? result.dt : undefined;

	            if (result.destination_address) {
	              // Federation record specifies destination
	              send.recipient_name = recipient;
	              send.recipient_address = result.destination_address;

	              $scope.check_destination();
	            } else if (result.quote_url) {
	              send.recipient_info = {};
	              // Federation destination requires us to request a quote
	              send.quote_url = result.quote_url;
	              send.quote_destination = result.destination;
	              send.path_status = 'waiting';
	              $scope.update_currency_constraints();
	            } else {
	              // Invalid federation result
	              send.path_status = 'waiting';
	              $scope.sendForm.send_destination.$setValidity('federation', false);
	              // XXX Show specific error message
	            }
	          }, function(error) {
	            // Check if this request is still current, exit if not
	            var now_recipient = send.recipient_actual || send.recipient_address;
	            if (recipient !== now_recipient) return;

	            send.path_status = 'waiting';
	            if (send.toBitcoin && Options.bridge.out.bitcoin != 'btc2ripple.com') {
	              $scope.sendForm.send_destination.$setValidity('btcBridgeWrong', false);
	            } else if (error && error.error === 'down') {
	              $scope.sendForm.send_destination.$setValidity('federationDown', false);
	              // super simple URL parsing to get only path
	              var url = error.url.split('/').slice(0, 3).join('/');
	              $scope.send.federationURL = url;
	            } else {
	              $scope.sendForm.send_destination.$setValidity('federation', false);
	            }
	          })
	        ;
	      } else if (send.rippleName) {
	        ripple.AuthInfo.get(Options.domain, send.recipient, function(err, response) {
	          $scope.$apply(function() {
	            send.recipient_name = '~' + response.username;
	            send.recipient_address = response.address;
	          });

	          $scope.check_destination();
	        });
	      } else if (isRecipientValidAddress && send.recipient_address == strippedRecipient) {
	        $id.resolveName(strippedRecipient, { tilde: true }).then(function(name) {
	          send.recipient_name = name;
	          if (send.recipient === name) {
	            // there is no name for this address
	            $scope.check_destination();
	          } else {
	            // this will trigger update
	            send.last_recipient = null;
	            send.recipient = name;
	          }
	        }, function(err) {
	          $scope.check_destination();
	        });
	      } else {
	        $scope.check_destination();
	      }
	    };

	    // Check destination for XRP sufficiency and flags
	    $scope.check_destination = function () {
	      var send = $scope.send;
	      var recipient = send.recipient_actual || send.recipient_address;

	      if (!ripple.UInt160.is_valid(recipient)) return;

	      if (!$scope.account || !$scope.account.reserve_base) return;

	      if (!send.federation && $scope.contact && $scope.contact.noDestinationCheck) {
	        send.recipient_info = {
	          loaded: true,
	          exists: true,
	          Balance: $scope.account.reserve_base,
	          // Flags
	          disallow_xrp: 0,
	          dest_tag_required: 0
	        };
	        send.recipient_resolved = true;
	        $scope.check_dt_visibility();
	        send.recipient_lines = false;
	        $scope.update_currency_constraints();
	        return;
	      }

	      var account = $network.remote.account(recipient);

	      send.path_status = 'checking';
	      send.recipient_info = null;
	      account.entry(function (e, data) {
	        $scope.$apply(function () {
	          // Check if this request is still current, exit if not
	          var now_recipient = send.recipient_actual || send.recipient_address;
	          if (recipient !== now_recipient) return;

	          // If we get this far, we have a Ripple address resolved
	          send.recipient_resolved = true;

	          if (e) {
	            if (e.remote.error === 'actNotFound') {
	              send.recipient_info = {
	                loaded: true,
	                exists: false,
	                Balance: '0'
	              };
	              $scope.update_currency_constraints();
	            } else {
	              // XXX Actual error
	            }
	          } else {
	            send.recipient_info = {
	              loaded: true,
	              exists: true,
	              Balance: data.account_data.Balance,

	              // Flags
	              disallow_xrp: data.account_data.Flags & ripple.Remote.flags.account_root.DisallowXRP,
	              dest_tag_required: data.account_data.Flags & ripple.Remote.flags.account_root.RequireDestTag
	            };

	            // Check destination tag visibility
	            $scope.check_dt_visibility();

	            if (!$scope.account || !$scope.account.reserve_base) return;

	            var reserve_base = $scope.account.reserve_base;
	            send.xrp_deficiency = reserve_base.subtract(data.account_data.Balance);

	            if (!send.federation && $scope.contact &&
	                !send.recipient_info.disallow_xrp &&
	                !send.recipient_info.dest_tag_required &&
	                send.xrp_deficiency.compareTo(0) <= 0) {
	              // save to contact flag to not check destination next time
	              $scope.userBlob.filter('/contacts', 'name', $scope.contact.name,
	                                     'set', '/noDestinationCheck', true);
	            }

	            send.recipient_lines = false;
	            $scope.update_currency_constraints();
	          }
	        });
	      });
	    };

	    /**
	     * Update any constraints on what currencies the user can select.
	     *
	     * In many modes, the user is restricted in terms of what they can send.
	     * For example, when sending to a Bitcoin address, they can only send BTC.
	     *
	     * This function checks those conditions and updates the UI.
	     */
	    $scope.update_currency_constraints = function () {
	      var send = $scope.send;

	      // Reset constraints
	      send.currency_choices = $scope.currencies_all;
	      send.currency_force = false;
	      send.currencyIsBTC = false;

	      send.currency_choices_constraints = {};

	      // Federation response can specific a fixed amount
	      if (send.federation_record &&
	          'undefined' !== typeof send.federation_record.amount) {
	        send.force_amount = Amount.from_json(send.federation_record.amount);
	        send.amount = send.force_amount.to_text();
	        send.currency_choices_constraints.federation = [send.force_amount.currency().to_json()];

	      // Apply federation currency restrictions
	      } else if (send.federation_record &&
	          $.isArray(send.federation_record.currencies) &&
	          send.federation_record.currencies.length >= 1 &&
	          'object' === typeof send.federation_record.currencies[0] &&
	          'string' === typeof send.federation_record.currencies[0].currency) {
	        // XXX Do some validation on this
	        send.currency_choices_constraints.federation = [];
	        $.each(send.federation_record.currencies, function () {
	          send.currency_choices_constraints.federation.push(this.currency);
	        });
	      }

	      // If this a bridge where we need a quote, we need to enter an
	      // amount first, before we can even find out who the recipient is. So
	      // if there is a quote_url, we want to bypass the recipient-based
	      // constraints.
	      if (send.quote_url) {
	        $scope.update_currency_choices();
	        return;
	      }

	      // If we don't have information about the recipient Ripple account yet,
	      // we'll just return. We'll get back here once we have that information.
	      if (!send.recipient_info.loaded) return;

	      if (send.recipient_info.exists) {
	        // Check allowed currencies for this address
	        var requestedRecipientAddress = send.recipient_address;
	        send.currency_choices_constraints.accountLines = 'pending';
	        $network.remote.requestAccountCurrencies({account: requestedRecipientAddress})
	          .on('success', function (data) {
	            $scope.$apply(function () {
	              if (data.receive_currencies &&
	                  // We need to make sure the destination account hasn't changed
	                  send.recipient_address === requestedRecipientAddress) {
	                send.currency_choices_constraints.accountLines = data.receive_currencies;

	                // add XRP if it's allowed
	                if (!$scope.send.recipient_info.disallow_xrp) {
	                  send.currency_choices_constraints.accountLines.unshift('XRP');
	                }

	                $scope.update_currency_choices();
	              }
	            });
	          })
	          .on('error', function () {})
	          .request();
	      } else {
	        // If the account doesn't exist, we can only send XRP
	        send.currency_choices_constraints.accountLines = ['XRP'];
	      }

	      $scope.update_currency_choices();
	    };

	    // Generate list of accepted currencies
	    $scope.update_currency_choices = function() {
	      var send = $scope.send;

	      var currencies = [];

	      // Make sure none of the currency_choices_constraints are pending
	      if (_.values(send.currency_choices_constraints).indexOf('pending') !== -1) {
	        send.path_status = 'account-currencies';
	        send.currency_choices = [];
	        return;
	      } else {
	        // The possible currencies are the intersection of all provided currency
	        // constraints.
	        currencies = _.intersection.apply(_, _.values(send.currency_choices_constraints));
	        currencies = _.uniq(_.compact(currencies));

	        // create the display version of the currencies
	        currencies = _.map(currencies, function (currency) {
	         // create a currency object for each of the currency codes
	          var currencyObj = ripple.Currency.from_json(currency);
	          if ($scope.currencies_all_keyed[currencyObj.get_iso()]) {
	            return currencyObj.to_human({full_name:$scope.currencies_all_keyed[currencyObj.get_iso()].name});
	          } else {
	            return currencyObj.to_human();
	          }
	        });
	      }

	      if (currencies.length === 1) {
	        send.currency = send.currency_force = currencies[0];
	        send.currencyIsBTC = (send.currency_force.indexOf('BTC') === 0);
	      } else if (currencies.length === 0) {
	        send.path_status = 'error-no-currency';
	        send.currency = '';
	      } else {
	        send.currency_force = false;
	        send.currencyIsBTC = false;

	        if (currencies.indexOf(send.currency) === -1) {
	          send.currency = currencies[0];
	        }
	      }

	      $scope.send.currency_choices = currencies;
	      $scope.update_currency();
	    };

	    // Reset anything that depends on the currency
	    $scope.reset_currency_deps = function() {
	      // XXX Reset

	      $scope.reset_amount_deps();
	    };

	    $scope.update_currency = function() {
	      var send = $scope.send;
	      var recipient = send.recipient_actual || send.recipient_address;
	      var currency = send.currency;

	      $scope.reset_currency_deps();

	      // We should have a valid recipient unless it's a quoting bridge, in
	      // which case we should continue so we can request a quote.
	      if (!ripple.UInt160.is_valid(recipient) && !send.quote_url) {
	        return;
	      }

	      if (!send.currency_choices ||
	          send.currency_choices.length === 0) {
	        return;
	      }

	      $scope.update_amount();
	    };

	    var pathUpdateTimeout;

	    $scope.reset_amount_deps = function() {
	      var send = $scope.send;
	      send.sender_insufficient_xrp = false;
	      send.quote = false;

	      $scope.reset_paths();
	    };

	    $scope.update_amount = function() {
	      var send = $scope.send;
	      var recipient = send.recipient_actual || send.recipient_address;

	      if (!send.currency_choices ||
	          send.currency_choices.length === 0) {
	        return;
	      }

	      var currency = ripple.Currency.from_human(send.currency);

	      var matchedCurrency = currency.has_interest() ? currency.to_hex() : currency.get_iso();
	      var match = /^([a-zA-Z0-9]{3}|[A-Fa-f0-9]{40})\b/.exec(matchedCurrency);

	      if (!match) {
	        // Currency code not recognized, should have been caught by
	        // form validator.
	        return;
	      }

	      // Demurrage: Get a reference date five minutes in the future
	      //
	      // Normally, when using demurrage currencies, we would immediately round
	      // down (e.g. 0.99999 instead of 1) as demurrage occurs continuously. Not
	      // a good user experience.
	      //
	      // By choosing a date in the future, this gives us a time window before
	      // this rounding down occurs. Note that for positive interest currencies
	      // this actually *causes* the same odd rounding problem, so in the future
	      // we'll want a better solution, but for right now this does what we need.
	      var refDate = new Date(new Date().getTime() + 5 * 60000);
	      var amount = send.amount_feedback = ripple.Amount.from_human('' + send.amount + ' ' + matchedCurrency, { reference_date: refDate });

	      $scope.reset_amount_deps();
	      send.path_status = 'waiting';

	      // If there is a timeout in progress, we want to cancel it, since the
	      // inputs have changed.
	      if (pathUpdateTimeout) $timeout.cancel(pathUpdateTimeout);

	      // If the form is invalid, we won't be able to submit anyway, so no point
	      // in calculating paths.
	      if ($scope.sendForm.$invalid) return;

	      if (send.quote_url) {
	        if (!send.amount_feedback.is_valid())
	          return;

	        // Dummy issuer
	        send.amount_feedback.set_issuer(1);
	        pathUpdateTimeout = $timeout($scope.update_quote, 500);
	      } else {
	        if (!ripple.UInt160.is_valid(recipient) || !ripple.Amount.is_valid(amount)) {
	          // XXX Error?
	          return;
	        }

	        // Create Amount object
	        if (!send.amount_feedback.is_native()) {
	          send.amount_feedback.set_issuer(recipient);
	        }

	        // If we don't have recipient info yet, then don't search for paths
	        if (!send.recipient_info) {
	          return;
	        }

	        // Cannot make XRP payment if the sender does not have enough XRP
	        send.sender_insufficient_xrp = send.amount_feedback.is_native()
	          && $scope.account.max_spend
	          && $scope.account.max_spend.to_number() > 1
	          && $scope.account.max_spend.compareTo(send.amount_feedback) < 0;

	        var total = send.amount_feedback.add(send.recipient_info.Balance);
	        var reserve_base = $scope.account.reserve_base;
	        if (total.compareTo(reserve_base) < 0) {
	          send.fund_status = 'insufficient-xrp';
	          send.xrp_deficiency = reserve_base.subtract(send.recipient_info.Balance);
	          send.insufficient = true;
	          return;
	        }
	        send.insufficient = false;
	        send.fund_status = 'none';

	        send.path_status = 'pending';
	        pathUpdateTimeout = $timeout($scope.update_paths, 500);
	      }
	    };

	    /**
	     * Query the bridge for a quote.
	     *
	     * This will set send.amount_actual and send.recipient_actual based on the
	     * quote that the bridge returns.
	     */
	    $scope.update_quote = function() {
	      var send = $scope.send;
	      var recipient = send.recipient_actual || send.recipient_address;

	      $scope.reset_paths();

	      try {
	        // Get a quote
	        send.path_status = 'bridge-quote';

	        var data = {
	          type: 'quote',
	          amount: send.amount_feedback.to_text() + '/' + send.amount_feedback.currency().to_json(),
	          destination: send.quote_destination,
	          address: $scope.address
	        };

	        if ($.isArray(send.extra_fields)) {
	          $.each(send.extra_fields, function () {
	            data[this.name] = this.value;
	          });
	        }

	        $.ajax({
	          url: send.quote_url,
	          dataType: 'json',
	          data: data,
	          error: function () {
	            setImmediate(function () {
	              $scope.$apply(function () {
	                $scope.send.pathfind.close();
	                $scope.send.path_status = 'error-quote';
	              });
	            });
	          },
	          success: function(data) {
	            $scope.$apply(function () {
	              // Check if this request is still current, exit if not
	              var now_recipient = send.recipient_actual || send.recipient_address;
	              if (recipient !== now_recipient) return;

	              var now_amount = send.amount_feedback;
	              if (!now_amount.equals(send.amount_feedback)) return;

	              if (!data || !data.quote ||
	                  !(data.result === 'success' || data.status === 'success') ||
	                  !Array.isArray(data.quote.send) ||
	                  !data.quote.send.length || !data.quote.address) {
	                $scope.send.pathfind.close();
	                $scope.send.path_status = 'error-quote';
	                $scope.send.quote_error = '';
	                if (data && data.result === 'error' &&
	                    'string' === typeof data.error_message) {
	                  $scope.send.quote_error = data.error_message;
	                }
	                return;
	              }

	              var amount = Amount.from_json(data.quote.send[0]);

	              send.quote = data.quote;

	              // We have a quote, now calculate a path
	              send.recipient_actual = data.quote.address;
	              send.amount_actual = amount;

	              $scope.update_paths();
	            });
	          }
	        });
	      } catch (e) {
	        console.error(e.stack || e);
	        $scope.send.pathfind.close();
	        $scope.send.path_status = 'error-quote';
	      }
	    };

	    $scope.reset_paths = function () {
	      var send = $scope.send;

	      send.alternatives = [];
	    };

	    $scope.update_paths = function () {
	      var send = $scope.send;
	      var recipient = send.recipient_actual || send.recipient_address;
	      var amount = send.amount_actual || send.amount_feedback;
	      var tracked;

	      $scope.reset_paths();

	      send.path_status = 'pending';

	      // Determine if we need to update the paths.
	      // if (send.pathfind &&
	      //     send.pathfind.src_account === $id.account &&
	      //     send.pathfind.dst_account === recipient &&
	      //     send.pathfind.dst_amount.equals(amount))
	      //   return;

	      // Start path find
	      var pf = $network.remote.pathFind($id.account,
	                                         recipient,
	                                         amount);
	                                         //$scope.generate_src_currencies());
	                                         // XXX: Roll back pathfinding changes temporarily
	      var isIssuer = $scope.generate_issuer_currencies();

	      send.pathfind = pf;
	      send.pathfindJustStarted = true;

	      var lastUpdate;

	      pf.on('update', function(upd) {
	        // wrong quote
	        if ($scope.send.path_status === 'error-quote')
	          return;

	        // if no paths found and it is first update - skip it, it often wrong
	        if (send.pathfindJustStarted && (!upd.alternatives || !upd.alternatives.length)) {
	          send.pathfindJustStarted = false;
	          return;
	        }
	        send.pathfindJustStarted = false;

	        $scope.$apply(function () {
	          lastUpdate = new Date();

	          clearInterval(timer);
	          timer = setInterval(function(){
	            $scope.$apply(function(){
	              var seconds = Math.round((new Date() - lastUpdate) / 1000);
	              $scope.lastUpdate = seconds || 0;
	            });
	          }, 1000);

	          // Check if this request is still current, exit if not
	          var now_recipient = send.recipient_actual || send.recipient_address;
	          if (recipient !== now_recipient) return;

	          var now_amount = send.amount_actual || send.amount_feedback;
	          if (!now_amount.equals(amount)) return;

	          if (!upd.alternatives || !upd.alternatives.length) {
	            $scope.send.path_status  = 'no-path';
	            $scope.send.alternatives = [];
	          } else {
	            var currencies = {};
	            var currentAlternatives = [];

	            $scope.send.path_status  = 'done';
	            $scope.send.alternatives = _.map(upd.alternatives, function (raw, key) {
	              var alt = {};

	              alt.amount   = Amount.from_json(raw.source_amount);

	              // Compensate for demurrage
	              //
	              // In the case of demurrage, the amount would immediately drop
	              // below where it is and because we currently always round down it
	              // would immediately show up as something like 0.99999.
	              var slightlyInFuture = new Date(+new Date() + 5 * 60000);

	              alt.rate     = alt.amount.ratio_human(amount, {reference_date: slightlyInFuture});
	              alt.send_max = alt.amount.product_human(Amount.from_json('1.01'));
	              alt.paths    = raw.paths_computed
	                ? raw.paths_computed
	                : raw.paths_canonical;

	              // Selected currency should be the first option
	              if (raw.source_amount.currency) {
	                if (raw.source_amount.currency === $scope.send.currency_code)
	                  currentAlternatives.push(alt);
	              } else if ($scope.send.currency_code === 'XRP') {
	                currentAlternatives.push(alt);
	              }

	              if (alt.amount.issuer().to_json() != $scope.address && !isIssuer[alt.amount.currency().to_hex()]) {
	                currencies[alt.amount.currency().to_hex()] = true;
	              }

	              return alt;
	            }).filter(function(alt) { return currentAlternatives.indexOf(alt) == -1; });
	            Array.prototype.unshift.apply($scope.send.alternatives, currentAlternatives);

	            $scope.send.alternatives = $scope.send.alternatives.filter(function(alt) {
	              // XXX: Roll back pathfinding changes temporarily
	              /* if (currencies[alt.amount.currency().to_hex()]) {
	                return alt.amount.issuer().to_json() != $scope.address;
	              } */
	              return true;
	            });
	          }
	        });
	      });

	      pf.on('error', function (res) {
	        setImmediate(function () {
	          $scope.$apply(function () {
	            send.path_status = 'error';
	          });
	        });
	      });

	      var pathFindTime = new Date();
	    };

	    $scope.$watch('userBlob.data.contacts', function (contacts) {
	      $scope.recipient_query = webutil.queryFromContacts(contacts);
	    }, true);

	    $scope.$watch('account.max_spend', function () {
	      $scope.update_amount();
	    }, true);

	    $scope.reset = function () {
	      $scope.mode = 'form';

	      // XXX Most of these variables should be properties of $scope.send.
	      //     The Angular devs recommend that models be objects due to the way
	      //     scope inheritance works.
	      $scope.send = {
	        recipient: '',
	        recipient_name: '',
	        recipient_address: '',
	        recipient_prev: '',
	        recipient_info: {},
	        amount: '',
	        amount_prev: new Amount(),
	        currency: $scope.xrp.name,
	        currency_choices: [],
	        currency_code: 'XRP',
	        path_status: 'waiting',
	        fund_status: 'none',
	        sender_insufficient_xrp: false
	      };
	      $scope.nickname = '';
	      $scope.error_type = '';
	      $scope.resetAddressForm();
	      if ($scope.sendForm) $scope.sendForm.$setPristine(true);
	    };

	    $scope.cancelConfirm = function () {
	      $scope.mode = 'form';
	      $scope.send.alt = null;

	      // Force pathfinding reset
	      $scope.update_paths();
	    };

	    $scope.resetAddressForm = function() {
	      $scope.show_save_address_form = false;
	      $scope.addressSaved = false;
	      $scope.saveAddressName = '';
	      $scope.addressSaving = false;
	      if ($scope.saveAddressForm) $scope.saveAddressForm.$setPristine(true);
	    };

	    $scope.reset_goto = function (tabName) {
	      $scope.reset();

	      // TODO do something clever instead of document.location
	      // because goToTab does $scope.$digest() which we don't need
	      document.location = '#' + tabName;
	    };

	    /**
	     * N3. Confirmation page
	     */
	    $scope.send_prepared = function () {
	      // check if paths are available, if not then it is a direct send
	      $scope.send.indirect = $scope.send.alt ? $scope.send.alt.paths.length : false;

	      $scope.confirm_wait = true;
	      $timeout(function () {
	        $scope.confirm_wait = false;
	      }, 1000, true);

	      // Stop the pathfind - once we're on the confirmation page, we'll freeze
	      // the last state we had so the user doesn't get surprises when
	      // submitting.
	      // XXX ST: The confirmation page should warn you somehow once it becomes
	      //         outdated.
	      if ($scope.send.pathfind) {
	        $scope.send.pathfind.close();
	        delete $scope.send.pathfind;
	      }

	      $scope.mode = 'confirm';

	      if (keychain.isUnlocked($id.account)) {
	        $scope.send.secret = keychain.getUnlockedSecret($id.account);
	      }
	    };

	    /**
	     * N4. Waiting for transaction result page
	     */

	    $scope.onTransactionProposed = function (res, tx) {
	      $scope.$apply(function () {
	        $scope.setEngineStatus(res, false);
	        $scope.sent(tx.hash);

	        // Remember currency and increase order
	        var found;

	        for (var i = 0; i < $scope.currencies_all.length; i++) {
	          if ($scope.currencies_all[i].value.toLowerCase() === $scope.send.amount_feedback.currency().get_iso().toLowerCase()) {
	            $scope.currencies_all[i].order++;
	            found = true;
	            break;
	          }
	        }

	        // // Removed feature until a permanent fix
	        // if (!found) {
	        //   $scope.currencies_all.push({
	        //     'name': $scope.send.amount_feedback.currency().to_human().toUpperCase(),
	        //     'value': $scope.send.amount_feedback.currency().to_human().toUpperCase(),
	        //     'order': 1
	        //   });
	        // }
	      });
	    };

	    $scope.onTransactionSuccess = function (res, tx) {
	      $scope.$apply(function () {
	        $scope.setEngineStatus(res, true);
	      });
	    };

	    $scope.onTransactionError = function (res, tx) {
	      setImmediate(function () {
	        $scope.$apply(function () {
	          $scope.mode = 'error';

	          if (res.engine_result) {
	            $scope.setEngineStatus(res);
	          } else if (res.error === 'remoteError') {
	            $scope.error_type = res.remote.error;
	          } else {
	            $scope.error_type = 'unknown';
	          }
	        });
	      });
	    };

	    $scope.send_confirmed = function() {
	      var send = $scope.send;
	      var currency = $scope.send.currency.slice(0, 3).toUpperCase();
	      var amount = send.amount_feedback;
	      var address = $scope.send.recipient_address;

	      $scope.mode = 'sending';

	      amount.set_issuer(address);

	      var tx = $network.remote.transaction();
	      // Source tag
	      if ($scope.send.st) {
	        tx.source_tag($scope.send.st);
	      }

	      // Invoice ID
	      // Later in the code, this will be overwritten by the one specified
	      // in quote if the latter exists
	      if ($scope.send.invoice_id) {
	        tx.invoiceID($scope.send.invoice_id.toUpperCase());
	      }

	      // Add memo to tx
	      tx.addMemo('client', 'rt' + $scope.version);

	      if (send.secret) {
	        tx.secret(send.secret);
	      } else {
	        // Get secret asynchronously
	        keychain.getSecret($id.account, $id.username, send.unlock_password,
	                           function (err, secret) {
	                             if (err) {
	                               console.log('client: send tab: error while ' +
	                                           'unlocking wallet: ', err);
	                               $scope.mode = 'error';
	                               $scope.error_type = 'unlockFailed';
	                               return;
	                             }

	                             send.secret = secret;
	                             $scope.send_confirmed();
	                           });
	        return;
	      }

	      if ($scope.send.quote) {
	        if ('number' === typeof $scope.send.quote.destination_tag) {
	          tx.destination_tag($scope.send.quote.destination_tag);
	        }

	        if ('string' === typeof $scope.send.quote.invoice_id) {
	          tx.tx_json.InvoiceID = $scope.send.quote.invoice_id.toUpperCase();
	        }

	        tx.payment($id.account,
	                   $scope.send.quote.address,
	                   $scope.send.quote.send[0]);
	      } else {
	        // Destination tag
	        var dt;
	        if ($scope.send.dt) {
	          dt = $scope.send.dt;
	        } else {
	          dt = webutil.getDestTagFromAddress($scope.send.recipient);
	        }

	        tx.destination_tag(dt ? +dt : undefined); // 'cause +dt is NaN when dt is undefined

	        tx.payment($id.account, address, amount.to_json());
	      }

	      if ($scope.send.alt) {
	        tx.send_max($scope.send.alt.send_max);
	        tx.paths($scope.send.alt.paths);
	      } else {
	        if (!amount.is_native()) {
	          tx.build_path(true);
	        }
	      }

	      var maxLedger = Options.tx_last_ledger || 3;
	      tx.lastLedger($network.remote._ledger_current_index + maxLedger);

	      tx.on('success', function (res) {
	        $scope.onTransactionSuccess(res, tx);
	      });

	      tx.on('proposed', function (res) {
	        $scope.onTransactionProposed(res, tx);
	      });

	      tx.on('error', function (res) {
	        $scope.onTransactionError(res, tx);
	      });

	      tx.submit();

	      $scope.confirmedTime = new Date();
	    };

	    /**
	     * N5. Sent page
	     */
	    $scope.sent = function (hash) {
	      $scope.mode = 'status';
	      $network.remote.on('transaction', handleAccountEvent);

	      function handleAccountEvent(e) {
	        $scope.$apply(function () {
	          if (e.transaction.hash === hash) {
	            $scope.setEngineStatus(e, true);
	            $network.remote.removeListener('transaction', handleAccountEvent);
	          }
	        });
	      }
	    };

	    $scope.setEngineStatus = function(res, accepted) {
	      $scope.engine_result = res.engine_result;
	      $scope.engine_result_message = res.engine_result_message;
	      $scope.engine_status_accepted = !!accepted;
	      $scope.mode = 'status';
	      $scope.tx_result = 'partial';
	      switch (res.engine_result.slice(0, 3)) {
	        case 'tes':
	          $scope.mode = 'status';
	          $scope.tx_result = accepted ? 'cleared' : 'pending';
	          break;
	        case 'tep':
	          $scope.mode = 'status';
	          $scope.tx_result = 'partial';
	          break;
	        default:
	          $scope.mode = 'rippleerror';
	      }
	    };

	    $scope.saveAddress = function() {
	      $scope.addressSaving = true;

	      var contact = {
	        name: $scope.saveAddressName,
	        view: $scope.send.recipient,
	        address: $scope.send.federation ? $scope.send.recipient : $scope.send.recipient_address
	      };

	      if ($scope.send.dt && !$scope.send.federation) {
	        contact.dt =  $scope.send.dt;
	      }

	      $scope.userBlob.unshift('/contacts', contact, function(err, data) {
	        $scope.addressSaving = false;
	        if (err) {
	          console.log('Can\'t save the contact. ', err);
	          return;
	        }

	        $scope.contact = data;
	        $scope.addressSaved = true;
	      });
	    };

	    $scope.$on('$destroy', function() {
	      // Stop pathfinding if the user leaves the tab
	      if ($scope.send.pathfind) {
	        $scope.send.pathfind.close();
	        delete $scope.send.pathfind;
	      }
	      clearInterval(timer);
	    });

	    $scope.reset();

	    if($routeParams.to && $routeParams.amount) {
	      var amountValue = $routeParams.amount;
	      if (amountValue === ('' + parseInt(amountValue, 10))) {
	        amountValue = amountValue + '.0';
	      }
	      var amount = ripple.Amount.from_json(amountValue);
	      var currency = amount.currency();
	      if ($scope.currencies_all_keyed[currency.get_iso()]) {
	        $scope.send.currency_choices = [currency.to_human({full_name:$scope.currencies_all_keyed[currency.get_iso()].name})];
	      } else {
	        $scope.send.currency_choices = [currency.to_human()];
	      }
	      $scope.update_destination();
	    }
	  }]);

	  /**
	   * Contact name and address uniqueness validator
	   */
	  // TODO move to global directives
	  module.directive('unique', function() {
	    return {
	      restrict: 'A',
	      require: '?ngModel',
	      link: function ($scope, elm, attr, ctrl) {
	        if (!ctrl) return;

	        var validator = function(value) {
	          var unique = !webutil.getContact($scope.userBlob.data.contacts,value);
	          ctrl.$setValidity('unique', unique);
	          if (unique) return value;
	        };

	        ctrl.$formatters.push(validator);
	        ctrl.$parsers.unshift(validator);

	        attr.$observe('unique', function() {
	          validator(ctrl.$viewValue);
	        });
	      }
	    };
	  });
	};

	module.exports = SendTab;


/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var webutil = __webpack_require__(51);
	var settings = __webpack_require__(56);
	var Tab = __webpack_require__(63).Tab;
	var Amount = ripple.Amount;
	var rewriter = __webpack_require__(54);
	var Currency = ripple.Currency;
	var gateways = __webpack_require__(81);

	var TradeTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(TradeTab, Tab);

	TradeTab.prototype.tabName = 'trade';
	TradeTab.prototype.mainMenu = 'trade';

	TradeTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(73)();
	};

	TradeTab.prototype.angularDeps = Tab.prototype.angularDeps.concat(['books']);

	TradeTab.prototype.extraRoutes = [
	  { name: '/trade/:first/:second' }
	];

	TradeTab.prototype.angular = function(module)
	{
	  module.controller('TradeCtrl', ['rpBooks', '$scope', 'rpId', 'rpNetwork',
	                                  '$routeParams', '$location', '$filter',
	                                  'rpKeychain', '$rootScope',
	                                  function (books, $scope, id, $network,
	                                            $routeParams, $location, $filter,
	                                            keychain, $rootScope)
	  {
	    if (!id.loginStatus) return id.goId();

	    // Remember user preference on Convert vs. Trade
	    $rootScope.ripple_exchange_selection_trade = true;

	    // $scope.pairs_query = $scope.pairs_all;

	    var currencyPairChangedByNonUser = false;

	    $scope.first_currency_selected = '';
	    $scope.second_currency_selected = '';
	    $scope.currencies_all = __webpack_require__(57);
	    $scope.currencies = [];

	    var widget = {
	      first: '',
	      price: '',
	      second: '',
	      mode: 'trade'
	    };

	    var OrderbookFilterOpts = {
	      'precision':5,
	      'min_precision':5,
	      'max_sig_digits':20
	    };

	    for (var i = 0; i < $scope.currencies_all.length; i++) {
	      if ($scope.currencies_all[i].custom_trade_currency_dropdown) {
	        $scope.currencies.push($scope.currencies_all[i].value);
	      }
	    }

	    function onBlobIsValid() {
	      $scope.pairs_query = settings.getSetting($scope.userBlob, 'trade_currency_pairs');
	      // Remember user preference on Convert vs. Trade
	      if (!settings.getSetting($scope.userBlob, 'rippleExchangeSelectionTrade', false)) {
	        $scope.userBlob.set('/clients/rippletradecom/rippleExchangeSelectionTrade', true);
	      }
	    }

	    if (settings.blobIsValid($scope.userBlob)) {
	      onBlobIsValid();
	    } else {
	      var removeListener = $scope.$on('$blobUpdate', function() {
	        if (!settings.blobIsValid($scope.userBlob)) return;
	        onBlobIsValid();
	        removeListener();
	      });
	    }

	    function update_pairs() {
	      var d = $scope.userBlob.data;
	      if (!settings.hasSetting($scope.userBlob, 'trade_currency_pairs')) {
	        $scope.pairs_query = [{name: 'XRP/USD.rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q' },
	          { name: 'XRP/USD.rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B' },
	          { name: 'XRP/JPY.r94s8px6kSw1uZ1MV98dhSRTvc6VMPoPcN' },
	          { name: 'BTC.rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B/XRP' },
	          { name: 'BTC.rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q/XRP' }];
	      }
	      else {
	        $scope.pairs_query = settings.getSetting($scope.userBlob, 'trade_currency_pairs');
	      }
	    }

	    if ($scope.userBlob.data) {
	      update_pairs();
	    }

	    $scope.$on('$blobUpdate', function() {
	      update_pairs();
	      resetIssuers(false);
	    });


	    $scope.reset = function () {
	      $scope.executedOnOfferCreate = 'none';
	      var pair = store.get('ripple_trade_currency_pair') || $scope.pairs_all[0].name;

	      // Decide which listing to show
	      var listing;
	      if ($scope.order) {
	        listing = $scope.order.listing;
	      }
	      else if(store.get('ripple_trade_listing')) {
	        listing = store.get('ripple_trade_listing');
	      }
	      else {
	        listing = 'orderbook';
	      }

	      $scope.order = {
	        currency_pair: pair,
	        // These will be filled in by updateSettings
	        //   first_currency
	        //   second_currency
	        first_issuer: null,
	        second_issuer: null,
	        listing: listing,

	        buy: jQuery.extend(true, {}, widget),
	        sell: jQuery.extend(true, {}, widget),

	        // This variable is true if both the pair and the issuers are set to
	        // valid values. It is used to enable or disable all the functionality
	        // on the page.
	        valid_settings: false
	      };

	      updateSettings();
	      // updateMRU();
	    };

	    /**
	     * Resets single order widget. Used to reset widgets after
	     * the order confirmation.
	     *
	     * @param type (buy, sell)
	     */
	     /*
	    $scope.reset_widget = function(type) {
	      $scope.order[type] = jQuery.extend(true, {}, widget);

	      updateSettings();
	      // updateMRU();
	    };
	    */

	    $scope.reset_widget = function(type, widgetOnly) {
	      $scope.order[type] = jQuery.extend(true, {}, widget);

	      if (widgetOnly) return;

	      // Update widgets
	      ['buy','sell'].forEach(function(type){
	        $scope.update_first(type);
	        $scope.update_price(type);
	        $scope.update_second(type);
	      });

	      updateCanBuySell();
	      //updateMRU();
	    };


	    /**
	     * Sets current listing, and stores it in local storage.
	     *
	     * @param listing (my, orderbook)
	     */
	    $scope.setListing = function(listing){
	      $scope.order.listing = listing;

	      if (!store.disabled) {
	        store.set('ripple_trade_listing', listing);
	      }
	    };

	    /**
	     * Fill buy/sell widget when clicking on orderbook orders (sum or price)
	     *
	     * @param type (buy/sell)
	     * @param order (order)
	     * @param sum fill sum or not
	     */
	    $scope.fill_widget = function (type, order, sum) {
	      $scope.reset_widget(type);

	      $scope.order[type].price = order.price.to_human({group_sep: false});

	      if (sum) {
	        $scope.order[type].first = order.sum.to_human({group_sep: false});
	        $scope.calc_second(type);
	      }

	    };

	    /**
	     * Happens when user clicks on "Place Order" button.
	     *
	     * @param type (buy, sell)
	     */
	    // TODO type is this....
	    $scope.place_order = function (type) {
	      $scope.order[type].mode = "confirm";

	      if (type === 'buy') {
	        $scope.order.buy.sell_amount = $scope.order.buy.second_amount;
	        $scope.order.buy.buy_amount = $scope.order.buy.first_amount;
	      } else {
	        $scope.order.sell.sell_amount = $scope.order.sell.first_amount;
	        $scope.order.sell.buy_amount = $scope.order.sell.second_amount;
	      }

	      $scope.fatFingerCheck(type);
	    };

	    /**
	     * Returns orders currency pair, so we can compare it with current pair.
	     */
	    function getOrderCurrency(entry) {
	      if (!entry) return '';
	      var first_currency = entry.first.currency().to_json();
	      var first_issuer = entry.first.issuer().to_json();
	      var second_currency = entry.second.currency().to_json();
	      var second_issuer = entry.second.issuer().to_json();

	      var first = first_currency === 'XRP'
	        ? 'XRP'
	        : first_currency + '.' + first_issuer;

	      var second = second_currency === 'XRP'
	        ? 'XRP'
	        : second_currency + '.' + second_issuer;

	      var currency_pair = first + '/' + second;
	      return currency_pair;
	    }

	    /**
	     * Happens when user cliens the currency in "My Orders".
	     */
	    $scope.goto_order_currency = function() {
	      if (!this.entry) return;
	      if (getOrderCurrency(this.entry) === $scope.order.currency_pair) {
	        // same pair, do nothing
	        return;
	      }

	      var entry = this.entry;
	      var order = $scope.order;
	      currencyPairChangedByNonUser = true;
	      order.first_currency = this.entry.first.currency().to_json();
	      order.first_issuer = this.entry.first.issuer().to_json();
	      order.second_currency = this.entry.second.currency().to_json();
	      order.second_issuer = this.entry.second.issuer().to_json();

	      var first = order.first_currency === 'XRP'
	        ? 'XRP'
	        : order.first_currency + '.' + order.first_issuer;

	      var second = order.second_currency === 'XRP'
	        ? 'XRP'
	        : order.second_currency + '.' + order.second_issuer;

	      order.currency_pair = first + '/' + second;

	      var changedPair = updateSettings();
	      // updateMRU();
	      if (changedPair) {
	        $scope.reset_widget('buy', true);
	        $scope.reset_widget('sell', true);
	      }
	      return changedPair;
	    }

	    /**
	     * Happens when user clicks on "Cancel" in "My Orders".
	     */
	    $scope.cancel_order = function() {
	      var seq   = this.entry ? this.entry.seq : this.order.Sequence;
	      var order = this;
	      var tx    = $network.remote.transaction();

	      $scope.cancelError = null;

	      tx.offer_cancel(id.account, seq);
	      tx.on('success', function() {
	      });

	      tx.on('error', function (err) {
	        console.log("cancel error: ", err);

	        order.cancelling   = false;
	        $scope.cancelError = err.engine_result_message;

	        if (!$scope.$$phase) {
	          $scope.$apply();
	        }
	      });

	      keychain.requestSecret(id.account, id.username, function (err, secret) {
	        if (err) {

	          //err should equal 'canceled' here, other errors are not passed through
	          order.cancelling = false;
	          return;
	        }

	        tx.secret(secret);
	        tx.submit();
	      });

	      order.cancelling = true;
	    };

	    $scope.dismissCancelError = function() {
	      $scope.cancelError = null;
	    };

	    /**
	     * Happens when user clicks "Confirm" in order confirmation view.
	     *
	     * @param type (buy, sell)
	     */
	    $scope.order_confirmed = function (type)
	    {
	      var order = $scope.order[type];
	      var tx = $network.remote.transaction();

	      tx.offer_create(
	        id.account,
	        order.buy_amount,
	        order.sell_amount
	      );

	      // Add memo to tx
	      tx.addMemo('client', 'rt' + $rootScope.version);

	      // Sets a tfSell flag. This is the only way to distinguish
	      // sell offers from buys.
	      if (type === 'sell')
	        tx.set_flags('Sell');

	      tx.on('proposed', function (res) {

	        setEngineStatus(res, false, type);

	      });

	      tx.on('success', function(res) {
	        setEngineStatus(res, true, type);
	        order.mode = "done";

	        var tx = rewriter.processTxn(res, res.metadata, id.account);

	        for (var i = 0; i < tx.effects.length; i++) {
	          var messageType = tx.effects[i].type;

	          switch (messageType) {
	            case 'trust_change_balance':
	              $scope.executedOnOfferCreate = 'all';
	              break;
	            case 'offer_partially_funded':
	              $scope.executedOnOfferCreate = 'partial';
	              break;
	            default:
	              $scope.executedOnOfferCreate = 'none';
	              break;
	          }
	        }

	        if (!$scope.$$phase) {
	          $scope.$apply();
	        }
	      });

	      tx.on('error', function (err) {
	        setEngineStatus(err, false, type);
	        order.mode = "done";

	        if (!$scope.$$phase) {
	          $scope.$apply();
	        }
	      });

	      keychain.requestSecret(id.account, id.username, function (err, secret) {
	        if (err) {

	          //err should equal 'canceled' here, other errors are not passed through
	          order.mode = 'trade';
	          return;
	        }

	        tx.secret(secret);
	        tx.submit();
	      });

	      order.mode = "sending";
	    };

	    $scope.loadMore = function () {
	      $scope.orderbookLength = books.getLength();
	      var multiplier = 30;

	      Options.orderbook_max_rows += multiplier;

	      loadOffers();

	      $scope.orderbookState = (($scope.orderbookLength - Options.orderbook_max_rows + multiplier) < 1) ? 'full' : 'ready';
	    }


	    /**
	     * Handle transaction result
	     */
	    function setEngineStatus(res, accepted, type) {
	      var order = $scope.order[type];

	      order.engine_result = res.engine_result;
	      order.engine_result_message = res.engine_result_message;
	      switch (res.engine_result.slice(0, 3)) {
	        case 'tes':
	          order.tx_result = accepted ? "cleared" : "pending";
	          break;
	        case 'tem':
	          order.tx_result = "malformed";
	          break;
	        case 'ter':
	          order.tx_result = "failed";
	          break;
	        case 'tec':
	          order.tx_result = "claim";
	          break;
	        case 'tel':
	          order.tx_result = "local";
	          break;
	        //case 'tep':
	        default:
	          order.tx_result = "unknown";
	          console.warn("Unhandled engine status encountered:"+res.engine_result);
	          break;
	      }
	    }

	    $scope.update_first = function (type) {
	      var order = $scope.order[type];
	      var first_currency = $scope.order.first_currency || Currency.from_json("XRP");
	      var formatted = "" + order.first + " " + (first_currency.has_interest() ? first_currency.to_hex() : first_currency.get_iso());

	      order.first_amount = ripple.Amount.from_human(formatted, {reference_date: new Date(+new Date() + 5*60000)});

	      if (!first_currency.is_native()) order.first_amount.set_issuer($scope.order.first_issuer);
	    };

	    $scope.update_price = function (type) {
	      var order = $scope.order[type];
	      var second_currency = $scope.order.second_currency || Currency.from_json("XRP");
	      var formatted = "" + order.price + " " + (second_currency.has_interest() ? second_currency.to_hex() : second_currency.get_iso());

	      order.price_amount = ripple.Amount.from_human(formatted, {reference_date: new Date(+new Date() + 5*60000)});

	      if (!second_currency.is_native()) order.price_amount.set_issuer($scope.order.second_issuer);
	    };

	    $scope.update_second = function (type) {
	      var order = $scope.order[type];
	      var second_currency = $scope.order.second_currency || Currency.from_json("XRP");
	      var formatted = "" + order.second + " " + (second_currency.has_interest() ? second_currency.to_hex() : second_currency.get_iso());

	      order.second_amount = ripple.Amount.from_human(formatted, {reference_date: new Date(+new Date() + 5*60000)});

	      if (!second_currency.is_native()) order.second_amount.set_issuer($scope.order.second_issuer);
	    };

	    $scope.fatFingerCheck = function(type) {
	      var order = $scope.order[type];
	      var fatFingerMarginMultiplier = 1.1;

	      $scope.fatFingerErr = false;

	      if (type === 'buy') {

	        if (order.price > ($scope.book.bids[0].showPrice * fatFingerMarginMultiplier) ||
	            order.price < ($scope.book.bids[0].showPrice / fatFingerMarginMultiplier)) {

	          $scope.fatFingerErr = true;
	        }
	      }

	      else if (type === 'sell') {

	        if (order.price > ($scope.book.asks[0].showPrice * fatFingerMarginMultiplier) ||
	            order.price < ($scope.book.asks[0].showPrice / fatFingerMarginMultiplier)) {

	          $scope.fatFingerErr = true;
	        }
	      }
	    }

	    /**
	     * Calculate second when first or price changes.
	     *
	     * @param type
	     */
	    $scope.calc_second = function (type) {
	      var order = $scope.order[type];

	      $scope.update_first(type);
	      $scope.update_price(type);
	      if (order.price_amount && order.price_amount.is_valid() &&
	          order.first_amount && order.first_amount.is_valid()) {
	        // order.second_amount = order.price_amount.product_human(+order.first);
	        order.second_amount = order.price_amount.product_human(order.first_amount);
	        order.second = order.second_amount.to_human({group_sep: false});
	      }
	    };

	    /**
	     * Calculate first when second changes.
	     *
	     * @param type
	     */
	    $scope.calc_first = function (type) {
	      var order = $scope.order[type];

	      $scope.update_second(type);
	      $scope.update_price(type);
	      if (order.price_amount  && order.price_amount.is_valid() &&
	          order.second_amount && order.second_amount.is_valid()) {

	        // order.first_amount = Amount.from_json(order.second_amount.to_text_full()).ratio_human(Amount.from_json(order.price_amount.to_text()), {reference_date: new Date()});
	        order.first_amount = Amount.from_json(order.second_amount.to_text_full().replace(/,/g, '')).ratio_human(Amount.from_json(price + '/' + currency + '/' + issuer), {reference_date: new Date()});
	        order.first = order.first_amount.to_human({group_sep: false});
	      }
	    };

	    $scope.flip_issuer = function () {
	      var order = $scope.order;
	      if (!order.valid_settings) return;
	      var currency = order['first_currency'];
	      var issuer = order['first_issuer'];
	      var pair = order['currency_pair'].split('/');
	      currencyPairChangedByNonUser = true;
	      order.first_currency = order.second_currency;
	      order.first_issuer = order.second_issuer;
	      order.second_currency = currency;
	      order.second_issuer = issuer;
	      order.currency_pair = pair[1] + '/' + pair[0];
	      updateSettings();
	      updateMRU();
	    }

	    // This functions is called whenever the settings, specifically the pair and
	    // the issuer(s) have been modified. It checks the new configuration and
	    // sets $scope.valid_settings.
	    function updateSettings() {
	      var order = $scope.order;
	      var pair = order.currency_pair;
	      
	      if (!store.disabled) {
	        store.set('ripple_trade_currency_pair', pair);
	      }
	      
	      if ("string" !== typeof pair) pair = "";
	      pair = pair.split('/');

	      // Invalid currency pair
	      if (pair.length != 2 || pair[0].length === 0 || pair[1].length === 0) {
	        order.first_currency = Currency.from_json('XRP');
	        order.second_currency = Currency.from_json('XRP');
	        order.valid_settings = false;
	        return;
	      }


	      var first_currency = order.first_currency = ripple.Currency.from_json(pair[0].substring(0,3));
	      var second_currency = order.second_currency = ripple.Currency.from_json(pair[1].substring(0,3));

	      function setIssuer(pairPart, where) {
	        var contact_to_address = webutil.resolveContact($scope.userBlob.data.contacts, pairPart.substring(4));
	        if (contact_to_address) {
	          order[where] = contact_to_address;
	        } else {
	          var name = pairPart.substring(4);
	          if (name.substr(0, 1) !== '~') {
	            name = '~' + name;
	          }
	          ripple.AuthInfo.get(Options.domain, name, function(err, response) {
	            if (err) return;
	            $scope.$apply(function() {
	              order[where] = response.address;
	            });
	          });
	        }
	      }

	      if (first_currency.is_native()) {
	        order.first_issuer = '';
	      } else {
	        setIssuer(pair[0], 'first_issuer');
	      }

	      if (second_currency.is_native()) {
	        order.second_issuer = '';
	      } else {
	        setIssuer(pair[1], 'second_issuer');
	      }

	      // var first_currency = order.first_currency = ripple.Currency.from_json(pair[0]);
	      // var second_currency = order.second_currency = ripple.Currency.from_json(pair[1]);
	      var first_issuer = ripple.UInt160.from_json(order.first_issuer);
	      var second_issuer = ripple.UInt160.from_json(order.second_issuer);

	      // Invalid issuers or XRP/XRP pair
	      if ((!first_currency.is_native() && !first_issuer.is_valid()) ||
	          (!second_currency.is_native() && !second_issuer.is_valid()) ||
	          (first_currency.is_native() && second_currency.is_native())) {
	        order.valid_settings = false;
	        return;
	      }

	      order.valid_settings = true;

	      // Remember pair
	      // Produces currency/issuer:currency/issuer
	      var key = "" +
	        order.first_currency.to_json() +
	        (order.first_currency.is_native() ? "" : "/" + order.first_issuer) +
	        ":" +
	        order.second_currency._iso_code +
	        (order.second_currency.is_native() ? "" : "/" + order.second_issuer);

	      var changedPair = false;
	      // Load orderbook
	      if (order.prev_settings !== key) {
	        changedPair = true;
	        $scope.priceTicker = {
	          bid: 'n/a',
	          ask: 'n/a',
	          spread: 'n/a'
	        };
	        loadOffers();

	        order.prev_settings = key;
	      }

	      // Update widgets
	      ['buy','sell'].forEach(function(type){
	        $scope.update_first(type);
	        $scope.update_price(type);
	        $scope.update_second(type);
	      });

	      updateCanBuySell();
	      return changedPair;
	    }

	    // This functions is called after the settings have been modified. 
	    // It updates the most recent used pairs dropdown.
	    function updateMRU() {
	      var order = $scope.order;
	      if (!order.valid_settings) return;
	      if (!order.first_currency || !order.second_currency) return;
	      if (!order.first_currency.is_valid() || !order.second_currency.is_valid()) return;
	      var canonical_name = order.first_currency.to_json() + "/" + order.second_currency.to_json();

	      // Remember currency pair and set last used time
	      var found = false;
	      for (var i = 0; i < $scope.pairs_all.length; i++) {
	        if ($scope.pairs_all[i].name.toLowerCase() == canonical_name.toLowerCase()) {
	          var pair_obj = $scope.pairs_all[i];
	          pair_obj.name = canonical_name;
	          pair_obj.last_used = new Date().getTime();
	          $scope.pairs_all.splice(i, 1);
	          $scope.pairs_all.unshift(pair_obj);
	          found = true;
	          break;
	        }
	      }

	      if (!found) {
	        $scope.pairs_all.unshift({
	          "name": canonical_name,
	          "last_used": new Date().getTime()
	        });
	      }

	      if (!$scope.$$phase) {
	        $scope.$apply();
	      }
	    }

	    /**
	     * Tries to guess an issuer based on user's preferred issuer or highest trust.
	     *
	     * @param currency
	     * @param exclude_issuer
	     * @returns issuer
	     */
	    function guessIssuer(currency, exclude_issuer) {
	      var guess;

	      // First guess: An explicit issuer preference setting in the user's blob
	      try {
	        guess = $scope.userBlob.data.preferred_issuer[currency];
	        if (guess && guess === exclude_issuer) {
	          guess = $scope.userBlob.data.preferred_second_issuer[currency];
	        }
	        if (guess) return guess;
	      } catch (e) {}

	      // Second guess: The user's highest trust line in this currency
	      try {
	        var issuers = $scope.balances[currency].components;
	        for (var counterparty in issuers) {
	          if (counterparty != exclude_issuer) {
	            return counterparty;
	          }
	        }
	      } catch (e) {}

	      // We found nothing
	      return null;
	    }

	    function resetIssuers(force) {
	      var guess;
	      var order = $scope.order;

	      if (force) {
	        order.first_issuer = null;
	        order.second_issuer = null;
	      }

	      ['first','second'].forEach(function(prefix){
	        if (!order[prefix + '_issuer'] &&
	            order[prefix + '_currency'] &&
	            order[prefix + '_currency'] !== 'XRP' &&
	            (guess = guessIssuer(order[prefix + '_currency'].to_json()))) {
	          order[prefix + '_issuer'] = guess;
	        }
	      });

	      // If the same currency, exclude first issuer for second issuer guess
	      if (order.first_currency.equals(order.second_currency) &&
	          order.first_issuer === order.second_issuer &&
	          (guess = guessIssuer(order.first_currency.to_json(), order.first_issuer))) {
	        order.second_issuer = guess;
	      }
	    }

	    /**
	     * $scope.first_issuer_edit
	     * $scope.first_issuer_save
	     * $scope.second_issuer_edit
	     * $scope.second_issuer_save
	     */
	    ['first','second'].forEach(function(prefix){
	      $scope['edit_' + prefix + '_issuer'] = function () {
	        $scope.show_issuer_form = prefix;
	        $scope.order[prefix + '_issuer_edit'] = webutil.unresolveContact($scope.userBlob.data.contacts, $scope.order[prefix + '_issuer']);

	        setImmediate(function () {
	          $('#' + prefix + '_issuer').select();
	        });
	      };

	      $scope['save_' + prefix + '_issuer'] = function () {
	        $scope.order[prefix + '_issuer'] = webutil.resolveContact($scope.userBlob.data.contacts, $scope.order[prefix + '_issuer_edit']);
	        $scope.show_issuer_form = false;

	        updateSettings();
	        updateMRU();

	        // Persist issuer setting
	        if ($scope.order.valid_settings && !$scope.order[prefix + '_currency'].is_native()) {
	          if (prefix === 'first') {
	            $scope.userBlob.set("/preferred_issuer/"+
	                                $scope.userBlob.escapeToken($scope.order.first_currency.to_json()),
	                                $scope.order['first_issuer']);
	          } else {
	            if ($scope.order.first_currency.equals($scope.order.second_currency)) {
	              $scope.userBlob.set("/preferred_second_issuer/"+
	                                  $scope.userBlob.escapeToken($scope.order.second_currency.to_json()),
	                                  $scope.order.second_issuer);
	            } else {
	              $scope.userBlob.set("/preferred_issuer/"+
	                                  $scope.userBlob.escapeToken($scope.order.second_currency.to_json()),
	                                  $scope.order.second_issuer);
	            }
	          }
	        }
	      };
	    });

	    /**
	     * Load orderbook
	     */
	    function loadOffers() {
	      // Make sure we unsubscribe from any previously loaded orderbook
	      if ($scope.book && "function" === typeof $scope.book.unsubscribe) {
	        $scope.book.unsubscribe();
	      }

	      $scope.book = books.get({
	        currency: ($scope.order.first_currency.has_interest() ? $scope.order.first_currency.to_hex() : $scope.order.first_currency.get_iso()),
	        issuer: $scope.order.first_issuer
	      }, {
	        currency: ($scope.order.second_currency.has_interest() ? $scope.order.second_currency.to_hex() : $scope.order.second_currency.get_iso()),
	        issuer: $scope.order.second_issuer
	      }, $scope.address);

	      $scope.orderbookState = 'ready';
	    }

	    /**
	     * Determine whether user can sell and/or buy on this pair
	     */
	    var updateCanBuySell = function () {
	      var first_currency = $scope.order.first_currency;
	      var first_issuer = $scope.order.first_issuer;
	      var second_currency = $scope.order.second_currency;
	      var second_issuer = $scope.order.second_issuer;

	      var canBuy = second_currency.is_native() ||
	          second_issuer == $scope.address ||
	          ($scope.lines[second_issuer+($scope.order.second_currency.has_interest() ? $scope.order.second_currency.to_hex() : $scope.order.second_currency.to_json())]
	            && $scope.lines[second_issuer+($scope.order.second_currency.has_interest() ? $scope.order.second_currency.to_hex() : $scope.order.second_currency.to_json())].balance.is_positive());

	      canBuy = !second_currency.is_native() || !$scope.account.max_spend ? canBuy : canBuy && $scope.account.max_spend.is_positive();

	      var canSell = first_currency.is_native() ||
	          first_issuer == $scope.address ||
	          ($scope.lines[first_issuer+($scope.order.first_currency.has_interest() ? $scope.order.first_currency.to_hex() : $scope.order.first_currency.to_json())]
	            && $scope.lines[first_issuer+($scope.order.first_currency.has_interest() ? $scope.order.first_currency.to_hex() : $scope.order.first_currency.to_json())].balance.is_positive());

	      canSell = !first_currency.is_native() || !$scope.account.max_spend ? canSell : canSell && $scope.account.max_spend.is_positive();

	      $scope.order.buy.showWidget = canBuy;
	      $scope.order.sell.showWidget = canSell;
	    };

	    $scope.$watch('first_currency_selected', function() {
	      $scope.first_issuer_selected = '';
	      if ($scope.first_currency_selected == 'XRP') {
	        $scope.gateway_change_form.first_iss.$setValidity('rpDest', true);
	        $scope.disable_first_issuer = true;
	      } else {
	        $scope.disable_first_issuer = false;
	        $scope.first_iss = {};
	        gateways.forEach(function(gateway) {
	          //$scope.first_iss[gateway.name] = gateway;
	          var accounts = gateway.accounts;
	          accounts.forEach(function(account){
	            account.currencies.forEach(function(currency){
	              if(currency === $scope.first_currency_selected){
	                $scope.first_iss[gateway.name] = gateway;
	                // $scope.first_iss[account.address] = { name: account.address };
	              }
	            });
	          });
	        });
	      }
	    });

	    $scope.$watch('second_currency_selected', function() {
	      $scope.second_issuer_selected = '';
	      if ($scope.second_currency_selected == 'XRP') {
	        $scope.gateway_change_form.second_iss.$setValidity('rpDest', true);
	        $scope.disable_second_issuer = true;
	      } else {
	        $scope.disable_second_issuer = false;
	        $scope.second_iss = {};
	        gateways.forEach(function(gateway) {
	          //$scope.second_iss[gateway.name] = gateway;
	          var accounts = gateway.accounts;
	          accounts.forEach(function(account){
	            account.currencies.forEach(function(currency){
	              if(currency === $scope.second_currency_selected){
	                $scope.second_iss[gateway.name] = gateway;
	              }
	            });
	          });
	        });
	      }
	    });

	    $scope.gotoSettings = function() {
	      $location.path('/settingstrade');
	    };

	    $scope.open_custom_currency_selector = function() {
	      $scope.first_currency_selected = '';
	      $scope.first_issuer_selected = '';
	      $scope.second_currency_selected = '';
	      $scope.second_issuer_selected = '';
	      $scope.adding_pair = true;
	    }

	    $scope.add_pair = function() {
	      var formattedIssuerFirst = $scope.first_currency_selected === 'XRP' ? '' : '.' + $scope.first_issuer_selected;
	      var formattedIssuerSecond = $scope.second_currency_selected === 'XRP' ? '' : '.' + $scope.second_issuer_selected;
	      if (($scope.second_currency_selected !== 'XRP' && ($scope.second_issuer_selected == null || $scope.second_issuer_selected === '')) ||
	          ($scope.first_currency_selected  !== 'XRP' && ($scope.first_issuer_selected  == null || $scope.first_issuer_selected  === ''))) {
	        // this could happen if gate is not validated
	        return;
	      }

	      $scope.order.currency_pair = $scope.first_currency_selected + formattedIssuerFirst + '/' + $scope.second_currency_selected + formattedIssuerSecond;

	      $scope.userBlob.unshift('/clients/rippletradecom/trade_currency_pairs', { name: $scope.order.currency_pair });

	      $scope.adding_pair = false;
	    };


	    var rpamountFilter = $filter('rpamount');

	    $scope.$watchCollection('book', function () {
	      if (!jQuery.isEmptyObject($scope.book)) {
	        ['asks','bids'].forEach(function(type){
	          if ($scope.book[type]) {
	            $scope.book[type].forEach(function(order){
	              order.showSum = rpamountFilter(order.sum,OrderbookFilterOpts);
	              order.showPrice = rpamountFilter(order.price,OrderbookFilterOpts);

	              var showValue = type === 'bids' ? 'TakerPays' : 'TakerGets';
	              order['show' + showValue] = rpamountFilter(order[showValue],OrderbookFilterOpts);
	            });
	          }
	        });
	      }
	    });

	    /**
	     * Watch widget field changes
	     */
	    ['buy','sell'].forEach(function(type){
	      $scope.$watch('order.' + type + '.first', function () {
	        $scope.update_first(type);
	      }, true);

	      $scope.$watch('order.' + type + '.price', function () {
	        $scope.update_price(type);
	      }, true);

	      $scope.$watch('order.' + type + '.second', function () {
	        $scope.update_second(type);
	      }, true);
	    });

	    $scope.$watch('order.currency_pair', function (pair) {
	      if (currencyPairChangedByNonUser) {
	        currencyPairChangedByNonUser = false;
	        return;
	      }

	      $scope.reset_widget('buy', true);
	      $scope.reset_widget('sell', true);

	      updateSettings();
	      resetIssuers(true);
	      // updateMRU();
	    }, true);

	    $scope.$on('$blobUpdate', function () {
	      resetIssuers(false);
	    });


	    $scope.$watch('order.type', function () {
	      updateCanBuySell();
	    });

	    $scope.$watch('order.first_issuer', function () {
	      updateSettings();
	      // updateMRU();
	    });

	    $scope.$watch('order.second_issuer', function () {
	      updateSettings();
	      // updateMRU();
	    });

	    var updateBalances = function(){
	      updateCanBuySell();
	      resetIssuers(false);
	    };

	    $scope.$on('$balancesUpdate', updateBalances);

	    $scope.$watch('userBlob.data.contacts', function (contacts) {
	      $scope.issuer_query = webutil.queryFromContacts(contacts);
	    }, true);

	    $scope.$watchCollection('offers', function(){
	      $scope.offersCount = _.size($scope.offers);
	    });

	    $scope.reset();

	    /**
	     * Route includes currency pair
	     */
	    if ($routeParams.first && $routeParams.second) {
	      var routeIssuers = {};
	      var routeCurrencies = {};

	      ['first','second'].forEach(function(prefix){
	        routeIssuers[prefix] = $routeParams[prefix].match(/:(.+)$/);
	        routeCurrencies[prefix] = $routeParams[prefix].match(/^(\w{3})/);

	        if (routeIssuers[prefix]) {
	          if (ripple.UInt160.is_valid(routeIssuers[prefix][1])) {
	            $scope.order[prefix + '_issuer'] = routeIssuers[prefix][1];
	          } else {
	            $location.path('/trade');
	          }
	        }
	      });

	      if (routeCurrencies['first'] && routeCurrencies['second']) {
	        if (routeCurrencies['first'][1] !== routeCurrencies['second'][1]) {
	          $scope.order.currency_pair = routeCurrencies['first'][1] + '/' + routeCurrencies['second'][1];
	        } else {
	          $location.path('/trade');
	        }
	      }

	      updateSettings();
	      updateMRU();
	    }

	    updateBalances();

	    // Unsubscribe from the book when leaving this page
	    $scope.$on('$destroy', function(){
	      if ($scope.book && "function" === typeof $scope.book.unsubscribe) {
	        $scope.book.unsubscribe();
	      }
	    });
	  }]);
	};

	module.exports = TradeTab;

/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    Tab = __webpack_require__(63).Tab,
	    Currency = ripple.Currency;

	var AdvancedTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(AdvancedTab, Tab);

	AdvancedTab.prototype.tabName = 'advanced';
	AdvancedTab.prototype.mainMenu = 'advanced';

	AdvancedTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(72)();
	};

	AdvancedTab.prototype.angular = function(module)
	{
	  module.controller('AdvancedCtrl', ['$scope', '$rootScope', 'rpId', 'rpKeychain',
	                                    function ($scope, $rootScope, $id, $keychain)
	  {
	    if (!$id.loginStatus) return $id.goId();

	    // XRP currency object.
	    // {name: "XRP - Ripples", order: 146, value: "XRP"}
	    var xrpCurrency = Currency.from_json("XRP");

	    $scope.xrp = {
	      name: xrpCurrency.to_human({full_name:$scope.currencies_all_keyed.XRP.name}),
	      code: xrpCurrency.get_iso(),
	      currency: xrpCurrency
	    };

	    $scope.options = Options;
	    $scope.optionsBackup = $.extend(true, {}, Options);
	    $scope.passwordProtection = !$scope.userBlob.data.persistUnlock;
	    $scope.editBlob = false;
	    $scope.editMaxNetworkFee = false;
	    $scope.editAcctOptions = false;
	    $scope.max_tx_network_fee_human = ripple.Amount.from_json($scope.options.max_tx_network_fee).to_human();

	    $scope.saveSetings = function() {
	      // force serve ports to be number
	      _.each($scope.options.server.servers, function(s) {
	        s.port = +s.port;
	      });
	      // Save in local storage
	      if (!store.disabled) {
	        store.set('ripple_settings', angular.toJson($scope.options));
	      }
	    }

	    $scope.saveBlob = function() {

	      $scope.saveSetings();

	      $scope.editBlob = false;

	      // Reload
	      location.reload();
	    };

	    $scope.saveMaxNetworkFee = function () {
	      // Save in local storage
	      if (!store.disabled) {
	        $scope.options.max_tx_network_fee = ripple.Amount.from_human($scope.max_tx_network_fee_human).to_json();
	        store.set('ripple_settings', angular.toJson($scope.options));
	      }

	      $scope.editMaxNetworkFee = false;

	      // Reload
	      location.reload();
	    };

	    $scope.cancelEditMaxNetworkFee = function () {
	      $scope.editMaxNetworkFee = false;
	      $scope.options.max_tx_network_fee = $scope.optionsBackup.max_tx_network_fee;
	    };

	    $scope.cancelEditAcctOptions = function () {
	      $scope.editAcctOptions = false;
	    };

	    $scope.$on('$blobUpdate', function(){
	      $scope.passwordProtection = !$scope.userBlob.data.persistUnlock;
	    });
	    
	    $scope.setPasswordProtection = function () {
	      $keychain.setPasswordProtection(!$scope.passwordProtection, function(err, resp){
	        if (err) {
	          $scope.passwordProtection = !$scope.PasswordProtection;
	          //TODO: report errors to user
	        }
	      });
	    };

	    // Add a new server
	    $scope.addServer = function () {
	      // Create a new server line
	      if(!$scope.options.server.servers.isEmptyServer)
	        $scope.options.server.servers.push({isEmptyServer: true, secure: false});

	      // Set editing to true
	      $scope.editing = true;
	      
	    }

	  }]);

	  module.controller('ServerRowCtrl', ['$scope',
	    function ($scope) {
	      $scope.editing = $scope.server.isEmptyServer;

	        // Delete the server
	      $scope.remove = function () {
	        $scope.options.server.servers.splice($scope.index,1);

	        $scope.saveSetings();
	      }

	      $scope.hasRemove = function () {
	        return !$scope.server.isEmptyServer && $scope.options.server.servers.length !== 1;
	      }

	      $scope.cancel = function () {
	        if ($scope.server.isEmptyServer) {
	          $scope.remove();
	          return;
	        }

	        $scope.editing = false;
	        console.log('---- ServerRowCtrl::cancel index: ' + $scope.index);
	        console.log(JSON.stringify($scope.server));
	        $scope.server = $.extend({ '$$hashKey' : $scope.server.$$hashKey }, $scope.optionsBackup.server.servers[$scope.index]);
	        Options.server.servers[$scope.index] = $.extend({}, $scope.optionsBackup.server.servers[$scope.index]);
	        console.log(JSON.stringify($scope.server));
	        console.log(JSON.stringify(Options.server.servers));
	      }

	      $scope.noCancel = function () {
	        return $scope.server.isEmptyServer && $scope.options.server.servers.length === 1;
	      }

	      $scope.save = function () {
	        $scope.server.isEmptyServer = false;
	        $scope.editing = false;

	        $scope.saveSetings();

	          // Reload
	        location.reload();
	      };
	    }
	  ]);
	};

	module.exports = AdvancedTab;


/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var Tab  = __webpack_require__(63).Tab;

	var SecurityTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(SecurityTab, Tab);

	SecurityTab.prototype.tabName = 'security';
	SecurityTab.prototype.mainMenu = 'security';

	SecurityTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(74)();
	};

	SecurityTab.prototype.angular = function (module) {
	  module.controller('SecurityCtrl', ['$scope', 'rpId',
	                                     'rpKeychain', '$timeout', 'rpAuthFlow', 'rpPopup',
	                                     function ($scope, $id,
	                                               keychain, $timeout, authflow, popup)
	  {
	    if (!$id.loginStatus) return $id.goId();

	    $scope.settingsPage = 'security';
	    
	    $scope.showComponent = [];


	    $scope.isUnlocked = true; //hiding the dialog for now
	    //$scope.isUnlocked = keychain.isUnlocked($id.account);
	    $scope.requirePasswordChanged = false;
	   
	    $scope.validation_pattern_phone = /^[0-9]*$/;

	    $scope.$on('$blobUpdate', onBlobUpdate);
	    onBlobUpdate();

	    $scope.security = {};

	    function onBlobUpdate()
	    {
	      if ("function" === typeof $scope.userBlob.encrypt) {
	        $scope.enc = $scope.userBlob.encrypt();
	      }
	      

	      $scope.requirePassword = !$scope.userBlob.data.persistUnlock;
	    }

	    $scope.restoreSession = function() {

	      if (!$scope.sessionPassword) {
	        $scope.unlockError = true;
	        return;
	      }

	      $scope.isConfirming = true;
	      $scope.unlockError  = null;

	      keychain.getSecret($id.account, $id.username, $scope.sessionPassword, function(err, secret) {
	        $scope.isConfirming = false;
	        $scope.sessionPassword = '';
	        
	        if (err) {
	          $scope.unlockError = err;
	          return;
	        }

	        $scope.isUnlocked = keychain.isUnlocked($id.account);
	      });

	    };


	    $scope.unmaskSecret = function () {
	      keychain.requestSecret($id.account, $id.username, 'showSecret', function (err, secret) {
	        if (err) {
	          // XXX Handle error
	          return;
	        }

	        $scope.security.master_seed = secret;
	      });
	    };


	    $scope.setPasswordProtection = function () {
	      $scope.editUnlock = false;
	      
	      //ignore it if we are not going to change anything
	      if (!$scope.requirePasswordChanged) return;
	      $scope.requirePasswordChanged = false;
	      $scope.requirePassword        = !$scope.requirePassword;
	      
	      keychain.setPasswordProtection($scope.requirePassword, function(err, resp){
	        if (err) {
	          console.log(err);
	          $scope.requirePassword = !$scope.requirePassword;
	          //TODO: report errors to user
	        }
	      });
	    };

	    $scope.cancelUnlockOptions = function () {
	      $scope.editUnlock = false;
	    };

	    $scope.changePassword = function() {
	      $scope.loading = true;
	      $scope.error = false;

	      // Get the master key
	      keychain.getSecret($id.account, $id.username, $scope.password,
	          function (err, masterkey) {
	            if (err) {
	              console.log("client: account tab: error while " +
	                  "unlocking wallet: ", err);

	              $scope.error = 'wrongpassword';
	              $scope.loading = false;
	              return;
	            }

	            // Change password
	            $id.changePassword({
	              username: $id.username,
	              password: $scope.password1,
	              masterkey: masterkey,
	              blob: $scope.userBlob
	            }, function(err){
	              if (err) {
	                console.log('client: account tab: error while ' +
	                    'changing the account password: ', err);
	                $scope.error = true;
	                $scope.loading = false;
	                return;
	              }

	              $scope.success = true;
	              reset();
	            });
	          }
	      );
	    };

	    function requestToken (force, callback) {

	      authflow.requestToken($scope.userBlob.url, $scope.userBlob.id, force, function(tokenError, tokenResp) {
	        $scope.via = tokenResp.via;

	        callback(tokenError, tokenResp);
	      });
	    }

	    $scope.requestToken = function () {
	      var force = $scope.via === 'app' ? true : false;
	      
	      $scope.isRequesting = true;
	      requestToken(force, function(err, resp) {
	        $scope.isRequesting = false;
	        //TODO: present message of resend success or failure
	      });
	    };

	    var reset = function() {

	      $scope.openFormPassword = false;
	      $scope.password1 = '';
	      $scope.password2 = '';
	      $scope.passwordSet = {};
	      $scope.loading = false;
	      $scope.error = false;

	      if ($scope.changeForm) {
	        $scope.changeForm.$setPristine(true);
	      }
	  };

	  reset();
	  $scope.success = false;

	  }]);
	};

	module.exports = SecurityTab;


/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var Tab = __webpack_require__(63).Tab;
	var rewriter = __webpack_require__(54);

	var TxTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(TxTab, Tab);

	TxTab.prototype.tabName = 'tx';

	TxTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(75)();
	};

	TxTab.prototype.angular = function (module)
	{
	  module.controller('TxCtrl', ['$scope', 'rpNetwork', '$routeParams', 'rpId', '$location',
	                               function ($scope, net, $routeParams, $id, $location)
	  {
	    $scope.logoutTx = function () {
	      $id.logout();
	      $location.path('/login');
	    };

	    if (!$id.loginStatus) return $scope.logoutTx();

	    $scope.state = 'loading';
	    $scope.transaction = {
	      hash: $routeParams.id
	    };

	    function loadTx() {
	      // XXX: Dirty, dirty. But it's going to change soon anyway.
	      var request = net.remote.request_ledger_hash();
	      request.message.command = 'tx';
	      request.message.transaction = $routeParams.id;
	      request.on('success', function (res) {
	        $scope.$apply(function () {
	          $scope.state = 'loaded';
	          // XXX This is for the upcoming tx RPC call format change.
	          var tx = res.tx ? res.tx : res;
	          _.extend($scope.transaction, res);

	          $scope.amountSent = rewriter.getAmountSent(tx, tx.meta);
	        });
	      });
	      request.on('error', function (res) {
	        $scope.$apply(function () {
	          $scope.state = 'error';
	          console.log(res);
	        });
	      });
	      request.request();
	    }

	    if (net.connected) loadTx();
	    else var removeListener = $scope.$on('$netConnected', function () {
	      removeListener();
	      loadTx();
	    });
	  }]);
	};

	module.exports = TxTab;


/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    Tab = __webpack_require__(63).Tab;

	var XrpTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(XrpTab, Tab);

	XrpTab.prototype.tabName = 'xrp';
	XrpTab.prototype.mainMenu = 'fund';

	XrpTab.prototype.angularDeps = Tab.prototype.angularDeps.concat(['qr']);

	XrpTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(76)();
	};


	XrpTab.prototype.angular = function (module)
	{
	  module.controller('XrpCtrl', ['$rootScope', 'rpId',
	                                     function ($scope, $id)
	  {
	    $scope.accountLines = {};
	    $scope.showComponent = [];
	    $scope.fundPage = 'xrp';

	    if (!$id.loginStatus) return $id.goId();

	  }]);
	};

	module.exports = XrpTab;


/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47);
	var Tab = __webpack_require__(63).Tab;

	var EulaTab = function ()
	{
	  Tab.call(this);
	};

	util.inherits(EulaTab, Tab);

	EulaTab.prototype.tabName = 'eula';
	EulaTab.prototype.pageMode = 'single';
	EulaTab.prototype.parent = 'main';

	EulaTab.prototype.generateHtml = function ()
	{
	  return __webpack_require__(77)();
	};

	EulaTab.prototype.angular = function (module) {
	  module.controller('EulaCtrl', ['$scope', '$element',
	                                  function ($scope, $element)
	  {

	    angular.element('nav').hide();

	  }]);

	};



	module.exports = EulaTab;


/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    Tab = __webpack_require__(63).Tab;

	var SettingsGatewayTab = function() {
	  Tab.call(this);
	};

	util.inherits(SettingsGatewayTab, Tab);

	SettingsGatewayTab.prototype.tabName = 'settingsgateway';
	SettingsGatewayTab.prototype.mainMenu = 'settingsgateway';

	SettingsGatewayTab.prototype.generateHtml = function() {
	  return __webpack_require__(78)();
	};


	SettingsGatewayTab.prototype.angular = function(module)
	{
	  module.controller('SettingsGatewayCtrl', ['$scope', 'rpId', 'rpKeychain', 'rpNetwork',
	                                    function ($scope, id, keychain, network)
	  {
	    if (!id.loginStatus) return id.goId();

	    // from new Ripple lib
	    var RemoteFlags = {
	      // AccountRoot
	      account_root: {
	        PasswordSpent: 0x00010000, // password set fee is spent
	        RequireDestTag: 0x00020000, // require a DestinationTag for payments
	        RequireAuth: 0x00040000, // require a authorization to hold IOUs
	        DisallowXRP: 0x00080000, // disallow sending XRP
	        DisableMaster: 0x00100000,  // force regular key
	        DefaultRipple: 0x00800000,
	        NoFreeze: 0x00200000, // permanently disallowed freezing trustlines
	        GlobalFreeze: 0x00400000 // trustlines globally frozen
	      },
	      // Offer
	      offer: {
	        Passive: 0x00010000,
	        Sell: 0x00020000  // offer was placed as a sell
	      },
	      // Ripple tate
	      state: {
	        LowReserve: 0x00010000, // entry counts toward reserve
	        HighReserve: 0x00020000,
	        LowAuth: 0x00040000,
	        HighAuth: 0x00080000,
	        LowNoRipple: 0x00100000,
	        HighNoRipple: 0x00200000
	      }
	    };
	    var Transaction = {
	      set_clear_flags : {
	        AccountSet: {
	          asfRequireDest: 1,
	          asfRequireAuth: 2,
	          asfDisallowXRP: 3,
	          asfDisableMaster: 4,
	          asfAccountTxnID: 5,
	          asfNoFreeze: 6,
	          asfGlobalFreeze: 7,
	          asfDefaultRipple: 8
	        }
	      }
	    };



	    $scope.options = Options;
	    $scope.optionsBackup = $.extend(true, {}, Options);
	    $scope.edit = {
	      advanced_feature_switch: false,
	      defaultRippleFlag: false,
	      defaultRippleFlagSaving: false
	    };

	    // Initialize the notification object
	    $scope.success = {};

	    $scope.saveBlob = function() {
	      // Save in local storage
	      if (!store.disabled) {
	        store.set('ripple_settings', JSON.stringify($scope.options));
	      }

	      $scope.editBlob = false;
	    };

	    $scope.save = function(type) {
	      switch (type) {
	        case 'advanced_feature_switch':
	          $scope.saveBlob();
	          break;
	        case 'defaultRippleFlag':
	          // Need to set flag on account_root only when chosen option is different from current setting
	          if ($scope.currentDefaultRipplingFlagSetting !== $scope.isDefaultRippleFlagEnabled) {
	            $scope.edit.defaultRippleFlagSaving = true;
	            var tx = network.remote.transaction();
	            !$scope.isDefaultRippleFlagEnabled ? tx.accountSet(id.account, undefined, Transaction.set_clear_flags.AccountSet.asfDefaultRipple) : tx.accountSet(id.account, Transaction.set_clear_flags.AccountSet.asfDefaultRipple);
	            tx.on('success', function(res) {
	              $scope.$apply(function() {
	                $scope.edit.defaultRippleFlagSaving = false;
	                $scope.load_notification('defaultRippleUpdated');
	              });
	            });
	            tx.on('error', function(res) {
	              console.warn(res);
	              $scope.$apply(function() {
	                $scope.edit.defaultRippleFlagSaving = false;
	              });
	            });

	            keychain.requestSecret(id.account, id.username, function(err, secret) {
	              if (err) {
	                console.log('Error: ', err);
	                $scope.isDefaultRippleFlagEnabled = !$scope.isDefaultRippleFlagEnabled;
	                $scope.edit.defaultRippleFlagSaving = false;
	                return;
	              }
	              tx.secret(secret);
	              tx.submit();
	            });
	          }
	          break;
	        default:
	          $scope.saveBlob();
	      }

	      $scope.edit[type] = false;

	      // Notify the user
	      $scope.success[type] = true;
	    };

	    $scope.cancelEdit = function(type) {
	      $scope.edit[type] = false;
	      $scope.options[type] = $scope.optionsBackup[type];
	    };

	    $scope.$watch('account', function() {
	      // Check if account has DefaultRipple flag set
	      $scope.isDefaultRippleFlagEnabled = !!($scope.account.Flags & RemoteFlags.account_root.DefaultRipple);
	      $scope.currentDefaultRipplingFlagSetting = $scope.isDefaultRippleFlagEnabled;
	    }, true);

	  }]);
	};

	module.exports = SettingsGatewayTab;


/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {

	(function(module) {
	'use strict';

	/* global ripple: false, angular: false, _: false, jQuery: false, store: false, Options: false */

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    settings = __webpack_require__(56),
	    Tab = __webpack_require__(63).Tab;

	var SettingsTradeTab = function() {
	  Tab.call(this);
	};

	util.inherits(SettingsTradeTab, Tab);

	SettingsTradeTab.prototype.tabName = 'settingstrade';
	SettingsTradeTab.prototype.mainMenu = 'settingstrade';

	SettingsTradeTab.prototype.generateHtml = function() {
	  return __webpack_require__(79)();
	};

	SettingsTradeTab.prototype.angular = function(module) {
	  module.controller('SettingsTradeCtrl', SettingsTradeCtrl);

	  SettingsTradeCtrl.$inject = ['$scope', '$timeout'];

	  function SettingsTradeCtrl($scope, $timeout) {
	    if ($scope.userBlob.data && $scope.userCredentials.username) {
	      $scope.pairs = settings.getSetting($scope.userBlob, 'trade_currency_pairs');
	    } else {
	      var removeWatcher = $scope.$on('$blobUpdate', function() {
	        if (!$scope.userCredentials.username)
	          return;
	        $scope.pairs = settings.getSetting($scope.userBlob, 'trade_currency_pairs');
	        removeWatcher();
	      });
	    }

	    $scope.deletePair = function(index){
	      for (var i = 0; i < $scope.pairs.length; i++) {
	        if ($scope.pairs[i].name === this.entry.name) {
	          $scope.userBlob.unset('/clients/rippletradecom/trade_currency_pairs/' + index);
	          return;
	        }
	      }
	    }

	    $scope.dragControlListeners = {
	        orderChanged: function(event) {
	          var sourceObj = _.clone($scope.pairs[event.source.index]);
	          var destObj = _.clone($scope.pairs[event.dest.index]);
	          $scope.userBlob.set('/clients/rippletradecom/trade_currency_pairs/' + event.source.index, sourceObj);
	          $scope.userBlob.set('/clients/rippletradecom/trade_currency_pairs/' + event.dest.index, destObj);
	        }
	    };
	  }
	};

	module.exports = SettingsTradeTab;

	})(module);


/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {//! moment.js
	//! version : 2.8.3
	//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
	//! license : MIT
	//! momentjs.com

	(function (undefined) {
	    /************************************
	        Constants
	    ************************************/

	    var moment,
	        VERSION = '2.8.3',
	        // the global-scope this is NOT the global object in Node.js
	        globalScope = typeof global !== 'undefined' ? global : this,
	        oldGlobalMoment,
	        round = Math.round,
	        hasOwnProperty = Object.prototype.hasOwnProperty,
	        i,

	        YEAR = 0,
	        MONTH = 1,
	        DATE = 2,
	        HOUR = 3,
	        MINUTE = 4,
	        SECOND = 5,
	        MILLISECOND = 6,

	        // internal storage for locale config files
	        locales = {},

	        // extra moment internal properties (plugins register props here)
	        momentProperties = [],

	        // check for nodeJS
	        hasModule = (typeof module !== 'undefined' && module.exports),

	        // ASP.NET json date format regex
	        aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,
	        aspNetTimeSpanJsonRegex = /(\-)?(?:(\d*)\.)?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?)?/,

	        // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
	        // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
	        isoDurationRegex = /^(-)?P(?:(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?|([0-9,.]*)W)$/,

	        // format tokens
	        formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Q|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,4}|X|zz?|ZZ?|.)/g,
	        localFormattingTokens = /(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,

	        // parsing token regexes
	        parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
	        parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
	        parseTokenOneToFourDigits = /\d{1,4}/, // 0 - 9999
	        parseTokenOneToSixDigits = /[+\-]?\d{1,6}/, // -999,999 - 999,999
	        parseTokenDigits = /\d+/, // nonzero number of digits
	        parseTokenWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i, // any word (or two) characters or numbers including two/three word month in arabic.
	        parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/gi, // +00:00 -00:00 +0000 -0000 or Z
	        parseTokenT = /T/i, // T (ISO separator)
	        parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
	        parseTokenOrdinal = /\d{1,2}/,

	        //strict parsing regexes
	        parseTokenOneDigit = /\d/, // 0 - 9
	        parseTokenTwoDigits = /\d\d/, // 00 - 99
	        parseTokenThreeDigits = /\d{3}/, // 000 - 999
	        parseTokenFourDigits = /\d{4}/, // 0000 - 9999
	        parseTokenSixDigits = /[+-]?\d{6}/, // -999,999 - 999,999
	        parseTokenSignedNumber = /[+-]?\d+/, // -inf - inf

	        // iso 8601 regex
	        // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
	        isoRegex = /^\s*(?:[+-]\d{6}|\d{4})-(?:(\d\d-\d\d)|(W\d\d$)|(W\d\d-\d)|(\d\d\d))((T| )(\d\d(:\d\d(:\d\d(\.\d+)?)?)?)?([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/,

	        isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',

	        isoDates = [
	            ['YYYYYY-MM-DD', /[+-]\d{6}-\d{2}-\d{2}/],
	            ['YYYY-MM-DD', /\d{4}-\d{2}-\d{2}/],
	            ['GGGG-[W]WW-E', /\d{4}-W\d{2}-\d/],
	            ['GGGG-[W]WW', /\d{4}-W\d{2}/],
	            ['YYYY-DDD', /\d{4}-\d{3}/]
	        ],

	        // iso time formats and regexes
	        isoTimes = [
	            ['HH:mm:ss.SSSS', /(T| )\d\d:\d\d:\d\d\.\d+/],
	            ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
	            ['HH:mm', /(T| )\d\d:\d\d/],
	            ['HH', /(T| )\d\d/]
	        ],

	        // timezone chunker '+10:00' > ['10', '00'] or '-1530' > ['-15', '30']
	        parseTimezoneChunker = /([\+\-]|\d\d)/gi,

	        // getter and setter names
	        proxyGettersAndSetters = 'Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
	        unitMillisecondFactors = {
	            'Milliseconds' : 1,
	            'Seconds' : 1e3,
	            'Minutes' : 6e4,
	            'Hours' : 36e5,
	            'Days' : 864e5,
	            'Months' : 2592e6,
	            'Years' : 31536e6
	        },

	        unitAliases = {
	            ms : 'millisecond',
	            s : 'second',
	            m : 'minute',
	            h : 'hour',
	            d : 'day',
	            D : 'date',
	            w : 'week',
	            W : 'isoWeek',
	            M : 'month',
	            Q : 'quarter',
	            y : 'year',
	            DDD : 'dayOfYear',
	            e : 'weekday',
	            E : 'isoWeekday',
	            gg: 'weekYear',
	            GG: 'isoWeekYear'
	        },

	        camelFunctions = {
	            dayofyear : 'dayOfYear',
	            isoweekday : 'isoWeekday',
	            isoweek : 'isoWeek',
	            weekyear : 'weekYear',
	            isoweekyear : 'isoWeekYear'
	        },

	        // format function strings
	        formatFunctions = {},

	        // default relative time thresholds
	        relativeTimeThresholds = {
	            s: 45,  // seconds to minute
	            m: 45,  // minutes to hour
	            h: 22,  // hours to day
	            d: 26,  // days to month
	            M: 11   // months to year
	        },

	        // tokens to ordinalize and pad
	        ordinalizeTokens = 'DDD w W M D d'.split(' '),
	        paddedTokens = 'M D H h m s w W'.split(' '),

	        formatTokenFunctions = {
	            M    : function () {
	                return this.month() + 1;
	            },
	            MMM  : function (format) {
	                return this.localeData().monthsShort(this, format);
	            },
	            MMMM : function (format) {
	                return this.localeData().months(this, format);
	            },
	            D    : function () {
	                return this.date();
	            },
	            DDD  : function () {
	                return this.dayOfYear();
	            },
	            d    : function () {
	                return this.day();
	            },
	            dd   : function (format) {
	                return this.localeData().weekdaysMin(this, format);
	            },
	            ddd  : function (format) {
	                return this.localeData().weekdaysShort(this, format);
	            },
	            dddd : function (format) {
	                return this.localeData().weekdays(this, format);
	            },
	            w    : function () {
	                return this.week();
	            },
	            W    : function () {
	                return this.isoWeek();
	            },
	            YY   : function () {
	                return leftZeroFill(this.year() % 100, 2);
	            },
	            YYYY : function () {
	                return leftZeroFill(this.year(), 4);
	            },
	            YYYYY : function () {
	                return leftZeroFill(this.year(), 5);
	            },
	            YYYYYY : function () {
	                var y = this.year(), sign = y >= 0 ? '+' : '-';
	                return sign + leftZeroFill(Math.abs(y), 6);
	            },
	            gg   : function () {
	                return leftZeroFill(this.weekYear() % 100, 2);
	            },
	            gggg : function () {
	                return leftZeroFill(this.weekYear(), 4);
	            },
	            ggggg : function () {
	                return leftZeroFill(this.weekYear(), 5);
	            },
	            GG   : function () {
	                return leftZeroFill(this.isoWeekYear() % 100, 2);
	            },
	            GGGG : function () {
	                return leftZeroFill(this.isoWeekYear(), 4);
	            },
	            GGGGG : function () {
	                return leftZeroFill(this.isoWeekYear(), 5);
	            },
	            e : function () {
	                return this.weekday();
	            },
	            E : function () {
	                return this.isoWeekday();
	            },
	            a    : function () {
	                return this.localeData().meridiem(this.hours(), this.minutes(), true);
	            },
	            A    : function () {
	                return this.localeData().meridiem(this.hours(), this.minutes(), false);
	            },
	            H    : function () {
	                return this.hours();
	            },
	            h    : function () {
	                return this.hours() % 12 || 12;
	            },
	            m    : function () {
	                return this.minutes();
	            },
	            s    : function () {
	                return this.seconds();
	            },
	            S    : function () {
	                return toInt(this.milliseconds() / 100);
	            },
	            SS   : function () {
	                return leftZeroFill(toInt(this.milliseconds() / 10), 2);
	            },
	            SSS  : function () {
	                return leftZeroFill(this.milliseconds(), 3);
	            },
	            SSSS : function () {
	                return leftZeroFill(this.milliseconds(), 3);
	            },
	            Z    : function () {
	                var a = -this.zone(),
	                    b = '+';
	                if (a < 0) {
	                    a = -a;
	                    b = '-';
	                }
	                return b + leftZeroFill(toInt(a / 60), 2) + ':' + leftZeroFill(toInt(a) % 60, 2);
	            },
	            ZZ   : function () {
	                var a = -this.zone(),
	                    b = '+';
	                if (a < 0) {
	                    a = -a;
	                    b = '-';
	                }
	                return b + leftZeroFill(toInt(a / 60), 2) + leftZeroFill(toInt(a) % 60, 2);
	            },
	            z : function () {
	                return this.zoneAbbr();
	            },
	            zz : function () {
	                return this.zoneName();
	            },
	            X    : function () {
	                return this.unix();
	            },
	            Q : function () {
	                return this.quarter();
	            }
	        },

	        deprecations = {},

	        lists = ['months', 'monthsShort', 'weekdays', 'weekdaysShort', 'weekdaysMin'];

	    // Pick the first defined of two or three arguments. dfl comes from
	    // default.
	    function dfl(a, b, c) {
	        switch (arguments.length) {
	            case 2: return a != null ? a : b;
	            case 3: return a != null ? a : b != null ? b : c;
	            default: throw new Error('Implement me');
	        }
	    }

	    function hasOwnProp(a, b) {
	        return hasOwnProperty.call(a, b);
	    }

	    function defaultParsingFlags() {
	        // We need to deep clone this object, and es5 standard is not very
	        // helpful.
	        return {
	            empty : false,
	            unusedTokens : [],
	            unusedInput : [],
	            overflow : -2,
	            charsLeftOver : 0,
	            nullInput : false,
	            invalidMonth : null,
	            invalidFormat : false,
	            userInvalidated : false,
	            iso: false
	        };
	    }

	    function printMsg(msg) {
	        if (moment.suppressDeprecationWarnings === false &&
	                typeof console !== 'undefined' && console.warn) {
	            console.warn('Deprecation warning: ' + msg);
	        }
	    }

	    function deprecate(msg, fn) {
	        var firstTime = true;
	        return extend(function () {
	            if (firstTime) {
	                printMsg(msg);
	                firstTime = false;
	            }
	            return fn.apply(this, arguments);
	        }, fn);
	    }

	    function deprecateSimple(name, msg) {
	        if (!deprecations[name]) {
	            printMsg(msg);
	            deprecations[name] = true;
	        }
	    }

	    function padToken(func, count) {
	        return function (a) {
	            return leftZeroFill(func.call(this, a), count);
	        };
	    }
	    function ordinalizeToken(func, period) {
	        return function (a) {
	            return this.localeData().ordinal(func.call(this, a), period);
	        };
	    }

	    while (ordinalizeTokens.length) {
	        i = ordinalizeTokens.pop();
	        formatTokenFunctions[i + 'o'] = ordinalizeToken(formatTokenFunctions[i], i);
	    }
	    while (paddedTokens.length) {
	        i = paddedTokens.pop();
	        formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);
	    }
	    formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);


	    /************************************
	        Constructors
	    ************************************/

	    function Locale() {
	    }

	    // Moment prototype object
	    function Moment(config, skipOverflow) {
	        if (skipOverflow !== false) {
	            checkOverflow(config);
	        }
	        copyConfig(this, config);
	        this._d = new Date(+config._d);
	    }

	    // Duration Constructor
	    function Duration(duration) {
	        var normalizedInput = normalizeObjectUnits(duration),
	            years = normalizedInput.year || 0,
	            quarters = normalizedInput.quarter || 0,
	            months = normalizedInput.month || 0,
	            weeks = normalizedInput.week || 0,
	            days = normalizedInput.day || 0,
	            hours = normalizedInput.hour || 0,
	            minutes = normalizedInput.minute || 0,
	            seconds = normalizedInput.second || 0,
	            milliseconds = normalizedInput.millisecond || 0;

	        // representation for dateAddRemove
	        this._milliseconds = +milliseconds +
	            seconds * 1e3 + // 1000
	            minutes * 6e4 + // 1000 * 60
	            hours * 36e5; // 1000 * 60 * 60
	        // Because of dateAddRemove treats 24 hours as different from a
	        // day when working around DST, we need to store them separately
	        this._days = +days +
	            weeks * 7;
	        // It is impossible translate months into days without knowing
	        // which months you are are talking about, so we have to store
	        // it separately.
	        this._months = +months +
	            quarters * 3 +
	            years * 12;

	        this._data = {};

	        this._locale = moment.localeData();

	        this._bubble();
	    }

	    /************************************
	        Helpers
	    ************************************/


	    function extend(a, b) {
	        for (var i in b) {
	            if (hasOwnProp(b, i)) {
	                a[i] = b[i];
	            }
	        }

	        if (hasOwnProp(b, 'toString')) {
	            a.toString = b.toString;
	        }

	        if (hasOwnProp(b, 'valueOf')) {
	            a.valueOf = b.valueOf;
	        }

	        return a;
	    }

	    function copyConfig(to, from) {
	        var i, prop, val;

	        if (typeof from._isAMomentObject !== 'undefined') {
	            to._isAMomentObject = from._isAMomentObject;
	        }
	        if (typeof from._i !== 'undefined') {
	            to._i = from._i;
	        }
	        if (typeof from._f !== 'undefined') {
	            to._f = from._f;
	        }
	        if (typeof from._l !== 'undefined') {
	            to._l = from._l;
	        }
	        if (typeof from._strict !== 'undefined') {
	            to._strict = from._strict;
	        }
	        if (typeof from._tzm !== 'undefined') {
	            to._tzm = from._tzm;
	        }
	        if (typeof from._isUTC !== 'undefined') {
	            to._isUTC = from._isUTC;
	        }
	        if (typeof from._offset !== 'undefined') {
	            to._offset = from._offset;
	        }
	        if (typeof from._pf !== 'undefined') {
	            to._pf = from._pf;
	        }
	        if (typeof from._locale !== 'undefined') {
	            to._locale = from._locale;
	        }

	        if (momentProperties.length > 0) {
	            for (i in momentProperties) {
	                prop = momentProperties[i];
	                val = from[prop];
	                if (typeof val !== 'undefined') {
	                    to[prop] = val;
	                }
	            }
	        }

	        return to;
	    }

	    function absRound(number) {
	        if (number < 0) {
	            return Math.ceil(number);
	        } else {
	            return Math.floor(number);
	        }
	    }

	    // left zero fill a number
	    // see http://jsperf.com/left-zero-filling for performance comparison
	    function leftZeroFill(number, targetLength, forceSign) {
	        var output = '' + Math.abs(number),
	            sign = number >= 0;

	        while (output.length < targetLength) {
	            output = '0' + output;
	        }
	        return (sign ? (forceSign ? '+' : '') : '-') + output;
	    }

	    function positiveMomentsDifference(base, other) {
	        var res = {milliseconds: 0, months: 0};

	        res.months = other.month() - base.month() +
	            (other.year() - base.year()) * 12;
	        if (base.clone().add(res.months, 'M').isAfter(other)) {
	            --res.months;
	        }

	        res.milliseconds = +other - +(base.clone().add(res.months, 'M'));

	        return res;
	    }

	    function momentsDifference(base, other) {
	        var res;
	        other = makeAs(other, base);
	        if (base.isBefore(other)) {
	            res = positiveMomentsDifference(base, other);
	        } else {
	            res = positiveMomentsDifference(other, base);
	            res.milliseconds = -res.milliseconds;
	            res.months = -res.months;
	        }

	        return res;
	    }

	    // TODO: remove 'name' arg after deprecation is removed
	    function createAdder(direction, name) {
	        return function (val, period) {
	            var dur, tmp;
	            //invert the arguments, but complain about it
	            if (period !== null && !isNaN(+period)) {
	                deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
	                tmp = val; val = period; period = tmp;
	            }

	            val = typeof val === 'string' ? +val : val;
	            dur = moment.duration(val, period);
	            addOrSubtractDurationFromMoment(this, dur, direction);
	            return this;
	        };
	    }

	    function addOrSubtractDurationFromMoment(mom, duration, isAdding, updateOffset) {
	        var milliseconds = duration._milliseconds,
	            days = duration._days,
	            months = duration._months;
	        updateOffset = updateOffset == null ? true : updateOffset;

	        if (milliseconds) {
	            mom._d.setTime(+mom._d + milliseconds * isAdding);
	        }
	        if (days) {
	            rawSetter(mom, 'Date', rawGetter(mom, 'Date') + days * isAdding);
	        }
	        if (months) {
	            rawMonthSetter(mom, rawGetter(mom, 'Month') + months * isAdding);
	        }
	        if (updateOffset) {
	            moment.updateOffset(mom, days || months);
	        }
	    }

	    // check if is an array
	    function isArray(input) {
	        return Object.prototype.toString.call(input) === '[object Array]';
	    }

	    function isDate(input) {
	        return Object.prototype.toString.call(input) === '[object Date]' ||
	            input instanceof Date;
	    }

	    // compare two arrays, return the number of differences
	    function compareArrays(array1, array2, dontConvert) {
	        var len = Math.min(array1.length, array2.length),
	            lengthDiff = Math.abs(array1.length - array2.length),
	            diffs = 0,
	            i;
	        for (i = 0; i < len; i++) {
	            if ((dontConvert && array1[i] !== array2[i]) ||
	                (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
	                diffs++;
	            }
	        }
	        return diffs + lengthDiff;
	    }

	    function normalizeUnits(units) {
	        if (units) {
	            var lowered = units.toLowerCase().replace(/(.)s$/, '$1');
	            units = unitAliases[units] || camelFunctions[lowered] || lowered;
	        }
	        return units;
	    }

	    function normalizeObjectUnits(inputObject) {
	        var normalizedInput = {},
	            normalizedProp,
	            prop;

	        for (prop in inputObject) {
	            if (hasOwnProp(inputObject, prop)) {
	                normalizedProp = normalizeUnits(prop);
	                if (normalizedProp) {
	                    normalizedInput[normalizedProp] = inputObject[prop];
	                }
	            }
	        }

	        return normalizedInput;
	    }

	    function makeList(field) {
	        var count, setter;

	        if (field.indexOf('week') === 0) {
	            count = 7;
	            setter = 'day';
	        }
	        else if (field.indexOf('month') === 0) {
	            count = 12;
	            setter = 'month';
	        }
	        else {
	            return;
	        }

	        moment[field] = function (format, index) {
	            var i, getter,
	                method = moment._locale[field],
	                results = [];

	            if (typeof format === 'number') {
	                index = format;
	                format = undefined;
	            }

	            getter = function (i) {
	                var m = moment().utc().set(setter, i);
	                return method.call(moment._locale, m, format || '');
	            };

	            if (index != null) {
	                return getter(index);
	            }
	            else {
	                for (i = 0; i < count; i++) {
	                    results.push(getter(i));
	                }
	                return results;
	            }
	        };
	    }

	    function toInt(argumentForCoercion) {
	        var coercedNumber = +argumentForCoercion,
	            value = 0;

	        if (coercedNumber !== 0 && isFinite(coercedNumber)) {
	            if (coercedNumber >= 0) {
	                value = Math.floor(coercedNumber);
	            } else {
	                value = Math.ceil(coercedNumber);
	            }
	        }

	        return value;
	    }

	    function daysInMonth(year, month) {
	        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
	    }

	    function weeksInYear(year, dow, doy) {
	        return weekOfYear(moment([year, 11, 31 + dow - doy]), dow, doy).week;
	    }

	    function daysInYear(year) {
	        return isLeapYear(year) ? 366 : 365;
	    }

	    function isLeapYear(year) {
	        return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
	    }

	    function checkOverflow(m) {
	        var overflow;
	        if (m._a && m._pf.overflow === -2) {
	            overflow =
	                m._a[MONTH] < 0 || m._a[MONTH] > 11 ? MONTH :
	                m._a[DATE] < 1 || m._a[DATE] > daysInMonth(m._a[YEAR], m._a[MONTH]) ? DATE :
	                m._a[HOUR] < 0 || m._a[HOUR] > 23 ? HOUR :
	                m._a[MINUTE] < 0 || m._a[MINUTE] > 59 ? MINUTE :
	                m._a[SECOND] < 0 || m._a[SECOND] > 59 ? SECOND :
	                m._a[MILLISECOND] < 0 || m._a[MILLISECOND] > 999 ? MILLISECOND :
	                -1;

	            if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
	                overflow = DATE;
	            }

	            m._pf.overflow = overflow;
	        }
	    }

	    function isValid(m) {
	        if (m._isValid == null) {
	            m._isValid = !isNaN(m._d.getTime()) &&
	                m._pf.overflow < 0 &&
	                !m._pf.empty &&
	                !m._pf.invalidMonth &&
	                !m._pf.nullInput &&
	                !m._pf.invalidFormat &&
	                !m._pf.userInvalidated;

	            if (m._strict) {
	                m._isValid = m._isValid &&
	                    m._pf.charsLeftOver === 0 &&
	                    m._pf.unusedTokens.length === 0;
	            }
	        }
	        return m._isValid;
	    }

	    function normalizeLocale(key) {
	        return key ? key.toLowerCase().replace('_', '-') : key;
	    }

	    // pick the locale from the array
	    // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
	    // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
	    function chooseLocale(names) {
	        var i = 0, j, next, locale, split;

	        while (i < names.length) {
	            split = normalizeLocale(names[i]).split('-');
	            j = split.length;
	            next = normalizeLocale(names[i + 1]);
	            next = next ? next.split('-') : null;
	            while (j > 0) {
	                locale = loadLocale(split.slice(0, j).join('-'));
	                if (locale) {
	                    return locale;
	                }
	                if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
	                    //the next array item is better than a shallower substring of this one
	                    break;
	                }
	                j--;
	            }
	            i++;
	        }
	        return null;
	    }

	    function loadLocale(name) {
	        var oldLocale = null;
	        if (!locales[name] && hasModule) {
	            try {
	                oldLocale = moment.locale();
	                __webpack_require__(80)("./" + name);
	                // because defineLocale currently also sets the global locale, we want to undo that for lazy loaded locales
	                moment.locale(oldLocale);
	            } catch (e) { }
	        }
	        return locales[name];
	    }

	    // Return a moment from input, that is local/utc/zone equivalent to model.
	    function makeAs(input, model) {
	        return model._isUTC ? moment(input).zone(model._offset || 0) :
	            moment(input).local();
	    }

	    /************************************
	        Locale
	    ************************************/


	    extend(Locale.prototype, {

	        set : function (config) {
	            var prop, i;
	            for (i in config) {
	                prop = config[i];
	                if (typeof prop === 'function') {
	                    this[i] = prop;
	                } else {
	                    this['_' + i] = prop;
	                }
	            }
	        },

	        _months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
	        months : function (m) {
	            return this._months[m.month()];
	        },

	        _monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
	        monthsShort : function (m) {
	            return this._monthsShort[m.month()];
	        },

	        monthsParse : function (monthName) {
	            var i, mom, regex;

	            if (!this._monthsParse) {
	                this._monthsParse = [];
	            }

	            for (i = 0; i < 12; i++) {
	                // make the regex if we don't have it already
	                if (!this._monthsParse[i]) {
	                    mom = moment.utc([2000, i]);
	                    regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
	                    this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
	                }
	                // test the regex
	                if (this._monthsParse[i].test(monthName)) {
	                    return i;
	                }
	            }
	        },

	        _weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
	        weekdays : function (m) {
	            return this._weekdays[m.day()];
	        },

	        _weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
	        weekdaysShort : function (m) {
	            return this._weekdaysShort[m.day()];
	        },

	        _weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
	        weekdaysMin : function (m) {
	            return this._weekdaysMin[m.day()];
	        },

	        weekdaysParse : function (weekdayName) {
	            var i, mom, regex;

	            if (!this._weekdaysParse) {
	                this._weekdaysParse = [];
	            }

	            for (i = 0; i < 7; i++) {
	                // make the regex if we don't have it already
	                if (!this._weekdaysParse[i]) {
	                    mom = moment([2000, 1]).day(i);
	                    regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
	                    this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
	                }
	                // test the regex
	                if (this._weekdaysParse[i].test(weekdayName)) {
	                    return i;
	                }
	            }
	        },

	        _longDateFormat : {
	            LT : 'h:mm A',
	            L : 'MM/DD/YYYY',
	            LL : 'MMMM D, YYYY',
	            LLL : 'MMMM D, YYYY LT',
	            LLLL : 'dddd, MMMM D, YYYY LT'
	        },
	        longDateFormat : function (key) {
	            var output = this._longDateFormat[key];
	            if (!output && this._longDateFormat[key.toUpperCase()]) {
	                output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
	                    return val.slice(1);
	                });
	                this._longDateFormat[key] = output;
	            }
	            return output;
	        },

	        isPM : function (input) {
	            // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
	            // Using charAt should be more compatible.
	            return ((input + '').toLowerCase().charAt(0) === 'p');
	        },

	        _meridiemParse : /[ap]\.?m?\.?/i,
	        meridiem : function (hours, minutes, isLower) {
	            if (hours > 11) {
	                return isLower ? 'pm' : 'PM';
	            } else {
	                return isLower ? 'am' : 'AM';
	            }
	        },

	        _calendar : {
	            sameDay : '[Today at] LT',
	            nextDay : '[Tomorrow at] LT',
	            nextWeek : 'dddd [at] LT',
	            lastDay : '[Yesterday at] LT',
	            lastWeek : '[Last] dddd [at] LT',
	            sameElse : 'L'
	        },
	        calendar : function (key, mom) {
	            var output = this._calendar[key];
	            return typeof output === 'function' ? output.apply(mom) : output;
	        },

	        _relativeTime : {
	            future : 'in %s',
	            past : '%s ago',
	            s : 'a few seconds',
	            m : 'a minute',
	            mm : '%d minutes',
	            h : 'an hour',
	            hh : '%d hours',
	            d : 'a day',
	            dd : '%d days',
	            M : 'a month',
	            MM : '%d months',
	            y : 'a year',
	            yy : '%d years'
	        },

	        relativeTime : function (number, withoutSuffix, string, isFuture) {
	            var output = this._relativeTime[string];
	            return (typeof output === 'function') ?
	                output(number, withoutSuffix, string, isFuture) :
	                output.replace(/%d/i, number);
	        },

	        pastFuture : function (diff, output) {
	            var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
	            return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
	        },

	        ordinal : function (number) {
	            return this._ordinal.replace('%d', number);
	        },
	        _ordinal : '%d',

	        preparse : function (string) {
	            return string;
	        },

	        postformat : function (string) {
	            return string;
	        },

	        week : function (mom) {
	            return weekOfYear(mom, this._week.dow, this._week.doy).week;
	        },

	        _week : {
	            dow : 0, // Sunday is the first day of the week.
	            doy : 6  // The week that contains Jan 1st is the first week of the year.
	        },

	        _invalidDate: 'Invalid date',
	        invalidDate: function () {
	            return this._invalidDate;
	        }
	    });

	    /************************************
	        Formatting
	    ************************************/


	    function removeFormattingTokens(input) {
	        if (input.match(/\[[\s\S]/)) {
	            return input.replace(/^\[|\]$/g, '');
	        }
	        return input.replace(/\\/g, '');
	    }

	    function makeFormatFunction(format) {
	        var array = format.match(formattingTokens), i, length;

	        for (i = 0, length = array.length; i < length; i++) {
	            if (formatTokenFunctions[array[i]]) {
	                array[i] = formatTokenFunctions[array[i]];
	            } else {
	                array[i] = removeFormattingTokens(array[i]);
	            }
	        }

	        return function (mom) {
	            var output = '';
	            for (i = 0; i < length; i++) {
	                output += array[i] instanceof Function ? array[i].call(mom, format) : array[i];
	            }
	            return output;
	        };
	    }

	    // format date using native date object
	    function formatMoment(m, format) {
	        if (!m.isValid()) {
	            return m.localeData().invalidDate();
	        }

	        format = expandFormat(format, m.localeData());

	        if (!formatFunctions[format]) {
	            formatFunctions[format] = makeFormatFunction(format);
	        }

	        return formatFunctions[format](m);
	    }

	    function expandFormat(format, locale) {
	        var i = 5;

	        function replaceLongDateFormatTokens(input) {
	            return locale.longDateFormat(input) || input;
	        }

	        localFormattingTokens.lastIndex = 0;
	        while (i >= 0 && localFormattingTokens.test(format)) {
	            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
	            localFormattingTokens.lastIndex = 0;
	            i -= 1;
	        }

	        return format;
	    }


	    /************************************
	        Parsing
	    ************************************/


	    // get the regex to find the next token
	    function getParseRegexForToken(token, config) {
	        var a, strict = config._strict;
	        switch (token) {
	        case 'Q':
	            return parseTokenOneDigit;
	        case 'DDDD':
	            return parseTokenThreeDigits;
	        case 'YYYY':
	        case 'GGGG':
	        case 'gggg':
	            return strict ? parseTokenFourDigits : parseTokenOneToFourDigits;
	        case 'Y':
	        case 'G':
	        case 'g':
	            return parseTokenSignedNumber;
	        case 'YYYYYY':
	        case 'YYYYY':
	        case 'GGGGG':
	        case 'ggggg':
	            return strict ? parseTokenSixDigits : parseTokenOneToSixDigits;
	        case 'S':
	            if (strict) {
	                return parseTokenOneDigit;
	            }
	            /* falls through */
	        case 'SS':
	            if (strict) {
	                return parseTokenTwoDigits;
	            }
	            /* falls through */
	        case 'SSS':
	            if (strict) {
	                return parseTokenThreeDigits;
	            }
	            /* falls through */
	        case 'DDD':
	            return parseTokenOneToThreeDigits;
	        case 'MMM':
	        case 'MMMM':
	        case 'dd':
	        case 'ddd':
	        case 'dddd':
	            return parseTokenWord;
	        case 'a':
	        case 'A':
	            return config._locale._meridiemParse;
	        case 'X':
	            return parseTokenTimestampMs;
	        case 'Z':
	        case 'ZZ':
	            return parseTokenTimezone;
	        case 'T':
	            return parseTokenT;
	        case 'SSSS':
	            return parseTokenDigits;
	        case 'MM':
	        case 'DD':
	        case 'YY':
	        case 'GG':
	        case 'gg':
	        case 'HH':
	        case 'hh':
	        case 'mm':
	        case 'ss':
	        case 'ww':
	        case 'WW':
	            return strict ? parseTokenTwoDigits : parseTokenOneOrTwoDigits;
	        case 'M':
	        case 'D':
	        case 'd':
	        case 'H':
	        case 'h':
	        case 'm':
	        case 's':
	        case 'w':
	        case 'W':
	        case 'e':
	        case 'E':
	            return parseTokenOneOrTwoDigits;
	        case 'Do':
	            return parseTokenOrdinal;
	        default :
	            a = new RegExp(regexpEscape(unescapeFormat(token.replace('\\', '')), 'i'));
	            return a;
	        }
	    }

	    function timezoneMinutesFromString(string) {
	        string = string || '';
	        var possibleTzMatches = (string.match(parseTokenTimezone) || []),
	            tzChunk = possibleTzMatches[possibleTzMatches.length - 1] || [],
	            parts = (tzChunk + '').match(parseTimezoneChunker) || ['-', 0, 0],
	            minutes = +(parts[1] * 60) + toInt(parts[2]);

	        return parts[0] === '+' ? -minutes : minutes;
	    }

	    // function to convert string input to date
	    function addTimeToArrayFromToken(token, input, config) {
	        var a, datePartArray = config._a;

	        switch (token) {
	        // QUARTER
	        case 'Q':
	            if (input != null) {
	                datePartArray[MONTH] = (toInt(input) - 1) * 3;
	            }
	            break;
	        // MONTH
	        case 'M' : // fall through to MM
	        case 'MM' :
	            if (input != null) {
	                datePartArray[MONTH] = toInt(input) - 1;
	            }
	            break;
	        case 'MMM' : // fall through to MMMM
	        case 'MMMM' :
	            a = config._locale.monthsParse(input);
	            // if we didn't find a month name, mark the date as invalid.
	            if (a != null) {
	                datePartArray[MONTH] = a;
	            } else {
	                config._pf.invalidMonth = input;
	            }
	            break;
	        // DAY OF MONTH
	        case 'D' : // fall through to DD
	        case 'DD' :
	            if (input != null) {
	                datePartArray[DATE] = toInt(input);
	            }
	            break;
	        case 'Do' :
	            if (input != null) {
	                datePartArray[DATE] = toInt(parseInt(input, 10));
	            }
	            break;
	        // DAY OF YEAR
	        case 'DDD' : // fall through to DDDD
	        case 'DDDD' :
	            if (input != null) {
	                config._dayOfYear = toInt(input);
	            }

	            break;
	        // YEAR
	        case 'YY' :
	            datePartArray[YEAR] = moment.parseTwoDigitYear(input);
	            break;
	        case 'YYYY' :
	        case 'YYYYY' :
	        case 'YYYYYY' :
	            datePartArray[YEAR] = toInt(input);
	            break;
	        // AM / PM
	        case 'a' : // fall through to A
	        case 'A' :
	            config._isPm = config._locale.isPM(input);
	            break;
	        // 24 HOUR
	        case 'H' : // fall through to hh
	        case 'HH' : // fall through to hh
	        case 'h' : // fall through to hh
	        case 'hh' :
	            datePartArray[HOUR] = toInt(input);
	            break;
	        // MINUTE
	        case 'm' : // fall through to mm
	        case 'mm' :
	            datePartArray[MINUTE] = toInt(input);
	            break;
	        // SECOND
	        case 's' : // fall through to ss
	        case 'ss' :
	            datePartArray[SECOND] = toInt(input);
	            break;
	        // MILLISECOND
	        case 'S' :
	        case 'SS' :
	        case 'SSS' :
	        case 'SSSS' :
	            datePartArray[MILLISECOND] = toInt(('0.' + input) * 1000);
	            break;
	        // UNIX TIMESTAMP WITH MS
	        case 'X':
	            config._d = new Date(parseFloat(input) * 1000);
	            break;
	        // TIMEZONE
	        case 'Z' : // fall through to ZZ
	        case 'ZZ' :
	            config._useUTC = true;
	            config._tzm = timezoneMinutesFromString(input);
	            break;
	        // WEEKDAY - human
	        case 'dd':
	        case 'ddd':
	        case 'dddd':
	            a = config._locale.weekdaysParse(input);
	            // if we didn't get a weekday name, mark the date as invalid
	            if (a != null) {
	                config._w = config._w || {};
	                config._w['d'] = a;
	            } else {
	                config._pf.invalidWeekday = input;
	            }
	            break;
	        // WEEK, WEEK DAY - numeric
	        case 'w':
	        case 'ww':
	        case 'W':
	        case 'WW':
	        case 'd':
	        case 'e':
	        case 'E':
	            token = token.substr(0, 1);
	            /* falls through */
	        case 'gggg':
	        case 'GGGG':
	        case 'GGGGG':
	            token = token.substr(0, 2);
	            if (input) {
	                config._w = config._w || {};
	                config._w[token] = toInt(input);
	            }
	            break;
	        case 'gg':
	        case 'GG':
	            config._w = config._w || {};
	            config._w[token] = moment.parseTwoDigitYear(input);
	        }
	    }

	    function dayOfYearFromWeekInfo(config) {
	        var w, weekYear, week, weekday, dow, doy, temp;

	        w = config._w;
	        if (w.GG != null || w.W != null || w.E != null) {
	            dow = 1;
	            doy = 4;

	            // TODO: We need to take the current isoWeekYear, but that depends on
	            // how we interpret now (local, utc, fixed offset). So create
	            // a now version of current config (take local/utc/offset flags, and
	            // create now).
	            weekYear = dfl(w.GG, config._a[YEAR], weekOfYear(moment(), 1, 4).year);
	            week = dfl(w.W, 1);
	            weekday = dfl(w.E, 1);
	        } else {
	            dow = config._locale._week.dow;
	            doy = config._locale._week.doy;

	            weekYear = dfl(w.gg, config._a[YEAR], weekOfYear(moment(), dow, doy).year);
	            week = dfl(w.w, 1);

	            if (w.d != null) {
	                // weekday -- low day numbers are considered next week
	                weekday = w.d;
	                if (weekday < dow) {
	                    ++week;
	                }
	            } else if (w.e != null) {
	                // local weekday -- counting starts from begining of week
	                weekday = w.e + dow;
	            } else {
	                // default to begining of week
	                weekday = dow;
	            }
	        }
	        temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);

	        config._a[YEAR] = temp.year;
	        config._dayOfYear = temp.dayOfYear;
	    }

	    // convert an array to a date.
	    // the array should mirror the parameters below
	    // note: all values past the year are optional and will default to the lowest possible value.
	    // [year, month, day , hour, minute, second, millisecond]
	    function dateFromConfig(config) {
	        var i, date, input = [], currentDate, yearToUse;

	        if (config._d) {
	            return;
	        }

	        currentDate = currentDateArray(config);

	        //compute day of the year from weeks and weekdays
	        if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
	            dayOfYearFromWeekInfo(config);
	        }

	        //if the day of the year is set, figure out what it is
	        if (config._dayOfYear) {
	            yearToUse = dfl(config._a[YEAR], currentDate[YEAR]);

	            if (config._dayOfYear > daysInYear(yearToUse)) {
	                config._pf._overflowDayOfYear = true;
	            }

	            date = makeUTCDate(yearToUse, 0, config._dayOfYear);
	            config._a[MONTH] = date.getUTCMonth();
	            config._a[DATE] = date.getUTCDate();
	        }

	        // Default to current date.
	        // * if no year, month, day of month are given, default to today
	        // * if day of month is given, default month and year
	        // * if month is given, default only year
	        // * if year is given, don't default anything
	        for (i = 0; i < 3 && config._a[i] == null; ++i) {
	            config._a[i] = input[i] = currentDate[i];
	        }

	        // Zero out whatever was not defaulted, including time
	        for (; i < 7; i++) {
	            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
	        }

	        config._d = (config._useUTC ? makeUTCDate : makeDate).apply(null, input);
	        // Apply timezone offset from input. The actual zone can be changed
	        // with parseZone.
	        if (config._tzm != null) {
	            config._d.setUTCMinutes(config._d.getUTCMinutes() + config._tzm);
	        }
	    }

	    function dateFromObject(config) {
	        var normalizedInput;

	        if (config._d) {
	            return;
	        }

	        normalizedInput = normalizeObjectUnits(config._i);
	        config._a = [
	            normalizedInput.year,
	            normalizedInput.month,
	            normalizedInput.day,
	            normalizedInput.hour,
	            normalizedInput.minute,
	            normalizedInput.second,
	            normalizedInput.millisecond
	        ];

	        dateFromConfig(config);
	    }

	    function currentDateArray(config) {
	        var now = new Date();
	        if (config._useUTC) {
	            return [
	                now.getUTCFullYear(),
	                now.getUTCMonth(),
	                now.getUTCDate()
	            ];
	        } else {
	            return [now.getFullYear(), now.getMonth(), now.getDate()];
	        }
	    }

	    // date from string and format string
	    function makeDateFromStringAndFormat(config) {
	        if (config._f === moment.ISO_8601) {
	            parseISO(config);
	            return;
	        }

	        config._a = [];
	        config._pf.empty = true;

	        // This array is used to make a Date, either with `new Date` or `Date.UTC`
	        var string = '' + config._i,
	            i, parsedInput, tokens, token, skipped,
	            stringLength = string.length,
	            totalParsedInputLength = 0;

	        tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];

	        for (i = 0; i < tokens.length; i++) {
	            token = tokens[i];
	            parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
	            if (parsedInput) {
	                skipped = string.substr(0, string.indexOf(parsedInput));
	                if (skipped.length > 0) {
	                    config._pf.unusedInput.push(skipped);
	                }
	                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
	                totalParsedInputLength += parsedInput.length;
	            }
	            // don't parse if it's not a known token
	            if (formatTokenFunctions[token]) {
	                if (parsedInput) {
	                    config._pf.empty = false;
	                }
	                else {
	                    config._pf.unusedTokens.push(token);
	                }
	                addTimeToArrayFromToken(token, parsedInput, config);
	            }
	            else if (config._strict && !parsedInput) {
	                config._pf.unusedTokens.push(token);
	            }
	        }

	        // add remaining unparsed input length to the string
	        config._pf.charsLeftOver = stringLength - totalParsedInputLength;
	        if (string.length > 0) {
	            config._pf.unusedInput.push(string);
	        }

	        // handle am pm
	        if (config._isPm && config._a[HOUR] < 12) {
	            config._a[HOUR] += 12;
	        }
	        // if is 12 am, change hours to 0
	        if (config._isPm === false && config._a[HOUR] === 12) {
	            config._a[HOUR] = 0;
	        }

	        dateFromConfig(config);
	        checkOverflow(config);
	    }

	    function unescapeFormat(s) {
	        return s.replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
	            return p1 || p2 || p3 || p4;
	        });
	    }

	    // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
	    function regexpEscape(s) {
	        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
	    }

	    // date from string and array of format strings
	    function makeDateFromStringAndArray(config) {
	        var tempConfig,
	            bestMoment,

	            scoreToBeat,
	            i,
	            currentScore;

	        if (config._f.length === 0) {
	            config._pf.invalidFormat = true;
	            config._d = new Date(NaN);
	            return;
	        }

	        for (i = 0; i < config._f.length; i++) {
	            currentScore = 0;
	            tempConfig = copyConfig({}, config);
	            if (config._useUTC != null) {
	                tempConfig._useUTC = config._useUTC;
	            }
	            tempConfig._pf = defaultParsingFlags();
	            tempConfig._f = config._f[i];
	            makeDateFromStringAndFormat(tempConfig);

	            if (!isValid(tempConfig)) {
	                continue;
	            }

	            // if there is any input that was not parsed add a penalty for that format
	            currentScore += tempConfig._pf.charsLeftOver;

	            //or tokens
	            currentScore += tempConfig._pf.unusedTokens.length * 10;

	            tempConfig._pf.score = currentScore;

	            if (scoreToBeat == null || currentScore < scoreToBeat) {
	                scoreToBeat = currentScore;
	                bestMoment = tempConfig;
	            }
	        }

	        extend(config, bestMoment || tempConfig);
	    }

	    // date from iso format
	    function parseISO(config) {
	        var i, l,
	            string = config._i,
	            match = isoRegex.exec(string);

	        if (match) {
	            config._pf.iso = true;
	            for (i = 0, l = isoDates.length; i < l; i++) {
	                if (isoDates[i][1].exec(string)) {
	                    // match[5] should be 'T' or undefined
	                    config._f = isoDates[i][0] + (match[6] || ' ');
	                    break;
	                }
	            }
	            for (i = 0, l = isoTimes.length; i < l; i++) {
	                if (isoTimes[i][1].exec(string)) {
	                    config._f += isoTimes[i][0];
	                    break;
	                }
	            }
	            if (string.match(parseTokenTimezone)) {
	                config._f += 'Z';
	            }
	            makeDateFromStringAndFormat(config);
	        } else {
	            config._isValid = false;
	        }
	    }

	    // date from iso format or fallback
	    function makeDateFromString(config) {
	        parseISO(config);
	        if (config._isValid === false) {
	            delete config._isValid;
	            moment.createFromInputFallback(config);
	        }
	    }

	    function map(arr, fn) {
	        var res = [], i;
	        for (i = 0; i < arr.length; ++i) {
	            res.push(fn(arr[i], i));
	        }
	        return res;
	    }

	    function makeDateFromInput(config) {
	        var input = config._i, matched;
	        if (input === undefined) {
	            config._d = new Date();
	        } else if (isDate(input)) {
	            config._d = new Date(+input);
	        } else if ((matched = aspNetJsonRegex.exec(input)) !== null) {
	            config._d = new Date(+matched[1]);
	        } else if (typeof input === 'string') {
	            makeDateFromString(config);
	        } else if (isArray(input)) {
	            config._a = map(input.slice(0), function (obj) {
	                return parseInt(obj, 10);
	            });
	            dateFromConfig(config);
	        } else if (typeof(input) === 'object') {
	            dateFromObject(config);
	        } else if (typeof(input) === 'number') {
	            // from milliseconds
	            config._d = new Date(input);
	        } else {
	            moment.createFromInputFallback(config);
	        }
	    }

	    function makeDate(y, m, d, h, M, s, ms) {
	        //can't just apply() to create a date:
	        //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
	        var date = new Date(y, m, d, h, M, s, ms);

	        //the date constructor doesn't accept years < 1970
	        if (y < 1970) {
	            date.setFullYear(y);
	        }
	        return date;
	    }

	    function makeUTCDate(y) {
	        var date = new Date(Date.UTC.apply(null, arguments));
	        if (y < 1970) {
	            date.setUTCFullYear(y);
	        }
	        return date;
	    }

	    function parseWeekday(input, locale) {
	        if (typeof input === 'string') {
	            if (!isNaN(input)) {
	                input = parseInt(input, 10);
	            }
	            else {
	                input = locale.weekdaysParse(input);
	                if (typeof input !== 'number') {
	                    return null;
	                }
	            }
	        }
	        return input;
	    }

	    /************************************
	        Relative Time
	    ************************************/


	    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
	    function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
	        return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
	    }

	    function relativeTime(posNegDuration, withoutSuffix, locale) {
	        var duration = moment.duration(posNegDuration).abs(),
	            seconds = round(duration.as('s')),
	            minutes = round(duration.as('m')),
	            hours = round(duration.as('h')),
	            days = round(duration.as('d')),
	            months = round(duration.as('M')),
	            years = round(duration.as('y')),

	            args = seconds < relativeTimeThresholds.s && ['s', seconds] ||
	                minutes === 1 && ['m'] ||
	                minutes < relativeTimeThresholds.m && ['mm', minutes] ||
	                hours === 1 && ['h'] ||
	                hours < relativeTimeThresholds.h && ['hh', hours] ||
	                days === 1 && ['d'] ||
	                days < relativeTimeThresholds.d && ['dd', days] ||
	                months === 1 && ['M'] ||
	                months < relativeTimeThresholds.M && ['MM', months] ||
	                years === 1 && ['y'] || ['yy', years];

	        args[2] = withoutSuffix;
	        args[3] = +posNegDuration > 0;
	        args[4] = locale;
	        return substituteTimeAgo.apply({}, args);
	    }


	    /************************************
	        Week of Year
	    ************************************/


	    // firstDayOfWeek       0 = sun, 6 = sat
	    //                      the day of the week that starts the week
	    //                      (usually sunday or monday)
	    // firstDayOfWeekOfYear 0 = sun, 6 = sat
	    //                      the first week is the week that contains the first
	    //                      of this day of the week
	    //                      (eg. ISO weeks use thursday (4))
	    function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
	        var end = firstDayOfWeekOfYear - firstDayOfWeek,
	            daysToDayOfWeek = firstDayOfWeekOfYear - mom.day(),
	            adjustedMoment;


	        if (daysToDayOfWeek > end) {
	            daysToDayOfWeek -= 7;
	        }

	        if (daysToDayOfWeek < end - 7) {
	            daysToDayOfWeek += 7;
	        }

	        adjustedMoment = moment(mom).add(daysToDayOfWeek, 'd');
	        return {
	            week: Math.ceil(adjustedMoment.dayOfYear() / 7),
	            year: adjustedMoment.year()
	        };
	    }

	    //http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
	    function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
	        var d = makeUTCDate(year, 0, 1).getUTCDay(), daysToAdd, dayOfYear;

	        d = d === 0 ? 7 : d;
	        weekday = weekday != null ? weekday : firstDayOfWeek;
	        daysToAdd = firstDayOfWeek - d + (d > firstDayOfWeekOfYear ? 7 : 0) - (d < firstDayOfWeek ? 7 : 0);
	        dayOfYear = 7 * (week - 1) + (weekday - firstDayOfWeek) + daysToAdd + 1;

	        return {
	            year: dayOfYear > 0 ? year : year - 1,
	            dayOfYear: dayOfYear > 0 ?  dayOfYear : daysInYear(year - 1) + dayOfYear
	        };
	    }

	    /************************************
	        Top Level Functions
	    ************************************/

	    function makeMoment(config) {
	        var input = config._i,
	            format = config._f;

	        config._locale = config._locale || moment.localeData(config._l);

	        if (input === null || (format === undefined && input === '')) {
	            return moment.invalid({nullInput: true});
	        }

	        if (typeof input === 'string') {
	            config._i = input = config._locale.preparse(input);
	        }

	        if (moment.isMoment(input)) {
	            return new Moment(input, true);
	        } else if (format) {
	            if (isArray(format)) {
	                makeDateFromStringAndArray(config);
	            } else {
	                makeDateFromStringAndFormat(config);
	            }
	        } else {
	            makeDateFromInput(config);
	        }

	        return new Moment(config);
	    }

	    moment = function (input, format, locale, strict) {
	        var c;

	        if (typeof(locale) === 'boolean') {
	            strict = locale;
	            locale = undefined;
	        }
	        // object construction must be done this way.
	        // https://github.com/moment/moment/issues/1423
	        c = {};
	        c._isAMomentObject = true;
	        c._i = input;
	        c._f = format;
	        c._l = locale;
	        c._strict = strict;
	        c._isUTC = false;
	        c._pf = defaultParsingFlags();

	        return makeMoment(c);
	    };

	    moment.suppressDeprecationWarnings = false;

	    moment.createFromInputFallback = deprecate(
	        'moment construction falls back to js Date. This is ' +
	        'discouraged and will be removed in upcoming major ' +
	        'release. Please refer to ' +
	        'https://github.com/moment/moment/issues/1407 for more info.',
	        function (config) {
	            config._d = new Date(config._i);
	        }
	    );

	    // Pick a moment m from moments so that m[fn](other) is true for all
	    // other. This relies on the function fn to be transitive.
	    //
	    // moments should either be an array of moment objects or an array, whose
	    // first element is an array of moment objects.
	    function pickBy(fn, moments) {
	        var res, i;
	        if (moments.length === 1 && isArray(moments[0])) {
	            moments = moments[0];
	        }
	        if (!moments.length) {
	            return moment();
	        }
	        res = moments[0];
	        for (i = 1; i < moments.length; ++i) {
	            if (moments[i][fn](res)) {
	                res = moments[i];
	            }
	        }
	        return res;
	    }

	    moment.min = function () {
	        var args = [].slice.call(arguments, 0);

	        return pickBy('isBefore', args);
	    };

	    moment.max = function () {
	        var args = [].slice.call(arguments, 0);

	        return pickBy('isAfter', args);
	    };

	    // creating with utc
	    moment.utc = function (input, format, locale, strict) {
	        var c;

	        if (typeof(locale) === 'boolean') {
	            strict = locale;
	            locale = undefined;
	        }
	        // object construction must be done this way.
	        // https://github.com/moment/moment/issues/1423
	        c = {};
	        c._isAMomentObject = true;
	        c._useUTC = true;
	        c._isUTC = true;
	        c._l = locale;
	        c._i = input;
	        c._f = format;
	        c._strict = strict;
	        c._pf = defaultParsingFlags();

	        return makeMoment(c).utc();
	    };

	    // creating with unix timestamp (in seconds)
	    moment.unix = function (input) {
	        return moment(input * 1000);
	    };

	    // duration
	    moment.duration = function (input, key) {
	        var duration = input,
	            // matching against regexp is expensive, do it on demand
	            match = null,
	            sign,
	            ret,
	            parseIso,
	            diffRes;

	        if (moment.isDuration(input)) {
	            duration = {
	                ms: input._milliseconds,
	                d: input._days,
	                M: input._months
	            };
	        } else if (typeof input === 'number') {
	            duration = {};
	            if (key) {
	                duration[key] = input;
	            } else {
	                duration.milliseconds = input;
	            }
	        } else if (!!(match = aspNetTimeSpanJsonRegex.exec(input))) {
	            sign = (match[1] === '-') ? -1 : 1;
	            duration = {
	                y: 0,
	                d: toInt(match[DATE]) * sign,
	                h: toInt(match[HOUR]) * sign,
	                m: toInt(match[MINUTE]) * sign,
	                s: toInt(match[SECOND]) * sign,
	                ms: toInt(match[MILLISECOND]) * sign
	            };
	        } else if (!!(match = isoDurationRegex.exec(input))) {
	            sign = (match[1] === '-') ? -1 : 1;
	            parseIso = function (inp) {
	                // We'd normally use ~~inp for this, but unfortunately it also
	                // converts floats to ints.
	                // inp may be undefined, so careful calling replace on it.
	                var res = inp && parseFloat(inp.replace(',', '.'));
	                // apply sign while we're at it
	                return (isNaN(res) ? 0 : res) * sign;
	            };
	            duration = {
	                y: parseIso(match[2]),
	                M: parseIso(match[3]),
	                d: parseIso(match[4]),
	                h: parseIso(match[5]),
	                m: parseIso(match[6]),
	                s: parseIso(match[7]),
	                w: parseIso(match[8])
	            };
	        } else if (typeof duration === 'object' &&
	                ('from' in duration || 'to' in duration)) {
	            diffRes = momentsDifference(moment(duration.from), moment(duration.to));

	            duration = {};
	            duration.ms = diffRes.milliseconds;
	            duration.M = diffRes.months;
	        }

	        ret = new Duration(duration);

	        if (moment.isDuration(input) && hasOwnProp(input, '_locale')) {
	            ret._locale = input._locale;
	        }

	        return ret;
	    };

	    // version number
	    moment.version = VERSION;

	    // default format
	    moment.defaultFormat = isoFormat;

	    // constant that refers to the ISO standard
	    moment.ISO_8601 = function () {};

	    // Plugins that add properties should also add the key here (null value),
	    // so we can properly clone ourselves.
	    moment.momentProperties = momentProperties;

	    // This function will be called whenever a moment is mutated.
	    // It is intended to keep the offset in sync with the timezone.
	    moment.updateOffset = function () {};

	    // This function allows you to set a threshold for relative time strings
	    moment.relativeTimeThreshold = function (threshold, limit) {
	        if (relativeTimeThresholds[threshold] === undefined) {
	            return false;
	        }
	        if (limit === undefined) {
	            return relativeTimeThresholds[threshold];
	        }
	        relativeTimeThresholds[threshold] = limit;
	        return true;
	    };

	    moment.lang = deprecate(
	        'moment.lang is deprecated. Use moment.locale instead.',
	        function (key, value) {
	            return moment.locale(key, value);
	        }
	    );

	    // This function will load locale and then set the global locale.  If
	    // no arguments are passed in, it will simply return the current global
	    // locale key.
	    moment.locale = function (key, values) {
	        var data;
	        if (key) {
	            if (typeof(values) !== 'undefined') {
	                data = moment.defineLocale(key, values);
	            }
	            else {
	                data = moment.localeData(key);
	            }

	            if (data) {
	                moment.duration._locale = moment._locale = data;
	            }
	        }

	        return moment._locale._abbr;
	    };

	    moment.defineLocale = function (name, values) {
	        if (values !== null) {
	            values.abbr = name;
	            if (!locales[name]) {
	                locales[name] = new Locale();
	            }
	            locales[name].set(values);

	            // backwards compat for now: also set the locale
	            moment.locale(name);

	            return locales[name];
	        } else {
	            // useful for testing
	            delete locales[name];
	            return null;
	        }
	    };

	    moment.langData = deprecate(
	        'moment.langData is deprecated. Use moment.localeData instead.',
	        function (key) {
	            return moment.localeData(key);
	        }
	    );

	    // returns locale data
	    moment.localeData = function (key) {
	        var locale;

	        if (key && key._locale && key._locale._abbr) {
	            key = key._locale._abbr;
	        }

	        if (!key) {
	            return moment._locale;
	        }

	        if (!isArray(key)) {
	            //short-circuit everything else
	            locale = loadLocale(key);
	            if (locale) {
	                return locale;
	            }
	            key = [key];
	        }

	        return chooseLocale(key);
	    };

	    // compare moment object
	    moment.isMoment = function (obj) {
	        return obj instanceof Moment ||
	            (obj != null && hasOwnProp(obj, '_isAMomentObject'));
	    };

	    // for typechecking Duration objects
	    moment.isDuration = function (obj) {
	        return obj instanceof Duration;
	    };

	    for (i = lists.length - 1; i >= 0; --i) {
	        makeList(lists[i]);
	    }

	    moment.normalizeUnits = function (units) {
	        return normalizeUnits(units);
	    };

	    moment.invalid = function (flags) {
	        var m = moment.utc(NaN);
	        if (flags != null) {
	            extend(m._pf, flags);
	        }
	        else {
	            m._pf.userInvalidated = true;
	        }

	        return m;
	    };

	    moment.parseZone = function () {
	        return moment.apply(null, arguments).parseZone();
	    };

	    moment.parseTwoDigitYear = function (input) {
	        return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
	    };

	    /************************************
	        Moment Prototype
	    ************************************/


	    extend(moment.fn = Moment.prototype, {

	        clone : function () {
	            return moment(this);
	        },

	        valueOf : function () {
	            return +this._d + ((this._offset || 0) * 60000);
	        },

	        unix : function () {
	            return Math.floor(+this / 1000);
	        },

	        toString : function () {
	            return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
	        },

	        toDate : function () {
	            return this._offset ? new Date(+this) : this._d;
	        },

	        toISOString : function () {
	            var m = moment(this).utc();
	            if (0 < m.year() && m.year() <= 9999) {
	                return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
	            } else {
	                return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
	            }
	        },

	        toArray : function () {
	            var m = this;
	            return [
	                m.year(),
	                m.month(),
	                m.date(),
	                m.hours(),
	                m.minutes(),
	                m.seconds(),
	                m.milliseconds()
	            ];
	        },

	        isValid : function () {
	            return isValid(this);
	        },

	        isDSTShifted : function () {
	            if (this._a) {
	                return this.isValid() && compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray()) > 0;
	            }

	            return false;
	        },

	        parsingFlags : function () {
	            return extend({}, this._pf);
	        },

	        invalidAt: function () {
	            return this._pf.overflow;
	        },

	        utc : function (keepLocalTime) {
	            return this.zone(0, keepLocalTime);
	        },

	        local : function (keepLocalTime) {
	            if (this._isUTC) {
	                this.zone(0, keepLocalTime);
	                this._isUTC = false;

	                if (keepLocalTime) {
	                    this.add(this._dateTzOffset(), 'm');
	                }
	            }
	            return this;
	        },

	        format : function (inputString) {
	            var output = formatMoment(this, inputString || moment.defaultFormat);
	            return this.localeData().postformat(output);
	        },

	        add : createAdder(1, 'add'),

	        subtract : createAdder(-1, 'subtract'),

	        diff : function (input, units, asFloat) {
	            var that = makeAs(input, this),
	                zoneDiff = (this.zone() - that.zone()) * 6e4,
	                diff, output, daysAdjust;

	            units = normalizeUnits(units);

	            if (units === 'year' || units === 'month') {
	                // average number of days in the months in the given dates
	                diff = (this.daysInMonth() + that.daysInMonth()) * 432e5; // 24 * 60 * 60 * 1000 / 2
	                // difference in months
	                output = ((this.year() - that.year()) * 12) + (this.month() - that.month());
	                // adjust by taking difference in days, average number of days
	                // and dst in the given months.
	                daysAdjust = (this - moment(this).startOf('month')) -
	                    (that - moment(that).startOf('month'));
	                // same as above but with zones, to negate all dst
	                daysAdjust -= ((this.zone() - moment(this).startOf('month').zone()) -
	                        (that.zone() - moment(that).startOf('month').zone())) * 6e4;
	                output += daysAdjust / diff;
	                if (units === 'year') {
	                    output = output / 12;
	                }
	            } else {
	                diff = (this - that);
	                output = units === 'second' ? diff / 1e3 : // 1000
	                    units === 'minute' ? diff / 6e4 : // 1000 * 60
	                    units === 'hour' ? diff / 36e5 : // 1000 * 60 * 60
	                    units === 'day' ? (diff - zoneDiff) / 864e5 : // 1000 * 60 * 60 * 24, negate dst
	                    units === 'week' ? (diff - zoneDiff) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst
	                    diff;
	            }
	            return asFloat ? output : absRound(output);
	        },

	        from : function (time, withoutSuffix) {
	            return moment.duration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
	        },

	        fromNow : function (withoutSuffix) {
	            return this.from(moment(), withoutSuffix);
	        },

	        calendar : function (time) {
	            // We want to compare the start of today, vs this.
	            // Getting start-of-today depends on whether we're zone'd or not.
	            var now = time || moment(),
	                sod = makeAs(now, this).startOf('day'),
	                diff = this.diff(sod, 'days', true),
	                format = diff < -6 ? 'sameElse' :
	                    diff < -1 ? 'lastWeek' :
	                    diff < 0 ? 'lastDay' :
	                    diff < 1 ? 'sameDay' :
	                    diff < 2 ? 'nextDay' :
	                    diff < 7 ? 'nextWeek' : 'sameElse';
	            return this.format(this.localeData().calendar(format, this));
	        },

	        isLeapYear : function () {
	            return isLeapYear(this.year());
	        },

	        isDST : function () {
	            return (this.zone() < this.clone().month(0).zone() ||
	                this.zone() < this.clone().month(5).zone());
	        },

	        day : function (input) {
	            var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
	            if (input != null) {
	                input = parseWeekday(input, this.localeData());
	                return this.add(input - day, 'd');
	            } else {
	                return day;
	            }
	        },

	        month : makeAccessor('Month', true),

	        startOf : function (units) {
	            units = normalizeUnits(units);
	            // the following switch intentionally omits break keywords
	            // to utilize falling through the cases.
	            switch (units) {
	            case 'year':
	                this.month(0);
	                /* falls through */
	            case 'quarter':
	            case 'month':
	                this.date(1);
	                /* falls through */
	            case 'week':
	            case 'isoWeek':
	            case 'day':
	                this.hours(0);
	                /* falls through */
	            case 'hour':
	                this.minutes(0);
	                /* falls through */
	            case 'minute':
	                this.seconds(0);
	                /* falls through */
	            case 'second':
	                this.milliseconds(0);
	                /* falls through */
	            }

	            // weeks are a special case
	            if (units === 'week') {
	                this.weekday(0);
	            } else if (units === 'isoWeek') {
	                this.isoWeekday(1);
	            }

	            // quarters are also special
	            if (units === 'quarter') {
	                this.month(Math.floor(this.month() / 3) * 3);
	            }

	            return this;
	        },

	        endOf: function (units) {
	            units = normalizeUnits(units);
	            return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');
	        },

	        isAfter: function (input, units) {
	            units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
	            if (units === 'millisecond') {
	                input = moment.isMoment(input) ? input : moment(input);
	                return +this > +input;
	            } else {
	                return +this.clone().startOf(units) > +moment(input).startOf(units);
	            }
	        },

	        isBefore: function (input, units) {
	            units = normalizeUnits(typeof units !== 'undefined' ? units : 'millisecond');
	            if (units === 'millisecond') {
	                input = moment.isMoment(input) ? input : moment(input);
	                return +this < +input;
	            } else {
	                return +this.clone().startOf(units) < +moment(input).startOf(units);
	            }
	        },

	        isSame: function (input, units) {
	            units = normalizeUnits(units || 'millisecond');
	            if (units === 'millisecond') {
	                input = moment.isMoment(input) ? input : moment(input);
	                return +this === +input;
	            } else {
	                return +this.clone().startOf(units) === +makeAs(input, this).startOf(units);
	            }
	        },

	        min: deprecate(
	                 'moment().min is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548',
	                 function (other) {
	                     other = moment.apply(null, arguments);
	                     return other < this ? this : other;
	                 }
	         ),

	        max: deprecate(
	                'moment().max is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548',
	                function (other) {
	                    other = moment.apply(null, arguments);
	                    return other > this ? this : other;
	                }
	        ),

	        // keepLocalTime = true means only change the timezone, without
	        // affecting the local hour. So 5:31:26 +0300 --[zone(2, true)]-->
	        // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist int zone
	        // +0200, so we adjust the time as needed, to be valid.
	        //
	        // Keeping the time actually adds/subtracts (one hour)
	        // from the actual represented time. That is why we call updateOffset
	        // a second time. In case it wants us to change the offset again
	        // _changeInProgress == true case, then we have to adjust, because
	        // there is no such time in the given timezone.
	        zone : function (input, keepLocalTime) {
	            var offset = this._offset || 0,
	                localAdjust;
	            if (input != null) {
	                if (typeof input === 'string') {
	                    input = timezoneMinutesFromString(input);
	                }
	                if (Math.abs(input) < 16) {
	                    input = input * 60;
	                }
	                if (!this._isUTC && keepLocalTime) {
	                    localAdjust = this._dateTzOffset();
	                }
	                this._offset = input;
	                this._isUTC = true;
	                if (localAdjust != null) {
	                    this.subtract(localAdjust, 'm');
	                }
	                if (offset !== input) {
	                    if (!keepLocalTime || this._changeInProgress) {
	                        addOrSubtractDurationFromMoment(this,
	                                moment.duration(offset - input, 'm'), 1, false);
	                    } else if (!this._changeInProgress) {
	                        this._changeInProgress = true;
	                        moment.updateOffset(this, true);
	                        this._changeInProgress = null;
	                    }
	                }
	            } else {
	                return this._isUTC ? offset : this._dateTzOffset();
	            }
	            return this;
	        },

	        zoneAbbr : function () {
	            return this._isUTC ? 'UTC' : '';
	        },

	        zoneName : function () {
	            return this._isUTC ? 'Coordinated Universal Time' : '';
	        },

	        parseZone : function () {
	            if (this._tzm) {
	                this.zone(this._tzm);
	            } else if (typeof this._i === 'string') {
	                this.zone(this._i);
	            }
	            return this;
	        },

	        hasAlignedHourOffset : function (input) {
	            if (!input) {
	                input = 0;
	            }
	            else {
	                input = moment(input).zone();
	            }

	            return (this.zone() - input) % 60 === 0;
	        },

	        daysInMonth : function () {
	            return daysInMonth(this.year(), this.month());
	        },

	        dayOfYear : function (input) {
	            var dayOfYear = round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5) + 1;
	            return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
	        },

	        quarter : function (input) {
	            return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
	        },

	        weekYear : function (input) {
	            var year = weekOfYear(this, this.localeData()._week.dow, this.localeData()._week.doy).year;
	            return input == null ? year : this.add((input - year), 'y');
	        },

	        isoWeekYear : function (input) {
	            var year = weekOfYear(this, 1, 4).year;
	            return input == null ? year : this.add((input - year), 'y');
	        },

	        week : function (input) {
	            var week = this.localeData().week(this);
	            return input == null ? week : this.add((input - week) * 7, 'd');
	        },

	        isoWeek : function (input) {
	            var week = weekOfYear(this, 1, 4).week;
	            return input == null ? week : this.add((input - week) * 7, 'd');
	        },

	        weekday : function (input) {
	            var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
	            return input == null ? weekday : this.add(input - weekday, 'd');
	        },

	        isoWeekday : function (input) {
	            // behaves the same as moment#day except
	            // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
	            // as a setter, sunday should belong to the previous week.
	            return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7);
	        },

	        isoWeeksInYear : function () {
	            return weeksInYear(this.year(), 1, 4);
	        },

	        weeksInYear : function () {
	            var weekInfo = this.localeData()._week;
	            return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
	        },

	        get : function (units) {
	            units = normalizeUnits(units);
	            return this[units]();
	        },

	        set : function (units, value) {
	            units = normalizeUnits(units);
	            if (typeof this[units] === 'function') {
	                this[units](value);
	            }
	            return this;
	        },

	        // If passed a locale key, it will set the locale for this
	        // instance.  Otherwise, it will return the locale configuration
	        // variables for this instance.
	        locale : function (key) {
	            var newLocaleData;

	            if (key === undefined) {
	                return this._locale._abbr;
	            } else {
	                newLocaleData = moment.localeData(key);
	                if (newLocaleData != null) {
	                    this._locale = newLocaleData;
	                }
	                return this;
	            }
	        },

	        lang : deprecate(
	            'moment().lang() is deprecated. Use moment().localeData() instead.',
	            function (key) {
	                if (key === undefined) {
	                    return this.localeData();
	                } else {
	                    return this.locale(key);
	                }
	            }
	        ),

	        localeData : function () {
	            return this._locale;
	        },

	        _dateTzOffset : function () {
	            // On Firefox.24 Date#getTimezoneOffset returns a floating point.
	            // https://github.com/moment/moment/pull/1871
	            return Math.round(this._d.getTimezoneOffset() / 15) * 15;
	        }
	    });

	    function rawMonthSetter(mom, value) {
	        var dayOfMonth;

	        // TODO: Move this out of here!
	        if (typeof value === 'string') {
	            value = mom.localeData().monthsParse(value);
	            // TODO: Another silent failure?
	            if (typeof value !== 'number') {
	                return mom;
	            }
	        }

	        dayOfMonth = Math.min(mom.date(),
	                daysInMonth(mom.year(), value));
	        mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
	        return mom;
	    }

	    function rawGetter(mom, unit) {
	        return mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]();
	    }

	    function rawSetter(mom, unit, value) {
	        if (unit === 'Month') {
	            return rawMonthSetter(mom, value);
	        } else {
	            return mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
	        }
	    }

	    function makeAccessor(unit, keepTime) {
	        return function (value) {
	            if (value != null) {
	                rawSetter(this, unit, value);
	                moment.updateOffset(this, keepTime);
	                return this;
	            } else {
	                return rawGetter(this, unit);
	            }
	        };
	    }

	    moment.fn.millisecond = moment.fn.milliseconds = makeAccessor('Milliseconds', false);
	    moment.fn.second = moment.fn.seconds = makeAccessor('Seconds', false);
	    moment.fn.minute = moment.fn.minutes = makeAccessor('Minutes', false);
	    // Setting the hour should keep the time, because the user explicitly
	    // specified which hour he wants. So trying to maintain the same hour (in
	    // a new timezone) makes sense. Adding/subtracting hours does not follow
	    // this rule.
	    moment.fn.hour = moment.fn.hours = makeAccessor('Hours', true);
	    // moment.fn.month is defined separately
	    moment.fn.date = makeAccessor('Date', true);
	    moment.fn.dates = deprecate('dates accessor is deprecated. Use date instead.', makeAccessor('Date', true));
	    moment.fn.year = makeAccessor('FullYear', true);
	    moment.fn.years = deprecate('years accessor is deprecated. Use year instead.', makeAccessor('FullYear', true));

	    // add plural methods
	    moment.fn.days = moment.fn.day;
	    moment.fn.months = moment.fn.month;
	    moment.fn.weeks = moment.fn.week;
	    moment.fn.isoWeeks = moment.fn.isoWeek;
	    moment.fn.quarters = moment.fn.quarter;

	    // add aliased format methods
	    moment.fn.toJSON = moment.fn.toISOString;

	    /************************************
	        Duration Prototype
	    ************************************/


	    function daysToYears (days) {
	        // 400 years have 146097 days (taking into account leap year rules)
	        return days * 400 / 146097;
	    }

	    function yearsToDays (years) {
	        // years * 365 + absRound(years / 4) -
	        //     absRound(years / 100) + absRound(years / 400);
	        return years * 146097 / 400;
	    }

	    extend(moment.duration.fn = Duration.prototype, {

	        _bubble : function () {
	            var milliseconds = this._milliseconds,
	                days = this._days,
	                months = this._months,
	                data = this._data,
	                seconds, minutes, hours, years = 0;

	            // The following code bubbles up values, see the tests for
	            // examples of what that means.
	            data.milliseconds = milliseconds % 1000;

	            seconds = absRound(milliseconds / 1000);
	            data.seconds = seconds % 60;

	            minutes = absRound(seconds / 60);
	            data.minutes = minutes % 60;

	            hours = absRound(minutes / 60);
	            data.hours = hours % 24;

	            days += absRound(hours / 24);

	            // Accurately convert days to years, assume start from year 0.
	            years = absRound(daysToYears(days));
	            days -= absRound(yearsToDays(years));

	            // 30 days to a month
	            // TODO (iskren): Use anchor date (like 1st Jan) to compute this.
	            months += absRound(days / 30);
	            days %= 30;

	            // 12 months -> 1 year
	            years += absRound(months / 12);
	            months %= 12;

	            data.days = days;
	            data.months = months;
	            data.years = years;
	        },

	        abs : function () {
	            this._milliseconds = Math.abs(this._milliseconds);
	            this._days = Math.abs(this._days);
	            this._months = Math.abs(this._months);

	            this._data.milliseconds = Math.abs(this._data.milliseconds);
	            this._data.seconds = Math.abs(this._data.seconds);
	            this._data.minutes = Math.abs(this._data.minutes);
	            this._data.hours = Math.abs(this._data.hours);
	            this._data.months = Math.abs(this._data.months);
	            this._data.years = Math.abs(this._data.years);

	            return this;
	        },

	        weeks : function () {
	            return absRound(this.days() / 7);
	        },

	        valueOf : function () {
	            return this._milliseconds +
	              this._days * 864e5 +
	              (this._months % 12) * 2592e6 +
	              toInt(this._months / 12) * 31536e6;
	        },

	        humanize : function (withSuffix) {
	            var output = relativeTime(this, !withSuffix, this.localeData());

	            if (withSuffix) {
	                output = this.localeData().pastFuture(+this, output);
	            }

	            return this.localeData().postformat(output);
	        },

	        add : function (input, val) {
	            // supports only 2.0-style add(1, 's') or add(moment)
	            var dur = moment.duration(input, val);

	            this._milliseconds += dur._milliseconds;
	            this._days += dur._days;
	            this._months += dur._months;

	            this._bubble();

	            return this;
	        },

	        subtract : function (input, val) {
	            var dur = moment.duration(input, val);

	            this._milliseconds -= dur._milliseconds;
	            this._days -= dur._days;
	            this._months -= dur._months;

	            this._bubble();

	            return this;
	        },

	        get : function (units) {
	            units = normalizeUnits(units);
	            return this[units.toLowerCase() + 's']();
	        },

	        as : function (units) {
	            var days, months;
	            units = normalizeUnits(units);

	            if (units === 'month' || units === 'year') {
	                days = this._days + this._milliseconds / 864e5;
	                months = this._months + daysToYears(days) * 12;
	                return units === 'month' ? months : months / 12;
	            } else {
	                // handle milliseconds separately because of floating point math errors (issue #1867)
	                days = this._days + yearsToDays(this._months / 12);
	                switch (units) {
	                    case 'week': return days / 7 + this._milliseconds / 6048e5;
	                    case 'day': return days + this._milliseconds / 864e5;
	                    case 'hour': return days * 24 + this._milliseconds / 36e5;
	                    case 'minute': return days * 24 * 60 + this._milliseconds / 6e4;
	                    case 'second': return days * 24 * 60 * 60 + this._milliseconds / 1000;
	                    // Math.floor prevents floating point math errors here
	                    case 'millisecond': return Math.floor(days * 24 * 60 * 60 * 1000) + this._milliseconds;
	                    default: throw new Error('Unknown unit ' + units);
	                }
	            }
	        },

	        lang : moment.fn.lang,
	        locale : moment.fn.locale,

	        toIsoString : deprecate(
	            'toIsoString() is deprecated. Please use toISOString() instead ' +
	            '(notice the capitals)',
	            function () {
	                return this.toISOString();
	            }
	        ),

	        toISOString : function () {
	            // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
	            var years = Math.abs(this.years()),
	                months = Math.abs(this.months()),
	                days = Math.abs(this.days()),
	                hours = Math.abs(this.hours()),
	                minutes = Math.abs(this.minutes()),
	                seconds = Math.abs(this.seconds() + this.milliseconds() / 1000);

	            if (!this.asSeconds()) {
	                // this is the same as C#'s (Noda) and python (isodate)...
	                // but not other JS (goog.date)
	                return 'P0D';
	            }

	            return (this.asSeconds() < 0 ? '-' : '') +
	                'P' +
	                (years ? years + 'Y' : '') +
	                (months ? months + 'M' : '') +
	                (days ? days + 'D' : '') +
	                ((hours || minutes || seconds) ? 'T' : '') +
	                (hours ? hours + 'H' : '') +
	                (minutes ? minutes + 'M' : '') +
	                (seconds ? seconds + 'S' : '');
	        },

	        localeData : function () {
	            return this._locale;
	        }
	    });

	    moment.duration.fn.toString = moment.duration.fn.toISOString;

	    function makeDurationGetter(name) {
	        moment.duration.fn[name] = function () {
	            return this._data[name];
	        };
	    }

	    for (i in unitMillisecondFactors) {
	        if (hasOwnProp(unitMillisecondFactors, i)) {
	            makeDurationGetter(i.toLowerCase());
	        }
	    }

	    moment.duration.fn.asMilliseconds = function () {
	        return this.as('ms');
	    };
	    moment.duration.fn.asSeconds = function () {
	        return this.as('s');
	    };
	    moment.duration.fn.asMinutes = function () {
	        return this.as('m');
	    };
	    moment.duration.fn.asHours = function () {
	        return this.as('h');
	    };
	    moment.duration.fn.asDays = function () {
	        return this.as('d');
	    };
	    moment.duration.fn.asWeeks = function () {
	        return this.as('weeks');
	    };
	    moment.duration.fn.asMonths = function () {
	        return this.as('M');
	    };
	    moment.duration.fn.asYears = function () {
	        return this.as('y');
	    };

	    /************************************
	        Default Locale
	    ************************************/


	    // Set default locale, other locale will inherit from English.
	    moment.locale('en', {
	        ordinal : function (number) {
	            var b = number % 10,
	                output = (toInt(number % 100 / 10) === 1) ? 'th' :
	                (b === 1) ? 'st' :
	                (b === 2) ? 'nd' :
	                (b === 3) ? 'rd' : 'th';
	            return number + output;
	        }
	    });

	    /* EMBED_LOCALES */

	    /************************************
	        Exposing Moment
	    ************************************/

	    function makeGlobal(shouldDeprecate) {
	        /*global ender:false */
	        if (typeof ender !== 'undefined') {
	            return;
	        }
	        oldGlobalMoment = globalScope.moment;
	        if (shouldDeprecate) {
	            globalScope.moment = deprecate(
	                    'Accessing Moment through the global scope is ' +
	                    'deprecated, and will be removed in an upcoming ' +
	                    'release.',
	                    moment);
	        } else {
	            globalScope.moment = moment;
	        }
	    }

	    // CommonJS module is defined
	    if (hasModule) {
	        module.exports = moment;
	    } else if (true) {
	        !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require, exports, module) {
	            if (module.config && module.config() && module.config().noGlobal === true) {
	                // release the global variable
	                globalScope.moment = oldGlobalMoment;
	            }

	            return moment;
	        }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	        makeGlobal(true);
	    } else {
	        makeGlobal();
	    }
	}).call(this);
	
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(162)(module)))

/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = require("util");

/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = require("events");

/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = require("fs");

/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {

	
	var Base58Utils = (function () {
	  var alphabets = {
	    'ripple':  "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz",
	    'bitcoin': "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
	  };

	  var SHA256  = function (bytes) {
	    return sjcl.codec.bytes.fromBits(sjcl.hash.sha256.hash(sjcl.codec.bytes.toBits(bytes)));
	  };

	  return {
	    // --> input: big-endian array of bytes.
	    // <-- string at least as long as input.
	    encode_base: function (input, alphabetName) {
	      var alphabet = alphabets[alphabetName || 'ripple'],
	          base     = new sjcl.bn(alphabet.length),
	          bi       = sjcl.bn.fromBits(sjcl.codec.bytes.toBits(input)),
	          buffer   = [];

	      while (bi.greaterEquals(base)) {
	        var mod = bi.mod(base);
	        buffer.push(alphabet[mod.limbs[0]]);
	        bi = bi.div(base);
	      }
	      buffer.push(alphabet[bi.limbs[0]]);

	      // Convert leading zeros too.
	      for (var i = 0; i != input.length && !input[i]; i += 1) {
	        buffer.push(alphabet[0]);
	      }

	      return buffer.reverse().join("");
	    },

	    // --> input: String
	    // <-- array of bytes or undefined.
	    decode_base: function (input, alphabetName) {
	      var alphabet = alphabets[alphabetName || 'ripple'],
	          base     = new sjcl.bn(alphabet.length),
	          bi       = new sjcl.bn(0);

	      var i;
	      while (i != input.length && input[i] === alphabet[0]) {
	        i += 1;
	      }

	      for (i = 0; i != input.length; i += 1) {
	        var v = alphabet.indexOf(input[i]);

	        if (v < 0) {
	          return null;
	        }

	        bi = bi.mul(base).addM(v);
	      }

	      var bytes = sjcl.codec.bytes.fromBits(bi.toBits()).reverse();

	      // Remove leading zeros
	      while(bytes[bytes.length-1] === 0) {
	        bytes.pop();
	      }

	      // Add the right number of leading zeros
	      for (i = 0; input[i] === alphabet[0]; i++) {
	        bytes.push(0);
	      }

	      bytes.reverse();

	      return bytes;
	    },

	    // --> input: Array
	    // <-- String
	    encode_base_check: function (version, input, alphabet) {
	      var buffer  = [].concat(version, input);
	      var check   = SHA256(SHA256(buffer)).slice(0, 4);
	      return Base58Utils.encode_base([].concat(buffer, check), alphabet);
	    },

	    // --> input : String
	    // <-- NaN || BigInteger
	    decode_base_check: function (version, input, alphabet) {
	      var buffer = Base58Utils.decode_base(input, alphabet);

	      if (!buffer || buffer[0] !== version || buffer.length < 5) {
	        return NaN;
	      }

	      var computed = SHA256(SHA256(buffer.slice(0, -4))).slice(0, 4),
	          checksum = buffer.slice(-4);

	      var i;
	      for (i = 0; i != 4; i += 1)
	        if (computed[i] !== checksum[i])
	          return NaN;

	      return buffer.slice(1, -4);
	    }
	  };
	})();

	module.exports = Base58Utils;


/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {

	// returns the raw address after removing any parameters 
	exports.stripRippleAddress = function (addr)
	{
	  if(typeof(addr)=='string')
	  {
	    var index=addr.indexOf("?");
	    if(index>=0)
	    {
	      return(addr.slice(0,index));
	    }
	  }
	  return(addr);
	}
	//returns the destination tag of an address if there is one 
	exports.getDestTagFromAddress = function (addr)
	{
	  var index=addr.indexOf("?");
	  if(index>=0)
	  {
	    addr=addr.slice(index,addr.length);
	    index=addr.indexOf("dt=");
	    if(index>=0)
	    {
	      addr=addr.slice(index+3,addr.length);
	      index=addr.indexOf("&");
	      if(index>0) return( addr.slice(0,index) );
	      else return(addr);
	    }
	    index=addr.indexOf("d=");
	    if(index>=0)
	    {
	      addr=addr.slice(index+2,addr.length);
	      index=addr.indexOf("&");
	      if(index>0) return( addr.slice(0,index) );
	      else return(addr);
	    }
	  }
	  return(undefined);
	}

	exports.removeClassPrefix = function (el, group)
	{
	  var $el = $(el);
	  var classes = $el.attr("class");

	  if (!classes || !classes.length) return;

	  classes = classes.split(" ").map(function(item) {
	    return item.indexOf(group) === 0 ? "" : item;
	  });
	  $el.attr("class", classes.join(" "));
	};

	/**
	 * Error handler for jQuery.ajax requests.
	 *
	 * @example
	 *   $.get('http://acme.com/')
	 *    .success(...)
	 *    .error(webutil.getAjaxErrorHandler(callback, "Acme GET"));
	 */
	exports.getAjaxErrorHandler = function (callback, context)
	{
	  return function (request, type, errorThrown)
	  {
	    switch (type) {
	      case 'timeout':
	        message = "The request timed out.";
	        break;
	      case 'notmodified':
	        message = "The request was not modified but was not retrieved from the cache.";
	        break;
	      case 'parsererror':
	        message = "XML/Json format is bad.";
	        break;
	      default:
	        message = "HTTP Error (" + request.status + " " + request.statusText + ").";
	    }
	    callback(new Error(message));
	  };
	};

	exports.scrollToTop = function ()
	{
	  $("html, body").animate({ scrollTop: 0 }, "fast");
	};

	exports.findIssuer= function(lines, currency)
	{
	  var maxIssuer=null;
	  var maxLimit=0;

	  for (var n in lines) {
	    if (lines.hasOwnProperty(n)) {
	      if (lines[n].currency === currency) {
	        var limit = +lines[n].limit.to_text();
	        if (limit > maxLimit) {
	          maxLimit = limit;
	          maxIssuer = lines[n].account;
	        }
	      }
	    }
	  }
	  return maxIssuer;
	}

	exports.getContact = function (contacts,value)
	{
	  if (!value) return false;

	  for (var i=0;i<contacts.length;i++) {
	    if (contacts[i].name === value || contacts[i].address === value) {
	      return contacts[i];
	    }
	  }

	  return false;
	};

	/**
	 * Given an address, return the contact name.
	 */
	exports.isContact = function (contacts, address) {
	  try {
	    for (var i = 0, l = contacts.length; i < l; i++) {
	      if (contacts[i].address === address) {
	        return contacts[i].name;
	      }
	    }
	  } catch (e) {}
	};

	/**
	 * Return the address of a contact.
	 *
	 * Pass in an address or a contact name and get an address back.
	 */
	exports.resolveContact = function (contacts, value)
	{
	  for (var i = 0, l = contacts.length; i < l; i++) {
	    if (contacts[i].name === value) {
	      return contacts[i].address;
	    }
	  }

	  if (ripple.UInt160.is_valid(value)) {
	    return ripple.UInt160.json_rewrite(value);
	  }

	  return '';
	};

	/**
	 * Given an address, return the contact name.
	 *
	 * If a contact is not found with the given address, simply return the address
	 * again.
	 */
	exports.unresolveContact = function (contacts, address)
	{
	  var contact;
	  return (contact = exports.isContact(contacts, address)) ? contact : address;
	};

	/**
	 * Creates a combobox query function out of a contacts list.
	 *
	 * @param options {array} An array of select options like {name: '', value: ''}.
	 */
	exports.queryFromContacts = function (contacts)
	{
	  return exports.queryFromOptions(
	    _.map(contacts, function (entry) {
	      return {
	        name: entry.name,
	        additional: entry.view || entry.address
	      }
	    })
	  );
	};

	/**
	 * Creates a combobox query function out of a select options array.
	 *
	 * @param options {array} An array of select options like {name: '', value: ''}.
	 */
	exports.queryFromOptions = function (options)
	{
	  var opts = _.map(options, function (entry) {
	    if ("object" === typeof entry || "string" === typeof entry ) {
	      return entry;
	    } else {
	      return null;
	    }
	  });
	  return exports.queryFromArray(opts);
	};

	exports.queryFromOptionsIncludingKeys = function (options)
	{
	  var opts = _.map(options, function (entry) {
	    if ("object" === typeof entry &&
	        entry.value && "string" === typeof entry.value && entry.name && "string" === typeof entry.name)
	    {
	      return entry.value + " - " + entry.name;
	    } else if ("object" === typeof entry || "string" === typeof entry) {
	      return entry;
	    } else {
	      return null;
	    }
	  });

	  return exports.queryFromArray(opts);
	};

	/**
	 * Creates a combobox query function out of a plain array of strings.
	 *
	 * @param options {array} An array of options, e.g. ['First choice', '2nd']
	 */
	exports.queryFromArray = function (options)
	{
	  return function (match, re) {
	    if (re instanceof RegExp) {
	      return options.filter(function (item) {
	        return "string" === typeof item
	          ? item.match(re)
	          : (item.name ? item.name.match(re) : false);
	      });
	    } else return options;
	  };
	};

	/**
	 * Escapes a string for use as a literal inside of a regular expression.
	 *
	 * From: http://stackoverflow.com/questions/3446170
	 */
	exports.escapeRegExp = function (str)
	{
	  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
	};

	/**
	 * Convert base64 encoded data into base64url encoded data.
	 *
	 * @param {String} base64 Data
	 */
	exports.base64ToBase64Url = function (encodedData) {
	  return encodedData.replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]+$/, '');
	};

	/**
	 * Convert base64url encoded data into base64 encoded data.
	 *
	 * @param {String} base64 Data
	 */
	exports.base64UrlToBase64 = function (encodedData) {
	  encodedData = encodedData.replace(/-/g, '+').replace(/_/g, '/');
	  while (encodedData.length % 4) {
	    encodedData += '=';
	  }
	  return encodedData;
	};

	/**
	 * Regex check if the string is a valid ripple name
	 *
	 * @param str
	 */
	exports.isRippleName = function (str) {
	  var nameRegex = /^~[a-zA-Z0-9]([\-]?[a-zA-Z0-9]){0,19}$/;
	  console.log('+++++++ webutil.isRippleName: ' + str + ' : ' + nameRegex.test(str));

	  return nameRegex.test(str);
	};


/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Print an exception for debug purposes.
	 *
	 * Includes some logic to try and log a stack in various browsers.
	 */
	exports.exception = function (exception) {
	  console.log("function" === typeof exception.getStack ? exception.getStack() : exception.stack);
	};



/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<div rp-snapper="rp-snapper" class="mobile-nav"><a href="#/balance" ng-class="{active: $route.current.tabName == \'balance\'}" class="wallet"><span class="nav-icon nav-icon-wallet"></span><span>Zostatok</span></a><a href="#/history" ng-class="{active: $route.current.tabName == \'history\'}" class="sub">História</a><a href="#/contacts" ng-class="{active: $route.current.tabName == \'contacts\'}" class="sub">Kontakty</a><a href="#/send" ng-class="{active: $route.current.tabName == \'send\'}" class="send"><span class="nav-icon nav-icon-send"></span><span>Odoslať</span></a><a href="#/exchange" ng-class="{active: $route.current.tabName == \'exchange\'}" class="exchange"><span class="nav-icon nav-icon-exchange"></span><span>Trade (simple)</span></a><a href="#/trade" ng-class="{active: $route.current.tabName == \'trade\'}" class="sub">Trade (advanced)</a><a href="#/xrp" ng-class="{active: $route.current.tabName == \'xrp\'}" class="fund"><span class="nav-icon nav-icon-advanced"></span><span>Fund</span></a><a href="#/trust" ng-class="{active: $route.current.tabName == \'trust\'}" class="sub">Gateways</a><a href="#/security" ng-class="{active: $route.current.tabName == \'security\'}" class="advanced"><img src="img/settings-gray.png"/><span>Settings</span></a><a href="#" ng-click="logout()" class="advanced"><img src="img/logout-gray.png"/><span>Logout</span></a></div><!-- Wrapper--><div id="wrapper"><!-- Header--><header><h1 ng-show="[\'t-login\',\'t-register\'].indexOf($route.current.tabClass) !== -1">Welcome to {{productName}}, a global value exchange</h1>');
	var __val__ = __webpack_require__(160)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</header><div class="container"><!-- Main--><div id="{{$route.current.tabClass}}" role="main" ng-view="ng-view" class="row main"></div><!-- Footer--><footer class="row"><div class="col-xs-12 col-sm-3"><a href="https://ripple.com/wiki/index.php?title=Ripple_Client_Release_Notes" target="_blank">Version: {{version}}</a></div><div class="col-xs-12 col-sm-9 right-links"><a href="https://rippletrade.com/#/eula" target="_blank">End-User License Agreement</a><a href="https://support.ripplelabs.com" target="_blank">Podpora</a><a href="https://ripplelabs.atlassian.net/browse/WC" target="_blank">Hlásenie chýb</a><a href="#/lang/en">English</a><a href="#/lang/zh_CN">中文</a><a href="#/lang/ja">日本語</a><!-- Language selector--><rp-popup><a href="" rp-popup-link="rp-popup-link" class="last">viac...</a><div rp-popup-content="rp-popup-content" class="languageSelector"><div class="modal-header"><button type="button" data-dismiss="modal" aria-hidden="true" class="close">&times;</button><div class="modal-title">Select a language</div></div><div class="modal-body row list"><div class="col-sm-6"><a href="#/lang/en">English</a></div><div class="col-sm-6"><a href="#/lang/zh_CN">中文</a></div><div class="col-sm-6"><a href="#/lang/nl_NL">Nederlands</a></div><div class="col-sm-6"><a href="#/lang/it">Italiano</a></div><div class="col-sm-6"><a href="#/lang/pl">Polski</a></div><div class="col-sm-6"><a href="#/lang/es">Español</a></div><div class="col-sm-6"><a href="#/lang/pt">Português</a></div><div class="col-sm-6"><a href="#/lang/de">Deutsch</a></div><div class="col-sm-6"><a href="#/lang/nb_NO">Norsk</a></div><div class="col-sm-6"><a href="#/lang/sk">Slovenská</a></div><div class="col-sm-6"><a href="#/lang/ca">Català</a></div><div class="col-sm-6"><a href="#/lang/he_IL">עברית</a></div><div class="col-sm-6"><a href="#/lang/ru">Русский</a></div><div class="col-sm-6"><a href="#/lang/ro">Român</a></div><div class="col-sm-6"><a href="#/lang/ja">日本語</a></div><div class="col-sm-6"><a href="#/lang/tr">Türkçe</a></div></div></div></rp-popup></div></footer></div></div>');
	}
	return buf.join("");
	}

/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {

	var pairs = __webpack_require__(58);

	/**
	 * Calculate executed order price
	 *
	 * @param effect
	 * @returns {*}
	 */
	var getPrice = function(effect, referenceDate){
	  var g = effect.got ? effect.got : effect.gets;
	  var p = effect.paid ? effect.paid : effect.pays;
	  var price;

	  if (!p.is_zero() && !g.is_zero()) {
	    _.find(pairs, function(pair){
	      if (pair.name == g.currency().to_human() + '/' + p.currency().to_human()) {
	        price = p.ratio_human(g, {reference_date: referenceDate});
	      }
	    });

	    if (!price) {
	      price = g.ratio_human(p, {reference_date: referenceDate});
	    }
	  }

	  return price || 0;
	};

	/**
	 * Determine if the transaction is a "rippling" transaction based on effects
	 *
	 * @param effects
	 */
	var isRippling = function(effects){
	  if (
	    effects
	    && effects.length
	    && 2 === effects.length
	    && 'trust_change_balance' == effects[0].type
	    && 'trust_change_balance' == effects[1].type
	    && effects[0].currency == effects[1].currency
	    && !effects[0].amount.compareTo(effects[1].amount.negate())
	  ) {
	    return true;
	  }
	};

	/**
	 * Simple static class for processing server-side JSON.
	 */
	var JsonRewriter = module.exports = {
	  /**
	   * Filter affected nodes by type.
	   *
	   * If affectedNodes is not a valid set of nodes, returns an empty array.
	   */
	  filterAnodes: function (affectedNodes, type) {
	    if (!affectedNodes) return [];

	    return affectedNodes.filter(function (an) {
	      an = an.CreatedNode ? an.CreatedNode :
	          an.ModifiedNode ? an.ModifiedNode :
	          {};

	      return an.LedgerEntryType === type;
	    });
	  },

	  /**
	   * Returns resulting (new or modified) fields from an affected node.
	   */
	  getAnodeResult: function (an) {
	    an = an.CreatedNode ? an.CreatedNode :
	        an.ModifiedNode ? an.ModifiedNode :
	        {};

	    var fields = $.extend({}, an.NewFields, an.FinalFields);

	    return fields;
	  },

	  /**
	   * Takes a metadata affected node and returns a simpler JSON object.
	   *
	   * The resulting object looks like this:
	   *
	   *   {
	   *     // Type of diff, e.g. CreatedNode, ModifiedNode
	   *     diffType: 'CreatedNode'
	   *
	   *     // Type of node affected, e.g. RippleState, AccountRoot
	   *     entryType: 'RippleState',
	   *
	   *     // Index of the ledger this change occurred in
	   *     ledgerIndex: '01AB01AB...',
	   *
	   *     // Contains all fields with later versions taking precedence
	   *     //
	   *     // This is a shorthand for doing things like checking which account
	   *     // this affected without having to check the diffType.
	   *     fields: {...},
	   *
	   *     // Old fields (before the change)
	   *     fieldsPrev: {...},
	   *
	   *     // New fields (that have been added)
	   *     fieldsNew: {...},
	   *
	   *     // Changed fields
	   *     fieldsFinal: {...}
	   *   }
	   */
	  processAnode: function (an) {
	    var result = {};

	    ["CreatedNode", "ModifiedNode", "DeletedNode"].forEach(function (x) {
	      if (an[x]) result.diffType = x;
	    });

	    if (!result.diffType) return null;

	    an = an[result.diffType];

	    result.entryType = an.LedgerEntryType;
	    result.ledgerIndex = an.LedgerIndex;

	    result.fields = $.extend({}, an.PreviousFields, an.NewFields, an.FinalFields);
	    result.fieldsPrev = an.PreviousFields || {};
	    result.fieldsNew = an.NewFields || {};
	    result.fieldsFinal = an.FinalFields || {};

	    return result;
	  },

	  /**
	   * Takes a transaction and its metadata and returns the amount sent as:
	   *
	   * If XRP, value sent as String
	   *
	   * If not XRP,
	      {
	       value: value sent as String,
	       currency: currency code of value sent
	      }
	    *
	    * If unable to determine, returns undefined
	    *
	    * If the caller needs the issuer of sent currency as well, try tx.sendMax.issuer
	   */
	  getAmountSent: function (tx, meta) {
	    var sender = tx.Account;
	    var difference = null;
	    var cur = null;
	    var i;
	    var affectedNode;
	    var amtSent;

	    if (tx.TransactionType === "Payment") {
	      if (meta.DeliveredAmount) {
	        return meta.DeliveredAmount;
	      }

	      if (meta.AffectedNodes) {
	        // Find the metadata node with entry type == "RippleState"
	        // and either HighLimit.issuer == [sender's account] or
	        // LowLimit.issuer == [sender's account] and
	        // Balance.currency == [currency of SendMax || Amount]
	        if (tx.SendMax && tx.SendMax.currency) {
	          for (i = 0; i < meta.AffectedNodes.length; i++) {
	            affectedNode = meta.AffectedNodes[i];
	            if (affectedNode.ModifiedNode && affectedNode.ModifiedNode.LedgerEntryType === "RippleState" &&
	              (affectedNode.ModifiedNode.FinalFields.HighLimit.issuer === sender ||
	                affectedNode.ModifiedNode.FinalFields.LowLimit.issuer === sender) &&
	              affectedNode.ModifiedNode.FinalFields.Balance.currency === tx.SendMax.currency) {

	              // Calculate the difference before/after. If HighLimit.issuer == [sender's account] negate it.
	              difference = affectedNode.ModifiedNode.PreviousFields.Balance.value - affectedNode.ModifiedNode.FinalFields.Balance.value;
	              if (affectedNode.ModifiedNode.FinalFields.HighLimit.issuer === sender) difference *= -1;
	              cur = affectedNode.ModifiedNode.FinalFields.Balance.currency;
	              break;
	            }
	          }
	        }

	        if (difference === null) {
	          // Find the metadata node with entry type == "AccountRoot" and Account == [sender's account].
	          for (i = 0; i < meta.AffectedNodes.length; i++) {
	            affectedNode = meta.AffectedNodes[i];
	            if (affectedNode.ModifiedNode && affectedNode.ModifiedNode.LedgerEntryType === "AccountRoot" &&
	              affectedNode.ModifiedNode.FinalFields && affectedNode.ModifiedNode.FinalFields.Account === sender) {

	              // Calculate the difference minus the fee
	              difference = affectedNode.ModifiedNode.PreviousFields.Balance - affectedNode.ModifiedNode.FinalFields.Balance - tx.Fee;
	              break;
	            }
	          }
	        }

	        if (difference) {  // calculated and non-zero
	          var diff = String(difference);
	          amtSent = cur ? {value: diff, currency:cur} : diff;
	        }
	      }
	    }

	    return amtSent;
	  },

	  /**
	   * Convert transactions into a more useful (for our purposes) format.
	   *
	   * The main operation this function performs is to change the view on the
	   * transaction from a neutral view to a subjective view specific to our
	   * account.
	   *
	   * For example, rather than having a sender and receiver, the transaction has
	   * a counterparty and a flag whether it is incoming or outgoing.
	   *
	   * processTxn returns main purpose of transaction and side effects.
	   *
	   * Main purpose
	   *  Real transaction names
	   *  - Payment (sent/received/exchange)
	   *  - TrustSet (trusting/trusted)
	   *  - OfferCreate (offernew)
	   *  - OfferCancel (offercancel)
	   *
	   *  Virtual transaction names
	   *  - Failed
	   *  - Rippling
	   *
	   * Side effects
	   *  - balance_change
	   *  - Trust (trust_create_local, trust_create_remote, trust_change_local,
	   *          trust_change_remote, trust_change_balance, trust_change_no_ripple)
	   *  - Offer (offer_created, offer_funded, offer_partially_funded,
	   *          offer_cancelled, offer_bought)
	   */
	  processTxn: function (tx, meta, account) {
	    try {
	      return JsonRewriter._processTxn(tx, meta, account);
	    } catch (err) {
	      var transaction = {};
	      transaction.type = 'error';
	      if (tx && 'object' === typeof tx) {
	        transaction.hash = tx.hash;
	        transaction.date = ripple.utils.toTimestamp(tx.date);
	        transaction.dateRaw = tx.date;
	      } else {
	        transaction.hash = 'unknown';
	        transaction.date = new Date().getTime();
	        transaction.dateRaw = ripple.utils.fromTimestamp(fromTimestamp);
	      }
	      return {transaction: transaction, error: err};
	    }
	  },

	  _processTxn: function (tx, meta, account) {
	    var obj = {};

	    // Currency balances that have been affected by the transaction
	    var affected_currencies = [];

	    // Main transaction
	    if (tx.Account === account
	        || (tx.Destination && tx.Destination === account)
	        || (tx.LimitAmount && tx.LimitAmount.issuer === account)) {

	      var transaction = {};

	      if ('tesSUCCESS' === meta.TransactionResult) {
	        switch (tx.TransactionType) {
	          case 'Payment':
	            var amount = ripple.Amount.from_json(tx.Amount);

	            if (tx.Account === account) {
	              if (tx.Destination === account) {
	                transaction.type = 'exchange';
	                transaction.spent = ripple.Amount.from_json(tx.SendMax);
	              }
	              else {
	                transaction.type = 'sent';
	                transaction.counterparty = tx.Destination;
	              }
	            }
	            else {
	              transaction.type = 'received';
	              transaction.counterparty = tx.Account;
	            }

	            if (typeof tx.SendMax === 'object') transaction.sendMax = tx.SendMax;

	            var amtSent = JsonRewriter.getAmountSent(tx, meta);
	            if (amtSent) transaction.amountSent = amtSent;

	            transaction.amount = amount;
	            transaction.currency = amount.currency().to_human();
	            break;

	          case 'TrustSet':
	            transaction.type = tx.Account === account ? 'trusting' : 'trusted';
	            transaction.counterparty = tx.Account === account ? tx.LimitAmount.issuer : tx.Account;
	            transaction.amount = ripple.Amount.from_json(tx.LimitAmount);
	            transaction.currency = tx.LimitAmount.currency;
	            break;

	          case 'OfferCreate':
	            transaction.type = 'offernew';
	            transaction.pays = ripple.Amount.from_json(tx.TakerPays);
	            transaction.gets = ripple.Amount.from_json(tx.TakerGets);
	            transaction.sell = tx.Flags & ripple.Transaction.flags.OfferCreate.Sell;
	            break;

	          case 'OfferCancel':
	            transaction.type = 'offercancel';
	            break;

	          case 'AccountSet':
	            // Ignore empty accountset transactions. (Used to sync sequence numbers)
	            if (meta.AffectedNodes.length === 1 && _.size(meta.AffectedNodes[0].ModifiedNode.PreviousFields) === 2)
	              break;

	            transaction.type = 'accountset';
	            break;

	          default:
	            console.log('Unknown transaction type: "'+tx.TransactionType+'"', tx);
	        }

	        if (tx.Flags) {
	          transaction.flags = tx.Flags;
	        }
	      } else {
	        transaction.type = 'failed';
	      }

	      if (!$.isEmptyObject(transaction)) {
	        obj.transaction = transaction;
	      }
	    }

	    // Side effects
	    if ('tesSUCCESS' === meta.TransactionResult) {
	      meta.AffectedNodes.forEach(function (n) {
	        var node = JsonRewriter.processAnode(n);
	        var feeEff;
	        var effect = {};

	        // AccountRoot - Current account node
	        if (node.entryType === "AccountRoot" && node.fields.Account === account) {
	          obj.accountRoot = node.fields;

	          if (node.fieldsPrev.Balance) {
	            var balance = ripple.Amount.from_json(node.fields.Balance);

	            // Fee
	            if(tx.Account === account && tx.Fee) {
	              feeEff = {
	                type: "fee",
	                amount: ripple.Amount.from_json(tx.Fee).negate(),
	                balance: balance
	              };
	            }

	            // Updated XRP Balance
	            if (tx.Fee != node.fieldsPrev.Balance - node.fields.Balance) {
	              if (feeEff)
	                balance = balance.subtract(feeEff.amount);

	              effect.type = "balance_change";
	              effect.amount = balance.subtract(node.fieldsPrev.Balance);
	              effect.balance = balance;

	              // balance_changer is set to true if the transaction / effect has changed one of the account balances
	              obj.balance_changer = effect.balance_changer = true;
	              affected_currencies.push('XRP');
	            }
	          }
	        }

	        // RippleState - Ripple Lines
	        if (node.entryType === "RippleState"
	            && (node.fields.HighLimit.issuer === account || node.fields.LowLimit.issuer === account)) {

	          var high = node.fields.HighLimit;
	          var low = node.fields.LowLimit;

	          var which = high.issuer === account ? 'HighNoRipple' : 'LowNoRipple';

	          // New trust line
	          if (node.diffType === "CreatedNode") {
	            effect.limit = ripple.Amount.from_json(high.value > 0 ? high : low);
	            effect.limit_peer = ripple.Amount.from_json(high.value > 0 ? low : high);

	            if ((high.value > 0 && high.issuer === account)
	                || (low.value > 0 && low.issuer === account)) {
	              effect.type = "trust_create_local";
	            } else {
	              effect.type = "trust_create_remote";
	            }
	          }

	          // Modified trust line
	          else if (node.diffType === "ModifiedNode" || node.diffType === "DeletedNode") {
	            var highPrev = node.fieldsPrev.HighLimit;
	            var lowPrev = node.fieldsPrev.LowLimit;

	            // Trust Balance change
	            if (node.fieldsPrev.Balance) {
	              effect.type = "trust_change_balance";

	              var issuer =  node.fields.Balance.value > 0 || node.fieldsPrev.Balance.value > 0
	                  ? high.issuer : low.issuer;

	              effect.amount = high.issuer === account
	                  ? effect.amount = ripple.Amount.from_json(
	                  node.fieldsPrev.Balance.value
	                      + "/" + node.fieldsPrev.Balance.currency
	                      + "/" + issuer).subtract(node.fields.Balance)
	                  : effect.amount = ripple.Amount.from_json(
	                  node.fields.Balance.value
	                      + "/" + node.fields.Balance.currency
	                      + "/" + issuer).subtract(node.fieldsPrev.Balance);

	              obj.balance_changer = effect.balance_changer = true;
	              affected_currencies.push(high.currency.toUpperCase());
	            }

	            // Trust Limit change
	            else if (highPrev || lowPrev) {
	              if (high.issuer === account) {
	                effect.limit = ripple.Amount.from_json(high);
	                effect.limit_peer = ripple.Amount.from_json(low);
	              } else {
	                effect.limit = ripple.Amount.from_json(low);
	                effect.limit_peer = ripple.Amount.from_json(high);
	              }

	              if (highPrev) {
	                effect.prevLimit = ripple.Amount.from_json(highPrev);
	                effect.type = high.issuer === account ? "trust_change_local" : "trust_change_remote";
	              }
	              else if (lowPrev) {
	                effect.prevLimit = ripple.Amount.from_json(lowPrev);
	                effect.type = high.issuer === account ? "trust_change_remote" : "trust_change_local";
	              }
	            }

	            // Trust flag change (effect gets this type only if nothing else but flags has been changed)
	            else if (node.fieldsPrev.Flags) {
	              // Account set a noRipple flag
	              if (node.fields.Flags & ripple.Remote.flags.state[which] &&
	                  !(node.fieldsPrev.Flags & ripple.Remote.flags.state[which])) {
	                effect.type = "trust_change_no_ripple";
	              }

	              // Account removed the noRipple flag
	              else if (node.fieldsPrev.Flags & ripple.Remote.flags.state[which] &&
	                  !(node.fields.Flags & ripple.Remote.flags.state[which])) {
	                effect.type = "trust_change_no_ripple";
	              }

	              if (effect.type)
	                effect.flags = node.fields.Flags;
	            }
	          }

	          if (!$.isEmptyObject(effect)) {
	            effect.counterparty = high.issuer === account ? low.issuer : high.issuer;
	            effect.currency = high.currency;
	            effect.balance = high.issuer === account
	                ? ripple.Amount.from_json(node.fields.Balance).negate(true)
	                : ripple.Amount.from_json(node.fields.Balance);

	            if (obj.transaction && obj.transaction.type === "trust_change_balance") {
	              obj.transaction.balance = effect.balance;
	            }

	            // noRipple flag
	            if (node.fields.Flags & ripple.Remote.flags.state[which]) {
	              effect.noRipple = true;
	            }
	          }
	        }

	        // Offer
	        else if (node.entryType === "Offer") {

	          // For new and cancelled offers we use "fields"
	          var fieldSet = node.fields;

	          // Current account offer
	          if (node.fields.Account === account) {

	            // Partially funded offer [and deleted.. no more funds]
	            /* Offer has been partially funded and deleted (because of the luck of funds)
	             if the node is deleted and the TakerGets/TakerPays field has been changed */
	            if (node.diffType === "ModifiedNode" ||
	                (node.diffType === "DeletedNode"
	                    && node.fieldsPrev.TakerGets
	                    && !ripple.Amount.from_json(node.fieldsFinal.TakerGets).is_zero())) {
	              effect.type = 'offer_partially_funded';

	              if (node.diffType !== "DeletedNode") {
	                effect.remaining = ripple.Amount.from_json(node.fields.TakerGets);
	              }
	              else {
	                effect.cancelled = true;
	              }
	            }
	            else {
	              // New / Funded / Cancelled offer
	              effect.type = node.diffType === "CreatedNode"
	                  ? 'offer_created'
	                  : node.fieldsPrev.TakerPays
	                  ? 'offer_funded'
	                  : 'offer_cancelled';

	              // For funded offers we use "fieldsPrev".
	              if (effect.type === 'offer_funded')
	                fieldSet = node.fieldsPrev;

	              // We don't count cancelling an offer as a side effect if it's
	              // already the primary effect of the transaction.
	              if (effect.type === 'offer_cancelled' &&
	                  obj.transaction &&
	                  obj.transaction.type === "offercancel") {

	                // Fill in remaining information about offer
	                obj.transaction.gets = fieldSet.TakerGets;
	                obj.transaction.pays = fieldSet.TakerPays;
	              }
	            }

	            effect.seq = +node.fields.Sequence;
	          }

	          // Another account offer. We care about it only if our transaction changed the offer amount (we bought currency)
	          else if(tx.Account === account && !$.isEmptyObject(node.fieldsPrev) /* Offer is unfunded if node.fieldsPrev is empty */) {
	            effect.type = 'offer_bought';
	          }

	          if (effect.type) {
	            effect.gets = ripple.Amount.from_json(fieldSet.TakerGets);
	            effect.pays = ripple.Amount.from_json(fieldSet.TakerPays);

	            if ('offer_partially_funded' === effect.type || 'offer_bought' === effect.type) {
	              effect.got = ripple.Amount.from_json(node.fieldsPrev.TakerGets).subtract(node.fields.TakerGets);
	              effect.paid = ripple.Amount.from_json(node.fieldsPrev.TakerPays).subtract(node.fields.TakerPays);
	            }
	          }

	          if (effect.gets && effect.pays) {
	            effect.price = getPrice(effect, tx.date);
	          }

	          // Flags
	          if (node.fields.Flags) {
	            effect.flags = node.fields.Flags;
	            effect.sell = node.fields.Flags & ripple.Remote.flags.offer.Sell;
	          }
	        }

	        if (!$.isEmptyObject(effect)) {
	          if (node.diffType === "DeletedNode") {
	            effect.deleted = true;
	          }

	          if (!obj.effects) obj.effects = [];
	          obj.effects.push(effect);
	        }

	        // Fee effect
	        if (feeEff) {
	          if (!obj.effects) obj.effects = [];
	          obj.effects.push(feeEff);
	        }
	      });
	    }

	    // Balance after the transaction
	    if (obj.accountRoot && obj.transaction && "undefined" === typeof obj.transaction.balance) {
	      obj.transaction.balance = ripple.Amount.from_json(obj.accountRoot.Balance);
	    }

	    if ($.isEmptyObject(obj))
	      return;

	    // If the transaction didn't wind up cancelling an offer
	    if (tx.TransactionType === 'OfferCancel' && obj.transaction &&
	      (!obj.transaction.gets || !obj.transaction.pays)) {
	      return;
	    }

	    // Rippling transaction
	    if (isRippling(obj.effects)) {
	      if (!obj.transaction) {
	        obj.transaction = {};
	      }
	      obj.transaction.type = 'rippling';
	    }

	    obj.tx_type = tx.TransactionType;
	    obj.tx_result = meta.TransactionResult;
	    obj.fee = tx.Fee;
	    obj.date = ripple.utils.toTimestamp(tx.date);
	    obj.dateRaw = tx.date;
	    obj.hash = tx.hash;
	    obj.affected_currencies = affected_currencies ? affected_currencies : [];
	    obj.ledger_index = tx.ledger_index;

	    return obj;
	  }
	};


/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Description: Combines 2 arrays removing duplicates based on a object key
	 * @param arr1: Array of objects
	 * @param arr2: Array of objects
	 * @param key:  object key to be unique
	 *
	 * @return array of unique objects based on key
	 */
	exports.uniqueObjArray = function(arr1, arr2, key) {
	  var obj = {};
	  _.each(arr1, function(v) {
	    obj[v[key]] = v;
	  });

	  _.each(arr2, function(v) {
	    if (!(v[key] in obj)) {
	      obj[v[key]] = v;
	    }
	  });

	  return _.values(obj);
	}


/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {

	
	/**
	 * Check if userblob is actual blob class, not just empty dummy object
	 *
	 * @param userBlob
	 */
	exports.blobIsValid = function(userBlob) {
	  return userBlob && typeof userBlob.set === 'function';
	}

	/**
	 * Check if there is such setting in user blob
	 * use like hasSetting($scope.userBlob, 'trust.advancedMode')
	 *
	 * @param userBlob
	 * @param settingName
	 */
	exports.hasSetting = function(userBlob, settingName) {
	  if (!userBlob || !userBlob.data || typeof settingName !== 'string') return false;
	  var d = userBlob.data;
	  if (d.clients && d.clients.rippletradecom) {
	    var parts = settingName.split('.');
	    var o = d.clients.rippletradecom;
	    while (parts.length) {
	      var part = parts.shift();
	      if (_.has(o, part)) {
	        o = o[part];
	      } else {
	        return false;
	      }
	    }
	    return true;
	  }
	  return false;
	};

	/**
	 * Check if there is such setting in user blob
	 * use like var s = getSetting($scope.userBlob, 'trust.advancedMode', false);
	 *
	 * @param userBlob
	 * @param settingName
	 * @param def Default value. Optional.
	 */
	exports.getSetting = function(userBlob, settingName, def) {
	  if (!userBlob || !userBlob.data || typeof settingName !== 'string') return def;
	  var d = userBlob.data;
	  if (d.clients && d.clients.rippletradecom) {
	    var parts = settingName.split('.');
	    var o = d.clients.rippletradecom;
	    while (parts.length) {
	      var part = parts.shift();
	      if (_.has(o, part)) {
	        o = o[part];
	      } else {
	        return def;
	      }
	    }
	    return o;
	  }
	  return def;
	};

	exports.getClearServers = function(servers) {
	  return _.map(servers, function(server) {
	    var o = _.pick(server, 'host', 'port', 'secure');
	    // when edited it comes as string from input,
	    // so convert to number to be stored in blob in consisten way
	    o.port = Number(o.port);
	    return o;
	  });
	}


/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Ripple default external currency list.
	 *
	 * Important: XRP must be the first entry in this list.
	 */
	module.exports = [

	  // Display used for dropdown menu
	  // XRP - IMPORTANT: XRP must be first entry in this list
	  {value: 'XRP', name: 'Ripples', custom_trade_currency_dropdown: true, standard_precision: 4, order: 5},

	  // Fiat - Official ISO-4217
	  // From USD until HKD, the order is based on https://www.bullionvault.com/gold-news/all_the_money_in_the_world_102720093.
	  // After HKD, the order is alphabetical.
	  {value: 'USD', name: 'US Dollar', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 4},
	  {value: 'EUR', name: 'Euro', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 3},
	  {value: 'JPY', name: 'Japanese Yen', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'CNY', name: 'Chinese Yuan', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'INR', name: 'Indian Rupee', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'RUB', name: 'Russian Ruble', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'GBP', name: 'British Pound', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'CAD', name: 'Canadian Dollar', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'BRL', name: 'Brazilian Real', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'CHF', name: 'Swiss Franc', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'DKK', name: 'Danish Krone', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'NOK', name: 'Norwegian Krone', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'SEK', name: 'Swedish Krona', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'CZK', name: 'Czech Koruna', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'PLN', name: 'Polish Zloty', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'AUD', name: 'Australian Dollar', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'MXN', name: 'Mexican Peso', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'KRW', name: 'South Korean Won', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'TWD', name: 'New Taiwan Dollar', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'HKD', name: 'Hong Kong Dollar', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  // Alphabetical from here
	  {value: 'AMD', name: 'Armenian Drams', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'KES', name: 'Kenyan Shilling', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'NZD', name: 'New Zealand Dollar', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'RON', name: 'Romanian Leu', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'TRY', name: 'Turkish Lira', display: true, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},

	  // Fiat currencies NOT SHOWN
	  {value: 'AFN', name: 'Afghan Afghani', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ALL', name: 'Albanian Lek', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'DZD', name: 'Algerian Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'AOA', name: 'Angolan Kwanza Readjustado', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'XCD', name: 'East Caribbean Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ARS', name: 'Argentine peso', display: false, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0 },
	  {value: 'AWG', name: 'Aruban Florin', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'AZN', name: 'Azerbaijani Manat', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BSD', name: 'Bahamian Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BHD', name: 'Bahraini Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'BDT', name: 'Taka', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BBD', name: 'Barbados Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BYR', name: 'Belarussian Ruble', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'BZD', name: 'Belize Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'XOF', name: 'CFA Franc BCEAO', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'BMD', name: 'Bermudian Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BTN', name: 'Ngultrum', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BOB', name: 'Boliviano', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BOV', name: 'Mvdol', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BAM', name: 'Convertible Mark', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BWP', name: 'Pula', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BND', name: 'Brunei Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BGN', name: 'Bulgarian Lev', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'BIF', name: 'Burundi Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'KHR', name: 'Riel', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'XAF', name: 'CFA Franc BEAC', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'CVE', name: 'Cabo Verde Escudo', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'KYD', name: 'Cayman Islands Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'CLF', name: 'Chilean Unidad de Formentos', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'CLP', name: 'Chilean Peso', display: false, custom_trade_currency_dropdown: true, standard_precision: 0, order: 0 },
	  {value: 'COP', name: 'Colombian Peso', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'COU', name: 'Unidad de Valor Real', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'KMF', name: 'Comoro Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'CDF', name: 'Congolese Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'CRC', name: 'Costa Rican Colon', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'HRK', name: 'Croatian Kuna', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'CUC', name: 'Peso Convertible', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'CUP', name: 'Cuban Peso', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ANG', name: 'Netherlands Antillean Guilder', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'DJF', name: 'Djibouti Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'DOP', name: 'Dominican Peso', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'EGP', name: 'Egyptian Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SVC', name: 'El Salvador Colon', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ERN', name: 'Nakfa', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ETB', name: 'Ethiopian Birr', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'FKP', name: 'Falkland Islands Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'FJD', name: 'Fiji Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'XPF', name: 'CFP Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'GMD', name: 'Dalasi', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'GEL', name: 'Lari', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'GHS', name: 'Ghana Cedi', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'GIP', name: 'Gibraltar Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'GTQ', name: 'Quetzal', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'GNF', name: 'Guinea Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'GYD', name: 'Guyana Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'HTG', name: 'Gourde', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'HNL', name: 'Lempira', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'HUF', name: 'Forint', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ISK', name: 'Iceland Krona', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'IDR', name: 'Indonesia Rupiah', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'IRR', name: 'Iranian Rial', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'IQD', name: 'Iraqi Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'ILS', name: 'New Israeli Sheqel', display: false, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0 },
	  {value: 'JMD', name: 'Jamaican Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'JOD', name: 'Jordanian Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'KZT', name: 'Tenge', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'KPW', name: 'North Korean Won', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'KWD', name: 'Kuwaiti Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'KGS', name: 'Som', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'LAK', name: 'Kip', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'LVL', name: 'Latvian Lats', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'LBP', name: 'Lebanese Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'LSL', name: 'Loti', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ZAR', name: 'Rand', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0 },
	  {value: 'LRD', name: 'Liberian Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'LYD', name: 'Libyan Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'LTL', name: 'Lithuanian Litas', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MOP', name: 'Pataca', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MKD', name: 'Denar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MGA', name: 'Malagasy Ariary', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MWK', name: 'Kwacha', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MYR', name: 'Malaysian Ringgit', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MVR', name: 'Rufiyaa', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MRO', name: 'Ouguiya', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MUR', name: 'Mauritius Rupee', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MXV', name: 'Mexican Unidad de Inversion (UDI)', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MDL', name: 'Moldovan Leu', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MNT', name: 'Tugrik', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MAD', name: 'Moroccan Dirham', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MZN', name: 'Mozambique Metical', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'MMK', name: 'Kyat', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'NAD', name: 'Namibia Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'NPR', name: 'Nepalese Rupee', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'NIO', name: 'Cordoba Oro', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'NGN', name: 'Naira', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'OMR', name: 'Rial Omani', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'PKR', name: 'Pakistan Rupee', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'PAB', name: 'Balboa', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'PGK', name: 'Kina', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'PYG', name: 'Guarani', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'PEN', name: 'Nuevo Sol', display: false, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0 },
	  {value: 'PHP', name: 'Philippine Peso', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'QAR', name: 'Qatari Rial', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'RWF', name: 'Rwanda Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'SHP', name: 'Saint Helena Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'WST', name: 'Tala', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'STD', name: 'Dobra', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SAR', name: 'Saudi Riyal', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'RSD', name: 'Serbian Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SCR', name: 'Seychelles Rupee', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SLL', name: 'Leone', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SGD', name: 'Singapore Dollar', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0 },
	  {value: 'SBD', name: 'Solomon Islands Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SOS', name: 'Somali Shilling', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SSP', name: 'South Sudanese Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'LKR', name: 'Sri Lanka Rupee', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SDG', name: 'Sudanese Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SRD', name: 'Surinam Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SZL', name: 'Lilangeni', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'CHE', name: 'WIR Euro', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'CHW', name: 'WIR Franc', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'SYP', name: 'Syrian Pound', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'TJS', name: 'Somoni', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'TZS', name: 'Tanzanian Shilling', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'THB', name: 'Thai Baht', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'TOP', name: 'Pa’anga', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'TTD', name: 'Trinidad and Tobago Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'TND', name: 'Tunisian Dinar', display: false, custom_trade_currency_dropdown: false, standard_precision: 3, order: 0 },
	  {value: 'TMT', name: 'Turkmenistan New Manat', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'UGX', name: 'Uganda Shilling', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'UAH', name: 'Hryvnia', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'AED', name: 'UAE Dirham', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'USN', name: 'US Dollar (Next day)', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'USS', name: 'US Dollar (Same day)', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'UYI', name: 'Uruguay Peso en Unidades Indexadas (URUIURUI)', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'UYU', name: 'Peso Uruguayo', display: false, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0 },
	  {value: 'UZS', name: 'Uzbekistan Sum', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'VUV', name: 'Vatu', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'VEF', name: 'Bolivar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'VND', name: 'Dong', display: false, custom_trade_currency_dropdown: false, standard_precision: 0, order: 0 },
	  {value: 'YER', name: 'Yemeni Rial', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ZMK', name: 'Zambian Kwacha', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },
	  {value: 'ZWL', name: 'Zimbabwean Dollar', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0 },

	  // Precious Metals
	  {value: 'XAU', name: 'Gold', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'XAU (-0.5%pa)', name: 'Gold', display: false, custom_trade_currency_dropdown: false, standard_precision: 2, order: 0},
	  {value: 'XAG', name: 'Silver', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},
	  {value: 'XPT', name: 'Platinum', display: true, custom_trade_currency_dropdown: true, standard_precision: 2, order: 0},

	  // Cryptocurrencies
	  {value: 'BTC', name: 'Bitcoin', display: true, custom_trade_currency_dropdown: true, standard_precision: 4, order: 2},
	  {value: 'LTC', name: 'Litecoin', display: true, custom_trade_currency_dropdown: true, standard_precision: 4, order: 1},
	  {value: 'STR', name: 'Stellars', display: true, custom_trade_currency_dropdown: true, standard_precision: 0, order: 0}
	];


/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Ripple trading default currency pairs.
	 *
	 * This list is a bit arbitrary, but it's basically the Majors [1] from forex
	 * trading with some XRP pairs added.
	 *
	 * [1] http://en.wikipedia.org/wiki/Currency_pair#The_Majors
	 */

	var DEFAULT_PAIRS = [
	  {name: 'XRP/USD.SnapSwap', last_used: 10}
	  // {name: 'XAU (-0.5%pa)/XRP', last_used: 2},
	  // {name: 'XAU (-0.5%pa)/USD', last_used: 2},
	  // {name: 'BTC/XRP', last_used: 1},
	  // {name: 'XRP/USD', last_used: 1},
	  // {name: 'XRP/EUR', last_used: 1},
	  // {name: 'XRP/JPY', last_used: 0},
	  // {name: 'XRP/GBP', last_used: 0},
	  // {name: 'XRP/AUD', last_used: 0},
	  // {name: 'XRP/CHF', last_used: 0},
	  // {name: 'XRP/CAD', last_used: 0},
	  // {name: 'XRP/CNY', last_used: 0},
	  // {name: 'XRP/MXN', last_used: 0},
	  // {name: 'BTC/USD', last_used: 0},
	  // {name: 'BTC/EUR', last_used: 0},
	  // {name: 'EUR/USD', last_used: 0},
	  // {name: 'USD/JPY', last_used: 0},
	  // {name: 'GBP/USD', last_used: 0},
	  // {name: 'AUD/USD', last_used: 0},
	  // {name: 'USD/MXN', last_used: 0},
	  // {name: 'USD/CHF', last_used: 0}
	];

	module.exports = DEFAULT_PAIRS;

/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	switch (tx.type){
	case "sent":
	buf.push('<div class="type-info">Odoslali ste <span class="number">{{tx.amount | rpamount}}</span> <span class="currency">{{tx.currency}}</span> na adresu <span title="{{tx.counterparty}}">{{tx.counterparty | rpcontactname}}</span></div>');
	  break;
	case "received":
	buf.push('<div class="type-success"><span title="{{tx.counterparty}}">{{tx.counterparty | rpcontactname}} vám odoslal/a</span>&#32;<span class="number">{{tx.amount | rpamount}}</span>&#32;<span class="currency">{{tx.currency}}</span></div>');
	  break;
	case "trusted":
	buf.push('<div class="type-success"><span title="{{tx.counterparty}}">{{tx.counterparty | rpcontactname}} vám poskytol úver vo výške</span>&#32;<span class="number">{{tx.amount | rpamount}}</span>&#32;<span class="currency">{{tx.currency}}</span></div>');
	  break;
	case "trusting":
	buf.push('<div class="type-success"><span title="{{tx.counterparty}}">You have now connected to the gateway&#32;<span>{{tx.counterparty | rpcontactname}}</span><span l10n-inc="l10n-inc">&#32;for&#32;</span><span><span class="number">{{tx.amount | rpamount}}</span>&#32;<span class="currency">{{tx.currency}}</span></span>.</span></div>');
	  break;
	}
	}
	return buf.join("");
	}

/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = {
	  // Ripple Credits
	  "XRP":[0, 0],

	  // Official ISO-4217
	  "AFN":[971, 2],
	  "EUR":[978, 2],
	  "ALL":[8, 2],
	  "DZD":[12, 2],
	  "USD":[840, 2],
	  "AOA":[973, 2],
	  "XCD":[951, 2],
	  "ARS":[32, 2],
	  "AMD":[51, 2],
	  "AWG":[533, 2],
	  "AUD":[36, 2],
	  "AZN":[944, 2],
	  "BSD":[44, 2],
	  "BHD":[48, 3],
	  "BDT":[50, 2],
	  "BBD":[52, 2],
	  "BYR":[974, 0],
	  "BZD":[84, 2],
	  "XOF":[952, 0],
	  "BMD":[60, 2],
	  "BTN":[64, 2],
	  "INR":[356, 2],
	  "BOB":[68, 2],
	  "BOV":[984, 2],
	  "BAM":[977, 2],
	  "BWP":[72, 2],
	  "NOK":[578, 2],
	  "BRL":[986, 2],
	  "BND":[96, 2],
	  "BGN":[975, 2],
	  "BIF":[108, 0],
	  "KHR":[116, 2],
	  "XAF":[950, 0],
	  "CAD":[124, 2],
	  "CVE":[132, 2],
	  "KYD":[136, 2],
	  "CLF":[990, 0],
	  "CLP":[152, 0],
	  "CNY":[156, 2],
	  "COP":[170, 2],
	  "COU":[970, 2],
	  "KMF":[174, 0],
	  "CDF":[976, 2],
	  "NZD":[554, 2],
	  "CRC":[188, 2],
	  "HRK":[191, 2],
	  "CUC":[931, 2],
	  "CUP":[192, 2],
	  "ANG":[532, 2],
	  "CZK":[203, 2],
	  "DKK":[208, 2],
	  "DJF":[262, 0],
	  "DOP":[214, 2],
	  "EGP":[818, 2],
	  "SVC":[222, 2],
	  "ERN":[232, 2],
	  "ETB":[230, 2],
	  "FKP":[238, 2],
	  "FJD":[242, 2],
	  "XPF":[953, 0],
	  "GMD":[270, 2],
	  "GEL":[981, 2],
	  "GHS":[936, 2],
	  "GIP":[292, 2],
	  "GTQ":[320, 2],
	  "GBP":[826, 2],
	  "GNF":[324, 0],
	  "GYD":[328, 2],
	  "HTG":[332, 2],
	  "HNL":[340, 2],
	  "HKD":[344, 2],
	  "HUF":[348, 2],
	  "ISK":[352, 0],
	  "IDR":[360, 2],
	  "IRR":[364, 2],
	  "IQD":[368, 3],
	  "ILS":[376, 2],
	  "JMD":[388, 2],
	  "JPY":[392, 0],
	  "JOD":[400, 3],
	  "KZT":[398, 2],
	  "KES":[404, 2],
	  "KPW":[408, 2],
	  "KRW":[410, 0],
	  "KWD":[414, 3],
	  "KGS":[417, 2],
	  "LAK":[418, 2],
	  "LVL":[428, 2],
	  "LBP":[422, 2],
	  "LSL":[426, 2],
	  "ZAR":[710, 2],
	  "LRD":[430, 2],
	  "LYD":[434, 3],
	  "CHF":[756, 2],
	  "LTL":[440, 2],
	  "MOP":[446, 2],
	  "MKD":[807, 2],
	  "MGA":[969, 2],
	  "MWK":[454, 2],
	  "MYR":[458, 2],
	  "MVR":[462, 2],
	  "MRO":[478, 2],
	  "MUR":[480, 2],
	  "MXN":[484, 2],
	  "MXV":[979, 2],
	  "MDL":[498, 2],
	  "MNT":[496, 2],
	  "MAD":[504, 2],
	  "MZN":[943, 2],
	  "MMK":[104, 2],
	  "NAD":[516, 2],
	  "NPR":[524, 2],
	  "NIO":[558, 2],
	  "NGN":[566, 2],
	  "OMR":[512, 3],
	  "PKR":[586, 2],
	  "PAB":[590, 2],
	  "PGK":[598, 2],
	  "PYG":[600, 0],
	  "PEN":[604, 2],
	  "PHP":[608, 2],
	  "PLN":[985, 2],
	  "QAR":[634, 2],
	  "RON":[946, 2],
	  "RUB":[643, 2],
	  "RWF":[646, 0],
	  "SHP":[654, 2],
	  "WST":[882, 2],
	  "STD":[678, 2],
	  "SAR":[682, 2],
	  "RSD":[941, 2],
	  "SCR":[690, 2],
	  "SLL":[694, 2],
	  "SGD":[702, 2],
	  "SBD":[90, 2],
	  "SOS":[706, 2],
	  "SSP":[728, 2],
	  "LKR":[144, 2],
	  "SDG":[938, 2],
	  "SRD":[968, 2],
	  "SZL":[748, 2],
	  "SEK":[752, 2],
	  "CHE":[947, 2],
	  "CHW":[948, 2],
	  "SYP":[760, 2],
	  "TWD":[901, 2],
	  "TJS":[972, 2],
	  "TZS":[834, 2],
	  "THB":[764, 2],
	  "TOP":[776, 2],
	  "TTD":[780, 2],
	  "TND":[788, 3],
	  "TRY":[949, 2],
	  "TMT":[934, 2],
	  "UGX":[800, 0],
	  "UAH":[980, 2],
	  "AED":[784, 2],
	  "USN":[997, 2],
	  "USS":[998, 2],
	  "UYI":[940, 0],
	  "UYU":[858, 2],
	  "UZS":[860, 2],
	  "VUV":[548, 0],
	  "VEF":[937, 2],
	  "VND":[704, 0],
	  "YER":[886, 2],
	  "ZMK":[894, 2],
	  "ZWL":[932, 2]
	}


/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<div ng-switch on="engine_result | rptruncate:3" class="transaction-error"><group ng-switch-when="tes"><group ng-hide="accepted" class="pending"><h2 class="tx-status">Payment pending</h2></group><group ng-show="accepted" class="result-success"><h2 class="tx-status">Payment successful</h2></group></group><group ng-switch-when="tem" class="result-malformed"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span ng-switch-default="ng-switch-default">Error code: {{engine_result}} - {{engine_result_message}}</span></p></group><group ng-switch-when="tef" class="result-malformed"><div ng-switch on="engine_result"><div ng-switch-when="tefMAX_LEDGER"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span>Your payment timed out, please try again.</span></p></div><div ng-switch-default="ng-switch-default"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tefDST_TAG_NEEDED">Error code: Destination tag needed [tefDST_TAG_NEEDED].</span></p></div></div></group><group ng-switch-when="tel" class="result-failed"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span ng-switch-when="telINSUF_FEE_P">Error code: This transaction failed because it exceeded the maximum network fee, please try again later [telINSUF_FEE_P].</span></p></group><group ng-switch-when="tec" class="result-malformed"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tecNO_DST">Error code: No destination [tecNO_DST].</span><span ng-switch-when="tecNO_DST_INSUF_XRP">Error code: Insufficient XRP sent to destination [tecNO_DST_INSUF_XRP].</span><span ng-switch-default="ng-switch-default">Chyba: {{engine_result_message}}</span></p></group><group ng-switch-when="ter" class="result-failed"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span ng-switch-when="terNO_LINE">Error code: You have no trust line in this currency [terNO_LINE].</span></p><span ng-switch-default="ng-switch-default">Your payment failed: {{engine_result}} - {{engine_result_message}}</span></group><group ng-switch-when="tej" class="result-failed"><h2 class="tx-status">Payment failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tejLost">Error code: Transaction could not be submitted [tejLost].</span><span ng-switch-when="tejMaxFeeExceeded">This transaction failed because the current network fee is higher than your account limit. You can adjust your maximum network fee in Settings &gt Advanced, or try again later. <br>\nError code: Network fee exceeded [tejMaxFeeExceeded].</span></p><span ng-switch-default="ng-switch-default">Your payment could not be submitted: {{engine_result}} - {{engine_result_message}}</span></group></div>');
	}
	return buf.join("");
	}

/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<form role="form" ng-submit="confirm()"><div class="modal-header">Unlock account</div><div class="modal-body"><div class="form-group"><label for="popup_unlock_password">Password</label><input id="popup_unlock_password" type="password" name="popup_unlock_password" ng-model="unlock.password" rp-focus="rp-focus" class="form-control"/></div><p ng-switch on="unlock.purpose" class="help-block"><span ng-switch-when="showSecret">Please enter your password to show your secret key.</span><span ng-switch-default="ng-switch-default">Please enter your password to confirm this transaction.</span></p><div ng-show="unlock.error == \'password\'" class="alert alert-danger">This password is incorrect, please try again.</div><p ng-show="unlock.isConfirming" rp-spinner="4" class="literal">Confirming password</p></div><div class="modal-footer"><div class="unlock-btns-wrapper"><button type="submit" ng-disabled="isConfirming" class="btn btn-primary modal-submit-btn">Submit</button><button type="button" ng-click="cancel()" class="btn btn-default modal-close-btn">Close</button></div></div></form>');
	}
	return buf.join("");
	}

/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {

	var util = __webpack_require__(47),
	    webutil = __webpack_require__(51),
	    log = __webpack_require__(52);

	var Tab = function (config)
	{
	};

	Tab.prototype.pageMode = 'default';

	Tab.prototype.mainMenu = 'none';

	/**
	 * AngularJS dependencies.
	 *
	 * List any controllers the tab uses here.
	 */
	Tab.prototype.angularDeps = [
	  // Directives
	  'charts',
	  'effects',
	  'events',
	  'fields',
	  'formatters',
	  'directives',
	  'validators',
	  'datalinks',
	  // Filters
	  'filters'
	];

	/**
	 * Other routes this tab should handle.
	 */
	Tab.prototype.aliases = [];

	exports.Tab = Tab;


/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="RegisterCtrl" class="col-xs-12 content"><div ng-show="mode==&quot;register_new_account&quot;" class="row auth-form-container col-sm-offset-2 col-sm-8 col-md-offset-3 col-md-6"><div class="auth-form-wrapper"><h2>Create new account</h2><div class="form-group"><a ng-click="goTo(&quot;/login&quot;)" class="btn btn-block btn-link">Open existing account</a></div><div class="form-group"><a ng-click="fileInputClick()" class="btn btn-block btn-default">Create an empty account</a></div><div class="form-group"><a ng-click="mode=&quot;register_with_secret&quot;" class="btn btn-block btn-default">Create a new account with a secret key</a></div></div></div><div ng-show="mode==&quot;register_empty_wallet&quot;" class="row auth-form-container col-sm-offset-2 col-sm-8 col-md-offset-3 col-md-6"><div class="auth-form-wrapper"><h2>Create empty account</h2><p>Encrypt your new account file: {{walletfile}}</p><form name="registerForm" ng-submit="submitForm()"><label for="register_password" class="hide">Wallet file</label><div ng-class="{\'field-error\': \'weak\' === strength}" class="form-group"><label for="register_password">Password</label><input id="register_password" name="register_password1" type="password" autocomplete="off" ng-model="password1" rp-strong-password="rp-strong-password" required="required" rp-same-in-set="passwordSet" rp-focus="rp-focus" class="form-control"/><p ng-show="strength==\'weak\'"><span>Your password is weak. It is not a mix of letters, numbers and symbols.</span></p></div><div ng-class="{\'field-error\': registerForm.register_password1.$error.rpSameInSet &amp;&amp; registerForm.register_password2.$dirty}" class="form-group"><label for="register_password2">Confirm password</label><input id="register_password2" name="register_password2" autocomplete="off" type="password" ng-model="password2" required="required" rp-same-in-set="passwordSet" class="form-control"/><p ng-show="registerForm.register_password1.$error.rpSameInSet &amp;&amp; registerForm.register_password2.$dirty"><span>Heslá sa nezhodujú</span></p></div><div ng-show=""></div><div class="form-group"><div class="strength {{strength}}">{{strength}}</div></div><div class="submit-btn-container"><button type="submit" ng-disabled="registerForm.$invalid || submitLoading" rp-spinner="{{submitLoading ? 4 : null}}" class="btn btn-block btn-success">Encrypt account</button><a ng-click="reset()" class="btn btn-block btn-link">Cancel and delete account file</a></div></form></div></div><div ng-show="mode==&quot;register_with_secret&quot; || oldUserBlob" class="row auth-form-container col-sm-offset-2 col-sm-8 col-md-offset-3 col-md-6"><div class="auth-form-wrapper"><h2>Create account with secret key</h2><form name="useSecretKey" ng-submit="submitSecretKeyForm()"><div ng-class="{\'field-error\': registerForm.secret.$error.rpMasterKey &amp;&amp; registerForm.secret.$dirty}" class="form-group"><label for="masterkey">Enter your secret key</label>&#32;<i rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-title="Using a secret key" rp-popover-trigger="hover" data-content="This will create a new Ripple account from your secret key." class="fa fa-question-circle"></i><input id="secretKey" type="text" name="secretKey" ng-model="secretKey" rp-master-key="rp-master-key" required="required" rp-focus="rp-focus" class="form-control"/><p ng-show="useSecretKey.secret.$error.rpMasterKey &amp;&amp; registerForm.secret.$dirty"><span>Secret is invalid</span></p></div><div class="submit-btn-container"><button type="submit" ng-disabled="useSecretKey.$invalid || submitLoading" rp-spinner="{{submitLoading ? 4 : null}}" class="btn btn-block btn-success">Create new account</button><a ng-click="reset()" class="btn btn-block btn-link">Zrušiť</a></div></form></div><div class="switch-mode-link-container">Have an account?&#32;<a href="#login" l10n-inc="l10n-inc">Log In</a></div></div><div ng-show="mode==&quot;welcome&quot;" class="row mode-welcome"><div class="col-xs-12 col-md-10 col-md-offset-1"><p class="important">Dôležité:</p><p class="hint">The secret key below gives access to your money in the unlikely case that you lose your password.\n In that case your contacts will be lost, but with this secret key alone anyone can retrieve your money. So please\n store it somewhere PRIVATE AND SAFE. Read more about keys and wallet safety in&#32;<a href="#">Bezpečnosť</a></p><div class="credentials"><span class="password">Passphrase:<span ng-show="showPassword==true" class="value">{{password1}}&#32;</span><span ng-hide="showPassword==true" class="value">{{password}}</span><rp-confirm action-text="Are you in a safe place where no person or camera can see your screen?" action-button-text="Yes, show me" action-function="showPassword=true" cancel-button-text="no" ng-hide="showPassword==true"><a href="">Zobraziť</a></rp-confirm><a href="" ng-click="showPassword=false" ng-show="showPassword==true">Skryť</a></span></div><div class="secret"><p class="important">Ripple address</p><p class="key">{{address}}</p><p class="important">Secret key:</p><p ng-show="showSecret==true" class="key">{{keyOpen}}</p><p ng-hide="showSecret==true" class="key">{{key}}</p><p ng-hide="showSecret==true"><rp-confirm action-text="Are you in a safe place where no person or camera can see your screen?" action-button-text="Yes, show me" action-function="showSecret=true" cancel-button-text="no"><button class="btn btn-info btn-sm">Show secret key</button></rp-confirm></p><p ng-show="showSecret==true"><button ng-click="showSecret=false" class="btn btn-info btn-sm">Hide secret key</button></p></div><p class="important">Have you saved your secret key somewhere safe?</p><div class="row"><div class="col-xs-12 col-sm-5 col-lg-4"><a href="#balance" ng-click="goToFund()" class="btn btn-info btn-block btn-big">Yes, I saved my secret key</a></div></div></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="LoginCtrl" class="col-xs-12 content"><div class="auth-attention text-center">You will not be able to login to the downloadable client using a username/password you create on Ripple Trade\n or the web version of the Ripple Client. You can only use a secret key to access an existing Ripple account.\n This is because the downloadable client stores your login information locally on your computer, so your account\n is as safe as the security of your personal computer.</div><div class="row auth-form-container col-sm-offset-2 col-sm-8 col-md-offset-3 col-md-6"><div class="auth-form-wrapper"><form name="loginForm" ng-disabled="loginForm.$invalid || ajax_loading" ng-submit="submitForm()"><h2>Open account</h2><div class="form-group"><a href="#register" class="btn btn-block btn-link">Create new account</a></div><div class="form-group"><a ng-click="fileInputClick()" class="btn btn-block btn-default">Select account file {{walletfile}}</a></div><div class="form-group hide"><label for="login_walletfile">Select account file</label><input id="login_walletfile" name="login_walletfile" type="file" ng-model="walletfile" class="form-control"/></div><div class="form-group"><label for="login_password">Account password</label><input id="login_password" name="login_password" type="password" ng-model="password" required="required" class="form-control"/></div><div ng-show="error" class="text-error"><br/><span>{{error}}</span></div><div ng-show="status" class="text-status"><span>{{status}}</span><div ng-repeat="message in backendMessages" class="backend"><b>{{message.backend}} &#32;</b><span>{{message.message}}</span></div></div><div class="submit-btn-container"><button type="submit" ng-disabled="loginForm.$invalid || ajax_loading" rp-spinner="{{ajax_loading ? 4 : null}}" class="btn btn-submit btn-block btn-success"><span>Open account</span></button></div></form></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="BalanceCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><group ng-hide="!connected || loadState.account" class="disconnected"><p class="literal">Načítanie...</p></group><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><group ng-show="connected &amp;&amp; loadState.account"><div class="row"><div class="col-xs-12"><div class="currency-summary"><div class="balancebox currency-xrp"><div class="total row"><div class="lbl col-xs-8"><a href="" ng-click="entry.show=!entry.show"><i class="icon-ripple-logo"></i>XRP – Ripple</a></div><div class="balance col-xs-2"><span ng-show="account.Balance">{{ account.Balance | rpamount:{precision: 5, min_precision: 5, max_sig_digits: 20} }}</span><span ng-hide="account.Balance">0</span></div></div><div ng-show="entry.show" class="component row"><div class="lbl col-xs-8"><span>Available&#32;</span><i rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-title="Available amount" rp-popover-trigger="hover" data-content="Total amount of XRP in your account minus the reserve amount." class="fa fa-question-circle"></i></div><div class="balance col-xs-2"><span ng-show="account.max_spend">{{account.max_spend | rpamount:{precision: 6, min_precision: 6, max_sig_digits: 20} }}</span><span ng-hide="account.max_spend">0</span></div></div><div ng-show="entry.show" class="component row"><div class="lbl col-xs-8"><span>Reserve&#32;</span><i rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-title="Reserve amount" rp-popover-trigger="hover" data-content="Minimum amount of XRP required to fund your account. You cannot spend the reserve." class="fa fa-question-circle"></i></div><div class="balance col-xs-2"><span ng-show="account.reserve">{{ account.reserve | rpamount:{precision: 6, min_precision: 6, max_sig_digits: 20} }}</span><span ng-hide="account.reserve">0</span></div></div></div><div ng-repeat="entry in balances" ng-class="\'currency-\' + (entry.total | rpcurrency | lowercase)" class="balancebox currency-non-native"><div class="total row"><div class="lbl col-xs-8"><a href="" ng-click="entry.show=!entry.show"><i ng-class="\'fa-\' + (entry.total | rpcurrency | lowercase)" class="icon fa fa-money"></i><span rp-currency="entry.total" rp-currency-full="rp-currency-full"></span></a></div><div class="balance col-xs-2"><a href="" ng-click="entry.show=!entry.show">{{ entry.total | rpamount:{precision: 5, min_precision: 5, max_sig_digits: 20} }}</a></div></div><div ng-repeat="(issuer, component) in entry.components" ng-show="entry.show" class="component row"><div class="head"><div ng-show="component.gateway.app" class="lbl col-xs-8">{{component.gateway.app.name}}<span ng-hide="true" class="status unverified">Unverified</span></div><div ng-hide="component.gateway.app" rp-pretty-identity="issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" class="lbl balance-text-wrapper col-xs-8"></div><div class="balance col-xs-2">{{ component | rpamount:{precision: 6, min_precision: 6, max_sig_digits: 20} }}</div></div></div></div></div></div></div></group></section>');
	}
	return buf.join("");
	}

/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="ContactsCtrl" class="col-xs-12 content"><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected &amp;&amp; !debug"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><div class="row row-padding-small head hidden-xs"><div class="col-xs-3 col-sm-3 col-md-3">Contact</div><div class="col-xs-6">Ripple address</div><div class="col-xs-12 col-sm-4 col-md-2 text-right"><a ng-click="toggle_form()" ng-disabled="addform_visible" class="btn btn-block btn-success btn-sm sign">Pridať kontakt</a></div></div><hr/><div class="row head visible-xs"><div class="col-xs-12 col-sm-2"><a ng-click="toggle_form()" ng-disabled="addform_visible" class="btn btn-success btn-block btn-sm sign custom-btn">Pridať kontakt</a></div></div><div ng-show="addform_visible" class="row row-padding-small addForm"><div class="col-xs-12 col-md-6 col-sm-8"><form id="addForm" name="addForm" ng-submit="create()" rp-unique-scope="rp-unique-scope"><div class="form-group"><label for="Name">Contact</label><input id="name" name="name" type="text" step="any" maxlength="70" ng-model="contact.name" rp-unique="userBlob.data.contacts" rp-unique-field="name" rp-autofill="$routeParams.name" rp-autofill-on="addform_visible = true" required="required" rp-focus="rp-focus" class="form-control input-lg name"/><div rp-errors="name" class="errorGroup"><div rp-error-on="required" class="error">Please enter a contact.</div><div rp-error-on="rpUnique" class="error">This contact already exists.</div></div></div><div class="form-group"><div><label for="address_desktop">Ripple address</label><div class="spinnerEnabledInput"><input id="address_desktop" name="address_desktop" type="text" step="any" ng-model="contact.view" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-ripple-name="rp-dest-ripple-name" rp-dest-email="rp-dest-email" rp-dest-check-federation="rp-dest-check-federation" rp-dest-federation-model="contact.federation" rp-dest-model="contact.address" rp-dest-loading="address_loading" rp-unique="userBlob.data.contacts" rp-unique-field="address" rp-unique-group="address-dt-desktop" rp-spinner="{{address_loading ? 4 : null}}" rp-autofill="$routeParams.to" rp-autofill-on="addform_visible = true" required="required" class="form-control input-lg address"/></div><div rp-errors="address_desktop" class="errorGroup"><div rp-error-on="required" class="error">Please enter a Ripple name or address.</div><div rp-error-on="rpUnique" class="error">You already have a contact with the same Ripple address and/or the same Destination tag.</div><div rp-error-on="rpDest" class="error">Not a valid Ripple name or address.</div></div></div></div><div class="form-group"><div ng-hide="contact.federation"><label for="dt_desktop">Značka adresáta</label><input id="dt_desktop" name="dt_desktop" type="text" step="any" placeholder="Leave blank if not applicable" ng-model="contact.dt" rp-unique="userBlob.data.contacts" rp-unique-field="dt" rp-unique-group="address-dt-desktop" rp-stdt="rp-stdt" rp-autofill="$routeParams.dt" class="form-control input-lg dt"/><div rp-errors="dt_desktop" class="errorGroup"><div rp-error-on="rpStdt" class="error">Neplatná značka adresáta</div><div rp-error-on="rpUnique" class="error">You already have a contact with the same Ripple address and/or the same Destination tag.</div></div></div></div><div class="row"><div class="col-xs-8 col-sm-8 col-md-9 text-left"><button type="submit" ng-disabled="addForm.$invalid" class="btn btn-success btn-block submit custom-btn">Pridať kontakt</button></div><div class="col-xs-4 col-sm-4 col-md-3 text-center"><button type="button" ng-click="addform_visible = false" class="btn btn-default btn-block custom-btn btn-cancel">zrušiť</button></div></div></form></div></div><div ng-repeat="entry in userBlob.data.contacts" ng-class="{editing: editing}" ng-controller="ContactRowCtrl" class="row row-padding-small contact"><div ng-hide="editing" class="col-xs-3 col-md-3 col-sm-3"><span ng-hide="editing" class="name">{{entry.name}}</span></div><div ng-hide="editing" class="col-xs-12 col-sm-6 col-md-6"><div class="hidden-xs"><b>{{entry.address | rpaddressorigin}}: </b><b rp-ripple-name="entry.address">???</b></div></div><div ng-hide="editing" class="col-xs-6 col-sm-3 col-md-3 text-right pull-right"><div class="row"><div ng-hide="editing" class="col-xs-4 col-md-4 col-sm-4"><button ng-click="edit($index)" class="edit btn btn-block btn-default btn-sm btn-link">upraviť</button></div><div ng-hide="editing" class="col-xs-8 col-md-8 col-sm-8"><button ng-click="send($index)" class="send btn btn-block btn-primary btn-sm">Odoslať</button></div></div></div><div class="col-xs-12"><div ng-show="editing" class="row"><div class="col-md-3 col-sm-4 col-xs-12 contact-input-wrapper"><ng-form name="inlineName" class="inline-name-form"><input name="editname" type="text" maxlength="70" ng-model="editname" rp-unique="userBlob.data.contacts" rp-unique-field="name" rp-unique-orig="entry.name" ng-enter="update($index)" class="form-control inline"/><div rp-errors="editname" class="errorGroup"><div rp-error-on="rpUnique" class="error">Už máte kontakt s týmto menom.</div></div></ng-form></div><div class="col-md-4 col-sm-4 col-xs-12 address-wrapper"><ng-form name="inlineAddress"><input name="editaddress" type="text" ng-model="editaddress" rp-unique="userBlob.data.contacts" rp-unique-field="address" rp-unique-orig="entry.address" rp-dest="rp-dest" rp-dest-address="rp-dest-address" ng-enter="update($index)" class="form-control inline"/><div rp-errors="editaddress" class="errorGroup"><div rp-error-on="rpUnique" class="error">Už máte túto adresu.</div><div rp-error-on="rpDest" class="error">Neplatná adresa.</div></div><div class="form-group"><label for="contact_dt">Značka adresáta</label><input id="contact_dt" name="dt" type="text" step="any" placeholder="Leave blank if not applicable" ng-model="editdt" rp-stdt="rp-stdt" rp-autofill="$routeParams.dt" ng-enter="update($index)" class="form-control dt inline"/><div rp-errors="dt" class="errorGroup"><div rp-error-on="rpStdt" class="error">Neplatná značka adresáta.</div></div></div></ng-form></div><div class="col-md-5 col-sm-4 col-xs-12"><div class="row"><div class="col-xs-4 col-md-4"><button ng-disabled="inlineAddress.editaddress.$error.rpDest" ng-click="update($index)" class="save btn btn-block btn-success">Uložiť</button></div><div class="col-xs-4 col-md-4"><rp-confirm action-text="Are you sure you want to delete this contact?" action-button-text="Delete" action-button-css="btn btn-default btn-danger delete-contact-btn" action-function="remove($index)" cancel-button-css="btn btn-default cancel-btn btn-cancel" cancel-button-text="Cancel" ng-hide="showPassword==true"><a href="" class="btn btn-danger btn-block">Vymazať</a></rp-confirm></div><div ng-show="editing" class="col-xs-4 col-md-4"><button ng-click="cancel($index)" class="editing btn-block btn btn-default btn-sm btn-cancel">zrušiť</button></div></div></div></div></div></div><div ng-hide="userBlob.data.contacts.length">You don\'t have any contacts yet.\n Click on \'Add contact\' button in the top right corner to add a new contact.</div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="HistoryCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><group ng-hide="!connected || loadState.transactions" class="disconnected"><p class="literal">Načítanie histórie...</p></group><group ng-show="connected &amp;&amp; loadState.transactions &amp;&amp; account.Balance" class="row"><div class="filters row-padding-small col-md-3 col-sm-5 col-xs-12"><div class="filter type-filter row"><div class="col-xs-12 filters-wrapper"><a href="" ng-click="showFilterTxTypes=!showFilterTxTypes" class="filter-title">Transaction type<div ng-show="showFilterTxTypes" class="fa fa-caret-right"></div><div ng-hide="showFilterTxTypes" class="fa fa-caret-down"></div></a><div ng-hide="showFilterTxTypes" class="filter-choices"><div ng-repeat="name in orderedTypes"><label ng-class="{active: types[name].checked}"><i ng-show="types[name].checked" class="fa fa-plus"></i><i ng-hide="types[name].checked" class="fa fa-minus"></i><span class="name">{{name}}</span><!--span.count {{typeUsage[name] || 0}}--><input type="checkbox" name="type-filter" ng-model="types[name].checked"/></label></div></div></div></div><div class="filter date-filter row"><div class="col-xs-12 filters-wrapper"><a href="" ng-click="showFilterDate=!showFilterDate" class="filter-title">Date<div ng-show="showFilterDate" class="fa fa-caret-right"></div><div ng-hide="showFilterDate" class="fa fa-caret-down"></div></a><div ng-hide="showFilterDate" class="row"><div class="col-xs-12"><div class="filter-description">Načítať históriu pre konkrétne časové obdobie</div><div class="filter-form-wrapper"><form ng-submit="submitDateRangeForm()" class="filter-choices"><div class="input-group inline-inputs-group"><div class="input-group-addon"><i class="fa fa-calendar"></i><span>Od</span></div><div class="input-wrapper"> <input type="text" rp-datepicker="rp-datepicker" ng-model="dateMinView" readonly="readonly" class="form-control"/></div></div><div class="input-group inline-inputs-group"><div class="input-group-addon"><i class="fa fa-calendar"></i><span>Komu</span></div><div class="input-wrapper"> <input type="text" rp-datepicker="rp-datepicker" ng-model="dateMaxView" readonly="readonly" class="form-control"/></div></div><button type="submit" class="btn btn-block btn-primary submit">Filter</button></form></div></div></div></div></div></div><div class="transactions col-md-9 col-sm-7 col-xs-12"><div class="head row hidden-xs"><div class="col-md-9 hidden-sm"><div class="type"></div><div class="i"></div><div class="dt">Dátum</div><div class="desc">Popis</div></div><div class="visible-sm col-sm-5"></div><div class="col-md-3 col-sm-7 export-btn-wrapper text-right"><a id="csv" href="" ng-click="exportCsv()" rp-download="historyCsv" rp-download-csv="true" rp-download-filename="ripple_historic.csv" class="btn btn-primary btn-block btn-sm">Export to CSV</a></div></div><div ng-hide="historyState==\'loading\' || historyShow" class="message">Prepáčte, žiadne transakcie nevyhovujú vami zadanému filtru.</div><div class="head row visible-xs"><div class="col-xs-12 export-btn-wrapper text-right"><a id="csv" href="" ng-click="exportCsv()" rp-download="historyCsv" rp-download-csv="true" rp-download-filename="ripple_historic.csv" class="btn btn-primary btn-block btn-sm">Export to CSV</a></div></div><ul><li ng-repeat="entry in historyShow track by entry.hash" ng-click="details[entry.hash] = !details[entry.hash]" ng-class="{open: details[entry.hash]}" ng-class-odd="\'odd\'" rp-pretty-amount-date="entry.dateRaw" class="{{entry.transaction.type}}"><div class="info"><span class="type">&nbsp;</span><span ng-hide="entry.details" class="i"><i ng-show="entry.transaction.type==\'received\'" class="fa fa-arrow-down"></i><i ng-show="entry.transaction.type==\'sent\'" class="fa fa-arrow-up"></i><i ng-show="entry.transaction.type==\'trusted\'" class="fa fa-download fa-rotate-90"></i><i ng-show="entry.transaction.type==\'trusting\'" class="fa fa-download fa-rotate-270"></i><i ng-show="!entry.transaction.type || entry.transaction.type==\'offernew\' || entry.transaction.type==\'offercancel\' || entry.transaction.type==\'exchange\' || entry.transaction.type==\'rippling\'" class="fa fa-exchange"></i><i ng-show="entry.transaction.type==\'accountset\'" class="fa fa-cogs"></i><i ng-show="entry.transaction.type==\'failed\'" class="fa fa-exclamation-triangle"></i></span><span ng-show="entry.details" class="i"><i class="fa fa-arrow-down"></i></span><span class="dt">{{entry.date | date:\'EEE, MMM d, h:mm:ss a\'}}</span><span ng-hide="entry.details" ng-switch on="entry.transaction.type" class="desc"><span ng-switch-when="sent"><span rp-span-spacing="rp-span-spacing">You sent<span rp-pretty-amount="entry.transaction.amountSent || entry.transaction.amount" class="amount"></span>to<span rp-pretty-identity="entry.transaction.counterparty" class="address"></span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="received"><span rp-span-spacing="rp-span-spacing"><span rp-pretty-identity="entry.transaction.counterparty" class="address"></span>sent you<span rp-pretty-amount="entry.transaction.amount" class="amount"></span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="exchange"><span rp-span-spacing="rp-span-spacing">You requested to exchange<span rp-pretty-amount="entry.transaction.spent" class="amount"></span>to<span rp-pretty-amount="entry.transaction.amount" class="amount"></span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="trusted"><span rp-span-spacing="rp-span-spacing"><span title="{{entry.transaction.counterparty}}" class="address">{{entry.transaction.counterparty | rpcontactname}}</span>now trusts you for<span rp-pretty-amount="entry.transaction.amount" class="amount"></span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="trusting"><span rp-span-spacing="rp-span-spacing">You have now connected to the gateway&#32;<span rp-pretty-identity="entry.transaction.counterparty" class="address"></span><span ng-show="advanced_feature_switch" l10n-inc="l10n-inc">&#32;for&#32;</span><span ng-show="advanced_feature_switch" rp-pretty-amount="entry.transaction.amount" class="amount"></span>.</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="offernew"><span ng-show="entry.transaction.sell" rp-span-spacing="rp-span-spacing">You created an order to sell<span rp-pretty-amount="entry.transaction.gets" class="amount"></span>for<span rp-pretty-amount="entry.transaction.pays" class="amount"></span></span><span ng-hide="entry.transaction.sell" rp-span-spacing="rp-span-spacing">You created an order to buy<span rp-pretty-amount="entry.transaction.pays" class="amount"></span>for<span rp-pretty-amount="entry.transaction.gets" class="amount"></span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="offercancel"><span rp-span-spacing="rp-span-spacing">You cancelled an order accepting&#32;<span rp-pretty-amount="entry.transaction.pays" class="amount"></span>for<span rp-pretty-amount="entry.transaction.gets" class="amount"></span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="accountset"><span>Informácie o účte boli zmenené</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="rippling"><span>Rippling</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="failed">Transakcia neúspešná</span><span ng-switch-when="error"><strong>Unknown transaction</strong><ul rp-if="details[entry.hash]" class="effects"><li><span>The client failed to parse this transaction. The developers have been notified of the issue.</span></li></ul></span><span ng-switch-default="ng-switch-default">');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span></span><span ng-show="entry.details" ng-switch on="entry.details.type" class="desc"><span ng-switch-when="giveaway"><span rp-span-spacing="rp-span-spacing"><span>{{entry.details.app.name}}</span> sent you<span rp-pretty-amount="entry.transaction.amount" class="amount"></span> and activated your account!</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span><span ng-switch-when="deposit"><span rp-span-spacing="rp-span-spacing">You deposited<span rp-pretty-amount="entry.transaction.amount" class="amount"></span> using {{entry.details.app.name}}</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</span></span></div><div ng-if="details[entry.hash]" class="details"><div ng-show="entry.balanceEffects" class="effects"><div class="title">Zmeny zostatku na účte</div><div class="effect header"><span class="description">Popis</span><span class="issuer">Vydavateľ</span><span class="amount">Množstvo</span><span class="balance">Konečný zostatok</span></div><div ng-repeat="effect in entry.balanceEffects" class="effect"><span class="description"><span ng-show="effect.type == \'balance_change\'" data-label="Description">XRP Balance Change</span><span ng-show="effect.type == \'trust_change_balance\'" data-label="Description">{{effect.currency}} Balance Change</span><span ng-show="effect.type == \'fee\'" data-label="Description">Poplatok</span></span><span rp-pretty-issuer="effect.amount.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-default="-" data-label="Issuer" class="issuer"></span><span data-label="Amount" rp-pretty-amount="effect.amount" class="amount"></span><span data-label="Final balance" rp-pretty-amount="effect.balance" class="balance"></span></div></div><div class="links"><a rp-link-tx="entry.hash" class="txLink">Podrobnosti transakcie</a><a href="#/contact?to={{entry.transaction.counterparty}}" rp-no-propagate="rp-no-propagate" ng-show="entry.transaction.counterparty &amp;&amp; !(entry.transaction.counterparty | rponlycontactname)" class="addLink">Pridať <strong> {{entry.transaction.counterparty | rpcontactname}}</strong> do zoznamu kontaktov</a></div></div></li></ul><div class="foot"><div ng-show="historyState==\'loading\'">Načítanie...</div><a ng-show="historyState==\'ready\'" href="" ng-click="loadMore()" class="loadmore">Načítať viac</a><div ng-show="historyState==\'full\'">Žiadne ďalšie transakcie</div></div></div></group></section><!-- TODO filter calendar: High/low limits.--><!-- TODO filter calendar: High limit calculation after the low limit--><!-- TODO we loose history after tab Change--><!-- TODO problem when manually editing date filter input field--><!-- TODO currency filter to work with also trust type--><!-- TODO optimization.. double (triple on load more) update history-->');
	}
	return buf.join("");
	}

/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="ExchangeCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><group ng-hide="!connected || loadState.account" class="disconnected"><div id="section_loader"><img src="img/sections.png" class="loader"/><div class="loading_sections">Načítanie...</div></div></group><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div><p class="literal">You have to be funded before you can submit an order.</p></div><form id="exchangeForm" name="exchangeForm" ng-show="mode==&quot;form&quot; &amp;&amp; account.Balance" ng-submit="exchange_prepared()" class="mode-form"><div class="form-group"><label for="amount">Receive</label><div class="row row-padding-small amount"><div class="col-sm-2 col-md-2 col-xs-3"><input id="amount" name="amount" type="text" ng-model="exchange.amount" required="required" rp-autofill="$routeParams.amount" rp-autofill-amount="rp-autofill-amount" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" class="value form-control"/></div><div class="col-sm-6 col-md-4 col-xs-9"><input id="amount_currency" name="amount_currency" type="text" rp-combobox="currency_choices" rp-combobox-select="rp-combobox-select" ng-model="exchange.currency_name" rp-autofill="$routeParams.amount" rp-autofill-currency="rp-autofill-currency" class="currency form-control"/></div></div><div rp-errors="amount" class="errorGroup"><div rp-error-on="required" class="error">Prosím, zadajte množstvo.</div><div rp-error-on="rpAmount" class="error">Neplatné množstvo.</div><div rp-error-on="rpAmountPositive" class="error">Prosím, zadajte množstvo väčšie ako 0.</div></div><p ng-show="exchange.path_status == \'waiting\'" class="literal"></p><p ng-show="exchange.path_status == \'pending\'" class="literal throbber">Prepočítavanie...</p><p ng-show="exchange.path_status == \'no-path\' &amp;&amp; exchange.currency_code != \'XRP\'" class="literal">Cannot convert to {{exchange.amount}} {{exchange.currency_name}}. Please make sure your account has enough funds, and a&#32;<a href="https://support.ripplelabs.com/hc/en-us/categories/200194186-Gateways" target="_blank">connection </a> to a {{exchange.currency_name}} gateway.</p><p ng-show="exchange.path_status == \'no-path\' &amp;&amp; exchange.currency_code == \'XRP\'" class="literal">Sorry! Cannot convert {{exchange.amount}} {{exchange.currency_name}}. Please make sure your account has enough funds.</p><p ng-show="exchange.path_status == \'error\'" class="literal">Chyba pri výpočte cesty</p></div><div class="currency_sets"><div ng-if="exchange.path_status == \'done\'" class="row row-padding-small"><div class="col-xs-12">Exchange</div></div><div class="row row-padding-small alternatives"><div ng-repeat="alt in exchange.alternatives" class="col-xs-12 col-sm-6 col-md-4"><div class="am"><span class="amnt">{{alt.amount | rpamount:{rel_precision: 4, rel_min_precision: 2} }}</span><span ng-hide="alt.amount.is_native() || alt.amount.issuer().to_json() == account.Account"><span rp-pretty-issuer="alt.amount.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span></span><span class="currency"> {{alt.amount | rpcurrency }}</span><div class="ex">(<span class="rate">{{alt.rate | rpamount:{rel_precision: 4, rel_min_precision: 2} }}</span><span class="pair">{{exchange.currency_code}}/{{alt.amount | rpcurrency}}</span>)</div></div><button type="submit" ng-disabled="exchangeForm.$invalid" ng-click="exchange.alt = alt" class="btn btn-block btn-success">Exchange {{ alt.amount | rpcurrency }}<span ng-hide="alt.amount.is_native() || alt.amount.issuer().to_json() == account.Account"> (<span rp-pretty-issuer="alt.amount.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span>)</span></button></div></div><div ng-show="exchange.alternatives.length &amp;&amp; lastUpdate" class="row pathupdate"><div class="col-xs-12">Cesty naposledy aktualizované pred <span> {{lastUpdate}}</span> <span ng-show="lastUpdate &gt; \'1\'" l10n-inc="l10n-inc"> sekundami</span> <span ng-show="lastUpdate == \'1\'" l10n-inc="l10n-inc"> sekundou</span></div></div></div></form><group ng-show="mode==&quot;wait_path&quot; &amp;&amp; account.Balance" class="mode-wait-path"><p class="throbber literal">Ripple vypočítava cestu pre vašu transakciu.</p></group><group ng-show="mode==&quot;confirm&quot; &amp;&amp; account.Balance" class="mode-confirm"><span><p l10n-inc="l10n-inc" class="literal">You are exchanging</p><p class="amount_feedback"><span class="value">{{exchange.alt.amount | rpamount}}&#32;</span><span class="currency">{{exchange.alt.amount | rpcurrency}}</span></p><p l10n-inc="l10n-inc" class="literal">to</p><p class="amount_feedback"><span class="value">{{exchange.amount_feedback | rpamount}}&#32;</span><span class="currency">{{exchange.amount_feedback | rpcurrency}}</span></p><p l10n-inc="l10n-inc" class="literal">You will pay at most</p><p class="amount_feedback"><span class="value">{{exchange.alt.amount | rpamount}}&#32;</span><span class="currency">{{exchange.alt.amount | rpcurrency}} &#32;</span><span>&plusmn; 1%</span></p><p l10n-inc="l10n-inc" class="literal">Are you sure?</p></span><div class="row row-padding-small"><div class="col-xs-6 col-sm-4 col-md-3 col-lg-2"><button type="submit" ng-click="exchange_confirmed()" ng-disabled="confirm_wait" class="btn btn-block btn-success submit">Potvrdiť</button></div><div class="col-xs-6 col-sm-4 col-md-3 col-lg-2"><button ng-click="cancelConfirm()" class="btn btn-link btn-default back">zrušiť</button></div></div></group><group ng-show="mode==&quot;sending&quot; &amp;&amp; account.Balance" class="mode-sending"><!-- Waiting message for the send and convert tabs--><p rp-spinner="4" class="literal">Sending transaction to the Ripple network</p><hr/></group><group ng-show="mode==&quot;error&quot; &amp;&amp; account.Balance" class="mode-error"><!-- Error messages for the send and convert tabs--><group ng-switch on="error_type"><group ng-switch-when="noDest" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: The account you&#39;re trying to send to does not exist [noDest].</p></group><group ng-switch-when="noPath" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: Ripple was unable to find a path between you and the destination account [noPath].</p></group><group ng-switch-when="maxFeeExceeded" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: This transaction failed because it exceeded the maximum network fee. [maxfeeExceeded].</p></group><group ng-switch-when="invalidTransaction" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: The transaction was rejected by the Ripple network [invalidTransaction].</p></group><group ng-switch-when="unlockFailed" class="result-error"><h2 class="tx-status">Account unlock failed</h2><p>Your account could not be unlocked. Please try again later.</p></group><group ng-switch-default="ng-switch-default"><p class="literal">Prepáčte, pri odosielaní vašej transakcie došlo k chybe. Overte si, či ste pripojený na internet a skúste to neskôr znova.</p><p class="literal">Pred opakovaným pokusom sa uistite, že vaša transakcia nebola už uskutočnená.</p></group></group><p><button ng-click="cancelConfirm()" class="btn btn-link btn-default">zrušiť</button></p></group><group ng-show="mode==&quot;status&quot; &amp;&amp; account.Balance" class="mode-status"><!-- Confirmation messages for the send and convert tabs--><group ng-show="tx_result==&quot;pending&quot;" class="pending"><h2 class="tx-status">Transaction pending.</h2></group><group ng-show="tx_result==&quot;cleared&quot;" class="result-success"><h2 class="tx-status">Transaction successful</h2></group><group ng-show="tx_result==&quot;error&quot;" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Please try again later.</p></group><group ng-show="tx_result==&quot;malformed&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-default="ng-switch-default">Error code: {{engine_result}} - {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;failure&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tefDST_TAG_NEEDED">Error code: Destination tag needed [tefDST_TAG_NEEDED].</span></p></group><group ng-show="tx_result==&quot;claim&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tecNO_DST">Error code: The destination account does not exist [tecNO_DST].</span><span ng-switch-when="tecNO_DST_INSUF_XRP">Error code: Insufficient XRP sent to destination [tecNO_DST_INSUF_XRP].</span><span ng-switch-default="ng-switch-default">Chyba: {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;failed&quot;" class="result-failed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="terNO_LINE">Error code: You have no trust line in this currency [terNO_LINE].</span><span ng-switch-default="ng-switch-default">Your transaction failed: {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;local&quot;" class="result-failed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="telINSUF_FEE_P">Error code: This transaction failed because it exceeded the maximum network fee, please try again later [telINSUF_FEE_P].</span></p></group><group class="actions"><hr/><div class="actionLink"><a href="" ng-click="reset()">Vykonať inú konverziu</a></div><div class="actionLink"><a href="" ng-click="reset_goto(\'balance\')">Späť na zostatok na účte</a></div><hr/></group></group></section>');
	}
	return buf.join("");
	}

/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="TrustCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><group ng-hide="!connected || loadState.lines" class="disconnected"><p class="literal">Načítanie...</p></group><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><group ng-show="connected &amp;&amp; loadState.lines"><div class="row"><div class="col-sm-12"><group ng-show="mode==&quot;granted&quot; &amp;&amp; account.Balance" class="mode-granted wide"><group ng-show="tx_result==&quot;pending&quot;" class="pending"><h2 class="tx-status">Connecting a gateway to your Ripple account...</h2></group><group ng-show="tx_result==&quot;cleared&quot;" class="result-success"><h2 class="tx-status">Gateway connected.</h2></group><group ng-show="tx_result==&quot;error&quot;" class="result-error"><h2 class="tx-status">Gateway could not be connected!</h2><p>There was a problem connecting the gateway. Please try again later.</p></group><group ng-show="tx_result==&quot;malformed&quot;" class="result-malformed"><h2 class="tx-status">There was a problem connecting the gateway. Please try again later.</h2><p>Vaša požiadavka je neplatná, dôvod: {{engine_result}} - {{engine_result_message}}</p></group><group ng-show="tx_result==&quot;failed&quot;" class="result-failed"><h2 class="tx-status">Gateway connection failed!</h2><p ng-switch on="engine_result"><span ng-switch-when="terNO_LINE">You have no gateway connected in this currency.</span><span ng-switch-when="tecINSUF_RESERVE_LINE">Insufficient reserve to connect gateway.</span><span ng-switch-when="tecNO_LINE_INSUF_RESERVE">You must have at\n least {{account.reserve_to_add_trust | rpamount:0}} XRP to connect a gateway.&#32;<a href="http://ripple.com/help/#reserve">Čítať viac.</a></span><span ng-switch-default="ng-switch-default">Gateway connection failed to clear,\n reason: {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;local&quot;" class="result-failed"><h2 class="tx-status">Transakcia zlyhala!</h2><p ng-switch on="engine_result"><span ng-switch-when="telINSUF_FEE_P">Server, ktorému ste odoslali transakciu, bol príliš zaneprázdnený pre spracovanie vašej transakcie s poplatkom, ktorý ste v nej zahrnuli.</span></p></group></group></div><div class="col-sm-12"><group ng-show="notif !== &quot;clear&quot;" class="mode-granted wide"><group ng-switch on="notif">         <group ng-switch-when="loading" class="pending"><h2 class="tx-status">Saving changes...</h2></group><group ng-switch-when="success" class="result-success"><h2 class="tx-status">Changes saved!</h2></group><group ng-switch-when="error" class="result-error"><h2 class="tx-status">There was an error while saving your changes.&#32;</h2><p>Please try again later.</p></group></group></group></div><div class="col-sm-12">         <group ng-show="notif !== &quot;clear&quot;" class="mode-granted wide"><group ng-switch on="notif">         <group ng-switch-when="remove_gateway" class="pending"><h2 class="tx-status">Removing gateway...</h2></group><group ng-switch-when="gateway_removed" class="result-success"><h2 class="tx-status">Gateway removed!</h2></group><group ng-switch-when="error" class="result-error"><h2 class="tx-status">There was an error while saving your changes.&#32;</h2><p>Please try again later.</p></group><group ng-switch-when="max_fee" class="result-error"><h2 class="tx-status">Request failed.</h2><p>This request failed because the current network fee is higher than your account limit. You can adjust your maximum network fee in Settings &gt; Advanced, or try again later. <br>\nError code: Network fee exceeded [tejMaxFeeExceeded].</p></group></group></group></div><div ng-show="addform_visible &amp;&amp; !can_add_trust" class="col-sm-12"><div class="alert alert-warning">Musíte mať aspoň <strong> {{account.reserve_to_add_trust | rpamount:0}} XRP</strong> pre pridanie nového úveru. <a href="https://ripple.com/wiki/Reserves" target="_blank">More information</a> </div></div></div><div ng-show="connected" class="row"><div class="col-sm-3"><div class="currencies"><a href="#/xrp" ng-class="{active: $route.current.tabName == \'xrp\'}">XRP</a><a href="#/trust" ng-class="{active: $route.current.tabName == \'trust\'}">Gateways</a></div><a href="https://ripple.com/knowledge_center/gateway-information" target="_blank">Learn more about gateways</a></div><div class="col-sm-9 trust-menu"><div ng-hide="true" class="row row-padding-small head"><div class="col-sm-5">Meno / Adresa</div><div class="col-sm-2"><a href="" ng-click="sorting.predicate = \'currency\'; sorting.reverse=!sorting.reverse">Mena</a></div><div class="col-sm-2"><a href="" ng-click="sorting.predicate = \'balance\'; sorting.reverse=!sorting.reverse">Zostatok</a></div><div class="col-sm-2">Limit úveru</div></div><div class="row"><div class="col-xs-12"><form id="trustForm" name="trustForm" ng-show="mode==&quot;main&quot; &amp;&amp; (addform_visible &amp;&amp; can_add_trust)" class="row-padding-small"><div rp-errors="trust_amount" class="errorGroup"><div rp-error-on="required" class="error">Pole "Množstvo" je povinné</div></div><div rp-errors="trust_amount_currency" class="errorGroup"><div rp-error-on="rpNotXrp" class="error">XRP môžu byť odoslané aj bez vytvorenia úveru. Ak chcete naozaj poskytnúť úver v XRP, použite prosím kód meny XRR.</div><div rp-error-on="required" class="error">Pole "Mena" je povinné</div></div><div class="row"><div class="col-xs-12 form-group"><input id="trust_counterparty" name="trust_counterparty" type="text" rp-combobox="counterparty_query" placeholder="Gateway\'s Ripple address" ng-model="counterparty_view" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-contact="rp-dest-contact" rp-not-me="rp-not-me" rp-dest-email="rp-dest-email" rp-dest-ripple-name="rp-dest-ripple-name" rp-dest-model="counterparty" rp-dest-loading="counterparty_loading" required="required" rp-autofill="$routeParams.to" rp-autofill-counterparty_view="rp-autofill-counterparty_view" rp-autofill-on="addform_visible = true" rp-focus="rp-focus" rp-spinner="{{counterparty_loading ? 4 : null}}" class="form-control"/><div rp-errors="trust_counterparty" class="errorGroup"><div rp-error-valid="rp-error-valid"><div ng-show="counterparty != counterparty_address &amp;&amp; counterparty_name &amp;&amp; !error_account_reserve" class="success">{{counterparty_address}}</div><div ng-show="error_account_reserve" class="error"><span>Účet nedisponuje minimálnou rezervou XRP.</span><a href="https://ripple.com/wiki/Account_Creation" target="_blank">Viac informácii</a></div></div><div rp-error-on="required" class="error">Please enter a Ripple address or contact.</div><div rp-error-on="rpNotMe" class="error">You\'ve entered your own address.</div><div rp-error-on="rpDest" class="error">Please enter a valid Ripple address or contact.</div></div></div></div><div class="row"><div class="col-xs-12 form-group"><label for="trust_amount" ng-show="advanced_feature_switch">Množstvo</label><label for="trust_amount" ng-hide="advanced_feature_switch">Mena</label><div ng-show="advanced_feature_switch" class="row"><div ng-init="amount = $routeParams.amount ? \'\' : 1000000000" class="col-md-3 col-sm-4 col-xs-3"><input id="trust_amount" name="trust_amount" type="number" step="any" ng-model="amount" ng-pattern="validation_pattern" rp-autofill="$routeParams.amount" rp-autofill-amount="rp-autofill-amount" rp-autofill-on="addform_visible = true" class="form-control value"/></div><div class="col-md-6 col-sm-6 col-xs-9"><input id="trust_amount_currency" name="trust_amount_currency" type="text" ng-model="currency" rp-combobox="currency_query" rp-combobox-select="rp-combobox-select" rp-autofill="$routeParams.currency || $routeParams.amount" rp-autofill-currency="rp-autofill-currency" rp-autofill-on="addform_visible = true" rp-not-xrp="rp-not-xrp" required="required" class="form-control currency-field"/></div></div><div ng-hide="advanced_feature_switch" class="row"><div class="col-md-9 col-sm-10 col-xs-12"><input id="trust_amount_currency" name="trust_amount_currency" type="text" ng-model="currency" rp-combobox="currency_query" rp-combobox-select="rp-combobox-select" rp-autofill="$routeParams.currency || $routeParams.amount" rp-autofill-currency="rp-autofill-currency" rp-autofill-on="addform_visible = true" rp-not-xrp="rp-not-xrp" required="required" class="form-control currency-field"/></div></div><div rp-errors="trust_amount" class="errorGroup"><div rp-error-on="required" class="error">Pole "Množstvo" je povinné</div></div><div rp-errors="trust_amount_currency" class="errorGroup"><div rp-error-on="rpNotXrp" class="error">XRP môžu byť odoslané aj bez vytvorenia úveru. Ak chcete naozaj poskytnúť úver v XRP, použite prosím kód meny XRR.</div><div rp-error-on="required" class="error">Pole "Mena" je povinné</div></div></div></div><div ng-show="advanced_feature_switch" class="row"><div class="col-xs-12 allow-rippling"><label for="trust_allowrippling" class="checkbox"><input id="trust_allowrippling" name="trust_allowrippling" type="checkbox" ng-model="allowrippling"/><span>Povoliť Rippling</span></label><i rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-title="Povoliť Rippling" rp-popover-trigger="click" data-content="Allow this trust line\'s balances to be transferred to another issuer you connect to. &lt;a href=https://ripple.com/wiki/No_Ripple target=_blank&gt;More information&lt;/a&gt;" class="fa fa-question-circle help-icon"></i></div></div><div class="row"><div class="col-xs-8 col-sm-7 col-md-6"><rp-popup rp-popup-on-open="grant()"> <a href="" rp-popup-link="rp-popup-link" ng-disabled="trustForm.$invalid || verifying" class="btn btn-block btn-primary submit">Uložiť</a><div rp-popup-content="rp-popup-content" class="connectModal"><div class="modal-header"><div id="logo" class="navbar-brand hidden-sm modal-logo"></div><div class="modal-title">Connect</div></div><div class="modal-body"><div class="modal-prompt"> <div l10n-inc="l10n-inc">You are connecting a gateway, which means</div><div l10n-inc="l10n-inc">{{ counterparty_address }} can:</div></div><div ng-show="advanced_feature_switch" class="grey-focus"><span l10n-inc="l10n-inc" class="modal-permissions">- Hold up to&#32;</span><span rp-pretty-amount="amount_feedback"></span><span l10n-inc="l10n-inc" class="modal-permissions"> on your behalf</span></div><div ng-hide="advanced_feature_switch" class="grey-focus"><span l10n-inc="l10n-inc" class="modal-permissions">- Hold&#32;</span><span>{{ currency }}</span><span l10n-inc="l10n-inc" class="modal-permissions"> on your behalf</span></div><div class="modal-buttons"><button data-dismiss="modal" ng-click="grant_confirmed()" rp-spinner="{{loading ? 4 : null}}" ng-disabled="loading" class="modal-btn btn btn-default btn-success btn-md"><span ng-show="loading">Načítanie...</span><span ng-hide="loading">Potvrdiť</span></button><button data-dismiss="modal" ng-click="toggle_form()" ng-hide="loading" class="modal-btn btn btn-cancel btn-md btn-cancel">zrušiť</button></div></div></div></rp-popup></div><div class="col-xs-4 col-sm-3 col-md-3"><button type="button" ng-click="toggle_form()" class="btn btn-block btn-cancel">zrušiť</button></div></div><div class="row delete-trust"><div ng-show="balance !== &quot;0&quot; &amp;&amp; orderbookStatus === &quot;exists&quot;" class="col-xs-6 col-sm-6 col-md-8 col-lg-9"><rp-confirm action-text="Are you sure you want to remove this gateway? Ripple Trade will attempt to convert the remaining balance of {{ trust.balance }} {{ trust.currency }} into XRP. This action can\'t be undone." action-button-text="Convert balance and remove" action-button-css="btn btn-default btn-danger" action-function="delete_line()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger btn-xs submit">Odstrániť</button></rp-confirm></div><div ng-show="balance !== &quot;0&quot; &amp;&amp; orderbookStatus === &quot;not&quot;" class="col-xs-6 col-sm-6 col-md-8 col-lg-9"><rp-confirm action-text="Are you sure you want to remove this gateway? Ripple Trade will return the balance of {{ trust.balance }} {{ trust.currency }} to the issuer. This action can\'t be undone." action-button-text="Return balance and remove" action-button-css="btn btn-default btn-danger" action-function="delete_line()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger btn-xs submit">Odstrániť</button></rp-confirm></div><div ng-show="balance === &quot;0&quot;" class="col-xs-6 col-sm-6 col-md-8 col-lg-9"><rp-confirm action-text="Are you sure you want to remove this gateway? This action can\'t be undone." action-button-text="Remove" action-button-css="btn btn-default btn-danger" action-function="delete_line()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger btn-xs submit">Odstrániť</button></rp-confirm></div></div><div class="row"><div class="col-xs-12"><p ng-show="verifying" class="literal throbber verifying">Overovanie adresy</p></div></div></form></div><div ng-show="addform_visible &amp;&amp; !can_add_trust" class="col-xs-12"><div class="alert alert-warning">Musíte mať aspoň <strong> {{account.reserve_to_add_trust | rpamount:0}} XRP</strong> pre pridanie nového úveru. <a href="https://ripple.com/wiki/Reserves" target="_blank">More information</a> </div></div></div><div class="row"><div ng-hide="account.Balance" class="unfunded literal">Your account has to be&#32;<a href="https://support.ripplelabs.com/hc/en-us/articles/202964876-Activating-Your-Wallet" target="_blank" l10n-inc="l10n-inc">activated</a>&#32;before you can add a gateway account.</div></div><div class="row"><div class="col-xs-12 col-sm-4 col-md-3 actions btn-add-trust"><a ng-click="toggle_form()" ng-show="!addform_visible &amp;&amp; account.Balance" ng-disabled="addform_visible" class="btn btn-primary btn-sm btn-block sign">Connect gateway </a></div></div><div ng-hide="true" ng-repeat="(key, line) in linesArray | orderBy:sorting.sort:sorting.reverse" class="row row-padding-small line padding-vertical-xs"><div class="col-sm-5">{{line.account | rpcontactnamefull }}</div><div rp-currency="line.balance" class="col-sm-2"></div><div class="col-sm-2"><span rp-tooltip="{{line.balance | rpamount }}">{{line.balance | rpamount:{rel_precision: 0} }}</span></div><div class="col-sm-2"><rp-trust-line rp-line-data="line"></rp-trust-line></div><div class="col-sm-1 actions"><button href="" ng-click="edit_line()" class="btn btn-default btn-sm">upraviť</button></div></div><div ng-repeat="entry in accountLines" ng-class="\'currency-\' + (entry.components[0].currency | lowercase)" class="currencyBox"><div class="row currencyTitle"><div class="col-xs-12"><i ng-class="\'fa-\' + (entry.components[0].currency | lowercase)" class="icon fa fa-money"></i><span rp-currency="entry.components[0].limit" rp-currency-full="rp-currency-full" class="currency"></span></div></div><div class="row head"><div ng-class="{ \'col-sm-3 col-xs-2\': advanced_feature_switch, \'col-sm-4 col-xs-4 col-md-5\': !advanced_feature_switch }">Gateway</div><div ng-class="{ \'col-xs-2 col-sm-2\': advanced_feature_switch, \'col-xs-4\': !advanced_feature_switch }">Zostatok</div><div ng-show="advanced_feature_switch" ng-class="{ \'col-xs-2\': advanced_feature_switch }">Limit</div><div ng-show="advanced_feature_switch" class="col-xs-2 col-sm-1">Min</div><div ng-show="advanced_feature_switch" class="col-xs-2">Rippling</div><div ng-class="{\'col-xs-2\' : advanced_feature_switch, \'col-xs-4 col-md-3\': !advanced_feature_switch }">Upraviť</div></div><hr id="divider"/><div class="lines"><div ng-controller="AccountRowCtrl" ng-repeat="component in entry.components" class="line"><div ng-class="{ \'frozen-account\': component.freeze_peer }" class="row"><div ng-class="{ \'col-sm-3 col-xs-2\': advanced_feature_switch, \'col-md-5 col-sm-4 col-xs-4\': !advanced_feature_switch }" rp-pretty-identity="component.account" rp-pretty-identity-filters="rpcontactnamefull" class="gateway"> </div><div ng-class="{ \'col-xs-2 col-sm-2\': advanced_feature_switch, \'col-xs-4\': !advanced_feature_switch }">{{ component.balance | rpamount:{rel_precision: 2} }}</div><div ng-show="advanced_feature_switch" ng-class="{ \'col-xs-1\': advanced_feature_switch }" class="col-xs-2"><div>{{ component.limit | rpamount }}</div></div><div ng-show="advanced_feature_switch &amp;&amp; component.limit_peer._offset == \'-100\'" class="col-sm-1 col-xs-2">{{ component.limit_peer | rpamount }}</div><div ng-show="advanced_feature_switch &amp;&amp; component.limit_peer._offset !== \'-100\'" ng-hide="component.limit_peer._offset == \'-100\' || !advanced_feature_switch" class="col-sm-1 col-xs-2">-{{ component.limit_peer | rpamount }}</div><div ng-show="advanced_feature_switch" class="col-sm-2 col-xs-2"><div ng-show="component.no_ripple">Off</div><div ng-hide="component.no_ripple">On</div></div><div ng-hide="component.freeze_peer" ng-class="{ \'col-xs-2\': advanced_feature_switch, \'col-xs-4 col-md-3\': !advanced_feature_switch }"><a href="" ng-hide="editing" ng-click="edit_account()">upraviť</a><span ng-show="editing &amp;&amp; !advanced_feature_switch"><span ng-hide="trust.loading"><div class="row row-padding-small"><div class="col-md-7 col-sm-7 col-xs-6"><span ng-show="trust.balance !== &quot;0&quot; &amp;&amp; orderbookStatus === &quot;exists&quot;"><rp-confirm action-text="Are you sure you want to remove this gateway? Ripple Trade will attempt to convert the remaining balance of {{ trust.balance }} {{ currency }} into XRP. This action can\'t be undone." action-button-text="Convert balance and remove" action-button-css="btn btn-default btn-danger custom-btn" action-function="delete_account()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger submit">Odstrániť</button></rp-confirm></span><span ng-show="trust.balance !== &quot;0&quot; &amp;&amp; orderbookStatus === &quot;not&quot;"><rp-confirm action-text="Are you sure you want to remove this gateway? Ripple Trade will return the balance of {{ trust.balance }} {{ currency }} to the issuer. This action can\'t be undone." action-button-text="Return balance and remove" action-button-css="btn btn-default btn-danger custom-btn" action-function="delete_account()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger submit">Odstrániť</button></rp-confirm></span><span ng-show="trust.balance === &quot;0&quot;"><rp-confirm action-text="Are you sure you want to remove this gateway? This action can\'t be undone." action-button-text="Remove" action-button-css="btn btn-default btn-danger custom-btn" action-function="delete_account()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger submit">Odstrániť</button></rp-confirm></span></div><div class="col-md-5 col-sm-5 col-xs-6"><a href="" ng-click="cancel()" ng-disabled="trust.loading" class="btn btn-block btn-cancel">zrušiť</a></div></div></span></span></div><div ng-show="component.freeze_peer" class="col-xs-2"><i rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-title="Account Frozen" rp-popover-trigger="click" data-content="This account has been frozen. Please contact the issuer to unfreeze your account. &lt;a href=https://ripple.com/wiki/Freeze target=_blank&gt;More about freezing&lt;/a&gt;" class="fa fa-lock"></i></div></div><div ng-show="editing &amp;&amp; advanced_feature_switch" class="row row-padding-small-xs editBox"><form ng-class="{ \'frozen-account\': component.freeze_peer }" ng-submit="save_account()"><ng-form name="accountForm"><div class="col-sm-1 col-md-1 inputPadding">Limit</div><div class="col-sm-2 col-md-3"><input name="limit" type="text" ng-model="trust.limit" ng-pattern="validation_pattern" ng-disabled="trust.loading" required="required" class="form-control"/></div><div class="col-sm-2 col-md-2 inputPadding"><div class="rippling-checkbox"><label>Rippling&#32;<input name="rippling" type="checkbox" ng-model="trust.rippling"/></label></div></div><div class="col-sm-7 col-md-6"><div class="row row-padding-small"><div class="col-xs-6 col-sm-5"><button id="save" type="submit" ng-disabled="accountForm.$invalid || trust.loading" class="btn btn-block btn-primary"><span ng-hide="trust.loading">Uložiť</span><span ng-show="trust.loading">Ukladanie...</span></button></div><div ng-hide="trust.loading" class="col-xs-3 col-sm-4 col-md-3"> <div class="row text-right"><div ng-show="trust.balance !== &quot;0&quot; &amp;&amp; orderbookStatus === &quot;exists&quot;" class="col-xs-12"><rp-confirm action-text="Are you sure you want to remove this gateway? Ripple Trade will attempt to convert the remaining balance of {{ trust.balance }} {{ currency }} into XRP. This action can\'t be undone." action-button-text="Convert balance and remove" action-button-css="btn btn-default btn-danger" action-function="delete_account()" cancel-button-css="btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger btn-xs submit">Odstrániť</button></rp-confirm></div><div ng-show="trust.balance !== &quot;0&quot; &amp;&amp; orderbookStatus === &quot;not&quot;" class="col-xs-12"><rp-confirm action-text="Are you sure you want to remove this gateway? Ripple Trade will return the balance of {{ trust.balance }} {{ currency }} to the issuer. This action can\'t be undone." action-button-text="Return balance and remove" action-button-css="btn btn-default btn-danger" action-function="delete_account()" cancel-button-css="btn btn-link" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger btn-xs submit">Odstrániť</button></rp-confirm></div><div ng-show="trust.balance === &quot;0&quot;" class="col-xs-12"><rp-confirm action-text="Are you sure you want to remove this gateway? This action can\'t be undone." action-button-text="Remove" action-button-css="btn btn-default btn-danger " action-function="delete_account()" cancel-button-css="btn btn-default cancel-btn btn-cancel" cancel-button-text="cancel" ng-hide="showPassword==true"><button type="button" ng-click="load_orderbook()" class="btn btn-block btn-danger btn-xs submit">Odstrániť</button></rp-confirm></div></div></div><div class="col-xs-3"><a href="" ng-click="cancel()" ng-disabled="trust.loading" class="btn btn-block btn-cancel">zrušiť</a></div></div></div></ng-form></form></div></div></div></div></div></div></group></section>');
	}
	return buf.join("");
	}

/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="SendCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div><p class="literal">You have to be funded before you can send money</p></div><form id="sendForm" name="sendForm" role="form" ng-show="mode==&quot;form&quot; &amp;&amp; account.Balance" ng-submit="send_prepared()" class="row-padding-small mode-form"><div class="row form-group"><div class="col-xs-12 col-sm-6 col-md-5"><label for="send_destination">Príjemca</label><input id="send_destination" name="send_destination" type="text" rp-combobox="recipient_query" placeholder="Enter a Ripple address or contact" ng-model="send.recipient" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-contact="rp-dest-contact" rp-dest-ripple-name="rp-dest-ripple-name" rp-dest-email="rp-dest-email" rp-dest-loading="recipient_loading" required="required" rp-autofill="$routeParams.to" rp-focus="rp-focus" rp-spinner="{{recipient_loading ? 4 : null}}" class="form-control"/><div rp-errors="send_destination" class="errorGroup"><div rp-error-valid ng-show="send.recipient != send.recipient_address" class="success">{{send.recipient_address}}</div><div rp-error-on="required" class="error">Prosím, zadajte príjemcu.</div><div rp-error-on="rpDest" class="error">Recipient should be a Ripple name, a contact, or Ripple address.</div><div rp-error-on="federation" class="error">Táto e-mailová adresa nie je povolená v Ripple.</div><div rp-error-on="federationDown" class="error">Could not contact {{send.federationURL}}.<br/>Please try again later or contact support.</div><div rp-error-on="btcBridgeWrong" class="error">Cannot use your specified bitcoin bridge. Please go to Settings &gt; Advanced and update your bitcoin bridge URL to btc2ripple.com.</div></div></div></div><ul class="tagsLinks"><li><a href="" ng-click="send.show_dt_field = true" ng-hide="send.show_dt_field">Show destination tag</a></li></ul><div ng-show="send.show_dt_field" class="row form-group"><div class="col-xs-12 col-sm-8 col-md-6"><label for="send_dt">Značka adresáta</label><a href="" ng-click="send.show_dt_field = false">hide</a><input id="send_dt" name="send_dt" type="text" ng-model="send.dt" rp-stdt="rp-stdt" rp-autofill="$routeParams.dt" ng-required="send.recipient_info.dest_tag_required" class="form-control"/><div rp-errors="send_dt" class="errorGroup"><div rp-error-on="rpStdt" class="error">Neplatná značka adresáta</div><div rp-error-on="required" class="error">Cieľová adresa nemôže byť prázdna.</div></div><div ng-show="send.recipient_info.dest_tag_required">Príjemca vyžaduje zadanie značky adresáta. Ak ju nepoznáte, prosím, kontaktujte ho pred vykonaním transakcie.</div></div></div><div ng-show="$routeParams.st || send.st" class="row form-group"><div class="col-xs-12 col-sm-6 col-md-5"><label for="send_st">Zdrojová značka</label><input id="send_st" name="send_st" type="text" ng-model="send.st" rp-stdt="rp-stdt" rp-autofill="$routeParams.st" class="form-control"/><div rp-errors="send_st" class="errorGroup"><div rp-error-on="rpStdt" class="error">Neplatná zdrojová značka</div></div></div></div><div ng-repeat="field in send.extra_fields" ng-switch="field.type" class="row form-group"><div ng-switch-when="text" class="col-xs-12 col-sm-6 col-md-5"><label ng-bind="field.label"></label><p ng-show="field.hint" ng-bind="field.hint" class="field-hint"></p><input type="text" ng-model="field.value" ng-required="{{field.required}}" class="form-control"/></div><div ng-switch-when="select" class="col-xs-12 col-sm-6 col-md-5"><label ng-bind="field.label"></label><p ng-show="field.hint" ng-bind="field.hint" class="field-hint"></p><select type="text" ng-model="field.value" ng-required="{{field.required}}" class="form-control"><option ng-repeat="option in field.options" ng-bind="option.label" value="{{option.value}}" ng-selected="option.selected" ng-disabled="option.disabled"></option></select></div></div><div ng-show="send.currency_choices.length" class="form-group"><label for="send_amount">Príjemca dostane</label><div ng-if="!send.currency_force" class="row amount"><div class="col-xs-3 col-sm-2 col-md-2"><input id="send_amount" name="send_amount" type="text" ng-model="send.amount" required="required" rp-autofill="$routeParams.amount" rp-autofill-amount="rp-autofill-amount" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" rp-amount-xrp-limit="rp-amount-xrp-limit" rp-amount-xrp-limit-currency="{{send.currency}}" class="form-control"/></div><div class="col-xs-9 col-sm-6 col-md-4"><input id="send_amount_currency" name="send_amount_currency" type="text" rp-combobox="{{send.currency_choices}}" rp-combobox-select="rp-combobox-select" ng-model="send.currency" rp-autofill="$routeParams.amount" rp-autofill-currency="rp-autofill-currency" rp-autofill-currency-fullname="rp-autofill-currency-fullname" rp-restrict-currencies="{{send.restrict_currencies}}" class="form-control currency"/></div></div><div ng-if="send.currency_force" class="row"><div class="col-xs-12 col-sm-6 col-md-3 input-group currency_force"><input id="send_amount" name="send_amount" type="text" ng-model="send.amount" required="required" ng-disabled="!!send.force_amount" rp-autofill="$routeParams.amount" rp-autofill-amount="rp-autofill-amount" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" rp-amount-xrp-limit="rp-amount-xrp-limit" rp-amount-xrp-limit-currency="{{send.currency}}" class="form-control"/><span ng-bind="send.currency_force" class="input-group-addon"></span></div></div><div rp-errors="send_amount_currency" class="errorGroup"><div rp-error-on="rpRestrictCurrencies" class="error">{{send.recipient | rpcontactname}} can\'t receive this currency.</div></div><div rp-errors="send_amount" class="errorGroup"><div rp-error-on="required" class="error">Prosím, zadajte množstvo.</div><div rp-error-on="rpAmount" class="error">Neplatné množstvo.</div><div rp-error-on="rpAmountPositive" class="error">Množstvo musí byť väčšie ako nula.</div><div rp-error-on="rpMaxAmount" class="error">Táto transakcia prevyšuje váš zostatok, môžete odoslať max. {{account.max_spend | rpamount:{rel_precision: 0} }} XRP</div><div ng-show="send.recipient_info.disallow_xrp &amp;&amp; send.currency_code==\'XRP\'" class="error">Príjemca nepovoľuje XRP platby. Napriek tomu chcete odoslať XRP?</div><div ng-show="send.trust_limit" class="notice">Máte úver od používateľa {{send.recipient | rpcontactname}} vo výške {{send.trust_limit | rpamount}} {{send.trust_limit | rpcurrency}}.</div></div></div><div class="row"><div ng-show="send.currency_code == \'XRP\'" class="col-xs-12 col-sm-6 col-md-4"><button id="sendXrpButton" type="submit" ng-disabled="sendForm.$invalid || send.self || !send.recipient_resolved || account.max_spend.to_number() &lt; send.amount * 1000000" class="btn btn-block btn-success submit">Poslať XRP</button></div></div><div class="remote"><p ng-show="send.fund_status == \'insufficient-xrp\'" class="literal">Cieľová adresa nemá minimálnu rezervu XRP; odošlite aspoň {{send.xrp_deficiency | rpamount}} XRP pre doplnenie rezervy.<a href="https://ripple.com/wiki/Reserves" target="_blank">Viac informácii</a></p><p ng-show="send.path_status == \'checking\'" rp-spinner="4" class="literal">Prebieha kontrola</p><p ng-show="send.path_status == \'fed-check\'" rp-spinner="4" class="literal">Analýza adresy</p><p ng-show="send.path_status == \'account-currencies\'" rp-spinner="4" class="literal">Scanning accepted currencies</p><p ng-show="send.path_status == \'pending\' &amp;&amp; send.currency_code != \'XRP\'" rp-spinner="4" class="literal">Prebieha výpočet trasy</p><p ng-show="send.path_status == \'pending\' &amp;&amp; send.currency_code == \'XRP\'" rp-spinner="4" class="literal">Vypočítavanie alternatívnych možností</p><p ng-show="send.path_status == \'no-path\' &amp;&amp; send.currency_code != \'XRP\'" class="literal">You cannot send {{send.amount}} {{send.currency}} to\n {{send.recipient}}. Either your account has insufficient funds,\n or {{send.recipient}} doesn\'t accept {{send.currency}}.</p><p ng-show="send.path_status == \'no-path\' &amp;&amp; send.currency_code == \'XRP\' &amp;&amp; send.sender_insufficient_xrp" class="literal">You cannot send {{send.amount}} {{send.currency}} to\n{{send.recipient}}. Your account has insufficient funds.</p><p ng-show="send.path_status == \'error-no-currency\'" class="literal">There are no valid currency choices for this destination.</p><p ng-show="send.path_status == \'error\'" class="literal">Chyba pri výpočte cesty</p><div ng-if="send.path_status == \'done\'" class="currency_sets"><div class="row row-padding-small"><div class="col-xs-12"><p ng-show="send.currency_code != \'XRP\'" class="literal">Môžete poslať</p><p ng-show="send.currency_code == \'XRP\'" class="literal">Alebo môžete poslať</p></div></div><div ng-show="send.alternatives.length" class="row row-padding-small alternatives"><div ng-repeat="alt in send.alternatives" class="col-xs-12 col-sm-6 col-md-4 col-lg-4"><div class="margin"><div class="am"><span class="amnt">{{alt.amount | rpamount:{rel_precision: 4, rel_min_precision: 2} }}</span><span ng-hide="alt.amount.is_native() || alt.amount.issuer().to_json() == account.Account"><span rp-pretty-issuer="alt.amount.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span></span><span class="currency"> {{alt.amount | rpcurrency }}</span><div class="ex">(<span class="rate">{{alt.rate | rpamount:{rel_precision: 4, rel_min_precision: 2 } }}</span><span class="pair">{{send.currency_code}}/{{alt.amount | rpcurrency}}</span>)</div></div><button type="submit" ng-disabled="sendForm.$invalid" ng-click="send.alt = alt" class="btn btn-block btn-success">Send {{ alt.amount | rpcurrency }}<span ng-hide="alt.amount.is_native() || alt.amount.issuer().to_json() == account.Account"> (<span rp-pretty-issuer="alt.amount.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span>)</span></button></div></div></div><div ng-show="send.alternatives.length &amp;&amp; lastUpdate" class="row row-padding-small pathupdate"><div class="col-xs-12">Cesty naposledy aktualizované pred <span> {{lastUpdate}}</span> <span ng-show="lastUpdate &gt; \'1\'" l10n-inc="l10n-inc"> sekundami</span> <span ng-show="lastUpdate == \'1\'" l10n-inc="l10n-inc"> sekundou</span></div></div></div></div></form><group ng-show="mode==&quot;wait_path&quot; &amp;&amp; account.Balance" class="mode-wait-path"><p rp-spinner="4" class="literal">Ripple vypočítava cestu pre vašu platbu.</p></group><group ng-show="mode==&quot;confirm&quot; &amp;&amp; account.Balance" class="mode-confirm"><p class="literal">You are sending<span> {{ (send.alt.amount || send.currency) | rpcurrency}}</span> to</p><div class="dest_feedback"><div ng-show="send.recipient_name" class="recipient">{{send.recipient_name}}</div><div ng-hide="send.recipient_name" class="recipient">{{send.recipient_address}}</div><div href="" ng-show="send.recipient != send.recipient_address || send.recipient_name" class="extra"> {{send.recipient_address}}</div><div ng-show="send.dt" class="dt">Značka adresáta: {{send.dt}}</div></div><p class="literal">Druhá strana dostane</p><p rp-pretty-amount="send.amount_feedback" class="amount_feedback"></p><group ng-show="send.indirect"><p class="literal">Zaplatíte najviac</p><p class="sendmax_feedback"><span class="value">{{send.alt.amount | rpamount}}&#32;</span><span class="currency">{{send.alt.amount | rpcurrency}} &#32;</span><span>&plusmn; 1%</span></p></group><form ng-submit="send_confirmed()" class="call-to-action"><p ng-show="send.secret" class="literal">Ste si istý?</p><p ng-hide="send.secret" class="literal">Please enter your password to confirm this transaction.</p><div ng-if="!send.secret" class="row row-padding-small"><div class="col-xs-12 col-sm-8 col-md-6"><input id="send_unlock_password" name="send_unlock_password" type="password" required="required" ng-model="send.unlock_password" class="form-control"/></div></div><div class="row row-padding-small"><div class="col-xs-8 col-sm-4 col-md-3 col-lg-3"><button id="confirmButton" type="submit" ng-disabled="confirm_wait" class="btn btn-block btn-success submit">Potvrdiť</button></div><div class="col-xs-6 col-sm-4 col-md-3 col-lg-2"><button type="button" ng-click="cancelConfirm()" class="btn btn-link back">zrušiť</button></div></div></form></group><group ng-show="mode==&quot;sending&quot; &amp;&amp; account.Balance" class="mode-sending"><!-- Waiting message for the send and convert tabs--><p rp-spinner="4" class="literal">Sending transaction to the Ripple network</p><hr/></group><group ng-show="mode==&quot;error&quot; &amp;&amp; account.Balance" class="mode-error"><!-- Error messages for the send and convert tabs--><group ng-switch on="error_type"><group ng-switch-when="noDest" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: The account you&#39;re trying to send to does not exist [noDest].</p></group><group ng-switch-when="noPath" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: Ripple was unable to find a path between you and the destination account [noPath].</p></group><group ng-switch-when="maxFeeExceeded" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: This transaction failed because it exceeded the maximum network fee. [maxfeeExceeded].</p></group><group ng-switch-when="invalidTransaction" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Error code: The transaction was rejected by the Ripple network [invalidTransaction].</p></group><group ng-switch-when="unlockFailed" class="result-error"><h2 class="tx-status">Account unlock failed</h2><p>Your account could not be unlocked. Please try again later.</p></group><group ng-switch-default="ng-switch-default"><p class="literal">Prepáčte, pri odosielaní vašej transakcie došlo k chybe. Overte si, či ste pripojený na internet a skúste to neskôr znova.</p><p class="literal">Pred opakovaným pokusom sa uistite, že vaša transakcia nebola už uskutočnená.</p></group></group><p><button ng-click="cancelConfirm()" class="btn btn-link btn-default">zrušiť</button></p></group><group ng-show="mode==&quot;rippleerror&quot; &amp;&amp; account.Balance" class="mode-ripplerror"><rp-transaction-status rp-engine-result="{{engine_result}}" rp-engine-result-message="{{engine_result_message}}" rp-accepted="{{engine_status_accepted}}"></rp-transaction-status><group class="actions"><hr/><div ng-show="addressSaved" class="text-success actionLink">Kontakt uložený!</div><div ng-hide="contact" class="save-address-form actionLink"><a href="" ng-click="show_save_address_form = true">Pridať túto adresu do kontaktov</a><form name="saveAddressForm" ng-class="{ show: show_save_address_form }" ng-submit="saveAddress()"><div class="address">{{send.recipient_address}}</div><label for="save_address_name">Pomenujte tohto používateľa</label><input id="contact_name" name="save_address_name" type="text" ng-model="saveAddressName" unique="unique" required="required" rp-autofill="$routeParams.name" class="form-control"/><div ng-show="saveAddressForm.save_address_name.$error.unique" class="error">Už máte kontakt s týmto menom.</div><div><button type="submit" ng-disabled="addressSaving" class="btn btn-success"><span ng-show="addressSaving">Ukladanie...</span><span ng-hide="addressSaving">Uložiť</span></button><a href="" ng-click="show_save_address_form = false">zrušiť</a></div><hr/></form></div><div class="actionLink"><a href="" ng-click="reset()">Odoslať ďalšiu platbu</a></div><div class="actionLink"><a href="" ng-click="reset_goto(\'balance\')">Späť na zostatok na účte</a></div><hr/></group></group><group ng-show="mode==&quot;status&quot; &amp;&amp; account.Balance" class="mode-status"><!-- Confirmation messages for the send and convert tabs--><group ng-show="tx_result==&quot;pending&quot;" class="pending"><h2 class="tx-status">Transaction pending.</h2></group><group ng-show="tx_result==&quot;cleared&quot;" class="result-success"><h2 class="tx-status">Transaction successful</h2></group><group ng-show="tx_result==&quot;error&quot;" class="result-error"><h2 class="tx-status">Transaction failed</h2><p>Please try again later.</p></group><group ng-show="tx_result==&quot;malformed&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-default="ng-switch-default">Error code: {{engine_result}} - {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;failure&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tefDST_TAG_NEEDED">Error code: Destination tag needed [tefDST_TAG_NEEDED].</span></p></group><group ng-show="tx_result==&quot;claim&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="tecNO_DST">Error code: The destination account does not exist [tecNO_DST].</span><span ng-switch-when="tecNO_DST_INSUF_XRP">Error code: Insufficient XRP sent to destination [tecNO_DST_INSUF_XRP].</span><span ng-switch-default="ng-switch-default">Chyba: {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;failed&quot;" class="result-failed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="terNO_LINE">Error code: You have no trust line in this currency [terNO_LINE].</span><span ng-switch-default="ng-switch-default">Your transaction failed: {{engine_result_message}}</span></p></group><group ng-show="tx_result==&quot;local&quot;" class="result-failed"><h2 class="tx-status">Transaction failed</h2><p ng-switch on="engine_result"><span ng-switch-when="telINSUF_FEE_P">Error code: This transaction failed because it exceeded the maximum network fee, please try again later [telINSUF_FEE_P].</span></p></group><group class="actions"><hr/><div ng-show="addressSaved" class="text-success actionLink">Kontakt uložený!</div><div ng-hide="contact" class="save-address-form actionLink"><a href="" ng-click="show_save_address_form = true">Pridať túto adresu do kontaktov</a><form name="saveAddressForm" ng-class="{ show: show_save_address_form }" ng-submit="saveAddress()"><div class="address">{{send.recipient_address}}</div><label for="save_address_name">Pomenujte tohto používateľa</label><input id="contact_name" name="save_address_name" type="text" ng-model="saveAddressName" unique="unique" required="required" rp-autofill="$routeParams.name" class="form-control"/><div ng-show="saveAddressForm.save_address_name.$error.unique" class="error">Už máte kontakt s týmto menom.</div><div class="row add-contact-btns-wrapper"><div class="col-md-3 col-sm-4 col-xs-8"><button type="submit" ng-disabled="addressSaving || saveAddressForm.$invalid" class="btn btn-success btn-block"><span ng-show="addressSaving">Ukladanie...</span><span ng-hide="addressSaving">Uložiť</span></button></div><div class="col-md-1 col-sm-2 col-xs-4"><a href="" ng-click="show_save_address_form = false" class="btn btn-block">zrušiť</a></div></div><hr/></form></div><div class="actionLink"><a href="" ng-click="reset()">Odoslať ďalšiu platbu</a></div><div class="actionLink"><a href="" ng-click="reset_goto(\'balance\')">Späť na zostatok na účte</a></div><hr/></group></group></section>');
	}
	return buf.join("");
	}

/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="AdvancedCtrl" class="col-xs-12 content"><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected &amp;&amp; !debug"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><div class="row"><div class="col-sm-3"><div class="settingPage"><a href="#/security" ng-class="{active: $route.current.tabName == \'security\'}">Security<a href="#/settingstrade" ng-class="{active: $route.current.tabName == \'settingstrade\'}">Obchod</a></a><a href="#/advanced" ng-class="{active: $route.current.tabName == \'advanced\'}">Advanced</a><a href="#/settingsgateway" ng-class="{active: $route.current.tabName == \'settingsgateway\'}">Gateways and trust lines</a></div></div><div class="col-sm-9 list"><section id="servers" class="content"><h4 id="networkSettings">Network settings</h4><form name="maxnetworkfeeForm" ng-submit="saveMaxNetworkFee()"><div class="descriptor">Maximum network fee</div><div ng-hide="editMaxNetworkFee" class="row advanced-form-row"><div class="col-xs-9 col-sm-8 col-md-6"><div class="description">{{max_tx_network_fee_human}} {{xrp.code}}</div></div><div class="col-xs-1"></div><div class="col-xs-3 col-sm-3 col-md-2"><a href="" ng-click="editMaxNetworkFee = true" class="btn btn-block btn-cancel">upraviť</a></div></div><div ng-show="editMaxNetworkFee" class="row row-padding-small field-edit-row"><div class="col-xs-12 col-sm-9 col-md-6 input-group"><input id="maxNetworkFee" name="maxNetworkFee" type="text" ng-model="max_tx_network_fee_human" required="required" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" rp-amount-xrp-limit="rp-amount-xrp-limit" rp-amount-currency="{{xrp.name}}" class="form-control maxNetworkFee"/><span ng-bind="xrp.name" class="input-group-addon"></span></div><div class="col-xs-6 col-sm-6 col-md-3"><button id="saveMaxNetworkFee" type="submit" ng-disabled="maxnetworkfeeForm.$invalid" class="btn btn-block btn-success btn-xs submit">Uložiť</button></div><div id="cancel" class="col-xs-3 col-sm-3 col-md-1 text-center"><a href="" ng-click="cancelEditMaxNetworkFee()" class="btn btn-cancel btn-block">zrušiť</a></div></div></form><h4 id="serverSettings">Server settings</h4><form ng-controller="ServerRowCtrl" ng-repeat="(index, server) in options.server.servers" ng-submit="save()" class="server-row-form"><ng-form name="serverForm"><div class="row"><div class="col-xs-6 col-sm-5 col-md-3"><div class="descriptor">WebSocket host name</div></div><div class="port col-xs-4 col-sm-7 col-md-9"><div class="descriptor portNumber">Port number</div></div></div><div ng-show="editing" class="row row-padding-small"><div class="col-xs-6 col-sm-5 col-md-3 hostname-wrapper"><input name="host" type="text" ng-model="server.host" rp-hostname="rp-hostname" class="form-control host"/><div class="errorGroup"><div rp-errors="host"><div rp-error-on="rpHostname" class="error">Socket ip alebo hostname je neplatný.</div></div><div rp-errors="port"><div rp-error-on="rpPortNumber" class="error">Číslo portu je nesprávne.</div></div></div></div><div class="col-xs-3 col-sm-2 col-md-2"><input name="port" type="text" ng-model="server.port" rp-port-number="rp-port-number" class="form-control socketPort"/></div><div id="secureSocket" class="col-xs-3 col-md-1 col-sm-2 editable"><div class="helperInput"><label><input type="checkbox" name="secure" ng-model="server.secure"/><span>Secure</span></label></div></div><div class="col-xs-6 col-sm-6 col-md-3"><button id="save" type="submit" ng-disabled="serverForm.$invalid" class="btn btn-block btn-success btn-xs submit">Uložiť</button></div><div ng-show="hasRemove()" class="col-xs-3 col-sm-3 col-md-2"></div><button id="delete" type="button" ng-click="remove()" ng-show="hasRemove()" class="btn btn-block btn-danger btn-xs submit">Vymazať</button><div id="cancel" class="col-xs-3 col-sm-3 col-md-1 text-center"><a href="" ng-click="cancel()" ng-hide="noCancel()" class="btn btn-cancel btn-block">zrušiť</a></div></div><div ng-hide="editing" class="row advanced-form-row"><div class="col-xs-6 col-sm-5 col-md-3"><div class="description">{{server.host}}</div></div><div class="col-xs-3 col-sm-3 col-md-2 port-wrapper"><div class="description">{{server.port}}</div></div><div id="secureSocket" class="col-xs-3 col-sm-2 col-md-2"><div ng-show="server.secure" class="description">Secure</div><div ng-hide="server.secure" class="description">Not Secure</div></div><div class="col-xs-3 col-sm-2 col-md-2"><a href="" ng-click="editing = true" class="btn btn-cancel btn-block">upraviť</a></div></div></ng-form></form><div class="row"><div class="col-xs-12 col-sm-6 col-md-3"><button id="newServer" type="button" ng-click="addServer()" class="btn btn-block btn-primary">Pridať nový server</button></div></div></section></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="TradeCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><group ng-hide="!connected || loadState.offers" class="disconnected"><p class="literal">Načítavanie knihy príkazov...</p></group><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected &amp;&amp; !debug"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><group ng-show="connected &amp;&amp; loadState.offers"><div class="settings"><div class="row"><div class="col-sm-10 col-md-7 col-lg-7 col-xs-10 currency-config"><input id="currency_pair" name="currency_pair" type="text" rp-combobox="pairs_query" rp-combobox-select="rp-combobox-select" ng-disabled="adding_pair" ng-model="order.currency_pair" class="form-control currency"/></div><div ng-hide="adding_pair" class="col-sm-2 col-md-1 col-lg-1 col-xs-2"><button href="" ng-click="flip_issuer()" class="btn btn-cancel btn-block">flip</button></div><div ng-hide="adding_pair" class="col-md-2 col-lg-2 col-xs-6"><button href="" ng-click="open_custom_currency_selector()" ng-disabled="adding_pair" class="btn btn-cancel btn-block">add pair</button></div><div ng-hide="adding_pair" class="col-md-2 col-lg-2 col-xs-6"><button ng-click="gotoSettings()" class="btn btn-cancel btn-block">edit pairs</button></div></div><form id="gateway_change_form" name="gateway_change_form" ng-show="adding_pair" ng-submit="add_pair()" class="row"><div class="col-sm-4 col-lg-2 col-xs-12"><div class="description">Base Currency</div><input name="first_currency" type="text" rp-combobox="currencies" rp-combobox-select="rp-combobox-select" ng-model="first_currency_selected" class="form-control"/></div><div class="col-sm-6 col-lg-3 col-xs-11"><div class="description">Base Gateway</div><input name="first_iss" type="text" ng-disabled="disable_first_issuer" rp-combobox="first_iss" rp-combobox-select="rp-combobox-select" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-contact="rp-dest-contact" rp-dest-ripple-name="rp-dest-ripple-name" rp-dest-ripple-name-no-tilde="rp-dest-ripple-name-no-tilde" ng-model="first_issuer_selected" class="form-control"/></div><div class="col-xs-1"><div class="description slash">/</div></div><div class="col-sm-4 col-lg-2 col-xs-12"><div class="description">Counter&nbsp;Currency</div><input name="second_currency" type="text" rp-combobox="currencies" rp-combobox-select="rp-combobox-select" ng-model="second_currency_selected" class="form-control"/></div><div class="col-sm-6 col-lg-3 col-xs-12"><div class="description">Counter Gateway</div><input name="second_iss" type="text" ng-disabled="disable_second_issuer" rp-combobox="second_iss" rp-combobox-select="rp-combobox-select" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-contact="rp-dest-contact" rp-dest-ripple-name="rp-dest-ripple-name" rp-dest-ripple-name-no-tilde="rp-dest-ripple-name-no-tilde" ng-model="second_issuer_selected" class="form-control"/></div><div id="cancel_button" class="col-sm-4 col-lg-2 col-xs-6"><button type="button" ng-click="adding_pair = false" class="btn btn-cancel btn-block">zrušiť</button></div><div id="add_button" class="col-sm-4 col-lg-2 col-xs-6"><button type="submit" ng-disabled="gateway_change_form.$invalid || gateway_change_form.$pending" class="btn btn-success btn-block submit">Add</button></div></form></div><form name="first_issuer_form" ng-show="show_issuer_form == &quot;first&quot;" class="issuerSelector first-issuer"><label for="first_issuer">Base currency issuer ({{order.first_currency | rpcurrency}})</label><div class="row"><div class="col-xs-12 col-sm-8 col-md-5"><input id="first_issuer" name="first_issuer" type="text" rp-combobox="issuer_query" placeholder="Ripple address or contact" ng-model="order.first_issuer_edit_name" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-contact="rp-dest-contact" rp-dest-model="order.first_issuer_edit" class="form-control"/><div rp-errors="first_issuer" class="errorGroup"><div rp-error-on="rpDest" class="error">Neplatná Ripple adresa alebo kontakt</div></div></div><div class="col-xs-12 col-sm-4 col-md-2"><button type="submit" ng-click="save_first_issuer()" ng-disabled="first_issuer_form.$invalid" class="btn btn-block btn-success submit">Potvrdiť</button></div></div></form><form name="second_issuer_form" ng-show="show_issuer_form == &quot;second&quot;" class="issuerSelector second-issuer"><label for="second_issuer">Counter currency issuer ({{order.second_currency | rpcurrency}})</label><div class="row"><div class="col-xs-9 col-sm-4 col-md-4"><input id="second_issuer" name="second_issuer" type="text" rp-combobox="issuer_query" placeholder="Contact name or Ripple address" ng-model="order.second_issuer_edit_name" rp-dest="rp-dest" rp-dest-address="rp-dest-address" rp-dest-contact="rp-dest-contact" rp-dest-model="order.second_issuer_edit" class="form-control"/><div rp-errors="second_issuer" class="errorGroup"><div rp-error-on="rpDest" class="error">Not a valid Ripple address</div></div></div><div class="col-xs-3 col-sm-2 col-md-2"><button type="submit" ng-click="save_second_issuer()" ng-disabled="second_issuer_form.$invalid" class="btn btn-block btn-success submit">Potvrdiť</button></div></div></form><div ng-hide="order.valid_settings" class="message-select-issuer">You must select a gateway to trade currencies.\n Click the “Change gateway” link above and enter the \n gateway\'s address.&#32;</div><group ng-if="order.valid_settings"><ul class="ticker"><div class="row"><li class="col-xs-6 col-sm-3"><span>Ponuka</span><span>&#32&#61;&#32;</span><span class="value">{{book.bids[0].TakerGets | rpamountratio:book.bids[0].TakerPays | rpamount:{rel_precision: 5, rel_min_precision: 5} }}</span></li><li class="col-xs-6 col-sm-3"><span>Dopyt</span><span>&#32&#61;&#32;</span><span class="value">{{book.asks[0].TakerPays | rpamountratio:book.asks[0].TakerGets | rpamount:{rel_precision: 5, rel_min_precision: 5} }}</span></li><li class="col-xs-6 col-sm-3"><span>Rozpätie</span><span>&#32&#61;&#32;</span><span class="value">{{book.asks[0].TakerPays | rpamountratio:book.asks[0].TakerGets | rpamountsubtract:(book.bids[0].TakerGets | rpamountratio:book.bids[0].TakerPays) | rpamount:{rel_precision: 5, rel_min_precision: 5} }}</span></li><li class="col-xs-6 col-sm-3"><span>Posledná cena</span><span>&#32&#61;&#32;</span><span class="value">{{book.last_price | rpamount:{rel_precision: 5, rel_min_precision: 5} }}</span></li></div></ul><div ng-hide="account.Balance" class="unfunded"><p class="literal">Pre obchodovanie musíte disponovať minimálnou rezervou XRP</p></div><group ng-show="account.Balance" class="row send-widgets"><div ng-repeat="type in [\'buy\',\'sell\']" class="col-xs-12 col-sm-6"><div ng-switch="order[type].mode" class="trade-widget"><div class="head"><span ng-show="type == \'buy\'">Buy&#32;<span ng-hide="order.first_currency.is_native()" rp-pretty-issuer="order.first_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span> {{order.first_currency | rpcurrency}}</span><span ng-show="type == \'sell\'">Sell&#32;<span ng-hide="order.first_currency.is_native()" rp-pretty-issuer="order.first_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span> {{order.first_currency | rpcurrency}}</span><span ng-show="type == \'buy\'" class="available"><span class="amount"><span ng-show="order.second_currency.is_native()">{{account.Balance | rpamount}} XRP</span><span ng-hide="order.second_currency.is_native()">{{lines[order.second_issuer+order.second_currency.to_json()].balance || "0" | rpamount}}&#32;<span rp-pretty-issuer="order.second_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short"></span> {{order.second_currency | rpcurrency}}</span></span> available</span><span ng-show="type == \'sell\'" class="available"><span class="amount"><span ng-show="order.first_currency.is_native()">{{account.Balance | rpamount}} XRP</span><span ng-hide="order.first_currency.is_native()">{{lines[order.first_issuer+order.first_currency.to_json()].balance || "0" | rpamount}}&#32;<span rp-pretty-issuer="order.first_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short"></span> {{order.first_currency | rpcurrency}}</span></span> available</span></div><div ng-switch-when="trade"><form name="tradeForm" ng-submit="place_order(type)" ng-show="order[type].showWidget" class="mode-form"><div class="row order-values"><div class="col-xs-12"><div class="value-field"><label ng-show="type == \'buy\'">Amount To Buy</label><label ng-show="type == \'sell\'">Amount To Sell</label><div class="input-group"><input name="amount" type="text" ng-model="order[type].first" ng-change="calc_second(type)" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" rp-amount-xrp-limit="rp-amount-xrp-limit" rp-amount-xrp-limit-currency="{{order.first_currency}}" required="required" class="form-control"/><div class="input-group-addon">{{order.first_currency | rpcurrency}}<div ng-hide="order.first_currency.is_native()" rp-pretty-issuer="order.first_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div></div><div rp-errors="amount" class="errorGroup"><div rp-error-on="required" class="error">Požadované</div><div rp-error-on="rpAmount" class="error">Neplatné množstvo.</div><div rp-error-on="rpAmountPositive" class="error">Musí byť viac ako nula</div><div rp-error-on="rpAmountXrpLimit" class="error">Minimum je Drop (0.000001) a maximum je 100 miliárd XRP</div></div></div></div><div class="col-xs-12"><div class="value-field"><label>Cena za jeden</label><div class="input-group"><input name="price" type="text" ng-model="order[type].price" ng-change="calc_second(type)" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" rp-amount-xrp-limit="rp-amount-xrp-limit" rp-amount-xrp-limit-currency="{{order.second_currency}}" required="required" class="form-control"/><div class="input-group-addon">{{order.second_currency | rpcurrency}}<div ng-hide="order.second_currency.is_native()" rp-pretty-issuer="order.second_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div></div><div rp-errors="price" class="errorGroup"><div rp-error-on="required" class="error">Požadované</div><div rp-error-on="rpAmount" class="error">Neplatné množstvo.</div><div rp-error-on="rpAmountPositive" class="error">Musí byť viac ako nula</div><div rp-error-on="rpAmountXrpLimit" class="error">Minimum je Drop (0.000001) a maximum je 100 miliárd XRP</div></div></div></div><div class="col-xs-12"><div class="value-field"><label>Hodnota príkazu (max)</label><div class="input-group"><input name="value" type="text" ng-model="order[type].second" ng-change="calc_first(type)" rp-amount="rp-amount" rp-amount-positive="rp-amount-positive" rp-amount-xrp-limit="rp-amount-xrp-limit" rp-amount-xrp-limit-currency="{{order.second_currency}}" required="required" class="form-control"/><div class="input-group-addon">{{order.second_currency | rpcurrency}}<div ng-hide="order.second_currency.is_native()" rp-pretty-issuer="order.second_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div></div><div rp-errors="value" class="errorGroup"><div rp-error-on="required" class="error">Požadované</div><div rp-error-on="rpAmount" class="error">Neplatné množstvo.</div><div rp-error-on="rpAmountPositive" class="error">Musí byť viac ako nula</div><div rp-error-on="rpAmountXrpLimit" class="error">Minimum je Drop (0.000001) a maximum je 100 miliárd XRP</div></div></div></div></div><div class="message"><p ng-show="tradeForm.$valid &amp;&amp; type == \'buy\'">Chcete kúpiť <span> {{order[type].first_amount | rpamount:{precision: 10} }} {{order[type].first_amount | rpcurrency}}</span> za <span> {{order[type].second_amount | rpamount:{precision: 10} }} {{order[type].second_amount | rpcurrency}}</span> (<span>{{order[type].price_amount | rpamount:{precision: 10} }} {{order[type].second_amount | rpcurrency}}</span> za <span> {{order[type].first_amount | rpcurrency}}</span>)</p><p ng-show="tradeForm.$valid &amp;&amp; type == \'sell\'">Chcete predať <span> {{order[type].first_amount | rpamount:{precision: 10} }} {{order[type].first_amount | rpcurrency}}</span> za <span> {{order[type].second_amount | rpamount:{precision: 10} }} {{order[type].second_amount | rpcurrency}}</span> (<span>{{order[type].price_amount | rpamount:{precision: 10} }} {{order[type].second_amount | rpcurrency}}</span> za <span> {{order[type].first_amount | rpcurrency}}</span>)</p></div><div class="row btns-row"><div class="col-xs-12 col-md-6 col-sm-8 btns-wrapper"><button type="submit" ng-disabled="tradeForm.$invalid" class="btn btn-success btn-block submit"><span ng-show="type == \'buy\'">Kúpiť</span><span ng-show="type == \'sell\'">Predať</span> {{order.first_currency | rpcurrency}}<span ng-hide="order.first_currency.is_native()"> (<span rp-pretty-issuer="order.first_issuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span>)</span></button></div></div></form><div ng-hide="order[type].showWidget"><p class="literal">Nemáte dostatok prostriedkov na vytvorenie príkazu.</p></div></div><form ng-switch-when="confirm" ng-submit="order_confirmed(type)" class="mode-confirm"><p class="title literal"><span>You are about to create an order to<span ng-show="type == \'buy\'" l10n-inc="l10n-inc"> buy</span><span ng-show="type == \'sell\'" l10n-inc="l10n-inc"> sell</span><div class="amount_feedback"><span class="value">{{order[type].first_amount | rpamount}}&#32;</span><span ng-show="(order[type].first_amount | rpcurrency) !== \'XRP\'" rp-pretty-issuer="order[type].first_amount | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span><span class="currency"> {{order[type].first_amount | rpcurrency}}</span></div><div l10n-inc="l10n-inc" class="literal">for</div><div class="dest_feedback"><span class="value">{{order[type].second_amount | rpamount}}&#32;</span><span ng-show="(order[type].second_amount | rpcurrency) !== \'XRP\'" rp-pretty-issuer="order[type].second_amount | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></span><span class="currency"> {{order[type].second_amount | rpcurrency}}</span></div><div class="rate_feedback">(<span class="rate">{{order[type].price}}</span><span class="pair">{{order[type].first_amount | rpcurrency}}/{{order[type].second_amount | rpcurrency}}</span>)</div><p l10n-inc="l10n-inc" class="literal">Are you sure?</p><p ng-show="fatFingerErr" class="order-warning">CAUTION: Your order is far off from the current market price.</p></span><div class="row row-padding-small"><div class="col-xs-6 col-sm-offset-2 col-sm-4 col-md-offset-3 col-md-3"><button type="button" ng-click="order[type].mode = \'trade\'" class="btn btn-block btn-default back">&laquo; Späť</button></div><div class="col-xs-6 col-sm-4 col-md-3"><button type="submit" ng-disabled="confirm_wait" class="btn btn-block btn-success submit">Potvrdiť</button></div></div></p></form><group ng-switch-when="sending" class="mode-sending"><p class="throbber literal">Odosielam príkaz do siete Ripple...</p></group><group ng-switch-when="done" class="mode-done"><group ng-show="order[type].tx_result==&quot;pending&quot;" class="pending"><h2 class="tx-status">Váš príkaz bol odoslaný.</h2></group><group ng-show="\'order[type].tx_result==cleared\' &amp;&amp; executedOnOfferCreate==\'none\'" class="result-success"><h2 class="tx-status">Your order is now active.</h2></group><group ng-show="\'order[type].tx_result==cleared\' &amp;&amp; executedOnOfferCreate==\'all\'" class="result-success"><h2 class="tx-status">Your order has been filled.</h2></group><group ng-show="\'order[type].tx_result==cleared\' &amp;&amp; executedOnOfferCreate==\'partial\'" class="result-success"><h2 class="tx-status">Your order has been partially filled. The remaining amount is now active.</h2></group><group ng-show="order[type].tx_result==&quot;error&quot;" class="result-error"><h2 class="tx-status">Request has been denied.</h2><p>Požiadavku nebolo možné odoslať. Skúste to, prosím, neskôr.</p></group><group ng-show="order[type].tx_result==&quot;malformed&quot;" class="result-malformed"><h2 class="tx-status">Request is malformed.</h2><p>Vaša požiadavka je neplatná, dôvod: {{order[type].engine_result}} - {{order[type].engine_result_message}}</p></group><group ng-show="order[type].tx_result==&quot;claim&quot;" class="result-malformed"><h2 class="tx-status">Transaction failed.</h2><p ng-switch on="order[type].engine_result"><span ng-switch-when="tecUNFUNDED_ORDER">You do not have enough {{(type == \'buy\' ? order.second_currency : order.first_currency) | rpcurrency}} to create this order.</span><span ng-switch-when="tecINSUF_RESERVE_OFFER">Musíte disponovať aspoň {{account.reserve_to_add_trust | rpamount}} XRP pre odoslanie príkazu. <a href="https://ripple.com/wiki/Reserves" target="_blank">Viac informácii.</a></span><span ng-switch-default="ng-switch-default">Chyba: {{order[type].engine_result_message}}</span></p></group><group ng-show="order[type].tx_result==&quot;failed&quot;" class="result-failed"><h2 class="tx-status">Trade failed.</h2><p ng-switch on="order[type].engine_result"><span ng-switch-default="ng-switch-default">Obchod zlyhal, dôvod: {{order[type].engine_result_message}}</span></p></group><group ng-show="order[type].tx_result==&quot;local&quot;" class="result-failed"><h2 class="tx-status">Transaction failed.</h2><p ng-switch on="order[type].engine_result"><span ng-switch-when="telINSUF_FEE_P">Server, ktorému ste odoslali transakciu, bol príliš zaneprázdnený pre spracovanie vašej transakcie s poplatkom, ktorý ste v nej zahrnuli.</span></p></group><group ng-show="order[type].tx_result==&quot;unknown&quot;" class="result-failed"><h2 class="tx-status">{{order[type].engine_result}}</h2><p ng-switch on="order[type].engine_result"><span ng-switch-default="ng-switch-default">{{order[type].engine_result_message}}</span></p></group><hr/><div class="actionLink"><a href="#trade" ng-click="reset_widget(type)">Odoslať ďalší príkaz</a></div></group></div></div></group><h3>My Orders<span>({{offersCount}})</span><small ng-hide="isEmpty(offers)" ng-click="hideOffers = !hideOffers" class="toggle">{{hideOffers ? "show" : "hide"}}</small></h3><div ng-class="{show : !hideOffers}" class="listings offers"><div class="my"><div ng-hide="isEmpty(offers)"><div class="row head hidden-xs"><div class="col-sm-1 type">Typ</div><div class="col-sm-4">Currencies<span l10n-inc="l10n-inc" class="issuer"> (Issuer)</span></div><div class="col-sm-2 price">Cena</div><div class="col-sm-3 amount">Množstvo</div><div class="col-sm-2 action">Akcia</div></div></div><div ng-repeat="entry in offers" ng-class="{cancelling: cancelling}" class="row"><div data-label="Type" class="col-sm-1 type">{{entry.type | rpucfirst}}</div><div data-label="Currencies" class="col-sm-4"><a href="" ng-click="goto_order_currency()"><span>{{entry.first | rpcurrency}}</span><span ng-show="entry.first.issuer().to_json()" class="issuer">&nbsp;(<span rp-pretty-issuer="entry.first.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts">???</span>)</span><span ng-show="\'buy\' == entry.type"> with</span><span ng-show="\'sell\' == entry.type"> for</span><span> {{entry.second | rpcurrency}}</span><span ng-show="entry.second.issuer().to_json()" class="issuer">&nbsp;(<span rp-pretty-issuer="entry.second.issuer().to_json()" rp-pretty-issuer-contacts="userBlob.data.contacts">???</span>)</span></a></div><div data-label="Price" class="col-sm-2 price rpamount">{{entry.second | rpamountratio:entry.first | rpamount:{precision: 5, min_precision: 5} }}<span class="currency"> {{entry.second | rpcurrency}}</span></div><div data-label="Amount" class="col-sm-3 amount rpamount">{{entry.first | rpamount}}<span class="currency"> {{entry.first | rpcurrency}}</span></div><div rp-spinner="{{cancelling ? 4 : null}}" class="col-sm-2 action"><rp-confirm action-text="Are you sure you want to cancel this order?" action-button-text="Cancel order" action-button-css="btn btn-default btn-danger" action-function="cancel_order()" cancel-button-css="btn btn-default" cancel-button-text="Keep order"><a href="" class="danger">Zrušiť</a></rp-confirm></div></div><div ng-show="isEmpty(offers)" class="emptyMessage"><p class="literal">Nezadali ste žiadne príkazy.</p></div></div></div><div ng-show="cancelError" class="alert alert-danger"><span>Unable to cancel order.    </span><span> Error: {{cancelError}}  </span><a href="" ng-click="dismissCancelError()" class="dismiss"> hide</a></div><h3><span>Orderbook</span><small ng-click="hideOrderBook = !hideOrderBook" class="toggle"><span ng-show="hideOrderBook">show</span><span ng-hide="hideOrderBook">hide</span></small></h3><div ng-hide="hideOrderBook"><div class="listings orders"><div class="row orderbook"><div class="bids col-xs-12 col-sm-6"><div class="title">Ponuky</div><div ng-show="book.bids.length" class="row head"><div class="col-xs-4 sum">Celkom<div class="currency">{{book.bids[0].TakerPays | rpcurrency}}</div><div ng-show="(book.bids[0].TakerPays | rpcurrency) !== \'XRP\'" rp-pretty-issuer="book.bids[0].TakerPays | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div><div class="col-xs-4 size">Veľkosť<div class="currency">{{book.bids[0].TakerPays | rpcurrency}}</div><div ng-show="(book.bids[0].TakerPays | rpcurrency) !== \'XRP\'" rp-pretty-issuer="book.bids[0].TakerPays | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div><div class="col-xs-4 price">Predajná cena<div class="currency">{{book.bids[0].TakerGets | rpcurrency}}</div><div ng-show="(book.bids[0].TakerGets | rpcurrency) !== \'XRP\'" rp-pretty-issuer="book.bids[0].TakerGets | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div></div><div ng-repeat="order in book.bids" ng-class="{my: order.my, cancelling: cancelling}" title="{{order.Account}}" class="row"><div class="col-xs-4 rpamount sum"><a href="" ng-click="fill_widget(\'sell\',order,true)"><span rp-bind-color-amount="order.showSum"></span></a></div><div rp-bind-color-amount="order.showTakerPays" class="col-xs-4 rpamount size"></div><div class="col-xs-4 rpamount price"><a href="" ng-click="fill_widget(\'sell\',order)"><span rp-bind-color-amount="order.showPrice"></span></a></div></div><div ng-show="!book.bids.length" class="message">Momentálne neexistujú žiadne ponuky pre tento pár.</div></div><div class="asks col-xs-12 col-sm-6"><div class="title">Dopyty</div><div ng-show="book.asks.length" class="row head"><div class="col-xs-4 price">Nákupná cena<div class="currency">{{book.asks[0].TakerPays | rpcurrency}}</div><div ng-show="(book.asks[0].TakerPays | rpcurrency) !== \'XRP\'" rp-pretty-issuer="book.asks[0].TakerPays | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div><div class="col-xs-4 size">Veľkosť<div class="currency">{{book.asks[0].TakerGets | rpcurrency}}</div><div ng-show="(book.asks[0].TakerGets | rpcurrency) !== \'XRP\'" rp-pretty-issuer="book.asks[0].TakerGets | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div><div class="col-xs-4 sum">Celkom<div class="currency">{{book.asks[0].TakerGets | rpcurrency}}</div><div ng-show="(book.asks[0].TakerGets | rpcurrency) !== \'XRP\'" rp-pretty-issuer="book.asks[0].TakerGets | rpissuer" rp-pretty-issuer-contacts="userBlob.data.contacts" rp-pretty-issuer-or-short="rp-pretty-issuer-or-short" class="issuer"></div></div></div><div ng-repeat="order in book.asks" ng-class="{my: order.my, cancelling: cancelling}" title="{{order.Account}}" class="row"><div class="col-xs-4 rpamount price"><a href="" ng-click="fill_widget(\'buy\',order)"><span rp-bind-color-amount="order.showPrice"></span></a></div><div rp-bind-color-amount="order.showTakerGets" class="col-xs-4 rpamount size"></div><div class="col-xs-4 rpamount sum"><a href="" ng-click="fill_widget(\'buy\',order,true)"><span rp-bind-color-amount="order.showSum"></span></a></div></div><div ng-show="!book.asks.length" class="message">Momentálne neexistujú žiadne dopyty k tomuto páru.</div></div></div></div><div class="foot"><a ng-show="orderbookState==\'ready\'" href="" ng-click="loadMore()" class="loadmore">Načítať viac</a><div ng-show="orderbookState==\'full\'">No more orders</div></div></div></group></group></section>');
	}
	return buf.join("");
	}

/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="SecurityCtrl" class="col-xs-12 content"><div class="row"><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected" class="col-xs-12"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><div ng-show="isUnlocked" class="col-sm-4 col-md-3 col-xs-12"><div class="settingPage"><a href="#/security" ng-class="{active: $route.current.tabName == \'security\'}">Security<a href="#/settingstrade" ng-class="{active: $route.current.tabName == \'settingstrade\'}">Obchod</a></a><a href="#/advanced" ng-class="{active: $route.current.tabName == \'advanced\'}">Advanced</a><a href="#/settingsgateway" ng-class="{active: $route.current.tabName == \'settingsgateway\'}">Gateways and trust lines</a></div></div><div ng-show="isUnlocked" class="col-sm-8 col-md-9 col-xs-12 list"><div ng-show="settingsPage == \'security\'" class="showSecurity"><div><h4>Security settings</h4><div class="section"><div class="descriptor">Secret key</div><div class="row"></div><label>Your secret key unlocks access to your account funds. Please write it down and store it\n somewhere private and safe. In the event you lose your password, you can use this secret\n key to recover your funds.</label><div class="row"><div class="col-xs-9 col-sm-8 col-md-6"><span ng-show="security.master_seed" class="value">{{security.master_seed}}</span><span ng-hide="security.master_seed" class="value">••••••••••••••••••••••••••••••••••••••••••••</span></div><div class="col-xs-3 col-sm-4 col-md-3"><a href="" ng-click="unmaskSecret()" ng-hide="security.master_seed">Zobraziť</a><a href="" ng-click="security.master_seed = null" ng-show="security.master_seed">Skryť</a></div></div></div></div></div></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="TxCtrl" ng-switch on="state" class="single ddpage content"><group ng-switch-when="loading"><p class="literal throbber">Načítanie detailov transakcie...</p></group><group ng-switch-when="error"><p class="literal">Pri načítaní detailov transakcie nastala chyba.</p></group><group ng-switch-when="loaded"><p class="literal hash"><span>Transakcia č.</span><span>{{transaction.hash}}</span><div><a href="{{\'https://ripplecharts.com/#/graph/\' + transaction.hash}}" target="_blank">Ukázať na grafe</a></div></p><hr/><p class="literal type">Typ transakcie: <strong> {{transaction.TransactionType}}</strong></p><group ng-switch on="transaction.TransactionType"><group ng-switch-when="Payment"><group class="clearfix"><dl class="details half"><dt><span>Adresa odosielateľa</span><span>:</span></dt><dd>{{transaction.Account}}</dd><dt><span>Odoslaná čiastka</span><span>:</span></dt><dd>{{amountSent | rpamount}} {{amountSent | rpcurrency}}</dd><dt><span>Odoslaná mena</span><span>:</span></dt><dd>{{amountSent | rpcurrencyfull}}</dd></dl><dl class="details half"><dt><span>Odoslané na adresu</span><span>:</span></dt><dd>{{transaction.Destination}}</dd><dt><span>Prijatá čiastka</span><span>:</span></dt><dd>{{transaction.Amount | rpamount}} {{transaction.Amount | rpcurrency}}</dd><dt><span>Prijatá mena</span><span>:</span></dt><dd>{{transaction.Amount | rpcurrencyfull}}</dd></dl></group><hr/><group class="clearfix"><dl class="details half"><dt><span>Uhradený poplatok siete</span><span>:</span></dt><dd>{{transaction.Fee | rpamount}} XRP</dd></dl><dl class="details half"><group ng-show="transaction.DestinationTag !== null &amp;&amp; transaction.DestinationTag !== undefined"><dt><span>Značka adresáta</span><span>:</span></dt><dd>{{transaction.DestinationTag}}</dd></group></dl></group><hr/><dl class="details"><dt><span>Čislo registra</span><span>:</span></dt><dd>{{transaction.inLedger}}</dd></dl></group><group ng-switch-default="ng-switch-default"><group class="clearfix"><dl class="details half"><dt>Adresa odoslaná z:</dt><dd>{{transaction.Account}}</dd></dl><dl class="details half"></dl></group><hr/><p class="literal">Prepáčte, ale zatiaľ neexistuje informačná stránka pre tento typ transakcie.</p></group></group></group></section>');
	}
	return buf.join("");
	}

/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="XrpCtrl" class="col-xs-12 content"><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><div ng-show="connected" class="row"><div class="col-sm-3"><div class="currencies"><a href="#/xrp" ng-class="{active: $route.current.tabName == \'xrp\'}">XRP</a><a href="#/trust" ng-class="{active: $route.current.tabName == \'trust\'}">Gateways</a></div><a href="https://ripple.com/knowledge_center/gateway-information" target="_blank">Learn more about gateways</a></div><div class="col-sm-9 list"><div ng-show="fundPage == \'xrp\'" class="fundXrp"><div class="nameLine">Ripple address&#32;<div class="address">{{address}}</div></div></div></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="EulaCtrl" class="content"><h1>Ripple Trade End-User License Agreement</h1><hr/><p>Welcome to the Ripple software client <strong>Ripple Trade</strong>\nprovided by Ripple Labs, Inc. (“we” or “us”).  Ripple Trade is a version of the open source\nRipple software client that allows users to access the decentralized Ripple transaction protocol\npayment network ("Ripple Protocol").  Source code for Ripple Trade and related software is available\nfree of charge under open source software license agreements at <a href="https://github.com/ripple">https://github.com/ripple</a>  We hope\nyou find Ripple Trade to be useful as a tool to access and use the Ripple Protocol.</p><p>Please read this End User License Agreement <strong>EULA</strong> carefully as it explains your and\nour respective rights and responsibilities associated with your access to, and use of, Ripple Trade.</p><p>1. <strong>RIPPLE PROTOCOL</strong>. You understand that Ripple Trade allows you to interact directly\nwith the Ripple Protocol to create a Ripple Protocol wallet (“Ripple Wallet”), initiate payments\npostings to the Ripple Protocol as well as view transaction histories and balances available via the\nRipple Protocol.  You understand that Ripple Trade itself does not process payments, or hold\ntransaction histories and balances and is merely a tool for initiating actions that occur within the\nRipple Protocol and viewing the record of those actions.  You understand that actual payments are\nprocessed via the Ripple Protocol, not Ripple Trade, and that resulting balances shown in Ripple\nTrade are (i) actually held by third parties or (ii) in the case of XRP, held through a chain of\ncustody documented on the Ripple Protocol public ledger (“The Ledger”).  You acknowledge and agree\nthat we have no control, responsibility or authority over such third parties.  Ripple Trade merely\ninteroperates with such entities via the Ripple Protocol.  For more information about the Ripple\nProtocol, including Ripple Protocol transaction fees, please visit the <a href="https://ripple.com/wiki/">Ripple Wiki</a>.  You further\nacknowledge and agree that transactions you initiate within the Ripple Protocol will be available to\nthe public on the Internet via The Ledger.  Ripple Trade allows you to view the public payments data\nposted for Ripple Wallets – including your own Ripple Wallet.  Once data is shared to the Ripple\nProtocol, neither Ripple Trade nor any third party may selectively censor or blacklist access to, and\nsubsequent use of, such data.</p><p>2. <strong>THIRD-PARTY SERVICES</strong>. You may be able to access and use third-party content and\nservices displayed via Ripple Trade, such as gateway services (“Third-Party Services”), including\nThird-Party Services that interact directly with the Ripple Protocol.  When using any Third-Party\nServices, you are interacting directly with such services, not us, and you agree to comply with any\nterms and conditions applicable to such services.  Ripple Trade may display or otherwise highlight\ncertain Third-Party Services for your convenience, but we do not endorse any Third-Party Services.\nYou are solely responsible for your use of any Third-Party Services.  We are not a party to, make no\nrepresentations or warranties as to, and have no responsibility or liability with respect to any of\nyour communications, transactions, interactions, disputes or any relations whatsoever between you and\nany third party providing the Third-Party Services, including any fees that may be charged to you in\nconnection with your use of any Third-Party Services.</p><p>3. <strong>RIPPLE WALLET DATA</strong>. Your Ripple Wallet, including any private and confidential data\naccessible therein, is protected from unauthorized access and use by others via a secret key and\npassword held by you and not Ripple Trade.  Ripple Trade cannot assist you in recovering your secret\nkey and password.  It is your sole responsibility to keep your secret key and password protected from\nunauthorized discovery.  Ripple Trade is not responsible for the consequences of another party\naccessing and using your Ripple Wallet data because it is your sole responsibility to keep you secret\nkey and password from being accessed and used by unauthorized third parties.</p><p>4. <strong>BLOCKING</strong>. You understand and agree that we may block excessive or abusive use of\nRipple Trade from a particular IP address at any point in time and for any length of time, in our\nsole discretion.  Even if we block access to Ripple Trade, you may still access your Ripple Wallet\nvia other Ripple client software.</p><p>5. <strong>ACCEPTABLE USE</strong>. You agree not use Ripple Trade to violate any applicable law,\ncontract, or third-party right or to engage in any transaction involving illegal products or\nservices.  You further agree not to:</p><p>- Use Ripple Trade in any manner that could interfere with, disrupt, negatively affect or inhibit\nother users from fully enjoying Ripple Trade, or that could damage, disable, overburden or impair\nthe functioning of Ripple Trade in any manner;</p><p>- Attempt to circumvent any security techniques we employ, or attempt to access any service or area\nof Ripple Trade that you are not authorized to access;</p><p>- Introduce to Ripple Trade any virus, trojan worms, logic bombs or other harmful material; and</p><p>- Encourage or induce any third party to engage in any of the activities prohibited under this Section.</p><p>6. <strong>COPYRIGHT COMPLAINTS</strong>. If you believe anything on Ripple Trade infringes upon any\ncopyright which you own or control, you may file a notification of such infringement with our\nDesignated Agent as set forth below.</p><p>Name of Designated Agent: Anna See</p><p>Full Address of Designated Agent: 118 2nd St, Floor 2, San Francisco, CA 94104-3503</p><p>Telephone Number of Designated Agent: 415.967.1836</p><p>E-Mail Address of Designated Agent: anna@ripple.com</p><p>7. <strong>DISCLAIMER</strong>. MANY JURISDICTIONS HAVE LAWS PROTECTING CONSUMERS AND OTHER CONTRACT\nPARTIES, LIMITING THEIR ABILITY TO WAIVE CERTAIN RIGHTS AND RESPONSIBILITIES. WE RESPECT SUCH LAWS;\nNOTHING HEREIN IS INTENDED TO WAIVE RIGHTS OR RESPONSIBILITIES THAT CANNOT BE WAIVED.</p><p>To the extent permitted by applicable law, (a) we make no promises as to Ripple Trade, its\ncompleteness, accuracy, availability, timeliness, propriety, security or reliability; (b) your\naccess and use are at your own risk, and Ripple Trade is provided “AS IS” and “AS AVAILABLE”; and\n(c) WE, OUR SUBSIDIARIES AND AFFILIATES, AND OUR AND THEIR OFFICERS, DIRECTORS, EMPLOYEES\n(“RIPPLE LAB ENTITIES”), DISCLAIM ALL WARRANTIES & CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT\nNOT LIMITED, TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSE, OR\nNON-INFRINGEMENT.</p><p>8. <strong>LIMITATION ON LIABILITY</strong>.</p><p>(A) TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL THE RIPPLE LAB ENTITIES BE\nLIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL OR PUNITIVE DAMAGES, OR ANY LOSS\n(E.G. OF PROFIT, REVENUE, DATA, OR GOODWILL).  Some jurisdictions do not allow the limitation or\nexclusion of liability for incidental or consequential damages, so some of the limitations of this\nsection may not apply to you.</p><p>(B) TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL THE AGGREGATE LIABILITY OF\nTHE RIPPLE LAB ENTITIES, WHETHER IN CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE, WHETHER ACTIVE,\nPASSIVE OR IMPUTED), PRODUCT LIABILITY, STRICT LIABILITY OR OTHER THEORY, ARISING OUT OF OR RELATING\nTO THE USE OF, OR INABILITY TO USE RIPPLE TRADE OR TO THIS EULA EXCEED $100 U.S. DOLLARS.</p><p>9. <strong>DISPUTES; INDEMNITY</strong>.  You agree (a) that any claim, cause of action and dispute\n(“Claim”) arising out of or related to this EULA or your Ripple Trade use is governed by California\nlaw regardless of your location or any conflict or choice of law principle; (b) that any Claim must\nbe resolved exclusively by state or federal court in San Francisco, California (except we may seek\ninjunctive remedy anywhere); (c) to submit to personal jurisdiction of said courts; (d) any Claim\nfiled later than 1 year after the facts giving rise to such Claim occurred are hereby waived and shall\nbe forever barred; and (e) (except government agencies) to defend, indemnify and hold harmless each\nand all of the Ripple Lab Entities for any damage, loss, and expense (including, but not limited to,\nattorneys’ fees) arising from any Claim related to this EULA or your Ripple Trade use.</p><p>10. <strong>OTHER TERMS</strong>. This EULA contains the entire agreement, and supersedes all prior\nand contemporaneous understandings between the parties regarding Ripple Trade.  This EULA do not alter\nthe terms or conditions of any other agreement you may have with us for any other product or service\nor otherwise.  In the event of any conflict between this EULA and any other agreement you may have with\nus, the terms of that other agreement will control only if this EULA is specifically identified and\ndeclared to be overridden by such other agreement.  Our failure or delay in exercising any right, power\nor privilege under this EULA will not operate as a waiver thereof.  The invalidity or unenforceability\nof any term in this EULA will not affect the validity or enforceability of any other term of this EULA,\nall of which will remain in full force and effect.</p></section>');
	}
	return buf.join("");
	}

/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="SettingsGatewayCtrl" class="col-xs-12 content"><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected &amp;&amp; !debug"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><div class="row"><div class="col-sm-12 notification-wrapper"><div ng-show="success.bridge" class="alert alert-success">Your bitcoin bridge has been changed successfully.</div><div ng-show="success.advanced_feature_switch" class="alert alert-success">Trustline advanced settings have been changed successfully.</div><div ng-show="edit.defaultRippleFlagSaving" class="alert alert-info">Updating DefaultRipple flag...</div><div ng-show="notif == \'defaultRippleUpdated\'" class="alert alert-success">DefaultRipple flag updated</div></div><div class="col-sm-3"><div class="settingPage"><a href="#/security" ng-class="{active: $route.current.tabName == \'security\'}">Security<a href="#/settingstrade" ng-class="{active: $route.current.tabName == \'settingstrade\'}">Obchod</a></a><a href="#/advanced" ng-class="{active: $route.current.tabName == \'advanced\'}">Advanced</a><a href="#/settingsgateway" ng-class="{active: $route.current.tabName == \'settingsgateway\'}">Gateways and trust lines</a></div></div><group ng-hide="connected" class="disconnected"><p class="literal">Pre zobrazenie tejto stránky musíte byť pripojení.</p></group><div ng-hide="account.Balance" class="col-sm-9 list"><div class="unfunded literal">Your account has to be&#32;<a href="https://ripple.com/knowledge_center/activating-your-wallet/" target="_blank" l10n-inc="l10n-inc">activated</a>&#32;before you can see this page.</div></div><div ng-show="connected &amp;&amp; account.Balance" class="col-sm-9 list"><section id="gateways" class="content"><h4>Settings</h4><form name="accountsAdvForm" ng-submit="save(&quot;advanced_feature_switch&quot;)" class="trust-line-form"><div class="descriptor">Trust line</div><div ng-hide="edit.advanced_feature_switch" class="row advanced-form-row"><div class="col-xs-6 col-sm-5 col-md-3"><div class="description">Advanced settings</div></div><div class="col-xs-3 col-sm-4 col-md-4"><div ng-show="options.advanced_feature_switch" class="description">Zobraziť</div><div ng-hide="options.advanced_feature_switch" class="description">Skryť</div></div><div class="col-xs-3 col-sm-3 col-md-2"><a href="" ng-click="edit.advanced_feature_switch = true" class="btn btn-cancel btn-block">upraviť</a></div></div><div ng-show="edit.advanced_feature_switch" class="row row-padding-small edit-trust-line"><div class="col-xs-6 col-sm-5 col-md-3"><div class="description">Advanced settings</div></div><div class="col-xs-4 col-sm-4 col-md-3"><div class="helperInput"><label><input type="checkbox" name="acct_adv" ng-model="options.advanced_feature_switch"/><span>Zobraziť</span></label></div></div><div class="col-xs-6 col-sm-6 col-md-3"><button id="save" type="submit" ng-disabled="serverForm.$invalid" class="btn btn-block btn-success btn-xs submit">Uložiť</button></div><div id="cancel" class="col-xs-6 col-sm-6 col-md-3"><a href="" ng-click="cancelEdit(\'advanced_feature_switch\')" class="btn btn-cancel btn-block">zrušiť</a></div></div></form><form name="accountsAdvForm" ng-submit="save(&quot;defaultRippleFlag&quot;)" class="trust-line-form"><div class="descriptor">Gateways: Enable if you plan to issue balances</div><div ng-hide="edit.defaultRippleFlag" class="row advanced-form-row"><div class="col-xs-6 col-sm-5 col-md-3"><div class="description">DefaultRipple flag</div></div><div class="col-xs-3 col-sm-4 col-md-4"><div ng-show="currentDefaultRipplingFlagSetting &amp;&amp; !edit.defaultRippleFlagSaving" class="description">Enabled</div><div ng-hide="currentDefaultRipplingFlagSetting || edit.defaultRippleFlagSaving" class="description">Disabled</div><div ng-show="edit.defaultRippleFlagSaving" class="description"><img src="img/button-s.png" class="loader"/></div></div><div class="col-xs-3 col-sm-3 col-md-2"><a href="" ng-click="edit.defaultRippleFlag = true" ng-hide="edit.defaultRippleFlagSaving" class="btn btn-cancel btn-block">upraviť</a></div></div><div ng-show="edit.defaultRippleFlag" class="row row-padding-small edit-trust-line"><div class="col-xs-6 col-sm-5 col-md-3"><div class="description">DefaultRipple flag</div></div><div class="col-xs-4 col-sm-4 col-md-3"><div class="helperInput"><label><input type="checkbox" name="acct_adv" ng-model="isDefaultRippleFlagEnabled"/><span>Enable</span></label></div></div><div class="col-xs-12 col-sm-4 col-md-4"><button id="save" type="submit" ng-disabled="serverForm.$invalid" class="btn btn-block btn-success btn-xs submit">Uložiť</button></div><div ng-show="hasRemove()" class="col-xs-3"><button id="delete" type="button" ng-click="remove()" ng-show="hasRemove()" class="btn btn-block btn-danger btn-xs submit">Vymazať</button></div></div></form></section></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<section ng-controller="SettingsTradeCtrl" class="col-xs-12 content"><div ng-show="debug">This page is not available in debug mode</div><div ng-show="!loadingAccount &amp;&amp; !account.Balance &amp;&amp; loadState.account &amp;&amp; connected &amp;&amp; !debug"><div class="auth-attention banner">Your Ripple account is not active. To activate it, you\'ll need to send at least 20 XRP to ({{address}}).</div></div><div ng-show="!debug" class="row"><div class="col-sm-12"></div><div class="col-sm-3"><div class="settingPage"><a href="#/security" ng-class="{active: $route.current.tabName == \'security\'}">Security<a href="#/settingstrade" ng-class="{active: $route.current.tabName == \'settingstrade\'}">Obchod</a></a><a href="#/advanced" ng-class="{active: $route.current.tabName == \'advanced\'}">Advanced</a><a href="#/settingsgateway" ng-class="{active: $route.current.tabName == \'settingsgateway\'}">Gateways and trust lines</a></div></div><div class="col-sm-9 list"><section><h4>Trade settings</h4><div class="section"><div class="descriptor">Trade currency pairs</div><div ng-show="!pairs || (pairs &amp;&amp; pairs.length == 0)">No trade pairs in this account. To add a pair, go to the <a href="#/trade" l10n-inc="l10n-inc">Trade &gt; Advanced </a>section.</div><div ng-if="pairs"><div as-sortable="dragControlListeners" ng-model="pairs"><div ng-repeat="entry in pairs track by entry.name" as-sortable-item="as-sortable-item" class="pair"><div as-sortable-item-handle="as-sortable-item-handle" class="col-xs-12"><i class="grip"></i><span ng-bind="entry.name" class="description"></span><a href="" ng-click="deletePair($index)"><span class="delete">remove</span></a></div></div></div></div></div></section></div></div></section>');
	}
	return buf.join("");
	}

/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {

	var map = {
		"./af": 82,
		"./af.js": 82,
		"./ar": 85,
		"./ar-ma": 83,
		"./ar-ma.js": 83,
		"./ar-sa": 84,
		"./ar-sa.js": 84,
		"./ar.js": 85,
		"./az": 86,
		"./az.js": 86,
		"./be": 87,
		"./be.js": 87,
		"./bg": 88,
		"./bg.js": 88,
		"./bn": 89,
		"./bn.js": 89,
		"./bo": 90,
		"./bo.js": 90,
		"./br": 91,
		"./br.js": 91,
		"./bs": 92,
		"./bs.js": 92,
		"./ca": 93,
		"./ca.js": 93,
		"./cs": 94,
		"./cs.js": 94,
		"./cv": 95,
		"./cv.js": 95,
		"./cy": 96,
		"./cy.js": 96,
		"./da": 97,
		"./da.js": 97,
		"./de": 99,
		"./de-at": 98,
		"./de-at.js": 98,
		"./de.js": 99,
		"./el": 100,
		"./el.js": 100,
		"./en-au": 101,
		"./en-au.js": 101,
		"./en-ca": 102,
		"./en-ca.js": 102,
		"./en-gb": 103,
		"./en-gb.js": 103,
		"./eo": 104,
		"./eo.js": 104,
		"./es": 105,
		"./es.js": 105,
		"./et": 106,
		"./et.js": 106,
		"./eu": 107,
		"./eu.js": 107,
		"./fa": 108,
		"./fa.js": 108,
		"./fi": 109,
		"./fi.js": 109,
		"./fo": 110,
		"./fo.js": 110,
		"./fr": 112,
		"./fr-ca": 111,
		"./fr-ca.js": 111,
		"./fr.js": 112,
		"./gl": 113,
		"./gl.js": 113,
		"./he": 114,
		"./he.js": 114,
		"./hi": 115,
		"./hi.js": 115,
		"./hr": 116,
		"./hr.js": 116,
		"./hu": 117,
		"./hu.js": 117,
		"./hy-am": 118,
		"./hy-am.js": 118,
		"./id": 119,
		"./id.js": 119,
		"./is": 120,
		"./is.js": 120,
		"./it": 121,
		"./it.js": 121,
		"./ja": 122,
		"./ja.js": 122,
		"./ka": 123,
		"./ka.js": 123,
		"./km": 124,
		"./km.js": 124,
		"./ko": 125,
		"./ko.js": 125,
		"./lb": 126,
		"./lb.js": 126,
		"./lt": 127,
		"./lt.js": 127,
		"./lv": 128,
		"./lv.js": 128,
		"./mk": 129,
		"./mk.js": 129,
		"./ml": 130,
		"./ml.js": 130,
		"./mr": 131,
		"./mr.js": 131,
		"./ms-my": 132,
		"./ms-my.js": 132,
		"./my": 133,
		"./my.js": 133,
		"./nb": 134,
		"./nb.js": 134,
		"./ne": 135,
		"./ne.js": 135,
		"./nl": 136,
		"./nl.js": 136,
		"./nn": 137,
		"./nn.js": 137,
		"./pl": 138,
		"./pl.js": 138,
		"./pt": 140,
		"./pt-br": 139,
		"./pt-br.js": 139,
		"./pt.js": 140,
		"./ro": 141,
		"./ro.js": 141,
		"./ru": 142,
		"./ru.js": 142,
		"./sk": 143,
		"./sk.js": 143,
		"./sl": 144,
		"./sl.js": 144,
		"./sq": 145,
		"./sq.js": 145,
		"./sr": 147,
		"./sr-cyrl": 146,
		"./sr-cyrl.js": 146,
		"./sr.js": 147,
		"./sv": 148,
		"./sv.js": 148,
		"./ta": 149,
		"./ta.js": 149,
		"./th": 150,
		"./th.js": 150,
		"./tl-ph": 151,
		"./tl-ph.js": 151,
		"./tr": 152,
		"./tr.js": 152,
		"./tzm": 154,
		"./tzm-latn": 153,
		"./tzm-latn.js": 153,
		"./tzm.js": 154,
		"./uk": 155,
		"./uk.js": 155,
		"./uz": 156,
		"./uz.js": 156,
		"./vi": 157,
		"./vi.js": 157,
		"./zh-cn": 158,
		"./zh-cn.js": 158,
		"./zh-tw": 159,
		"./zh-tw.js": 159
	};
	function webpackContext(req) {
		return __webpack_require__(webpackContextResolve(req));
	};
	function webpackContextResolve(req) {
		return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
	};
	webpackContext.keys = function webpackContextKeys() {
		return Object.keys(map);
	};
	webpackContext.resolve = webpackContextResolve;
	module.exports = webpackContext;


/***/ },
/* 81 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = [
		{
			"name": "Bitstamp",
			"accounts": [
				{
					"address": "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
					"currencies": [
						"BTC",
						"USD",
						"EUR"
					],
					"hotwallets": [
						"rrpNnNLKrartuEqfJGpqyDwPj1AFPg9vn1"
					]
				}
			]
		},
		{
			"name": "RippleChina",
			"accounts": [
				{
					"address": "razqQKzJRdB4UxFPWf5NEpEG3WMkmwgcXA",
					"currencies": [
						"CNY"
					],
					"hotwallets": [
						"r45dBj4S3VvMMYXxr9vHX4Z4Ma6ifPMCkK"
					]
				}
			]
		},
		{
			"name": "rippleCN",
			"accounts": [
				{
					"address": "rnuF96W4SZoCJmbHYBFoJZpR8eCaxNvekK",
					"currencies": [
						"BTC",
						"CNY"
					],
					"hotwallets": [
						"rNaptDNfFXo1quhKwMaNPf66iwPqA8YLky",
						"rno91tGDJeRcnM7EMXj8KG9UTyxRGMMz8s"
					]
				}
			]
		},
		{
			"name": "Payroutes",
			"accounts": [
				{
					"address": "rNPRNzBB92BVpAhhZr4iXDTveCgV5Pofm9",
					"currencies": [
						"BTC",
						"ILS"
					],
					"hotwallets": []
				}
			]
		},
		{
			"name": "SnapSwap",
			"accounts": [
				{
					"address": "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
					"currencies": [
						"USD",
						"BTC",
						"EUR",
						"GBP"
					],
					"hotwallets": [
						"rUQTpMqAF5jhykj4FExVeXakrZpiKF6cQV",
						"rhasPLL5GaXzBh5amQkN7Dr1SNF4Whb2ZT"
					]
				}
			]
		},
		{
			"name": "TheRock",
			"accounts": [
				{
					"address": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
					"currencies": [
						"BTC",
						"EUR",
						"USD"
					],
					"hotwallets": [
						"rUeFPRGNjtcbtezyQKKiDcS1eQyYLQ1gcr"
					]
				}
			]
		},
		{
			"name": "WisePass",
			"accounts": [
				{
					"address": "rPDXxSZcuVL3ZWoyU82bcde3zwvmShkRyF",
					"currencies": [
						"BTC",
						"LTC",
						"USD"
					],
					"hotwallets": [
						"r9xAQUyqs53QH2PLxe7iFbNbpU2RA9QtZx"
					]
				}
			]
		},
		{
			"name": "RippleUnion",
			"accounts": [
				{
					"address": "r3ADD8kXSUKHd6zTCKfnKT3zV9EZHjzp1S",
					"currencies": [
						"CAD"
					],
					"hotwallets": []
				}
			]
		},
		{
			"name": "Justcoin",
			"accounts": [
				{
					"address": "rJHygWcTLVpSXkowott6kzgZU6viQSVYM1",
					"currencies": [
						"LTC",
						"BTC",
						"STR",
						"EUR",
						"NOK"
					],
					"hotwallets": []
				}
			]
		},
		{
			"name": "DotPayco",
			"accounts": [
				{
					"address": "rM8199qFwspxiWNZRChZdZbGN5WrCepVP1",
					"currencies": [
						"CNY"
					],
					"hotwallets": []
				}
			]
		},
		{
			"name": "RippleSingapore",
			"accounts": [
				{
					"address": "r9Dr5xwkeLegBeXq6ujinjSBLQzQ1zQGjH",
					"currencies": [
						"XAU",
						"XAG",
						"XPT",
						"SGD"
					],
					"hotwallets": []
				}
			]
		},
		{
			"name": "Bitso",
			"accounts": [
				{
					"address": "rG6FZ31hDHN1K5Dkbma3PSB5uVCuVVRzfn",
					"currencies": [
						"MXN",
						"BTC"
					],
					"hotwallets": [
						"rHZaDC6tsGN2JWGeXhjKL6664RNCq5hu4B"
					]
				}
			]
		},
		{
			"name": "Coinex",
			"accounts": [
				{
					"address": "rsP3mgGb2tcYUrxiLFiHJiQXhsziegtwBc",
					"currencies": [
						"NZD",
						"BTC",
						"USD",
						"AUD",
						"STR"
					],
					"hotwallets": [
						"rGAmy1w1ENyTJ9BCAEicYyRM2Yk1iWZ7Z5"
					],
					"domain": "coinexgateway.com"
				}
			]
		},
		{
			"name": "RippleLatAm",
			"accounts": [
				{
					"address": "rP5ShE8dGBH6hHtNvRESdMceen36XFBQmh",
					"currencies": [
						"BRL",
						"UYU",
						"PEN",
						"MXN",
						"BTC",
						"LTC",
						"USD",
						"CLP",
						"ARS"
					],
					"hotwallets": [
						"raoFdQah8c8owTj4TPMr8o1WntnXybXCgB"
					],
					"domain": "ripplelatam.com"
				}
			]
		},
		{
			"name": "GBI",
			"accounts": [
				{
					"address": "rrh7rf1gV2pXAoqA8oYbpHd8TKv5ZQeo67",
					"currencies": [
						"XAU"
					],
					"hotwallets": [],
					"domain": "goldbullioninternational.com"
				}
			]
		},
		{
			"name": "LakeBTC",
			"accounts": [
				{
					"address": "rpDMez6pm6dBve2TJsmDpv7Yae6V5Pyvy2",
					"currencies": [
						"USD"
					]
				}
			],
			"hotwallets": [
				"rP9gFJKqKGWdR4n6XjdsUPqmJfXkg4kSgZ"
			],
			"domain": "lakebtc.com"
		},
		{
			"name": "RippleFox",
			"accounts": [
				{
					"address": "rKiCet8SdvWxPXnAgYarFUXMh1zCPz432Y",
					"currencies": [
						"CNY",
						"STR"
					]
				}
			],
			"hotwallets": [
				"rLSnkKvMfPD9abLoQFxQJMYyZqJcsqkL3o",
				"rPcQaiyDxMwLr7Q9eFmn5VnVx2RN57MUmN",
				"r3ipidkRUZWq8JYVjnSnNMf3v7o69vgLEW"
			],
			"domain": "ripplefox.com"
		},
		{
			"name": "TokyoJPY",
			"accounts": [
				{
					"address": "r94s8px6kSw1uZ1MV98dhSRTvc6VMPoPcN",
					"currencies": [
						"JPY"
					]
				}
			],
			"hotwallets": [],
			"domain": "tokyojpy.com"
		},
		{
			"name": "Rippex",
			"accounts": [
				{
					"address": "rfNZPxoZ5Uaamdp339U9dCLWz2T73nZJZH",
					"currencies": [
						"BRL"
					]
				}
			],
			"hotwallets": [
				"r37FUji17jCgCZvAUc8m5YqXquwHpgwa9q"
			],
			"domain": "rippex.net"
		},
		{
			"name": "RippleMarketJapan",
			"accounts": [
				{
					"address": "rJRi8WW24gt9X85PHAxfWNPCizMMhqUQwg",
					"currencies": [
						"JPY"
					]
				}
			],
			"hotwallets": [],
			"domain": "ripple-market.jp"
		},
		{
			"name": "RippleExchangeTokyo",
			"accounts": [
				{
					"address": "r9ZFPSb1TFdnJwbTMYHvVwFK1bQPUCVNfJ",
					"currencies": [
						"JPY"
					]
				}
			],
			"hotwallets": [],
			"domain": "ripplex.co.jp"
		},
		{
			"name": "Ripula-UK",
			"accounts": [
				{
					"address": "rBycsjqxD8RVZP5zrrndiVtJwht7Z457A8",
					"currencies": [
						"GBP"
					]
				}
			],
			"hotwallets": [
				"rUR5QVHqFxRa8TSQawc1M6jKj7BvKzbHek"
			],
			"domain": "ripula.co.uk"
		},
		{
			"name": "ice3x",
			"accounts": [
				{
					"address": "rLpKwneVStAVwPhgCgNJVFCePq5J3xaNpN",
					"currencies": [
						"ZAR"
					]
				}
			],
			"domain": "www.ice3x.co.za"
		},
		{
			"name": "Senderas",
			"accounts": [
				{
					"address": "rJypGvB8H2JBj1QVYofUTU8kFtWLspNWqs",
					"currencies": [
						"GBP"
					]
				}
			],
			"domain": "www.senderas.com"
		}
	]

/***/ },
/* 82 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : afrikaans (af)
	// author : Werner Mollentze : https://github.com/wernerm

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('af', {
	        months : 'Januarie_Februarie_Maart_April_Mei_Junie_Julie_Augustus_September_Oktober_November_Desember'.split('_'),
	        monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Aug_Sep_Okt_Nov_Des'.split('_'),
	        weekdays : 'Sondag_Maandag_Dinsdag_Woensdag_Donderdag_Vrydag_Saterdag'.split('_'),
	        weekdaysShort : 'Son_Maa_Din_Woe_Don_Vry_Sat'.split('_'),
	        weekdaysMin : 'So_Ma_Di_Wo_Do_Vr_Sa'.split('_'),
	        meridiem : function (hours, minutes, isLower) {
	            if (hours < 12) {
	                return isLower ? 'vm' : 'VM';
	            } else {
	                return isLower ? 'nm' : 'NM';
	            }
	        },
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Vandag om] LT',
	            nextDay : '[Môre om] LT',
	            nextWeek : 'dddd [om] LT',
	            lastDay : '[Gister om] LT',
	            lastWeek : '[Laas] dddd [om] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'oor %s',
	            past : '%s gelede',
	            s : '\'n paar sekondes',
	            m : '\'n minuut',
	            mm : '%d minute',
	            h : '\'n uur',
	            hh : '%d ure',
	            d : '\'n dag',
	            dd : '%d dae',
	            M : '\'n maand',
	            MM : '%d maande',
	            y : '\'n jaar',
	            yy : '%d jaar'
	        },
	        ordinal : function (number) {
	            return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de'); // Thanks to Joris Röling : https://github.com/jjupiter
	        },
	        week : {
	            dow : 1, // Maandag is die eerste dag van die week.
	            doy : 4  // Die week wat die 4de Januarie bevat is die eerste week van die jaar.
	        }
	    });
	}));


/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Moroccan Arabic (ar-ma)
	// author : ElFadili Yassine : https://github.com/ElFadiliY
	// author : Abdel Said : https://github.com/abdelsaid

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('ar-ma', {
	        months : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
	        monthsShort : 'يناير_فبراير_مارس_أبريل_ماي_يونيو_يوليوز_غشت_شتنبر_أكتوبر_نونبر_دجنبر'.split('_'),
	        weekdays : 'الأحد_الإتنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
	        weekdaysShort : 'احد_اتنين_ثلاثاء_اربعاء_خميس_جمعة_سبت'.split('_'),
	        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[اليوم على الساعة] LT',
	            nextDay: '[غدا على الساعة] LT',
	            nextWeek: 'dddd [على الساعة] LT',
	            lastDay: '[أمس على الساعة] LT',
	            lastWeek: 'dddd [على الساعة] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'في %s',
	            past : 'منذ %s',
	            s : 'ثوان',
	            m : 'دقيقة',
	            mm : '%d دقائق',
	            h : 'ساعة',
	            hh : '%d ساعات',
	            d : 'يوم',
	            dd : '%d أيام',
	            M : 'شهر',
	            MM : '%d أشهر',
	            y : 'سنة',
	            yy : '%d سنوات'
	        },
	        week : {
	            dow : 6, // Saturday is the first day of the week.
	            doy : 12  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Arabic Saudi Arabia (ar-sa)
	// author : Suhail Alkowaileet : https://github.com/xsoh

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '١',
	        '2': '٢',
	        '3': '٣',
	        '4': '٤',
	        '5': '٥',
	        '6': '٦',
	        '7': '٧',
	        '8': '٨',
	        '9': '٩',
	        '0': '٠'
	    }, numberMap = {
	        '١': '1',
	        '٢': '2',
	        '٣': '3',
	        '٤': '4',
	        '٥': '5',
	        '٦': '6',
	        '٧': '7',
	        '٨': '8',
	        '٩': '9',
	        '٠': '0'
	    };

	    return moment.defineLocale('ar-sa', {
	        months : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
	        monthsShort : 'يناير_فبراير_مارس_أبريل_مايو_يونيو_يوليو_أغسطس_سبتمبر_أكتوبر_نوفمبر_ديسمبر'.split('_'),
	        weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
	        weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
	        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 12) {
	                return 'ص';
	            } else {
	                return 'م';
	            }
	        },
	        calendar : {
	            sameDay: '[اليوم على الساعة] LT',
	            nextDay: '[غدا على الساعة] LT',
	            nextWeek: 'dddd [على الساعة] LT',
	            lastDay: '[أمس على الساعة] LT',
	            lastWeek: 'dddd [على الساعة] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'في %s',
	            past : 'منذ %s',
	            s : 'ثوان',
	            m : 'دقيقة',
	            mm : '%d دقائق',
	            h : 'ساعة',
	            hh : '%d ساعات',
	            d : 'يوم',
	            dd : '%d أيام',
	            M : 'شهر',
	            MM : '%d أشهر',
	            y : 'سنة',
	            yy : '%d سنوات'
	        },
	        preparse: function (string) {
	            return string.replace(/[۰-۹]/g, function (match) {
	                return numberMap[match];
	            }).replace(/،/g, ',');
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            }).replace(/,/g, '،');
	        },
	        week : {
	            dow : 6, // Saturday is the first day of the week.
	            doy : 12  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// Locale: Arabic (ar)
	// Author: Abdel Said: https://github.com/abdelsaid
	// Changes in months, weekdays: Ahmed Elkhatib
	// Native plural forms: forabi https://github.com/forabi

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '١',
	        '2': '٢',
	        '3': '٣',
	        '4': '٤',
	        '5': '٥',
	        '6': '٦',
	        '7': '٧',
	        '8': '٨',
	        '9': '٩',
	        '0': '٠'
	    }, numberMap = {
	        '١': '1',
	        '٢': '2',
	        '٣': '3',
	        '٤': '4',
	        '٥': '5',
	        '٦': '6',
	        '٧': '7',
	        '٨': '8',
	        '٩': '9',
	        '٠': '0'
	    }, pluralForm = function (n) {
	        return n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5;
	    }, plurals = {
	        s : ['أقل من ثانية', 'ثانية واحدة', ['ثانيتان', 'ثانيتين'], '%d ثوان', '%d ثانية', '%d ثانية'],
	        m : ['أقل من دقيقة', 'دقيقة واحدة', ['دقيقتان', 'دقيقتين'], '%d دقائق', '%d دقيقة', '%d دقيقة'],
	        h : ['أقل من ساعة', 'ساعة واحدة', ['ساعتان', 'ساعتين'], '%d ساعات', '%d ساعة', '%d ساعة'],
	        d : ['أقل من يوم', 'يوم واحد', ['يومان', 'يومين'], '%d أيام', '%d يومًا', '%d يوم'],
	        M : ['أقل من شهر', 'شهر واحد', ['شهران', 'شهرين'], '%d أشهر', '%d شهرا', '%d شهر'],
	        y : ['أقل من عام', 'عام واحد', ['عامان', 'عامين'], '%d أعوام', '%d عامًا', '%d عام']
	    }, pluralize = function (u) {
	        return function (number, withoutSuffix, string, isFuture) {
	            var f = pluralForm(number),
	                str = plurals[u][pluralForm(number)];
	            if (f === 2) {
	                str = str[withoutSuffix ? 0 : 1];
	            }
	            return str.replace(/%d/i, number);
	        };
	    }, months = [
	        'كانون الثاني يناير',
	        'شباط فبراير',
	        'آذار مارس',
	        'نيسان أبريل',
	        'أيار مايو',
	        'حزيران يونيو',
	        'تموز يوليو',
	        'آب أغسطس',
	        'أيلول سبتمبر',
	        'تشرين الأول أكتوبر',
	        'تشرين الثاني نوفمبر',
	        'كانون الأول ديسمبر'
	    ];

	    return moment.defineLocale('ar', {
	        months : months,
	        monthsShort : months,
	        weekdays : 'الأحد_الإثنين_الثلاثاء_الأربعاء_الخميس_الجمعة_السبت'.split('_'),
	        weekdaysShort : 'أحد_إثنين_ثلاثاء_أربعاء_خميس_جمعة_سبت'.split('_'),
	        weekdaysMin : 'ح_ن_ث_ر_خ_ج_س'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 12) {
	                return 'ص';
	            } else {
	                return 'م';
	            }
	        },
	        calendar : {
	            sameDay: '[اليوم عند الساعة] LT',
	            nextDay: '[غدًا عند الساعة] LT',
	            nextWeek: 'dddd [عند الساعة] LT',
	            lastDay: '[أمس عند الساعة] LT',
	            lastWeek: 'dddd [عند الساعة] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'بعد %s',
	            past : 'منذ %s',
	            s : pluralize('s'),
	            m : pluralize('m'),
	            mm : pluralize('m'),
	            h : pluralize('h'),
	            hh : pluralize('h'),
	            d : pluralize('d'),
	            dd : pluralize('d'),
	            M : pluralize('M'),
	            MM : pluralize('M'),
	            y : pluralize('y'),
	            yy : pluralize('y')
	        },
	        preparse: function (string) {
	            return string.replace(/[۰-۹]/g, function (match) {
	                return numberMap[match];
	            }).replace(/،/g, ',');
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            }).replace(/,/g, '،');
	        },
	        week : {
	            dow : 6, // Saturday is the first day of the week.
	            doy : 12  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : azerbaijani (az)
	// author : topchiyev : https://github.com/topchiyev

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var suffixes = {
	        1: '-inci',
	        5: '-inci',
	        8: '-inci',
	        70: '-inci',
	        80: '-inci',

	        2: '-nci',
	        7: '-nci',
	        20: '-nci',
	        50: '-nci',

	        3: '-üncü',
	        4: '-üncü',
	        100: '-üncü',

	        6: '-ncı',

	        9: '-uncu',
	        10: '-uncu',
	        30: '-uncu',

	        60: '-ıncı',
	        90: '-ıncı'
	    };
	    return moment.defineLocale('az', {
	        months : 'yanvar_fevral_mart_aprel_may_iyun_iyul_avqust_sentyabr_oktyabr_noyabr_dekabr'.split('_'),
	        monthsShort : 'yan_fev_mar_apr_may_iyn_iyl_avq_sen_okt_noy_dek'.split('_'),
	        weekdays : 'Bazar_Bazar ertəsi_Çərşənbə axşamı_Çərşənbə_Cümə axşamı_Cümə_Şənbə'.split('_'),
	        weekdaysShort : 'Baz_BzE_ÇAx_Çər_CAx_Cüm_Şən'.split('_'),
	        weekdaysMin : 'Bz_BE_ÇA_Çə_CA_Cü_Şə'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[bugün saat] LT',
	            nextDay : '[sabah saat] LT',
	            nextWeek : '[gələn həftə] dddd [saat] LT',
	            lastDay : '[dünən] LT',
	            lastWeek : '[keçən həftə] dddd [saat] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s sonra',
	            past : '%s əvvəl',
	            s : 'birneçə saniyyə',
	            m : 'bir dəqiqə',
	            mm : '%d dəqiqə',
	            h : 'bir saat',
	            hh : '%d saat',
	            d : 'bir gün',
	            dd : '%d gün',
	            M : 'bir ay',
	            MM : '%d ay',
	            y : 'bir il',
	            yy : '%d il'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'gecə';
	            } else if (hour < 12) {
	                return 'səhər';
	            } else if (hour < 17) {
	                return 'gündüz';
	            } else {
	                return 'axşam';
	            }
	        },
	        ordinal : function (number) {
	            if (number === 0) {  // special case for zero
	                return number + '-ıncı';
	            }
	            var a = number % 10,
	                b = number % 100 - a,
	                c = number >= 100 ? 100 : null;

	            return number + (suffixes[a] || suffixes[b] || suffixes[c]);
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : belarusian (be)
	// author : Dmitry Demidov : https://github.com/demidov91
	// author: Praleska: http://praleska.pro/
	// Author : Menelion Elensúle : https://github.com/Oire

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function plural(word, num) {
	        var forms = word.split('_');
	        return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
	    }

	    function relativeTimeWithPlural(number, withoutSuffix, key) {
	        var format = {
	            'mm': withoutSuffix ? 'хвіліна_хвіліны_хвілін' : 'хвіліну_хвіліны_хвілін',
	            'hh': withoutSuffix ? 'гадзіна_гадзіны_гадзін' : 'гадзіну_гадзіны_гадзін',
	            'dd': 'дзень_дні_дзён',
	            'MM': 'месяц_месяцы_месяцаў',
	            'yy': 'год_гады_гадоў'
	        };
	        if (key === 'm') {
	            return withoutSuffix ? 'хвіліна' : 'хвіліну';
	        }
	        else if (key === 'h') {
	            return withoutSuffix ? 'гадзіна' : 'гадзіну';
	        }
	        else {
	            return number + ' ' + plural(format[key], +number);
	        }
	    }

	    function monthsCaseReplace(m, format) {
	        var months = {
	            'nominative': 'студзень_люты_сакавік_красавік_травень_чэрвень_ліпень_жнівень_верасень_кастрычнік_лістапад_снежань'.split('_'),
	            'accusative': 'студзеня_лютага_сакавіка_красавіка_траўня_чэрвеня_ліпеня_жніўня_верасня_кастрычніка_лістапада_снежня'.split('_')
	        },

	        nounCase = (/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/).test(format) ?
	            'accusative' :
	            'nominative';

	        return months[nounCase][m.month()];
	    }

	    function weekdaysCaseReplace(m, format) {
	        var weekdays = {
	            'nominative': 'нядзеля_панядзелак_аўторак_серада_чацвер_пятніца_субота'.split('_'),
	            'accusative': 'нядзелю_панядзелак_аўторак_сераду_чацвер_пятніцу_суботу'.split('_')
	        },

	        nounCase = (/\[ ?[Вв] ?(?:мінулую|наступную)? ?\] ?dddd/).test(format) ?
	            'accusative' :
	            'nominative';

	        return weekdays[nounCase][m.day()];
	    }

	    return moment.defineLocale('be', {
	        months : monthsCaseReplace,
	        monthsShort : 'студ_лют_сак_крас_трав_чэрв_ліп_жнів_вер_каст_ліст_снеж'.split('_'),
	        weekdays : weekdaysCaseReplace,
	        weekdaysShort : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
	        weekdaysMin : 'нд_пн_ат_ср_чц_пт_сб'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY г.',
	            LLL : 'D MMMM YYYY г., LT',
	            LLLL : 'dddd, D MMMM YYYY г., LT'
	        },
	        calendar : {
	            sameDay: '[Сёння ў] LT',
	            nextDay: '[Заўтра ў] LT',
	            lastDay: '[Учора ў] LT',
	            nextWeek: function () {
	                return '[У] dddd [ў] LT';
	            },
	            lastWeek: function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                case 5:
	                case 6:
	                    return '[У мінулую] dddd [ў] LT';
	                case 1:
	                case 2:
	                case 4:
	                    return '[У мінулы] dddd [ў] LT';
	                }
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'праз %s',
	            past : '%s таму',
	            s : 'некалькі секунд',
	            m : relativeTimeWithPlural,
	            mm : relativeTimeWithPlural,
	            h : relativeTimeWithPlural,
	            hh : relativeTimeWithPlural,
	            d : 'дзень',
	            dd : relativeTimeWithPlural,
	            M : 'месяц',
	            MM : relativeTimeWithPlural,
	            y : 'год',
	            yy : relativeTimeWithPlural
	        },


	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'ночы';
	            } else if (hour < 12) {
	                return 'раніцы';
	            } else if (hour < 17) {
	                return 'дня';
	            } else {
	                return 'вечара';
	            }
	        },

	        ordinal: function (number, period) {
	            switch (period) {
	            case 'M':
	            case 'd':
	            case 'DDD':
	            case 'w':
	            case 'W':
	                return (number % 10 === 2 || number % 10 === 3) && (number % 100 !== 12 && number % 100 !== 13) ? number + '-і' : number + '-ы';
	            case 'D':
	                return number + '-га';
	            default:
	                return number;
	            }
	        },

	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 88 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : bulgarian (bg)
	// author : Krasen Borisov : https://github.com/kraz

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('bg', {
	        months : 'януари_февруари_март_април_май_юни_юли_август_септември_октомври_ноември_декември'.split('_'),
	        monthsShort : 'янр_фев_мар_апр_май_юни_юли_авг_сеп_окт_ное_дек'.split('_'),
	        weekdays : 'неделя_понеделник_вторник_сряда_четвъртък_петък_събота'.split('_'),
	        weekdaysShort : 'нед_пон_вто_сря_чет_пет_съб'.split('_'),
	        weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'D.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Днес в] LT',
	            nextDay : '[Утре в] LT',
	            nextWeek : 'dddd [в] LT',
	            lastDay : '[Вчера в] LT',
	            lastWeek : function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                case 6:
	                    return '[В изминалата] dddd [в] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[В изминалия] dddd [в] LT';
	                }
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'след %s',
	            past : 'преди %s',
	            s : 'няколко секунди',
	            m : 'минута',
	            mm : '%d минути',
	            h : 'час',
	            hh : '%d часа',
	            d : 'ден',
	            dd : '%d дни',
	            M : 'месец',
	            MM : '%d месеца',
	            y : 'година',
	            yy : '%d години'
	        },
	        ordinal : function (number) {
	            var lastDigit = number % 10,
	                last2Digits = number % 100;
	            if (number === 0) {
	                return number + '-ев';
	            } else if (last2Digits === 0) {
	                return number + '-ен';
	            } else if (last2Digits > 10 && last2Digits < 20) {
	                return number + '-ти';
	            } else if (lastDigit === 1) {
	                return number + '-ви';
	            } else if (lastDigit === 2) {
	                return number + '-ри';
	            } else if (lastDigit === 7 || lastDigit === 8) {
	                return number + '-ми';
	            } else {
	                return number + '-ти';
	            }
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Bengali (bn)
	// author : Kaushik Gandhi : https://github.com/kaushikgandhi

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '১',
	        '2': '২',
	        '3': '৩',
	        '4': '৪',
	        '5': '৫',
	        '6': '৬',
	        '7': '৭',
	        '8': '৮',
	        '9': '৯',
	        '0': '০'
	    },
	    numberMap = {
	        '১': '1',
	        '২': '2',
	        '৩': '3',
	        '৪': '4',
	        '৫': '5',
	        '৬': '6',
	        '৭': '7',
	        '৮': '8',
	        '৯': '9',
	        '০': '0'
	    };

	    return moment.defineLocale('bn', {
	        months : 'জানুয়ারী_ফেবুয়ারী_মার্চ_এপ্রিল_মে_জুন_জুলাই_অগাস্ট_সেপ্টেম্বর_অক্টোবর_নভেম্বর_ডিসেম্বর'.split('_'),
	        monthsShort : 'জানু_ফেব_মার্চ_এপর_মে_জুন_জুল_অগ_সেপ্ট_অক্টো_নভ_ডিসেম্'.split('_'),
	        weekdays : 'রবিবার_সোমবার_মঙ্গলবার_বুধবার_বৃহস্পত্তিবার_শুক্রুবার_শনিবার'.split('_'),
	        weekdaysShort : 'রবি_সোম_মঙ্গল_বুধ_বৃহস্পত্তি_শুক্রু_শনি'.split('_'),
	        weekdaysMin : 'রব_সম_মঙ্গ_বু_ব্রিহ_শু_শনি'.split('_'),
	        longDateFormat : {
	            LT : 'A h:mm সময়',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        calendar : {
	            sameDay : '[আজ] LT',
	            nextDay : '[আগামীকাল] LT',
	            nextWeek : 'dddd, LT',
	            lastDay : '[গতকাল] LT',
	            lastWeek : '[গত] dddd, LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s পরে',
	            past : '%s আগে',
	            s : 'কএক সেকেন্ড',
	            m : 'এক মিনিট',
	            mm : '%d মিনিট',
	            h : 'এক ঘন্টা',
	            hh : '%d ঘন্টা',
	            d : 'এক দিন',
	            dd : '%d দিন',
	            M : 'এক মাস',
	            MM : '%d মাস',
	            y : 'এক বছর',
	            yy : '%d বছর'
	        },
	        preparse: function (string) {
	            return string.replace(/[১২৩৪৫৬৭৮৯০]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },
	        //Bengali is a vast language its spoken
	        //in different forms in various parts of the world.
	        //I have just generalized with most common one used
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'রাত';
	            } else if (hour < 10) {
	                return 'শকাল';
	            } else if (hour < 17) {
	                return 'দুপুর';
	            } else if (hour < 20) {
	                return 'বিকেল';
	            } else {
	                return 'রাত';
	            }
	        },
	        week : {
	            dow : 0, // Sunday is the first day of the week.
	            doy : 6  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : tibetan (bo)
	// author : Thupten N. Chakrishar : https://github.com/vajradog

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '༡',
	        '2': '༢',
	        '3': '༣',
	        '4': '༤',
	        '5': '༥',
	        '6': '༦',
	        '7': '༧',
	        '8': '༨',
	        '9': '༩',
	        '0': '༠'
	    },
	    numberMap = {
	        '༡': '1',
	        '༢': '2',
	        '༣': '3',
	        '༤': '4',
	        '༥': '5',
	        '༦': '6',
	        '༧': '7',
	        '༨': '8',
	        '༩': '9',
	        '༠': '0'
	    };

	    return moment.defineLocale('bo', {
	        months : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
	        monthsShort : 'ཟླ་བ་དང་པོ_ཟླ་བ་གཉིས་པ_ཟླ་བ་གསུམ་པ_ཟླ་བ་བཞི་པ_ཟླ་བ་ལྔ་པ_ཟླ་བ་དྲུག་པ_ཟླ་བ་བདུན་པ_ཟླ་བ་བརྒྱད་པ_ཟླ་བ་དགུ་པ_ཟླ་བ་བཅུ་པ_ཟླ་བ་བཅུ་གཅིག་པ_ཟླ་བ་བཅུ་གཉིས་པ'.split('_'),
	        weekdays : 'གཟའ་ཉི་མ་_གཟའ་ཟླ་བ་_གཟའ་མིག་དམར་_གཟའ་ལྷག་པ་_གཟའ་ཕུར་བུ_གཟའ་པ་སངས་_གཟའ་སྤེན་པ་'.split('_'),
	        weekdaysShort : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
	        weekdaysMin : 'ཉི་མ་_ཟླ་བ་_མིག་དམར་_ལྷག་པ་_ཕུར་བུ_པ་སངས་_སྤེན་པ་'.split('_'),
	        longDateFormat : {
	            LT : 'A h:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        calendar : {
	            sameDay : '[དི་རིང] LT',
	            nextDay : '[སང་ཉིན] LT',
	            nextWeek : '[བདུན་ཕྲག་རྗེས་མ], LT',
	            lastDay : '[ཁ་སང] LT',
	            lastWeek : '[བདུན་ཕྲག་མཐའ་མ] dddd, LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s ལ་',
	            past : '%s སྔན་ལ',
	            s : 'ལམ་སང',
	            m : 'སྐར་མ་གཅིག',
	            mm : '%d སྐར་མ',
	            h : 'ཆུ་ཚོད་གཅིག',
	            hh : '%d ཆུ་ཚོད',
	            d : 'ཉིན་གཅིག',
	            dd : '%d ཉིན་',
	            M : 'ཟླ་བ་གཅིག',
	            MM : '%d ཟླ་བ',
	            y : 'ལོ་གཅིག',
	            yy : '%d ལོ'
	        },
	        preparse: function (string) {
	            return string.replace(/[༡༢༣༤༥༦༧༨༩༠]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'མཚན་མོ';
	            } else if (hour < 10) {
	                return 'ཞོགས་ཀས';
	            } else if (hour < 17) {
	                return 'ཉིན་གུང';
	            } else if (hour < 20) {
	                return 'དགོང་དག';
	            } else {
	                return 'མཚན་མོ';
	            }
	        },
	        week : {
	            dow : 0, // Sunday is the first day of the week.
	            doy : 6  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : breton (br)
	// author : Jean-Baptiste Le Duigou : https://github.com/jbleduigou

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function relativeTimeWithMutation(number, withoutSuffix, key) {
	        var format = {
	            'mm': 'munutenn',
	            'MM': 'miz',
	            'dd': 'devezh'
	        };
	        return number + ' ' + mutation(format[key], number);
	    }

	    function specialMutationForYears(number) {
	        switch (lastNumber(number)) {
	        case 1:
	        case 3:
	        case 4:
	        case 5:
	        case 9:
	            return number + ' bloaz';
	        default:
	            return number + ' vloaz';
	        }
	    }

	    function lastNumber(number) {
	        if (number > 9) {
	            return lastNumber(number % 10);
	        }
	        return number;
	    }

	    function mutation(text, number) {
	        if (number === 2) {
	            return softMutation(text);
	        }
	        return text;
	    }

	    function softMutation(text) {
	        var mutationTable = {
	            'm': 'v',
	            'b': 'v',
	            'd': 'z'
	        };
	        if (mutationTable[text.charAt(0)] === undefined) {
	            return text;
	        }
	        return mutationTable[text.charAt(0)] + text.substring(1);
	    }

	    return moment.defineLocale('br', {
	        months : 'Genver_C\'hwevrer_Meurzh_Ebrel_Mae_Mezheven_Gouere_Eost_Gwengolo_Here_Du_Kerzu'.split('_'),
	        monthsShort : 'Gen_C\'hwe_Meu_Ebr_Mae_Eve_Gou_Eos_Gwe_Her_Du_Ker'.split('_'),
	        weekdays : 'Sul_Lun_Meurzh_Merc\'her_Yaou_Gwener_Sadorn'.split('_'),
	        weekdaysShort : 'Sul_Lun_Meu_Mer_Yao_Gwe_Sad'.split('_'),
	        weekdaysMin : 'Su_Lu_Me_Mer_Ya_Gw_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'h[e]mm A',
	            L : 'DD/MM/YYYY',
	            LL : 'D [a viz] MMMM YYYY',
	            LLL : 'D [a viz] MMMM YYYY LT',
	            LLLL : 'dddd, D [a viz] MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Hiziv da] LT',
	            nextDay : '[Warc\'hoazh da] LT',
	            nextWeek : 'dddd [da] LT',
	            lastDay : '[Dec\'h da] LT',
	            lastWeek : 'dddd [paset da] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'a-benn %s',
	            past : '%s \'zo',
	            s : 'un nebeud segondennoù',
	            m : 'ur vunutenn',
	            mm : relativeTimeWithMutation,
	            h : 'un eur',
	            hh : '%d eur',
	            d : 'un devezh',
	            dd : relativeTimeWithMutation,
	            M : 'ur miz',
	            MM : relativeTimeWithMutation,
	            y : 'ur bloaz',
	            yy : specialMutationForYears
	        },
	        ordinal : function (number) {
	            var output = (number === 1) ? 'añ' : 'vet';
	            return number + output;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : bosnian (bs)
	// author : Nedim Cholich : https://github.com/frontyard
	// based on (hr) translation by Bojan Marković

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function translate(number, withoutSuffix, key) {
	        var result = number + ' ';
	        switch (key) {
	        case 'm':
	            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
	        case 'mm':
	            if (number === 1) {
	                result += 'minuta';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'minute';
	            } else {
	                result += 'minuta';
	            }
	            return result;
	        case 'h':
	            return withoutSuffix ? 'jedan sat' : 'jednog sata';
	        case 'hh':
	            if (number === 1) {
	                result += 'sat';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'sata';
	            } else {
	                result += 'sati';
	            }
	            return result;
	        case 'dd':
	            if (number === 1) {
	                result += 'dan';
	            } else {
	                result += 'dana';
	            }
	            return result;
	        case 'MM':
	            if (number === 1) {
	                result += 'mjesec';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'mjeseca';
	            } else {
	                result += 'mjeseci';
	            }
	            return result;
	        case 'yy':
	            if (number === 1) {
	                result += 'godina';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'godine';
	            } else {
	                result += 'godina';
	            }
	            return result;
	        }
	    }

	    return moment.defineLocale('bs', {
	        months : 'januar_februar_mart_april_maj_juni_juli_avgust_septembar_oktobar_novembar_decembar'.split('_'),
	        monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
	        weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
	        weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
	        weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD. MM. YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd, D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay  : '[danas u] LT',
	            nextDay  : '[sutra u] LT',

	            nextWeek : function () {
	                switch (this.day()) {
	                case 0:
	                    return '[u] [nedjelju] [u] LT';
	                case 3:
	                    return '[u] [srijedu] [u] LT';
	                case 6:
	                    return '[u] [subotu] [u] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[u] dddd [u] LT';
	                }
	            },
	            lastDay  : '[jučer u] LT',
	            lastWeek : function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                    return '[prošlu] dddd [u] LT';
	                case 6:
	                    return '[prošle] [subote] [u] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[prošli] dddd [u] LT';
	                }
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'za %s',
	            past   : 'prije %s',
	            s      : 'par sekundi',
	            m      : translate,
	            mm     : translate,
	            h      : translate,
	            hh     : translate,
	            d      : 'dan',
	            dd     : translate,
	            M      : 'mjesec',
	            MM     : translate,
	            y      : 'godinu',
	            yy     : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : catalan (ca)
	// author : Juan G. Hurtado : https://github.com/juanghurtado

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('ca', {
	        months : 'gener_febrer_març_abril_maig_juny_juliol_agost_setembre_octubre_novembre_desembre'.split('_'),
	        monthsShort : 'gen._febr._mar._abr._mai._jun._jul._ag._set._oct._nov._des.'.split('_'),
	        weekdays : 'diumenge_dilluns_dimarts_dimecres_dijous_divendres_dissabte'.split('_'),
	        weekdaysShort : 'dg._dl._dt._dc._dj._dv._ds.'.split('_'),
	        weekdaysMin : 'Dg_Dl_Dt_Dc_Dj_Dv_Ds'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : function () {
	                return '[avui a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
	            },
	            nextDay : function () {
	                return '[demà a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
	            },
	            nextWeek : function () {
	                return 'dddd [a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
	            },
	            lastDay : function () {
	                return '[ahir a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
	            },
	            lastWeek : function () {
	                return '[el] dddd [passat a ' + ((this.hours() !== 1) ? 'les' : 'la') + '] LT';
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'en %s',
	            past : 'fa %s',
	            s : 'uns segons',
	            m : 'un minut',
	            mm : '%d minuts',
	            h : 'una hora',
	            hh : '%d hores',
	            d : 'un dia',
	            dd : '%d dies',
	            M : 'un mes',
	            MM : '%d mesos',
	            y : 'un any',
	            yy : '%d anys'
	        },
	        ordinal : '%dº',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 94 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : czech (cs)
	// author : petrbela : https://github.com/petrbela

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var months = 'leden_únor_březen_duben_květen_červen_červenec_srpen_září_říjen_listopad_prosinec'.split('_'),
	        monthsShort = 'led_úno_bře_dub_kvě_čvn_čvc_srp_zář_říj_lis_pro'.split('_');

	    function plural(n) {
	        return (n > 1) && (n < 5) && (~~(n / 10) !== 1);
	    }

	    function translate(number, withoutSuffix, key, isFuture) {
	        var result = number + ' ';
	        switch (key) {
	        case 's':  // a few seconds / in a few seconds / a few seconds ago
	            return (withoutSuffix || isFuture) ? 'pár sekund' : 'pár sekundami';
	        case 'm':  // a minute / in a minute / a minute ago
	            return withoutSuffix ? 'minuta' : (isFuture ? 'minutu' : 'minutou');
	        case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'minuty' : 'minut');
	            } else {
	                return result + 'minutami';
	            }
	            break;
	        case 'h':  // an hour / in an hour / an hour ago
	            return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
	        case 'hh': // 9 hours / in 9 hours / 9 hours ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'hodiny' : 'hodin');
	            } else {
	                return result + 'hodinami';
	            }
	            break;
	        case 'd':  // a day / in a day / a day ago
	            return (withoutSuffix || isFuture) ? 'den' : 'dnem';
	        case 'dd': // 9 days / in 9 days / 9 days ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'dny' : 'dní');
	            } else {
	                return result + 'dny';
	            }
	            break;
	        case 'M':  // a month / in a month / a month ago
	            return (withoutSuffix || isFuture) ? 'měsíc' : 'měsícem';
	        case 'MM': // 9 months / in 9 months / 9 months ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'měsíce' : 'měsíců');
	            } else {
	                return result + 'měsíci';
	            }
	            break;
	        case 'y':  // a year / in a year / a year ago
	            return (withoutSuffix || isFuture) ? 'rok' : 'rokem';
	        case 'yy': // 9 years / in 9 years / 9 years ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'roky' : 'let');
	            } else {
	                return result + 'lety';
	            }
	            break;
	        }
	    }

	    return moment.defineLocale('cs', {
	        months : months,
	        monthsShort : monthsShort,
	        monthsParse : (function (months, monthsShort) {
	            var i, _monthsParse = [];
	            for (i = 0; i < 12; i++) {
	                // use custom parser to solve problem with July (červenec)
	                _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
	            }
	            return _monthsParse;
	        }(months, monthsShort)),
	        weekdays : 'neděle_pondělí_úterý_středa_čtvrtek_pátek_sobota'.split('_'),
	        weekdaysShort : 'ne_po_út_st_čt_pá_so'.split('_'),
	        weekdaysMin : 'ne_po_út_st_čt_pá_so'.split('_'),
	        longDateFormat : {
	            LT: 'H:mm',
	            L : 'DD. MM. YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[dnes v] LT',
	            nextDay: '[zítra v] LT',
	            nextWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[v neděli v] LT';
	                case 1:
	                case 2:
	                    return '[v] dddd [v] LT';
	                case 3:
	                    return '[ve středu v] LT';
	                case 4:
	                    return '[ve čtvrtek v] LT';
	                case 5:
	                    return '[v pátek v] LT';
	                case 6:
	                    return '[v sobotu v] LT';
	                }
	            },
	            lastDay: '[včera v] LT',
	            lastWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[minulou neděli v] LT';
	                case 1:
	                case 2:
	                    return '[minulé] dddd [v] LT';
	                case 3:
	                    return '[minulou středu v] LT';
	                case 4:
	                case 5:
	                    return '[minulý] dddd [v] LT';
	                case 6:
	                    return '[minulou sobotu v] LT';
	                }
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'za %s',
	            past : 'před %s',
	            s : translate,
	            m : translate,
	            mm : translate,
	            h : translate,
	            hh : translate,
	            d : translate,
	            dd : translate,
	            M : translate,
	            MM : translate,
	            y : translate,
	            yy : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 95 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : chuvash (cv)
	// author : Anatoly Mironov : https://github.com/mirontoli

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('cv', {
	        months : 'кăрлач_нарăс_пуш_ака_май_çĕртме_утă_çурла_авăн_юпа_чӳк_раштав'.split('_'),
	        monthsShort : 'кăр_нар_пуш_ака_май_çĕр_утă_çур_ав_юпа_чӳк_раш'.split('_'),
	        weekdays : 'вырсарникун_тунтикун_ытларикун_юнкун_кĕçнерникун_эрнекун_шăматкун'.split('_'),
	        weekdaysShort : 'выр_тун_ытл_юн_кĕç_эрн_шăм'.split('_'),
	        weekdaysMin : 'вр_тн_ыт_юн_кç_эр_шм'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD-MM-YYYY',
	            LL : 'YYYY [çулхи] MMMM [уйăхĕн] D[-мĕшĕ]',
	            LLL : 'YYYY [çулхи] MMMM [уйăхĕн] D[-мĕшĕ], LT',
	            LLLL : 'dddd, YYYY [çулхи] MMMM [уйăхĕн] D[-мĕшĕ], LT'
	        },
	        calendar : {
	            sameDay: '[Паян] LT [сехетре]',
	            nextDay: '[Ыран] LT [сехетре]',
	            lastDay: '[Ĕнер] LT [сехетре]',
	            nextWeek: '[Çитес] dddd LT [сехетре]',
	            lastWeek: '[Иртнĕ] dddd LT [сехетре]',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : function (output) {
	                var affix = /сехет$/i.exec(output) ? 'рен' : /çул$/i.exec(output) ? 'тан' : 'ран';
	                return output + affix;
	            },
	            past : '%s каялла',
	            s : 'пĕр-ик çеккунт',
	            m : 'пĕр минут',
	            mm : '%d минут',
	            h : 'пĕр сехет',
	            hh : '%d сехет',
	            d : 'пĕр кун',
	            dd : '%d кун',
	            M : 'пĕр уйăх',
	            MM : '%d уйăх',
	            y : 'пĕр çул',
	            yy : '%d çул'
	        },
	        ordinal : '%d-мĕш',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 96 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Welsh (cy)
	// author : Robert Allen

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('cy', {
	        months: 'Ionawr_Chwefror_Mawrth_Ebrill_Mai_Mehefin_Gorffennaf_Awst_Medi_Hydref_Tachwedd_Rhagfyr'.split('_'),
	        monthsShort: 'Ion_Chwe_Maw_Ebr_Mai_Meh_Gor_Aws_Med_Hyd_Tach_Rhag'.split('_'),
	        weekdays: 'Dydd Sul_Dydd Llun_Dydd Mawrth_Dydd Mercher_Dydd Iau_Dydd Gwener_Dydd Sadwrn'.split('_'),
	        weekdaysShort: 'Sul_Llun_Maw_Mer_Iau_Gwe_Sad'.split('_'),
	        weekdaysMin: 'Su_Ll_Ma_Me_Ia_Gw_Sa'.split('_'),
	        // time formats are the same as en-gb
	        longDateFormat: {
	            LT: 'HH:mm',
	            L: 'DD/MM/YYYY',
	            LL: 'D MMMM YYYY',
	            LLL: 'D MMMM YYYY LT',
	            LLLL: 'dddd, D MMMM YYYY LT'
	        },
	        calendar: {
	            sameDay: '[Heddiw am] LT',
	            nextDay: '[Yfory am] LT',
	            nextWeek: 'dddd [am] LT',
	            lastDay: '[Ddoe am] LT',
	            lastWeek: 'dddd [diwethaf am] LT',
	            sameElse: 'L'
	        },
	        relativeTime: {
	            future: 'mewn %s',
	            past: '%s yn ôl',
	            s: 'ychydig eiliadau',
	            m: 'munud',
	            mm: '%d munud',
	            h: 'awr',
	            hh: '%d awr',
	            d: 'diwrnod',
	            dd: '%d diwrnod',
	            M: 'mis',
	            MM: '%d mis',
	            y: 'blwyddyn',
	            yy: '%d flynedd'
	        },
	        // traditional ordinal numbers above 31 are not commonly used in colloquial Welsh
	        ordinal: function (number) {
	            var b = number,
	                output = '',
	                lookup = [
	                    '', 'af', 'il', 'ydd', 'ydd', 'ed', 'ed', 'ed', 'fed', 'fed', 'fed', // 1af to 10fed
	                    'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'eg', 'fed', 'eg', 'fed' // 11eg to 20fed
	                ];

	            if (b > 20) {
	                if (b === 40 || b === 50 || b === 60 || b === 80 || b === 100) {
	                    output = 'fed'; // not 30ain, 70ain or 90ain
	                } else {
	                    output = 'ain';
	                }
	            } else if (b > 0) {
	                output = lookup[b];
	            }

	            return number + output;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 97 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : danish (da)
	// author : Ulrik Nielsen : https://github.com/mrbase

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('da', {
	        months : 'januar_februar_marts_april_maj_juni_juli_august_september_oktober_november_december'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
	        weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
	        weekdaysShort : 'søn_man_tir_ons_tor_fre_lør'.split('_'),
	        weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd [d.] D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[I dag kl.] LT',
	            nextDay : '[I morgen kl.] LT',
	            nextWeek : 'dddd [kl.] LT',
	            lastDay : '[I går kl.] LT',
	            lastWeek : '[sidste] dddd [kl] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'om %s',
	            past : '%s siden',
	            s : 'få sekunder',
	            m : 'et minut',
	            mm : '%d minutter',
	            h : 'en time',
	            hh : '%d timer',
	            d : 'en dag',
	            dd : '%d dage',
	            M : 'en måned',
	            MM : '%d måneder',
	            y : 'et år',
	            yy : '%d år'
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : austrian german (de-at)
	// author : lluchs : https://github.com/lluchs
	// author: Menelion Elensúle: https://github.com/Oire
	// author : Martin Groller : https://github.com/MadMG

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function processRelativeTime(number, withoutSuffix, key, isFuture) {
	        var format = {
	            'm': ['eine Minute', 'einer Minute'],
	            'h': ['eine Stunde', 'einer Stunde'],
	            'd': ['ein Tag', 'einem Tag'],
	            'dd': [number + ' Tage', number + ' Tagen'],
	            'M': ['ein Monat', 'einem Monat'],
	            'MM': [number + ' Monate', number + ' Monaten'],
	            'y': ['ein Jahr', 'einem Jahr'],
	            'yy': [number + ' Jahre', number + ' Jahren']
	        };
	        return withoutSuffix ? format[key][0] : format[key][1];
	    }

	    return moment.defineLocale('de-at', {
	        months : 'Jänner_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
	        monthsShort : 'Jän._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
	        weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
	        weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
	        weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
	        longDateFormat : {
	            LT: 'HH:mm [Uhr]',
	            L : 'DD.MM.YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd, D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Heute um] LT',
	            sameElse: 'L',
	            nextDay: '[Morgen um] LT',
	            nextWeek: 'dddd [um] LT',
	            lastDay: '[Gestern um] LT',
	            lastWeek: '[letzten] dddd [um] LT'
	        },
	        relativeTime : {
	            future : 'in %s',
	            past : 'vor %s',
	            s : 'ein paar Sekunden',
	            m : processRelativeTime,
	            mm : '%d Minuten',
	            h : processRelativeTime,
	            hh : '%d Stunden',
	            d : processRelativeTime,
	            dd : processRelativeTime,
	            M : processRelativeTime,
	            MM : processRelativeTime,
	            y : processRelativeTime,
	            yy : processRelativeTime
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 99 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : german (de)
	// author : lluchs : https://github.com/lluchs
	// author: Menelion Elensúle: https://github.com/Oire

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function processRelativeTime(number, withoutSuffix, key, isFuture) {
	        var format = {
	            'm': ['eine Minute', 'einer Minute'],
	            'h': ['eine Stunde', 'einer Stunde'],
	            'd': ['ein Tag', 'einem Tag'],
	            'dd': [number + ' Tage', number + ' Tagen'],
	            'M': ['ein Monat', 'einem Monat'],
	            'MM': [number + ' Monate', number + ' Monaten'],
	            'y': ['ein Jahr', 'einem Jahr'],
	            'yy': [number + ' Jahre', number + ' Jahren']
	        };
	        return withoutSuffix ? format[key][0] : format[key][1];
	    }

	    return moment.defineLocale('de', {
	        months : 'Januar_Februar_März_April_Mai_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
	        monthsShort : 'Jan._Febr._Mrz._Apr._Mai_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
	        weekdays : 'Sonntag_Montag_Dienstag_Mittwoch_Donnerstag_Freitag_Samstag'.split('_'),
	        weekdaysShort : 'So._Mo._Di._Mi._Do._Fr._Sa.'.split('_'),
	        weekdaysMin : 'So_Mo_Di_Mi_Do_Fr_Sa'.split('_'),
	        longDateFormat : {
	            LT: 'HH:mm [Uhr]',
	            L : 'DD.MM.YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd, D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Heute um] LT',
	            sameElse: 'L',
	            nextDay: '[Morgen um] LT',
	            nextWeek: 'dddd [um] LT',
	            lastDay: '[Gestern um] LT',
	            lastWeek: '[letzten] dddd [um] LT'
	        },
	        relativeTime : {
	            future : 'in %s',
	            past : 'vor %s',
	            s : 'ein paar Sekunden',
	            m : processRelativeTime,
	            mm : '%d Minuten',
	            h : processRelativeTime,
	            hh : '%d Stunden',
	            d : processRelativeTime,
	            dd : processRelativeTime,
	            M : processRelativeTime,
	            MM : processRelativeTime,
	            y : processRelativeTime,
	            yy : processRelativeTime
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : modern greek (el)
	// author : Aggelos Karalias : https://github.com/mehiel

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('el', {
	        monthsNominativeEl : 'Ιανουάριος_Φεβρουάριος_Μάρτιος_Απρίλιος_Μάιος_Ιούνιος_Ιούλιος_Αύγουστος_Σεπτέμβριος_Οκτώβριος_Νοέμβριος_Δεκέμβριος'.split('_'),
	        monthsGenitiveEl : 'Ιανουαρίου_Φεβρουαρίου_Μαρτίου_Απριλίου_Μαΐου_Ιουνίου_Ιουλίου_Αυγούστου_Σεπτεμβρίου_Οκτωβρίου_Νοεμβρίου_Δεκεμβρίου'.split('_'),
	        months : function (momentToFormat, format) {
	            if (/D/.test(format.substring(0, format.indexOf('MMMM')))) { // if there is a day number before 'MMMM'
	                return this._monthsGenitiveEl[momentToFormat.month()];
	            } else {
	                return this._monthsNominativeEl[momentToFormat.month()];
	            }
	        },
	        monthsShort : 'Ιαν_Φεβ_Μαρ_Απρ_Μαϊ_Ιουν_Ιουλ_Αυγ_Σεπ_Οκτ_Νοε_Δεκ'.split('_'),
	        weekdays : 'Κυριακή_Δευτέρα_Τρίτη_Τετάρτη_Πέμπτη_Παρασκευή_Σάββατο'.split('_'),
	        weekdaysShort : 'Κυρ_Δευ_Τρι_Τετ_Πεμ_Παρ_Σαβ'.split('_'),
	        weekdaysMin : 'Κυ_Δε_Τρ_Τε_Πε_Πα_Σα'.split('_'),
	        meridiem : function (hours, minutes, isLower) {
	            if (hours > 11) {
	                return isLower ? 'μμ' : 'ΜΜ';
	            } else {
	                return isLower ? 'πμ' : 'ΠΜ';
	            }
	        },
	        isPM : function (input) {
	            return ((input + '').toLowerCase()[0] === 'μ');
	        },
	        meridiemParse : /[ΠΜ]\.?Μ?\.?/i,
	        longDateFormat : {
	            LT : 'h:mm A',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendarEl : {
	            sameDay : '[Σήμερα {}] LT',
	            nextDay : '[Αύριο {}] LT',
	            nextWeek : 'dddd [{}] LT',
	            lastDay : '[Χθες {}] LT',
	            lastWeek : function () {
	                switch (this.day()) {
	                    case 6:
	                        return '[το προηγούμενο] dddd [{}] LT';
	                    default:
	                        return '[την προηγούμενη] dddd [{}] LT';
	                }
	            },
	            sameElse : 'L'
	        },
	        calendar : function (key, mom) {
	            var output = this._calendarEl[key],
	                hours = mom && mom.hours();

	            if (typeof output === 'function') {
	                output = output.apply(mom);
	            }

	            return output.replace('{}', (hours % 12 === 1 ? 'στη' : 'στις'));
	        },
	        relativeTime : {
	            future : 'σε %s',
	            past : '%s πριν',
	            s : 'δευτερόλεπτα',
	            m : 'ένα λεπτό',
	            mm : '%d λεπτά',
	            h : 'μία ώρα',
	            hh : '%d ώρες',
	            d : 'μία μέρα',
	            dd : '%d μέρες',
	            M : 'ένας μήνας',
	            MM : '%d μήνες',
	            y : 'ένας χρόνος',
	            yy : '%d χρόνια'
	        },
	        ordinal : function (number) {
	            return number + 'η';
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : australian english (en-au)

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('en-au', {
	        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
	        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
	        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
	        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
	        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'h:mm A',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Today at] LT',
	            nextDay : '[Tomorrow at] LT',
	            nextWeek : 'dddd [at] LT',
	            lastDay : '[Yesterday at] LT',
	            lastWeek : '[Last] dddd [at] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'in %s',
	            past : '%s ago',
	            s : 'a few seconds',
	            m : 'a minute',
	            mm : '%d minutes',
	            h : 'an hour',
	            hh : '%d hours',
	            d : 'a day',
	            dd : '%d days',
	            M : 'a month',
	            MM : '%d months',
	            y : 'a year',
	            yy : '%d years'
	        },
	        ordinal : function (number) {
	            var b = number % 10,
	                output = (~~(number % 100 / 10) === 1) ? 'th' :
	                (b === 1) ? 'st' :
	                (b === 2) ? 'nd' :
	                (b === 3) ? 'rd' : 'th';
	            return number + output;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 102 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : canadian english (en-ca)
	// author : Jonathan Abourbih : https://github.com/jonbca

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('en-ca', {
	        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
	        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
	        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
	        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
	        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'h:mm A',
	            L : 'YYYY-MM-DD',
	            LL : 'D MMMM, YYYY',
	            LLL : 'D MMMM, YYYY LT',
	            LLLL : 'dddd, D MMMM, YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Today at] LT',
	            nextDay : '[Tomorrow at] LT',
	            nextWeek : 'dddd [at] LT',
	            lastDay : '[Yesterday at] LT',
	            lastWeek : '[Last] dddd [at] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'in %s',
	            past : '%s ago',
	            s : 'a few seconds',
	            m : 'a minute',
	            mm : '%d minutes',
	            h : 'an hour',
	            hh : '%d hours',
	            d : 'a day',
	            dd : '%d days',
	            M : 'a month',
	            MM : '%d months',
	            y : 'a year',
	            yy : '%d years'
	        },
	        ordinal : function (number) {
	            var b = number % 10,
	                output = (~~(number % 100 / 10) === 1) ? 'th' :
	                (b === 1) ? 'st' :
	                (b === 2) ? 'nd' :
	                (b === 3) ? 'rd' : 'th';
	            return number + output;
	        }
	    });
	}));


/***/ },
/* 103 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : great britain english (en-gb)
	// author : Chris Gedrim : https://github.com/chrisgedrim

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('en-gb', {
	        months : 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
	        monthsShort : 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_'),
	        weekdays : 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
	        weekdaysShort : 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_'),
	        weekdaysMin : 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Today at] LT',
	            nextDay : '[Tomorrow at] LT',
	            nextWeek : 'dddd [at] LT',
	            lastDay : '[Yesterday at] LT',
	            lastWeek : '[Last] dddd [at] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'in %s',
	            past : '%s ago',
	            s : 'a few seconds',
	            m : 'a minute',
	            mm : '%d minutes',
	            h : 'an hour',
	            hh : '%d hours',
	            d : 'a day',
	            dd : '%d days',
	            M : 'a month',
	            MM : '%d months',
	            y : 'a year',
	            yy : '%d years'
	        },
	        ordinal : function (number) {
	            var b = number % 10,
	                output = (~~(number % 100 / 10) === 1) ? 'th' :
	                (b === 1) ? 'st' :
	                (b === 2) ? 'nd' :
	                (b === 3) ? 'rd' : 'th';
	            return number + output;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 104 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : esperanto (eo)
	// author : Colin Dean : https://github.com/colindean
	// komento: Mi estas malcerta se mi korekte traktis akuzativojn en tiu traduko.
	//          Se ne, bonvolu korekti kaj avizi min por ke mi povas lerni!

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('eo', {
	        months : 'januaro_februaro_marto_aprilo_majo_junio_julio_aŭgusto_septembro_oktobro_novembro_decembro'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aŭg_sep_okt_nov_dec'.split('_'),
	        weekdays : 'Dimanĉo_Lundo_Mardo_Merkredo_Ĵaŭdo_Vendredo_Sabato'.split('_'),
	        weekdaysShort : 'Dim_Lun_Mard_Merk_Ĵaŭ_Ven_Sab'.split('_'),
	        weekdaysMin : 'Di_Lu_Ma_Me_Ĵa_Ve_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'YYYY-MM-DD',
	            LL : 'D[-an de] MMMM, YYYY',
	            LLL : 'D[-an de] MMMM, YYYY LT',
	            LLLL : 'dddd, [la] D[-an de] MMMM, YYYY LT'
	        },
	        meridiem : function (hours, minutes, isLower) {
	            if (hours > 11) {
	                return isLower ? 'p.t.m.' : 'P.T.M.';
	            } else {
	                return isLower ? 'a.t.m.' : 'A.T.M.';
	            }
	        },
	        calendar : {
	            sameDay : '[Hodiaŭ je] LT',
	            nextDay : '[Morgaŭ je] LT',
	            nextWeek : 'dddd [je] LT',
	            lastDay : '[Hieraŭ je] LT',
	            lastWeek : '[pasinta] dddd [je] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'je %s',
	            past : 'antaŭ %s',
	            s : 'sekundoj',
	            m : 'minuto',
	            mm : '%d minutoj',
	            h : 'horo',
	            hh : '%d horoj',
	            d : 'tago',//ne 'diurno', ĉar estas uzita por proksimumo
	            dd : '%d tagoj',
	            M : 'monato',
	            MM : '%d monatoj',
	            y : 'jaro',
	            yy : '%d jaroj'
	        },
	        ordinal : '%da',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 105 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : spanish (es)
	// author : Julio Napurí : https://github.com/julionc

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var monthsShortDot = 'ene._feb._mar._abr._may._jun._jul._ago._sep._oct._nov._dic.'.split('_'),
	        monthsShort = 'ene_feb_mar_abr_may_jun_jul_ago_sep_oct_nov_dic'.split('_');

	    return moment.defineLocale('es', {
	        months : 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split('_'),
	        monthsShort : function (m, format) {
	            if (/-MMM-/.test(format)) {
	                return monthsShort[m.month()];
	            } else {
	                return monthsShortDot[m.month()];
	            }
	        },
	        weekdays : 'domingo_lunes_martes_miércoles_jueves_viernes_sábado'.split('_'),
	        weekdaysShort : 'dom._lun._mar._mié._jue._vie._sáb.'.split('_'),
	        weekdaysMin : 'Do_Lu_Ma_Mi_Ju_Vi_Sá'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D [de] MMMM [de] YYYY',
	            LLL : 'D [de] MMMM [de] YYYY LT',
	            LLLL : 'dddd, D [de] MMMM [de] YYYY LT'
	        },
	        calendar : {
	            sameDay : function () {
	                return '[hoy a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
	            },
	            nextDay : function () {
	                return '[mañana a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
	            },
	            nextWeek : function () {
	                return 'dddd [a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
	            },
	            lastDay : function () {
	                return '[ayer a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
	            },
	            lastWeek : function () {
	                return '[el] dddd [pasado a la' + ((this.hours() !== 1) ? 's' : '') + '] LT';
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'en %s',
	            past : 'hace %s',
	            s : 'unos segundos',
	            m : 'un minuto',
	            mm : '%d minutos',
	            h : 'una hora',
	            hh : '%d horas',
	            d : 'un día',
	            dd : '%d días',
	            M : 'un mes',
	            MM : '%d meses',
	            y : 'un año',
	            yy : '%d años'
	        },
	        ordinal : '%dº',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 106 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : estonian (et)
	// author : Henry Kehlmann : https://github.com/madhenry
	// improvements : Illimar Tambek : https://github.com/ragulka

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function processRelativeTime(number, withoutSuffix, key, isFuture) {
	        var format = {
	            's' : ['mõne sekundi', 'mõni sekund', 'paar sekundit'],
	            'm' : ['ühe minuti', 'üks minut'],
	            'mm': [number + ' minuti', number + ' minutit'],
	            'h' : ['ühe tunni', 'tund aega', 'üks tund'],
	            'hh': [number + ' tunni', number + ' tundi'],
	            'd' : ['ühe päeva', 'üks päev'],
	            'M' : ['kuu aja', 'kuu aega', 'üks kuu'],
	            'MM': [number + ' kuu', number + ' kuud'],
	            'y' : ['ühe aasta', 'aasta', 'üks aasta'],
	            'yy': [number + ' aasta', number + ' aastat']
	        };
	        if (withoutSuffix) {
	            return format[key][2] ? format[key][2] : format[key][1];
	        }
	        return isFuture ? format[key][0] : format[key][1];
	    }

	    return moment.defineLocale('et', {
	        months        : 'jaanuar_veebruar_märts_aprill_mai_juuni_juuli_august_september_oktoober_november_detsember'.split('_'),
	        monthsShort   : 'jaan_veebr_märts_apr_mai_juuni_juuli_aug_sept_okt_nov_dets'.split('_'),
	        weekdays      : 'pühapäev_esmaspäev_teisipäev_kolmapäev_neljapäev_reede_laupäev'.split('_'),
	        weekdaysShort : 'P_E_T_K_N_R_L'.split('_'),
	        weekdaysMin   : 'P_E_T_K_N_R_L'.split('_'),
	        longDateFormat : {
	            LT   : 'H:mm',
	            L    : 'DD.MM.YYYY',
	            LL   : 'D. MMMM YYYY',
	            LLL  : 'D. MMMM YYYY LT',
	            LLLL : 'dddd, D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay  : '[Täna,] LT',
	            nextDay  : '[Homme,] LT',
	            nextWeek : '[Järgmine] dddd LT',
	            lastDay  : '[Eile,] LT',
	            lastWeek : '[Eelmine] dddd LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s pärast',
	            past   : '%s tagasi',
	            s      : processRelativeTime,
	            m      : processRelativeTime,
	            mm     : processRelativeTime,
	            h      : processRelativeTime,
	            hh     : processRelativeTime,
	            d      : processRelativeTime,
	            dd     : '%d päeva',
	            M      : processRelativeTime,
	            MM     : processRelativeTime,
	            y      : processRelativeTime,
	            yy     : processRelativeTime
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 107 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : euskara (eu)
	// author : Eneko Illarramendi : https://github.com/eillarra

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('eu', {
	        months : 'urtarrila_otsaila_martxoa_apirila_maiatza_ekaina_uztaila_abuztua_iraila_urria_azaroa_abendua'.split('_'),
	        monthsShort : 'urt._ots._mar._api._mai._eka._uzt._abu._ira._urr._aza._abe.'.split('_'),
	        weekdays : 'igandea_astelehena_asteartea_asteazkena_osteguna_ostirala_larunbata'.split('_'),
	        weekdaysShort : 'ig._al._ar._az._og._ol._lr.'.split('_'),
	        weekdaysMin : 'ig_al_ar_az_og_ol_lr'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'YYYY-MM-DD',
	            LL : 'YYYY[ko] MMMM[ren] D[a]',
	            LLL : 'YYYY[ko] MMMM[ren] D[a] LT',
	            LLLL : 'dddd, YYYY[ko] MMMM[ren] D[a] LT',
	            l : 'YYYY-M-D',
	            ll : 'YYYY[ko] MMM D[a]',
	            lll : 'YYYY[ko] MMM D[a] LT',
	            llll : 'ddd, YYYY[ko] MMM D[a] LT'
	        },
	        calendar : {
	            sameDay : '[gaur] LT[etan]',
	            nextDay : '[bihar] LT[etan]',
	            nextWeek : 'dddd LT[etan]',
	            lastDay : '[atzo] LT[etan]',
	            lastWeek : '[aurreko] dddd LT[etan]',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s barru',
	            past : 'duela %s',
	            s : 'segundo batzuk',
	            m : 'minutu bat',
	            mm : '%d minutu',
	            h : 'ordu bat',
	            hh : '%d ordu',
	            d : 'egun bat',
	            dd : '%d egun',
	            M : 'hilabete bat',
	            MM : '%d hilabete',
	            y : 'urte bat',
	            yy : '%d urte'
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 108 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Persian (fa)
	// author : Ebrahim Byagowi : https://github.com/ebraminio

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '۱',
	        '2': '۲',
	        '3': '۳',
	        '4': '۴',
	        '5': '۵',
	        '6': '۶',
	        '7': '۷',
	        '8': '۸',
	        '9': '۹',
	        '0': '۰'
	    }, numberMap = {
	        '۱': '1',
	        '۲': '2',
	        '۳': '3',
	        '۴': '4',
	        '۵': '5',
	        '۶': '6',
	        '۷': '7',
	        '۸': '8',
	        '۹': '9',
	        '۰': '0'
	    };

	    return moment.defineLocale('fa', {
	        months : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
	        monthsShort : 'ژانویه_فوریه_مارس_آوریل_مه_ژوئن_ژوئیه_اوت_سپتامبر_اکتبر_نوامبر_دسامبر'.split('_'),
	        weekdays : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
	        weekdaysShort : 'یک\u200cشنبه_دوشنبه_سه\u200cشنبه_چهارشنبه_پنج\u200cشنبه_جمعه_شنبه'.split('_'),
	        weekdaysMin : 'ی_د_س_چ_پ_ج_ش'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 12) {
	                return 'قبل از ظهر';
	            } else {
	                return 'بعد از ظهر';
	            }
	        },
	        calendar : {
	            sameDay : '[امروز ساعت] LT',
	            nextDay : '[فردا ساعت] LT',
	            nextWeek : 'dddd [ساعت] LT',
	            lastDay : '[دیروز ساعت] LT',
	            lastWeek : 'dddd [پیش] [ساعت] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'در %s',
	            past : '%s پیش',
	            s : 'چندین ثانیه',
	            m : 'یک دقیقه',
	            mm : '%d دقیقه',
	            h : 'یک ساعت',
	            hh : '%d ساعت',
	            d : 'یک روز',
	            dd : '%d روز',
	            M : 'یک ماه',
	            MM : '%d ماه',
	            y : 'یک سال',
	            yy : '%d سال'
	        },
	        preparse: function (string) {
	            return string.replace(/[۰-۹]/g, function (match) {
	                return numberMap[match];
	            }).replace(/،/g, ',');
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            }).replace(/,/g, '،');
	        },
	        ordinal : '%dم',
	        week : {
	            dow : 6, // Saturday is the first day of the week.
	            doy : 12 // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 109 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : finnish (fi)
	// author : Tarmo Aidantausta : https://github.com/bleadof

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var numbersPast = 'nolla yksi kaksi kolme neljä viisi kuusi seitsemän kahdeksan yhdeksän'.split(' '),
	        numbersFuture = [
	            'nolla', 'yhden', 'kahden', 'kolmen', 'neljän', 'viiden', 'kuuden',
	            numbersPast[7], numbersPast[8], numbersPast[9]
	        ];

	    function translate(number, withoutSuffix, key, isFuture) {
	        var result = '';
	        switch (key) {
	        case 's':
	            return isFuture ? 'muutaman sekunnin' : 'muutama sekunti';
	        case 'm':
	            return isFuture ? 'minuutin' : 'minuutti';
	        case 'mm':
	            result = isFuture ? 'minuutin' : 'minuuttia';
	            break;
	        case 'h':
	            return isFuture ? 'tunnin' : 'tunti';
	        case 'hh':
	            result = isFuture ? 'tunnin' : 'tuntia';
	            break;
	        case 'd':
	            return isFuture ? 'päivän' : 'päivä';
	        case 'dd':
	            result = isFuture ? 'päivän' : 'päivää';
	            break;
	        case 'M':
	            return isFuture ? 'kuukauden' : 'kuukausi';
	        case 'MM':
	            result = isFuture ? 'kuukauden' : 'kuukautta';
	            break;
	        case 'y':
	            return isFuture ? 'vuoden' : 'vuosi';
	        case 'yy':
	            result = isFuture ? 'vuoden' : 'vuotta';
	            break;
	        }
	        result = verbalNumber(number, isFuture) + ' ' + result;
	        return result;
	    }

	    function verbalNumber(number, isFuture) {
	        return number < 10 ? (isFuture ? numbersFuture[number] : numbersPast[number]) : number;
	    }

	    return moment.defineLocale('fi', {
	        months : 'tammikuu_helmikuu_maaliskuu_huhtikuu_toukokuu_kesäkuu_heinäkuu_elokuu_syyskuu_lokakuu_marraskuu_joulukuu'.split('_'),
	        monthsShort : 'tammi_helmi_maalis_huhti_touko_kesä_heinä_elo_syys_loka_marras_joulu'.split('_'),
	        weekdays : 'sunnuntai_maanantai_tiistai_keskiviikko_torstai_perjantai_lauantai'.split('_'),
	        weekdaysShort : 'su_ma_ti_ke_to_pe_la'.split('_'),
	        weekdaysMin : 'su_ma_ti_ke_to_pe_la'.split('_'),
	        longDateFormat : {
	            LT : 'HH.mm',
	            L : 'DD.MM.YYYY',
	            LL : 'Do MMMM[ta] YYYY',
	            LLL : 'Do MMMM[ta] YYYY, [klo] LT',
	            LLLL : 'dddd, Do MMMM[ta] YYYY, [klo] LT',
	            l : 'D.M.YYYY',
	            ll : 'Do MMM YYYY',
	            lll : 'Do MMM YYYY, [klo] LT',
	            llll : 'ddd, Do MMM YYYY, [klo] LT'
	        },
	        calendar : {
	            sameDay : '[tänään] [klo] LT',
	            nextDay : '[huomenna] [klo] LT',
	            nextWeek : 'dddd [klo] LT',
	            lastDay : '[eilen] [klo] LT',
	            lastWeek : '[viime] dddd[na] [klo] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s päästä',
	            past : '%s sitten',
	            s : translate,
	            m : translate,
	            mm : translate,
	            h : translate,
	            hh : translate,
	            d : translate,
	            dd : translate,
	            M : translate,
	            MM : translate,
	            y : translate,
	            yy : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 110 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : faroese (fo)
	// author : Ragnar Johannesen : https://github.com/ragnar123

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('fo', {
	        months : 'januar_februar_mars_apríl_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
	        weekdays : 'sunnudagur_mánadagur_týsdagur_mikudagur_hósdagur_fríggjadagur_leygardagur'.split('_'),
	        weekdaysShort : 'sun_mán_týs_mik_hós_frí_ley'.split('_'),
	        weekdaysMin : 'su_má_tý_mi_hó_fr_le'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D. MMMM, YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Í dag kl.] LT',
	            nextDay : '[Í morgin kl.] LT',
	            nextWeek : 'dddd [kl.] LT',
	            lastDay : '[Í gjár kl.] LT',
	            lastWeek : '[síðstu] dddd [kl] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'um %s',
	            past : '%s síðani',
	            s : 'fá sekund',
	            m : 'ein minutt',
	            mm : '%d minuttir',
	            h : 'ein tími',
	            hh : '%d tímar',
	            d : 'ein dagur',
	            dd : '%d dagar',
	            M : 'ein mánaði',
	            MM : '%d mánaðir',
	            y : 'eitt ár',
	            yy : '%d ár'
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 111 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : canadian french (fr-ca)
	// author : Jonathan Abourbih : https://github.com/jonbca

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('fr-ca', {
	        months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
	        monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
	        weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
	        weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
	        weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'YYYY-MM-DD',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Aujourd\'hui à] LT',
	            nextDay: '[Demain à] LT',
	            nextWeek: 'dddd [à] LT',
	            lastDay: '[Hier à] LT',
	            lastWeek: 'dddd [dernier à] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'dans %s',
	            past : 'il y a %s',
	            s : 'quelques secondes',
	            m : 'une minute',
	            mm : '%d minutes',
	            h : 'une heure',
	            hh : '%d heures',
	            d : 'un jour',
	            dd : '%d jours',
	            M : 'un mois',
	            MM : '%d mois',
	            y : 'un an',
	            yy : '%d ans'
	        },
	        ordinal : function (number) {
	            return number + (number === 1 ? 'er' : '');
	        }
	    });
	}));


/***/ },
/* 112 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : french (fr)
	// author : John Fischer : https://github.com/jfroffice

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('fr', {
	        months : 'janvier_février_mars_avril_mai_juin_juillet_août_septembre_octobre_novembre_décembre'.split('_'),
	        monthsShort : 'janv._févr._mars_avr._mai_juin_juil._août_sept._oct._nov._déc.'.split('_'),
	        weekdays : 'dimanche_lundi_mardi_mercredi_jeudi_vendredi_samedi'.split('_'),
	        weekdaysShort : 'dim._lun._mar._mer._jeu._ven._sam.'.split('_'),
	        weekdaysMin : 'Di_Lu_Ma_Me_Je_Ve_Sa'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Aujourd\'hui à] LT',
	            nextDay: '[Demain à] LT',
	            nextWeek: 'dddd [à] LT',
	            lastDay: '[Hier à] LT',
	            lastWeek: 'dddd [dernier à] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'dans %s',
	            past : 'il y a %s',
	            s : 'quelques secondes',
	            m : 'une minute',
	            mm : '%d minutes',
	            h : 'une heure',
	            hh : '%d heures',
	            d : 'un jour',
	            dd : '%d jours',
	            M : 'un mois',
	            MM : '%d mois',
	            y : 'un an',
	            yy : '%d ans'
	        },
	        ordinal : function (number) {
	            return number + (number === 1 ? 'er' : '');
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 113 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : galician (gl)
	// author : Juan G. Hurtado : https://github.com/juanghurtado

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('gl', {
	        months : 'Xaneiro_Febreiro_Marzo_Abril_Maio_Xuño_Xullo_Agosto_Setembro_Outubro_Novembro_Decembro'.split('_'),
	        monthsShort : 'Xan._Feb._Mar._Abr._Mai._Xuñ._Xul._Ago._Set._Out._Nov._Dec.'.split('_'),
	        weekdays : 'Domingo_Luns_Martes_Mércores_Xoves_Venres_Sábado'.split('_'),
	        weekdaysShort : 'Dom._Lun._Mar._Mér._Xov._Ven._Sáb.'.split('_'),
	        weekdaysMin : 'Do_Lu_Ma_Mé_Xo_Ve_Sá'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : function () {
	                return '[hoxe ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
	            },
	            nextDay : function () {
	                return '[mañá ' + ((this.hours() !== 1) ? 'ás' : 'á') + '] LT';
	            },
	            nextWeek : function () {
	                return 'dddd [' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
	            },
	            lastDay : function () {
	                return '[onte ' + ((this.hours() !== 1) ? 'á' : 'a') + '] LT';
	            },
	            lastWeek : function () {
	                return '[o] dddd [pasado ' + ((this.hours() !== 1) ? 'ás' : 'a') + '] LT';
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : function (str) {
	                if (str === 'uns segundos') {
	                    return 'nuns segundos';
	                }
	                return 'en ' + str;
	            },
	            past : 'hai %s',
	            s : 'uns segundos',
	            m : 'un minuto',
	            mm : '%d minutos',
	            h : 'unha hora',
	            hh : '%d horas',
	            d : 'un día',
	            dd : '%d días',
	            M : 'un mes',
	            MM : '%d meses',
	            y : 'un ano',
	            yy : '%d anos'
	        },
	        ordinal : '%dº',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 114 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Hebrew (he)
	// author : Tomer Cohen : https://github.com/tomer
	// author : Moshe Simantov : https://github.com/DevelopmentIL
	// author : Tal Ater : https://github.com/TalAter

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('he', {
	        months : 'ינואר_פברואר_מרץ_אפריל_מאי_יוני_יולי_אוגוסט_ספטמבר_אוקטובר_נובמבר_דצמבר'.split('_'),
	        monthsShort : 'ינו׳_פבר׳_מרץ_אפר׳_מאי_יוני_יולי_אוג׳_ספט׳_אוק׳_נוב׳_דצמ׳'.split('_'),
	        weekdays : 'ראשון_שני_שלישי_רביעי_חמישי_שישי_שבת'.split('_'),
	        weekdaysShort : 'א׳_ב׳_ג׳_ד׳_ה׳_ו׳_ש׳'.split('_'),
	        weekdaysMin : 'א_ב_ג_ד_ה_ו_ש'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D [ב]MMMM YYYY',
	            LLL : 'D [ב]MMMM YYYY LT',
	            LLLL : 'dddd, D [ב]MMMM YYYY LT',
	            l : 'D/M/YYYY',
	            ll : 'D MMM YYYY',
	            lll : 'D MMM YYYY LT',
	            llll : 'ddd, D MMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[היום ב־]LT',
	            nextDay : '[מחר ב־]LT',
	            nextWeek : 'dddd [בשעה] LT',
	            lastDay : '[אתמול ב־]LT',
	            lastWeek : '[ביום] dddd [האחרון בשעה] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'בעוד %s',
	            past : 'לפני %s',
	            s : 'מספר שניות',
	            m : 'דקה',
	            mm : '%d דקות',
	            h : 'שעה',
	            hh : function (number) {
	                if (number === 2) {
	                    return 'שעתיים';
	                }
	                return number + ' שעות';
	            },
	            d : 'יום',
	            dd : function (number) {
	                if (number === 2) {
	                    return 'יומיים';
	                }
	                return number + ' ימים';
	            },
	            M : 'חודש',
	            MM : function (number) {
	                if (number === 2) {
	                    return 'חודשיים';
	                }
	                return number + ' חודשים';
	            },
	            y : 'שנה',
	            yy : function (number) {
	                if (number === 2) {
	                    return 'שנתיים';
	                }
	                return number + ' שנים';
	            }
	        }
	    });
	}));


/***/ },
/* 115 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : hindi (hi)
	// author : Mayank Singhal : https://github.com/mayanksinghal

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '१',
	        '2': '२',
	        '3': '३',
	        '4': '४',
	        '5': '५',
	        '6': '६',
	        '7': '७',
	        '8': '८',
	        '9': '९',
	        '0': '०'
	    },
	    numberMap = {
	        '१': '1',
	        '२': '2',
	        '३': '3',
	        '४': '4',
	        '५': '5',
	        '६': '6',
	        '७': '7',
	        '८': '8',
	        '९': '9',
	        '०': '0'
	    };

	    return moment.defineLocale('hi', {
	        months : 'जनवरी_फ़रवरी_मार्च_अप्रैल_मई_जून_जुलाई_अगस्त_सितम्बर_अक्टूबर_नवम्बर_दिसम्बर'.split('_'),
	        monthsShort : 'जन._फ़र._मार्च_अप्रै._मई_जून_जुल._अग._सित._अक्टू._नव._दिस.'.split('_'),
	        weekdays : 'रविवार_सोमवार_मंगलवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
	        weekdaysShort : 'रवि_सोम_मंगल_बुध_गुरू_शुक्र_शनि'.split('_'),
	        weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
	        longDateFormat : {
	            LT : 'A h:mm बजे',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        calendar : {
	            sameDay : '[आज] LT',
	            nextDay : '[कल] LT',
	            nextWeek : 'dddd, LT',
	            lastDay : '[कल] LT',
	            lastWeek : '[पिछले] dddd, LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s में',
	            past : '%s पहले',
	            s : 'कुछ ही क्षण',
	            m : 'एक मिनट',
	            mm : '%d मिनट',
	            h : 'एक घंटा',
	            hh : '%d घंटे',
	            d : 'एक दिन',
	            dd : '%d दिन',
	            M : 'एक महीने',
	            MM : '%d महीने',
	            y : 'एक वर्ष',
	            yy : '%d वर्ष'
	        },
	        preparse: function (string) {
	            return string.replace(/[१२३४५६७८९०]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },
	        // Hindi notation for meridiems are quite fuzzy in practice. While there exists
	        // a rigid notion of a 'Pahar' it is not used as rigidly in modern Hindi.
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'रात';
	            } else if (hour < 10) {
	                return 'सुबह';
	            } else if (hour < 17) {
	                return 'दोपहर';
	            } else if (hour < 20) {
	                return 'शाम';
	            } else {
	                return 'रात';
	            }
	        },
	        week : {
	            dow : 0, // Sunday is the first day of the week.
	            doy : 6  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 116 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : hrvatski (hr)
	// author : Bojan Marković : https://github.com/bmarkovic

	// based on (sl) translation by Robert Sedovšek

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function translate(number, withoutSuffix, key) {
	        var result = number + ' ';
	        switch (key) {
	        case 'm':
	            return withoutSuffix ? 'jedna minuta' : 'jedne minute';
	        case 'mm':
	            if (number === 1) {
	                result += 'minuta';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'minute';
	            } else {
	                result += 'minuta';
	            }
	            return result;
	        case 'h':
	            return withoutSuffix ? 'jedan sat' : 'jednog sata';
	        case 'hh':
	            if (number === 1) {
	                result += 'sat';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'sata';
	            } else {
	                result += 'sati';
	            }
	            return result;
	        case 'dd':
	            if (number === 1) {
	                result += 'dan';
	            } else {
	                result += 'dana';
	            }
	            return result;
	        case 'MM':
	            if (number === 1) {
	                result += 'mjesec';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'mjeseca';
	            } else {
	                result += 'mjeseci';
	            }
	            return result;
	        case 'yy':
	            if (number === 1) {
	                result += 'godina';
	            } else if (number === 2 || number === 3 || number === 4) {
	                result += 'godine';
	            } else {
	                result += 'godina';
	            }
	            return result;
	        }
	    }

	    return moment.defineLocale('hr', {
	        months : 'sječanj_veljača_ožujak_travanj_svibanj_lipanj_srpanj_kolovoz_rujan_listopad_studeni_prosinac'.split('_'),
	        monthsShort : 'sje._vel._ožu._tra._svi._lip._srp._kol._ruj._lis._stu._pro.'.split('_'),
	        weekdays : 'nedjelja_ponedjeljak_utorak_srijeda_četvrtak_petak_subota'.split('_'),
	        weekdaysShort : 'ned._pon._uto._sri._čet._pet._sub.'.split('_'),
	        weekdaysMin : 'ne_po_ut_sr_če_pe_su'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD. MM. YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd, D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay  : '[danas u] LT',
	            nextDay  : '[sutra u] LT',

	            nextWeek : function () {
	                switch (this.day()) {
	                case 0:
	                    return '[u] [nedjelju] [u] LT';
	                case 3:
	                    return '[u] [srijedu] [u] LT';
	                case 6:
	                    return '[u] [subotu] [u] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[u] dddd [u] LT';
	                }
	            },
	            lastDay  : '[jučer u] LT',
	            lastWeek : function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                    return '[prošlu] dddd [u] LT';
	                case 6:
	                    return '[prošle] [subote] [u] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[prošli] dddd [u] LT';
	                }
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'za %s',
	            past   : 'prije %s',
	            s      : 'par sekundi',
	            m      : translate,
	            mm     : translate,
	            h      : translate,
	            hh     : translate,
	            d      : 'dan',
	            dd     : translate,
	            M      : 'mjesec',
	            MM     : translate,
	            y      : 'godinu',
	            yy     : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 117 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : hungarian (hu)
	// author : Adam Brunner : https://github.com/adambrunner

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var weekEndings = 'vasárnap hétfőn kedden szerdán csütörtökön pénteken szombaton'.split(' ');

	    function translate(number, withoutSuffix, key, isFuture) {
	        var num = number,
	            suffix;

	        switch (key) {
	        case 's':
	            return (isFuture || withoutSuffix) ? 'néhány másodperc' : 'néhány másodperce';
	        case 'm':
	            return 'egy' + (isFuture || withoutSuffix ? ' perc' : ' perce');
	        case 'mm':
	            return num + (isFuture || withoutSuffix ? ' perc' : ' perce');
	        case 'h':
	            return 'egy' + (isFuture || withoutSuffix ? ' óra' : ' órája');
	        case 'hh':
	            return num + (isFuture || withoutSuffix ? ' óra' : ' órája');
	        case 'd':
	            return 'egy' + (isFuture || withoutSuffix ? ' nap' : ' napja');
	        case 'dd':
	            return num + (isFuture || withoutSuffix ? ' nap' : ' napja');
	        case 'M':
	            return 'egy' + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
	        case 'MM':
	            return num + (isFuture || withoutSuffix ? ' hónap' : ' hónapja');
	        case 'y':
	            return 'egy' + (isFuture || withoutSuffix ? ' év' : ' éve');
	        case 'yy':
	            return num + (isFuture || withoutSuffix ? ' év' : ' éve');
	        }

	        return '';
	    }

	    function week(isFuture) {
	        return (isFuture ? '' : '[múlt] ') + '[' + weekEndings[this.day()] + '] LT[-kor]';
	    }

	    return moment.defineLocale('hu', {
	        months : 'január_február_március_április_május_június_július_augusztus_szeptember_október_november_december'.split('_'),
	        monthsShort : 'jan_feb_márc_ápr_máj_jún_júl_aug_szept_okt_nov_dec'.split('_'),
	        weekdays : 'vasárnap_hétfő_kedd_szerda_csütörtök_péntek_szombat'.split('_'),
	        weekdaysShort : 'vas_hét_kedd_sze_csüt_pén_szo'.split('_'),
	        weekdaysMin : 'v_h_k_sze_cs_p_szo'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'YYYY.MM.DD.',
	            LL : 'YYYY. MMMM D.',
	            LLL : 'YYYY. MMMM D., LT',
	            LLLL : 'YYYY. MMMM D., dddd LT'
	        },
	        meridiem : function (hours, minutes, isLower) {
	            if (hours < 12) {
	                return isLower === true ? 'de' : 'DE';
	            } else {
	                return isLower === true ? 'du' : 'DU';
	            }
	        },
	        calendar : {
	            sameDay : '[ma] LT[-kor]',
	            nextDay : '[holnap] LT[-kor]',
	            nextWeek : function () {
	                return week.call(this, true);
	            },
	            lastDay : '[tegnap] LT[-kor]',
	            lastWeek : function () {
	                return week.call(this, false);
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s múlva',
	            past : '%s',
	            s : translate,
	            m : translate,
	            mm : translate,
	            h : translate,
	            hh : translate,
	            d : translate,
	            dd : translate,
	            M : translate,
	            MM : translate,
	            y : translate,
	            yy : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 118 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Armenian (hy-am)
	// author : Armendarabyan : https://github.com/armendarabyan

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function monthsCaseReplace(m, format) {
	        var months = {
	            'nominative': 'հունվար_փետրվար_մարտ_ապրիլ_մայիս_հունիս_հուլիս_օգոստոս_սեպտեմբեր_հոկտեմբեր_նոյեմբեր_դեկտեմբեր'.split('_'),
	            'accusative': 'հունվարի_փետրվարի_մարտի_ապրիլի_մայիսի_հունիսի_հուլիսի_օգոստոսի_սեպտեմբերի_հոկտեմբերի_նոյեմբերի_դեկտեմբերի'.split('_')
	        },

	        nounCase = (/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/).test(format) ?
	            'accusative' :
	            'nominative';

	        return months[nounCase][m.month()];
	    }

	    function monthsShortCaseReplace(m, format) {
	        var monthsShort = 'հնվ_փտր_մրտ_ապր_մյս_հնս_հլս_օգս_սպտ_հկտ_նմբ_դկտ'.split('_');

	        return monthsShort[m.month()];
	    }

	    function weekdaysCaseReplace(m, format) {
	        var weekdays = 'կիրակի_երկուշաբթի_երեքշաբթի_չորեքշաբթի_հինգշաբթի_ուրբաթ_շաբաթ'.split('_');

	        return weekdays[m.day()];
	    }

	    return moment.defineLocale('hy-am', {
	        months : monthsCaseReplace,
	        monthsShort : monthsShortCaseReplace,
	        weekdays : weekdaysCaseReplace,
	        weekdaysShort : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
	        weekdaysMin : 'կրկ_երկ_երք_չրք_հնգ_ուրբ_շբթ'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY թ.',
	            LLL : 'D MMMM YYYY թ., LT',
	            LLLL : 'dddd, D MMMM YYYY թ., LT'
	        },
	        calendar : {
	            sameDay: '[այսօր] LT',
	            nextDay: '[վաղը] LT',
	            lastDay: '[երեկ] LT',
	            nextWeek: function () {
	                return 'dddd [օրը ժամը] LT';
	            },
	            lastWeek: function () {
	                return '[անցած] dddd [օրը ժամը] LT';
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : '%s հետո',
	            past : '%s առաջ',
	            s : 'մի քանի վայրկյան',
	            m : 'րոպե',
	            mm : '%d րոպե',
	            h : 'ժամ',
	            hh : '%d ժամ',
	            d : 'օր',
	            dd : '%d օր',
	            M : 'ամիս',
	            MM : '%d ամիս',
	            y : 'տարի',
	            yy : '%d տարի'
	        },

	        meridiem : function (hour) {
	            if (hour < 4) {
	                return 'գիշերվա';
	            } else if (hour < 12) {
	                return 'առավոտվա';
	            } else if (hour < 17) {
	                return 'ցերեկվա';
	            } else {
	                return 'երեկոյան';
	            }
	        },

	        ordinal: function (number, period) {
	            switch (period) {
	            case 'DDD':
	            case 'w':
	            case 'W':
	            case 'DDDo':
	                if (number === 1) {
	                    return number + '-ին';
	                }
	                return number + '-րդ';
	            default:
	                return number;
	            }
	        },

	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 119 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Bahasa Indonesia (id)
	// author : Mohammad Satrio Utomo : https://github.com/tyok
	// reference: http://id.wikisource.org/wiki/Pedoman_Umum_Ejaan_Bahasa_Indonesia_yang_Disempurnakan

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('id', {
	        months : 'Januari_Februari_Maret_April_Mei_Juni_Juli_Agustus_September_Oktober_November_Desember'.split('_'),
	        monthsShort : 'Jan_Feb_Mar_Apr_Mei_Jun_Jul_Ags_Sep_Okt_Nov_Des'.split('_'),
	        weekdays : 'Minggu_Senin_Selasa_Rabu_Kamis_Jumat_Sabtu'.split('_'),
	        weekdaysShort : 'Min_Sen_Sel_Rab_Kam_Jum_Sab'.split('_'),
	        weekdaysMin : 'Mg_Sn_Sl_Rb_Km_Jm_Sb'.split('_'),
	        longDateFormat : {
	            LT : 'HH.mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY [pukul] LT',
	            LLLL : 'dddd, D MMMM YYYY [pukul] LT'
	        },
	        meridiem : function (hours, minutes, isLower) {
	            if (hours < 11) {
	                return 'pagi';
	            } else if (hours < 15) {
	                return 'siang';
	            } else if (hours < 19) {
	                return 'sore';
	            } else {
	                return 'malam';
	            }
	        },
	        calendar : {
	            sameDay : '[Hari ini pukul] LT',
	            nextDay : '[Besok pukul] LT',
	            nextWeek : 'dddd [pukul] LT',
	            lastDay : '[Kemarin pukul] LT',
	            lastWeek : 'dddd [lalu pukul] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'dalam %s',
	            past : '%s yang lalu',
	            s : 'beberapa detik',
	            m : 'semenit',
	            mm : '%d menit',
	            h : 'sejam',
	            hh : '%d jam',
	            d : 'sehari',
	            dd : '%d hari',
	            M : 'sebulan',
	            MM : '%d bulan',
	            y : 'setahun',
	            yy : '%d tahun'
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 120 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : icelandic (is)
	// author : Hinrik Örn Sigurðsson : https://github.com/hinrik

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function plural(n) {
	        if (n % 100 === 11) {
	            return true;
	        } else if (n % 10 === 1) {
	            return false;
	        }
	        return true;
	    }

	    function translate(number, withoutSuffix, key, isFuture) {
	        var result = number + ' ';
	        switch (key) {
	        case 's':
	            return withoutSuffix || isFuture ? 'nokkrar sekúndur' : 'nokkrum sekúndum';
	        case 'm':
	            return withoutSuffix ? 'mínúta' : 'mínútu';
	        case 'mm':
	            if (plural(number)) {
	                return result + (withoutSuffix || isFuture ? 'mínútur' : 'mínútum');
	            } else if (withoutSuffix) {
	                return result + 'mínúta';
	            }
	            return result + 'mínútu';
	        case 'hh':
	            if (plural(number)) {
	                return result + (withoutSuffix || isFuture ? 'klukkustundir' : 'klukkustundum');
	            }
	            return result + 'klukkustund';
	        case 'd':
	            if (withoutSuffix) {
	                return 'dagur';
	            }
	            return isFuture ? 'dag' : 'degi';
	        case 'dd':
	            if (plural(number)) {
	                if (withoutSuffix) {
	                    return result + 'dagar';
	                }
	                return result + (isFuture ? 'daga' : 'dögum');
	            } else if (withoutSuffix) {
	                return result + 'dagur';
	            }
	            return result + (isFuture ? 'dag' : 'degi');
	        case 'M':
	            if (withoutSuffix) {
	                return 'mánuður';
	            }
	            return isFuture ? 'mánuð' : 'mánuði';
	        case 'MM':
	            if (plural(number)) {
	                if (withoutSuffix) {
	                    return result + 'mánuðir';
	                }
	                return result + (isFuture ? 'mánuði' : 'mánuðum');
	            } else if (withoutSuffix) {
	                return result + 'mánuður';
	            }
	            return result + (isFuture ? 'mánuð' : 'mánuði');
	        case 'y':
	            return withoutSuffix || isFuture ? 'ár' : 'ári';
	        case 'yy':
	            if (plural(number)) {
	                return result + (withoutSuffix || isFuture ? 'ár' : 'árum');
	            }
	            return result + (withoutSuffix || isFuture ? 'ár' : 'ári');
	        }
	    }

	    return moment.defineLocale('is', {
	        months : 'janúar_febrúar_mars_apríl_maí_júní_júlí_ágúst_september_október_nóvember_desember'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_maí_jún_júl_ágú_sep_okt_nóv_des'.split('_'),
	        weekdays : 'sunnudagur_mánudagur_þriðjudagur_miðvikudagur_fimmtudagur_föstudagur_laugardagur'.split('_'),
	        weekdaysShort : 'sun_mán_þri_mið_fim_fös_lau'.split('_'),
	        weekdaysMin : 'Su_Má_Þr_Mi_Fi_Fö_La'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY [kl.] LT',
	            LLLL : 'dddd, D. MMMM YYYY [kl.] LT'
	        },
	        calendar : {
	            sameDay : '[í dag kl.] LT',
	            nextDay : '[á morgun kl.] LT',
	            nextWeek : 'dddd [kl.] LT',
	            lastDay : '[í gær kl.] LT',
	            lastWeek : '[síðasta] dddd [kl.] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'eftir %s',
	            past : 'fyrir %s síðan',
	            s : translate,
	            m : translate,
	            mm : translate,
	            h : 'klukkustund',
	            hh : translate,
	            d : translate,
	            dd : translate,
	            M : translate,
	            MM : translate,
	            y : translate,
	            yy : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 121 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : italian (it)
	// author : Lorenzo : https://github.com/aliem
	// author: Mattia Larentis: https://github.com/nostalgiaz

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('it', {
	        months : 'gennaio_febbraio_marzo_aprile_maggio_giugno_luglio_agosto_settembre_ottobre_novembre_dicembre'.split('_'),
	        monthsShort : 'gen_feb_mar_apr_mag_giu_lug_ago_set_ott_nov_dic'.split('_'),
	        weekdays : 'Domenica_Lunedì_Martedì_Mercoledì_Giovedì_Venerdì_Sabato'.split('_'),
	        weekdaysShort : 'Dom_Lun_Mar_Mer_Gio_Ven_Sab'.split('_'),
	        weekdaysMin : 'D_L_Ma_Me_G_V_S'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Oggi alle] LT',
	            nextDay: '[Domani alle] LT',
	            nextWeek: 'dddd [alle] LT',
	            lastDay: '[Ieri alle] LT',
	            lastWeek: '[lo scorso] dddd [alle] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : function (s) {
	                return ((/^[0-9].+$/).test(s) ? 'tra' : 'in') + ' ' + s;
	            },
	            past : '%s fa',
	            s : 'alcuni secondi',
	            m : 'un minuto',
	            mm : '%d minuti',
	            h : 'un\'ora',
	            hh : '%d ore',
	            d : 'un giorno',
	            dd : '%d giorni',
	            M : 'un mese',
	            MM : '%d mesi',
	            y : 'un anno',
	            yy : '%d anni'
	        },
	        ordinal: '%dº',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 122 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : japanese (ja)
	// author : LI Long : https://github.com/baryon

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('ja', {
	        months : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
	        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
	        weekdays : '日曜日_月曜日_火曜日_水曜日_木曜日_金曜日_土曜日'.split('_'),
	        weekdaysShort : '日_月_火_水_木_金_土'.split('_'),
	        weekdaysMin : '日_月_火_水_木_金_土'.split('_'),
	        longDateFormat : {
	            LT : 'Ah時m分',
	            L : 'YYYY/MM/DD',
	            LL : 'YYYY年M月D日',
	            LLL : 'YYYY年M月D日LT',
	            LLLL : 'YYYY年M月D日LT dddd'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 12) {
	                return '午前';
	            } else {
	                return '午後';
	            }
	        },
	        calendar : {
	            sameDay : '[今日] LT',
	            nextDay : '[明日] LT',
	            nextWeek : '[来週]dddd LT',
	            lastDay : '[昨日] LT',
	            lastWeek : '[前週]dddd LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s後',
	            past : '%s前',
	            s : '数秒',
	            m : '1分',
	            mm : '%d分',
	            h : '1時間',
	            hh : '%d時間',
	            d : '1日',
	            dd : '%d日',
	            M : '1ヶ月',
	            MM : '%dヶ月',
	            y : '1年',
	            yy : '%d年'
	        }
	    });
	}));


/***/ },
/* 123 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Georgian (ka)
	// author : Irakli Janiashvili : https://github.com/irakli-janiashvili

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function monthsCaseReplace(m, format) {
	        var months = {
	            'nominative': 'იანვარი_თებერვალი_მარტი_აპრილი_მაისი_ივნისი_ივლისი_აგვისტო_სექტემბერი_ოქტომბერი_ნოემბერი_დეკემბერი'.split('_'),
	            'accusative': 'იანვარს_თებერვალს_მარტს_აპრილის_მაისს_ივნისს_ივლისს_აგვისტს_სექტემბერს_ოქტომბერს_ნოემბერს_დეკემბერს'.split('_')
	        },

	        nounCase = (/D[oD] *MMMM?/).test(format) ?
	            'accusative' :
	            'nominative';

	        return months[nounCase][m.month()];
	    }

	    function weekdaysCaseReplace(m, format) {
	        var weekdays = {
	            'nominative': 'კვირა_ორშაბათი_სამშაბათი_ოთხშაბათი_ხუთშაბათი_პარასკევი_შაბათი'.split('_'),
	            'accusative': 'კვირას_ორშაბათს_სამშაბათს_ოთხშაბათს_ხუთშაბათს_პარასკევს_შაბათს'.split('_')
	        },

	        nounCase = (/(წინა|შემდეგ)/).test(format) ?
	            'accusative' :
	            'nominative';

	        return weekdays[nounCase][m.day()];
	    }

	    return moment.defineLocale('ka', {
	        months : monthsCaseReplace,
	        monthsShort : 'იან_თებ_მარ_აპრ_მაი_ივნ_ივლ_აგვ_სექ_ოქტ_ნოე_დეკ'.split('_'),
	        weekdays : weekdaysCaseReplace,
	        weekdaysShort : 'კვი_ორშ_სამ_ოთხ_ხუთ_პარ_შაბ'.split('_'),
	        weekdaysMin : 'კვ_ორ_სა_ოთ_ხუ_პა_შა'.split('_'),
	        longDateFormat : {
	            LT : 'h:mm A',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[დღეს] LT[-ზე]',
	            nextDay : '[ხვალ] LT[-ზე]',
	            lastDay : '[გუშინ] LT[-ზე]',
	            nextWeek : '[შემდეგ] dddd LT[-ზე]',
	            lastWeek : '[წინა] dddd LT-ზე',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : function (s) {
	                return (/(წამი|წუთი|საათი|წელი)/).test(s) ?
	                    s.replace(/ი$/, 'ში') :
	                    s + 'ში';
	            },
	            past : function (s) {
	                if ((/(წამი|წუთი|საათი|დღე|თვე)/).test(s)) {
	                    return s.replace(/(ი|ე)$/, 'ის წინ');
	                }
	                if ((/წელი/).test(s)) {
	                    return s.replace(/წელი$/, 'წლის წინ');
	                }
	            },
	            s : 'რამდენიმე წამი',
	            m : 'წუთი',
	            mm : '%d წუთი',
	            h : 'საათი',
	            hh : '%d საათი',
	            d : 'დღე',
	            dd : '%d დღე',
	            M : 'თვე',
	            MM : '%d თვე',
	            y : 'წელი',
	            yy : '%d წელი'
	        },
	        ordinal : function (number) {
	            if (number === 0) {
	                return number;
	            }

	            if (number === 1) {
	                return number + '-ლი';
	            }

	            if ((number < 20) || (number <= 100 && (number % 20 === 0)) || (number % 100 === 0)) {
	                return 'მე-' + number;
	            }

	            return number + '-ე';
	        },
	        week : {
	            dow : 1,
	            doy : 7
	        }
	    });
	}));


/***/ },
/* 124 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : khmer (km)
	// author : Kruy Vanna : https://github.com/kruyvanna

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('km', {
	        months: 'មករា_កុម្ភៈ_មិនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
	        monthsShort: 'មករា_កុម្ភៈ_មិនា_មេសា_ឧសភា_មិថុនា_កក្កដា_សីហា_កញ្ញា_តុលា_វិច្ឆិកា_ធ្នូ'.split('_'),
	        weekdays: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
	        weekdaysShort: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
	        weekdaysMin: 'អាទិត្យ_ច័ន្ទ_អង្គារ_ពុធ_ព្រហស្បតិ៍_សុក្រ_សៅរ៍'.split('_'),
	        longDateFormat: {
	            LT: 'HH:mm',
	            L: 'DD/MM/YYYY',
	            LL: 'D MMMM YYYY',
	            LLL: 'D MMMM YYYY LT',
	            LLLL: 'dddd, D MMMM YYYY LT'
	        },
	        calendar: {
	            sameDay: '[ថ្ងៃនៈ ម៉ោង] LT',
	            nextDay: '[ស្អែក ម៉ោង] LT',
	            nextWeek: 'dddd [ម៉ោង] LT',
	            lastDay: '[ម្សិលមិញ ម៉ោង] LT',
	            lastWeek: 'dddd [សប្តាហ៍មុន] [ម៉ោង] LT',
	            sameElse: 'L'
	        },
	        relativeTime: {
	            future: '%sទៀត',
	            past: '%sមុន',
	            s: 'ប៉ុន្មានវិនាទី',
	            m: 'មួយនាទី',
	            mm: '%d នាទី',
	            h: 'មួយម៉ោង',
	            hh: '%d ម៉ោង',
	            d: 'មួយថ្ងៃ',
	            dd: '%d ថ្ងៃ',
	            M: 'មួយខែ',
	            MM: '%d ខែ',
	            y: 'មួយឆ្នាំ',
	            yy: '%d ឆ្នាំ'
	        },
	        week: {
	            dow: 1, // Monday is the first day of the week.
	            doy: 4 // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 125 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : korean (ko)
	//
	// authors
	//
	// - Kyungwook, Park : https://github.com/kyungw00k
	// - Jeeeyul Lee <jeeeyul@gmail.com>
	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('ko', {
	        months : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
	        monthsShort : '1월_2월_3월_4월_5월_6월_7월_8월_9월_10월_11월_12월'.split('_'),
	        weekdays : '일요일_월요일_화요일_수요일_목요일_금요일_토요일'.split('_'),
	        weekdaysShort : '일_월_화_수_목_금_토'.split('_'),
	        weekdaysMin : '일_월_화_수_목_금_토'.split('_'),
	        longDateFormat : {
	            LT : 'A h시 m분',
	            L : 'YYYY.MM.DD',
	            LL : 'YYYY년 MMMM D일',
	            LLL : 'YYYY년 MMMM D일 LT',
	            LLLL : 'YYYY년 MMMM D일 dddd LT'
	        },
	        meridiem : function (hour, minute, isUpper) {
	            return hour < 12 ? '오전' : '오후';
	        },
	        calendar : {
	            sameDay : '오늘 LT',
	            nextDay : '내일 LT',
	            nextWeek : 'dddd LT',
	            lastDay : '어제 LT',
	            lastWeek : '지난주 dddd LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s 후',
	            past : '%s 전',
	            s : '몇초',
	            ss : '%d초',
	            m : '일분',
	            mm : '%d분',
	            h : '한시간',
	            hh : '%d시간',
	            d : '하루',
	            dd : '%d일',
	            M : '한달',
	            MM : '%d달',
	            y : '일년',
	            yy : '%d년'
	        },
	        ordinal : '%d일',
	        meridiemParse : /(오전|오후)/,
	        isPM : function (token) {
	            return token === '오후';
	        }
	    });
	}));


/***/ },
/* 126 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Luxembourgish (lb)
	// author : mweimerskirch : https://github.com/mweimerskirch, David Raison : https://github.com/kwisatz

	// Note: Luxembourgish has a very particular phonological rule ('Eifeler Regel') that causes the
	// deletion of the final 'n' in certain contexts. That's what the 'eifelerRegelAppliesToWeekday'
	// and 'eifelerRegelAppliesToNumber' methods are meant for

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function processRelativeTime(number, withoutSuffix, key, isFuture) {
	        var format = {
	            'm': ['eng Minutt', 'enger Minutt'],
	            'h': ['eng Stonn', 'enger Stonn'],
	            'd': ['een Dag', 'engem Dag'],
	            'M': ['ee Mount', 'engem Mount'],
	            'y': ['ee Joer', 'engem Joer']
	        };
	        return withoutSuffix ? format[key][0] : format[key][1];
	    }

	    function processFutureTime(string) {
	        var number = string.substr(0, string.indexOf(' '));
	        if (eifelerRegelAppliesToNumber(number)) {
	            return 'a ' + string;
	        }
	        return 'an ' + string;
	    }

	    function processPastTime(string) {
	        var number = string.substr(0, string.indexOf(' '));
	        if (eifelerRegelAppliesToNumber(number)) {
	            return 'viru ' + string;
	        }
	        return 'virun ' + string;
	    }

	    /**
	     * Returns true if the word before the given number loses the '-n' ending.
	     * e.g. 'an 10 Deeg' but 'a 5 Deeg'
	     *
	     * @param number {integer}
	     * @returns {boolean}
	     */
	    function eifelerRegelAppliesToNumber(number) {
	        number = parseInt(number, 10);
	        if (isNaN(number)) {
	            return false;
	        }
	        if (number < 0) {
	            // Negative Number --> always true
	            return true;
	        } else if (number < 10) {
	            // Only 1 digit
	            if (4 <= number && number <= 7) {
	                return true;
	            }
	            return false;
	        } else if (number < 100) {
	            // 2 digits
	            var lastDigit = number % 10, firstDigit = number / 10;
	            if (lastDigit === 0) {
	                return eifelerRegelAppliesToNumber(firstDigit);
	            }
	            return eifelerRegelAppliesToNumber(lastDigit);
	        } else if (number < 10000) {
	            // 3 or 4 digits --> recursively check first digit
	            while (number >= 10) {
	                number = number / 10;
	            }
	            return eifelerRegelAppliesToNumber(number);
	        } else {
	            // Anything larger than 4 digits: recursively check first n-3 digits
	            number = number / 1000;
	            return eifelerRegelAppliesToNumber(number);
	        }
	    }

	    return moment.defineLocale('lb', {
	        months: 'Januar_Februar_Mäerz_Abrëll_Mee_Juni_Juli_August_September_Oktober_November_Dezember'.split('_'),
	        monthsShort: 'Jan._Febr._Mrz._Abr._Mee_Jun._Jul._Aug._Sept._Okt._Nov._Dez.'.split('_'),
	        weekdays: 'Sonndeg_Méindeg_Dënschdeg_Mëttwoch_Donneschdeg_Freideg_Samschdeg'.split('_'),
	        weekdaysShort: 'So._Mé._Dë._Më._Do._Fr._Sa.'.split('_'),
	        weekdaysMin: 'So_Mé_Dë_Më_Do_Fr_Sa'.split('_'),
	        longDateFormat: {
	            LT: 'H:mm [Auer]',
	            L: 'DD.MM.YYYY',
	            LL: 'D. MMMM YYYY',
	            LLL: 'D. MMMM YYYY LT',
	            LLLL: 'dddd, D. MMMM YYYY LT'
	        },
	        calendar: {
	            sameDay: '[Haut um] LT',
	            sameElse: 'L',
	            nextDay: '[Muer um] LT',
	            nextWeek: 'dddd [um] LT',
	            lastDay: '[Gëschter um] LT',
	            lastWeek: function () {
	                // Different date string for 'Dënschdeg' (Tuesday) and 'Donneschdeg' (Thursday) due to phonological rule
	                switch (this.day()) {
	                    case 2:
	                    case 4:
	                        return '[Leschten] dddd [um] LT';
	                    default:
	                        return '[Leschte] dddd [um] LT';
	                }
	            }
	        },
	        relativeTime : {
	            future : processFutureTime,
	            past : processPastTime,
	            s : 'e puer Sekonnen',
	            m : processRelativeTime,
	            mm : '%d Minutten',
	            h : processRelativeTime,
	            hh : '%d Stonnen',
	            d : processRelativeTime,
	            dd : '%d Deeg',
	            M : processRelativeTime,
	            MM : '%d Méint',
	            y : processRelativeTime,
	            yy : '%d Joer'
	        },
	        ordinal: '%d.',
	        week: {
	            dow: 1, // Monday is the first day of the week.
	            doy: 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 127 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Lithuanian (lt)
	// author : Mindaugas Mozūras : https://github.com/mmozuras

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var units = {
	        'm' : 'minutė_minutės_minutę',
	        'mm': 'minutės_minučių_minutes',
	        'h' : 'valanda_valandos_valandą',
	        'hh': 'valandos_valandų_valandas',
	        'd' : 'diena_dienos_dieną',
	        'dd': 'dienos_dienų_dienas',
	        'M' : 'mėnuo_mėnesio_mėnesį',
	        'MM': 'mėnesiai_mėnesių_mėnesius',
	        'y' : 'metai_metų_metus',
	        'yy': 'metai_metų_metus'
	    },
	    weekDays = 'sekmadienis_pirmadienis_antradienis_trečiadienis_ketvirtadienis_penktadienis_šeštadienis'.split('_');

	    function translateSeconds(number, withoutSuffix, key, isFuture) {
	        if (withoutSuffix) {
	            return 'kelios sekundės';
	        } else {
	            return isFuture ? 'kelių sekundžių' : 'kelias sekundes';
	        }
	    }

	    function translateSingular(number, withoutSuffix, key, isFuture) {
	        return withoutSuffix ? forms(key)[0] : (isFuture ? forms(key)[1] : forms(key)[2]);
	    }

	    function special(number) {
	        return number % 10 === 0 || (number > 10 && number < 20);
	    }

	    function forms(key) {
	        return units[key].split('_');
	    }

	    function translate(number, withoutSuffix, key, isFuture) {
	        var result = number + ' ';
	        if (number === 1) {
	            return result + translateSingular(number, withoutSuffix, key[0], isFuture);
	        } else if (withoutSuffix) {
	            return result + (special(number) ? forms(key)[1] : forms(key)[0]);
	        } else {
	            if (isFuture) {
	                return result + forms(key)[1];
	            } else {
	                return result + (special(number) ? forms(key)[1] : forms(key)[2]);
	            }
	        }
	    }

	    function relativeWeekDay(moment, format) {
	        var nominative = format.indexOf('dddd HH:mm') === -1,
	            weekDay = weekDays[moment.day()];

	        return nominative ? weekDay : weekDay.substring(0, weekDay.length - 2) + 'į';
	    }

	    return moment.defineLocale('lt', {
	        months : 'sausio_vasario_kovo_balandžio_gegužės_birželio_liepos_rugpjūčio_rugsėjo_spalio_lapkričio_gruodžio'.split('_'),
	        monthsShort : 'sau_vas_kov_bal_geg_bir_lie_rgp_rgs_spa_lap_grd'.split('_'),
	        weekdays : relativeWeekDay,
	        weekdaysShort : 'Sek_Pir_Ant_Tre_Ket_Pen_Šeš'.split('_'),
	        weekdaysMin : 'S_P_A_T_K_Pn_Š'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'YYYY-MM-DD',
	            LL : 'YYYY [m.] MMMM D [d.]',
	            LLL : 'YYYY [m.] MMMM D [d.], LT [val.]',
	            LLLL : 'YYYY [m.] MMMM D [d.], dddd, LT [val.]',
	            l : 'YYYY-MM-DD',
	            ll : 'YYYY [m.] MMMM D [d.]',
	            lll : 'YYYY [m.] MMMM D [d.], LT [val.]',
	            llll : 'YYYY [m.] MMMM D [d.], ddd, LT [val.]'
	        },
	        calendar : {
	            sameDay : '[Šiandien] LT',
	            nextDay : '[Rytoj] LT',
	            nextWeek : 'dddd LT',
	            lastDay : '[Vakar] LT',
	            lastWeek : '[Praėjusį] dddd LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'po %s',
	            past : 'prieš %s',
	            s : translateSeconds,
	            m : translateSingular,
	            mm : translate,
	            h : translateSingular,
	            hh : translate,
	            d : translateSingular,
	            dd : translate,
	            M : translateSingular,
	            MM : translate,
	            y : translateSingular,
	            yy : translate
	        },
	        ordinal : function (number) {
	            return number + '-oji';
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 128 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : latvian (lv)
	// author : Kristaps Karlsons : https://github.com/skakri

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var units = {
	        'mm': 'minūti_minūtes_minūte_minūtes',
	        'hh': 'stundu_stundas_stunda_stundas',
	        'dd': 'dienu_dienas_diena_dienas',
	        'MM': 'mēnesi_mēnešus_mēnesis_mēneši',
	        'yy': 'gadu_gadus_gads_gadi'
	    };

	    function format(word, number, withoutSuffix) {
	        var forms = word.split('_');
	        if (withoutSuffix) {
	            return number % 10 === 1 && number !== 11 ? forms[2] : forms[3];
	        } else {
	            return number % 10 === 1 && number !== 11 ? forms[0] : forms[1];
	        }
	    }

	    function relativeTimeWithPlural(number, withoutSuffix, key) {
	        return number + ' ' + format(units[key], number, withoutSuffix);
	    }

	    return moment.defineLocale('lv', {
	        months : 'janvāris_februāris_marts_aprīlis_maijs_jūnijs_jūlijs_augusts_septembris_oktobris_novembris_decembris'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_mai_jūn_jūl_aug_sep_okt_nov_dec'.split('_'),
	        weekdays : 'svētdiena_pirmdiena_otrdiena_trešdiena_ceturtdiena_piektdiena_sestdiena'.split('_'),
	        weekdaysShort : 'Sv_P_O_T_C_Pk_S'.split('_'),
	        weekdaysMin : 'Sv_P_O_T_C_Pk_S'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'YYYY. [gada] D. MMMM',
	            LLL : 'YYYY. [gada] D. MMMM, LT',
	            LLLL : 'YYYY. [gada] D. MMMM, dddd, LT'
	        },
	        calendar : {
	            sameDay : '[Šodien pulksten] LT',
	            nextDay : '[Rīt pulksten] LT',
	            nextWeek : 'dddd [pulksten] LT',
	            lastDay : '[Vakar pulksten] LT',
	            lastWeek : '[Pagājušā] dddd [pulksten] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s vēlāk',
	            past : '%s agrāk',
	            s : 'dažas sekundes',
	            m : 'minūti',
	            mm : relativeTimeWithPlural,
	            h : 'stundu',
	            hh : relativeTimeWithPlural,
	            d : 'dienu',
	            dd : relativeTimeWithPlural,
	            M : 'mēnesi',
	            MM : relativeTimeWithPlural,
	            y : 'gadu',
	            yy : relativeTimeWithPlural
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 129 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : macedonian (mk)
	// author : Borislav Mickov : https://github.com/B0k0

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('mk', {
	        months : 'јануари_февруари_март_април_мај_јуни_јули_август_септември_октомври_ноември_декември'.split('_'),
	        monthsShort : 'јан_фев_мар_апр_мај_јун_јул_авг_сеп_окт_ное_дек'.split('_'),
	        weekdays : 'недела_понеделник_вторник_среда_четврток_петок_сабота'.split('_'),
	        weekdaysShort : 'нед_пон_вто_сре_чет_пет_саб'.split('_'),
	        weekdaysMin : 'нe_пo_вт_ср_че_пе_сa'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'D.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Денес во] LT',
	            nextDay : '[Утре во] LT',
	            nextWeek : 'dddd [во] LT',
	            lastDay : '[Вчера во] LT',
	            lastWeek : function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                case 6:
	                    return '[Во изминатата] dddd [во] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[Во изминатиот] dddd [во] LT';
	                }
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'после %s',
	            past : 'пред %s',
	            s : 'неколку секунди',
	            m : 'минута',
	            mm : '%d минути',
	            h : 'час',
	            hh : '%d часа',
	            d : 'ден',
	            dd : '%d дена',
	            M : 'месец',
	            MM : '%d месеци',
	            y : 'година',
	            yy : '%d години'
	        },
	        ordinal : function (number) {
	            var lastDigit = number % 10,
	                last2Digits = number % 100;
	            if (number === 0) {
	                return number + '-ев';
	            } else if (last2Digits === 0) {
	                return number + '-ен';
	            } else if (last2Digits > 10 && last2Digits < 20) {
	                return number + '-ти';
	            } else if (lastDigit === 1) {
	                return number + '-ви';
	            } else if (lastDigit === 2) {
	                return number + '-ри';
	            } else if (lastDigit === 7 || lastDigit === 8) {
	                return number + '-ми';
	            } else {
	                return number + '-ти';
	            }
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 130 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : malayalam (ml)
	// author : Floyd Pink : https://github.com/floydpink

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('ml', {
	        months : 'ജനുവരി_ഫെബ്രുവരി_മാർച്ച്_ഏപ്രിൽ_മേയ്_ജൂൺ_ജൂലൈ_ഓഗസ്റ്റ്_സെപ്റ്റംബർ_ഒക്ടോബർ_നവംബർ_ഡിസംബർ'.split('_'),
	        monthsShort : 'ജനു._ഫെബ്രു._മാർ._ഏപ്രി._മേയ്_ജൂൺ_ജൂലൈ._ഓഗ._സെപ്റ്റ._ഒക്ടോ._നവം._ഡിസം.'.split('_'),
	        weekdays : 'ഞായറാഴ്ച_തിങ്കളാഴ്ച_ചൊവ്വാഴ്ച_ബുധനാഴ്ച_വ്യാഴാഴ്ച_വെള്ളിയാഴ്ച_ശനിയാഴ്ച'.split('_'),
	        weekdaysShort : 'ഞായർ_തിങ്കൾ_ചൊവ്വ_ബുധൻ_വ്യാഴം_വെള്ളി_ശനി'.split('_'),
	        weekdaysMin : 'ഞാ_തി_ചൊ_ബു_വ്യാ_വെ_ശ'.split('_'),
	        longDateFormat : {
	            LT : 'A h:mm -നു',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        calendar : {
	            sameDay : '[ഇന്ന്] LT',
	            nextDay : '[നാളെ] LT',
	            nextWeek : 'dddd, LT',
	            lastDay : '[ഇന്നലെ] LT',
	            lastWeek : '[കഴിഞ്ഞ] dddd, LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s കഴിഞ്ഞ്',
	            past : '%s മുൻപ്',
	            s : 'അൽപ നിമിഷങ്ങൾ',
	            m : 'ഒരു മിനിറ്റ്',
	            mm : '%d മിനിറ്റ്',
	            h : 'ഒരു മണിക്കൂർ',
	            hh : '%d മണിക്കൂർ',
	            d : 'ഒരു ദിവസം',
	            dd : '%d ദിവസം',
	            M : 'ഒരു മാസം',
	            MM : '%d മാസം',
	            y : 'ഒരു വർഷം',
	            yy : '%d വർഷം'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'രാത്രി';
	            } else if (hour < 12) {
	                return 'രാവിലെ';
	            } else if (hour < 17) {
	                return 'ഉച്ച കഴിഞ്ഞ്';
	            } else if (hour < 20) {
	                return 'വൈകുന്നേരം';
	            } else {
	                return 'രാത്രി';
	            }
	        }
	    });
	}));


/***/ },
/* 131 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Marathi (mr)
	// author : Harshad Kale : https://github.com/kalehv

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '१',
	        '2': '२',
	        '3': '३',
	        '4': '४',
	        '5': '५',
	        '6': '६',
	        '7': '७',
	        '8': '८',
	        '9': '९',
	        '0': '०'
	    },
	    numberMap = {
	        '१': '1',
	        '२': '2',
	        '३': '3',
	        '४': '4',
	        '५': '5',
	        '६': '6',
	        '७': '7',
	        '८': '8',
	        '९': '9',
	        '०': '0'
	    };

	    return moment.defineLocale('mr', {
	        months : 'जानेवारी_फेब्रुवारी_मार्च_एप्रिल_मे_जून_जुलै_ऑगस्ट_सप्टेंबर_ऑक्टोबर_नोव्हेंबर_डिसेंबर'.split('_'),
	        monthsShort: 'जाने._फेब्रु._मार्च._एप्रि._मे._जून._जुलै._ऑग._सप्टें._ऑक्टो._नोव्हें._डिसें.'.split('_'),
	        weekdays : 'रविवार_सोमवार_मंगळवार_बुधवार_गुरूवार_शुक्रवार_शनिवार'.split('_'),
	        weekdaysShort : 'रवि_सोम_मंगळ_बुध_गुरू_शुक्र_शनि'.split('_'),
	        weekdaysMin : 'र_सो_मं_बु_गु_शु_श'.split('_'),
	        longDateFormat : {
	            LT : 'A h:mm वाजता',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        calendar : {
	            sameDay : '[आज] LT',
	            nextDay : '[उद्या] LT',
	            nextWeek : 'dddd, LT',
	            lastDay : '[काल] LT',
	            lastWeek: '[मागील] dddd, LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s नंतर',
	            past : '%s पूर्वी',
	            s : 'सेकंद',
	            m: 'एक मिनिट',
	            mm: '%d मिनिटे',
	            h : 'एक तास',
	            hh : '%d तास',
	            d : 'एक दिवस',
	            dd : '%d दिवस',
	            M : 'एक महिना',
	            MM : '%d महिने',
	            y : 'एक वर्ष',
	            yy : '%d वर्षे'
	        },
	        preparse: function (string) {
	            return string.replace(/[१२३४५६७८९०]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },
	        meridiem: function (hour, minute, isLower)
	        {
	            if (hour < 4) {
	                return 'रात्री';
	            } else if (hour < 10) {
	                return 'सकाळी';
	            } else if (hour < 17) {
	                return 'दुपारी';
	            } else if (hour < 20) {
	                return 'सायंकाळी';
	            } else {
	                return 'रात्री';
	            }
	        },
	        week : {
	            dow : 0, // Sunday is the first day of the week.
	            doy : 6  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 132 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Bahasa Malaysia (ms-MY)
	// author : Weldan Jamili : https://github.com/weldan

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('ms-my', {
	        months : 'Januari_Februari_Mac_April_Mei_Jun_Julai_Ogos_September_Oktober_November_Disember'.split('_'),
	        monthsShort : 'Jan_Feb_Mac_Apr_Mei_Jun_Jul_Ogs_Sep_Okt_Nov_Dis'.split('_'),
	        weekdays : 'Ahad_Isnin_Selasa_Rabu_Khamis_Jumaat_Sabtu'.split('_'),
	        weekdaysShort : 'Ahd_Isn_Sel_Rab_Kha_Jum_Sab'.split('_'),
	        weekdaysMin : 'Ah_Is_Sl_Rb_Km_Jm_Sb'.split('_'),
	        longDateFormat : {
	            LT : 'HH.mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY [pukul] LT',
	            LLLL : 'dddd, D MMMM YYYY [pukul] LT'
	        },
	        meridiem : function (hours, minutes, isLower) {
	            if (hours < 11) {
	                return 'pagi';
	            } else if (hours < 15) {
	                return 'tengahari';
	            } else if (hours < 19) {
	                return 'petang';
	            } else {
	                return 'malam';
	            }
	        },
	        calendar : {
	            sameDay : '[Hari ini pukul] LT',
	            nextDay : '[Esok pukul] LT',
	            nextWeek : 'dddd [pukul] LT',
	            lastDay : '[Kelmarin pukul] LT',
	            lastWeek : 'dddd [lepas pukul] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'dalam %s',
	            past : '%s yang lepas',
	            s : 'beberapa saat',
	            m : 'seminit',
	            mm : '%d minit',
	            h : 'sejam',
	            hh : '%d jam',
	            d : 'sehari',
	            dd : '%d hari',
	            M : 'sebulan',
	            MM : '%d bulan',
	            y : 'setahun',
	            yy : '%d tahun'
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 133 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Burmese (my)
	// author : Squar team, mysquar.com

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '၁',
	        '2': '၂',
	        '3': '၃',
	        '4': '၄',
	        '5': '၅',
	        '6': '၆',
	        '7': '၇',
	        '8': '၈',
	        '9': '၉',
	        '0': '၀'
	    }, numberMap = {
	        '၁': '1',
	        '၂': '2',
	        '၃': '3',
	        '၄': '4',
	        '၅': '5',
	        '၆': '6',
	        '၇': '7',
	        '၈': '8',
	        '၉': '9',
	        '၀': '0'
	    };
	    return moment.defineLocale('my', {
	        months: 'ဇန်နဝါရီ_ဖေဖော်ဝါရီ_မတ်_ဧပြီ_မေ_ဇွန်_ဇူလိုင်_သြဂုတ်_စက်တင်ဘာ_အောက်တိုဘာ_နိုဝင်ဘာ_ဒီဇင်ဘာ'.split('_'),
	        monthsShort: 'ဇန်_ဖေ_မတ်_ပြီ_မေ_ဇွန်_လိုင်_သြ_စက်_အောက်_နို_ဒီ'.split('_'),
	        weekdays: 'တနင်္ဂနွေ_တနင်္လာ_အင်္ဂါ_ဗုဒ္ဓဟူး_ကြာသပတေး_သောကြာ_စနေ'.split('_'),
	        weekdaysShort: 'နွေ_လာ_င်္ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
	        weekdaysMin: 'နွေ_လာ_င်္ဂါ_ဟူး_ကြာ_သော_နေ'.split('_'),
	        longDateFormat: {
	            LT: 'HH:mm',
	            L: 'DD/MM/YYYY',
	            LL: 'D MMMM YYYY',
	            LLL: 'D MMMM YYYY LT',
	            LLLL: 'dddd D MMMM YYYY LT'
	        },
	        calendar: {
	            sameDay: '[ယနေ.] LT [မှာ]',
	            nextDay: '[မနက်ဖြန်] LT [မှာ]',
	            nextWeek: 'dddd LT [မှာ]',
	            lastDay: '[မနေ.က] LT [မှာ]',
	            lastWeek: '[ပြီးခဲ့သော] dddd LT [မှာ]',
	            sameElse: 'L'
	        },
	        relativeTime: {
	            future: 'လာမည့် %s မှာ',
	            past: 'လွန်ခဲ့သော %s က',
	            s: 'စက္ကန်.အနည်းငယ်',
	            m: 'တစ်မိနစ်',
	            mm: '%d မိနစ်',
	            h: 'တစ်နာရီ',
	            hh: '%d နာရီ',
	            d: 'တစ်ရက်',
	            dd: '%d ရက်',
	            M: 'တစ်လ',
	            MM: '%d လ',
	            y: 'တစ်နှစ်',
	            yy: '%d နှစ်'
	        },
	        preparse: function (string) {
	            return string.replace(/[၁၂၃၄၅၆၇၈၉၀]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },
	        week: {
	            dow: 1, // Monday is the first day of the week.
	            doy: 4 // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 134 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : norwegian bokmål (nb)
	// authors : Espen Hovlandsdal : https://github.com/rexxars
	//           Sigurd Gartmann : https://github.com/sigurdga

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('nb', {
	        months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
	        weekdays : 'søndag_mandag_tirsdag_onsdag_torsdag_fredag_lørdag'.split('_'),
	        weekdaysShort : 'søn_man_tirs_ons_tors_fre_lør'.split('_'),
	        weekdaysMin : 'sø_ma_ti_on_to_fr_lø'.split('_'),
	        longDateFormat : {
	            LT : 'H.mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY [kl.] LT',
	            LLLL : 'dddd D. MMMM YYYY [kl.] LT'
	        },
	        calendar : {
	            sameDay: '[i dag kl.] LT',
	            nextDay: '[i morgen kl.] LT',
	            nextWeek: 'dddd [kl.] LT',
	            lastDay: '[i går kl.] LT',
	            lastWeek: '[forrige] dddd [kl.] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'om %s',
	            past : 'for %s siden',
	            s : 'noen sekunder',
	            m : 'ett minutt',
	            mm : '%d minutter',
	            h : 'en time',
	            hh : '%d timer',
	            d : 'en dag',
	            dd : '%d dager',
	            M : 'en måned',
	            MM : '%d måneder',
	            y : 'ett år',
	            yy : '%d år'
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 135 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : nepali/nepalese
	// author : suvash : https://github.com/suvash

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var symbolMap = {
	        '1': '१',
	        '2': '२',
	        '3': '३',
	        '4': '४',
	        '5': '५',
	        '6': '६',
	        '7': '७',
	        '8': '८',
	        '9': '९',
	        '0': '०'
	    },
	    numberMap = {
	        '१': '1',
	        '२': '2',
	        '३': '3',
	        '४': '4',
	        '५': '5',
	        '६': '6',
	        '७': '7',
	        '८': '8',
	        '९': '9',
	        '०': '0'
	    };

	    return moment.defineLocale('ne', {
	        months : 'जनवरी_फेब्रुवरी_मार्च_अप्रिल_मई_जुन_जुलाई_अगष्ट_सेप्टेम्बर_अक्टोबर_नोभेम्बर_डिसेम्बर'.split('_'),
	        monthsShort : 'जन._फेब्रु._मार्च_अप्रि._मई_जुन_जुलाई._अग._सेप्ट._अक्टो._नोभे._डिसे.'.split('_'),
	        weekdays : 'आइतबार_सोमबार_मङ्गलबार_बुधबार_बिहिबार_शुक्रबार_शनिबार'.split('_'),
	        weekdaysShort : 'आइत._सोम._मङ्गल._बुध._बिहि._शुक्र._शनि.'.split('_'),
	        weekdaysMin : 'आइ._सो._मङ्_बु._बि._शु._श.'.split('_'),
	        longDateFormat : {
	            LT : 'Aको h:mm बजे',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        preparse: function (string) {
	            return string.replace(/[१२३४५६७८९०]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 3) {
	                return 'राती';
	            } else if (hour < 10) {
	                return 'बिहान';
	            } else if (hour < 15) {
	                return 'दिउँसो';
	            } else if (hour < 18) {
	                return 'बेलुका';
	            } else if (hour < 20) {
	                return 'साँझ';
	            } else {
	                return 'राती';
	            }
	        },
	        calendar : {
	            sameDay : '[आज] LT',
	            nextDay : '[भोली] LT',
	            nextWeek : '[आउँदो] dddd[,] LT',
	            lastDay : '[हिजो] LT',
	            lastWeek : '[गएको] dddd[,] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%sमा',
	            past : '%s अगाडी',
	            s : 'केही समय',
	            m : 'एक मिनेट',
	            mm : '%d मिनेट',
	            h : 'एक घण्टा',
	            hh : '%d घण्टा',
	            d : 'एक दिन',
	            dd : '%d दिन',
	            M : 'एक महिना',
	            MM : '%d महिना',
	            y : 'एक बर्ष',
	            yy : '%d बर्ष'
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 136 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : dutch (nl)
	// author : Joris Röling : https://github.com/jjupiter

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var monthsShortWithDots = 'jan._feb._mrt._apr._mei_jun._jul._aug._sep._okt._nov._dec.'.split('_'),
	        monthsShortWithoutDots = 'jan_feb_mrt_apr_mei_jun_jul_aug_sep_okt_nov_dec'.split('_');

	    return moment.defineLocale('nl', {
	        months : 'januari_februari_maart_april_mei_juni_juli_augustus_september_oktober_november_december'.split('_'),
	        monthsShort : function (m, format) {
	            if (/-MMM-/.test(format)) {
	                return monthsShortWithoutDots[m.month()];
	            } else {
	                return monthsShortWithDots[m.month()];
	            }
	        },
	        weekdays : 'zondag_maandag_dinsdag_woensdag_donderdag_vrijdag_zaterdag'.split('_'),
	        weekdaysShort : 'zo._ma._di._wo._do._vr._za.'.split('_'),
	        weekdaysMin : 'Zo_Ma_Di_Wo_Do_Vr_Za'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD-MM-YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[vandaag om] LT',
	            nextDay: '[morgen om] LT',
	            nextWeek: 'dddd [om] LT',
	            lastDay: '[gisteren om] LT',
	            lastWeek: '[afgelopen] dddd [om] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'over %s',
	            past : '%s geleden',
	            s : 'een paar seconden',
	            m : 'één minuut',
	            mm : '%d minuten',
	            h : 'één uur',
	            hh : '%d uur',
	            d : 'één dag',
	            dd : '%d dagen',
	            M : 'één maand',
	            MM : '%d maanden',
	            y : 'één jaar',
	            yy : '%d jaar'
	        },
	        ordinal : function (number) {
	            return number + ((number === 1 || number === 8 || number >= 20) ? 'ste' : 'de');
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 137 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : norwegian nynorsk (nn)
	// author : https://github.com/mechuwind

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('nn', {
	        months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),
	        weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),
	        weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),
	        weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[I dag klokka] LT',
	            nextDay: '[I morgon klokka] LT',
	            nextWeek: 'dddd [klokka] LT',
	            lastDay: '[I går klokka] LT',
	            lastWeek: '[Føregåande] dddd [klokka] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'om %s',
	            past : 'for %s sidan',
	            s : 'nokre sekund',
	            m : 'eit minutt',
	            mm : '%d minutt',
	            h : 'ein time',
	            hh : '%d timar',
	            d : 'ein dag',
	            dd : '%d dagar',
	            M : 'ein månad',
	            MM : '%d månader',
	            y : 'eit år',
	            yy : '%d år'
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 138 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : polish (pl)
	// author : Rafal Hirsz : https://github.com/evoL

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var monthsNominative = 'styczeń_luty_marzec_kwiecień_maj_czerwiec_lipiec_sierpień_wrzesień_październik_listopad_grudzień'.split('_'),
	        monthsSubjective = 'stycznia_lutego_marca_kwietnia_maja_czerwca_lipca_sierpnia_września_października_listopada_grudnia'.split('_');

	    function plural(n) {
	        return (n % 10 < 5) && (n % 10 > 1) && ((~~(n / 10) % 10) !== 1);
	    }

	    function translate(number, withoutSuffix, key) {
	        var result = number + ' ';
	        switch (key) {
	        case 'm':
	            return withoutSuffix ? 'minuta' : 'minutę';
	        case 'mm':
	            return result + (plural(number) ? 'minuty' : 'minut');
	        case 'h':
	            return withoutSuffix  ? 'godzina'  : 'godzinę';
	        case 'hh':
	            return result + (plural(number) ? 'godziny' : 'godzin');
	        case 'MM':
	            return result + (plural(number) ? 'miesiące' : 'miesięcy');
	        case 'yy':
	            return result + (plural(number) ? 'lata' : 'lat');
	        }
	    }

	    return moment.defineLocale('pl', {
	        months : function (momentToFormat, format) {
	            if (/D MMMM/.test(format)) {
	                return monthsSubjective[momentToFormat.month()];
	            } else {
	                return monthsNominative[momentToFormat.month()];
	            }
	        },
	        monthsShort : 'sty_lut_mar_kwi_maj_cze_lip_sie_wrz_paź_lis_gru'.split('_'),
	        weekdays : 'niedziela_poniedziałek_wtorek_środa_czwartek_piątek_sobota'.split('_'),
	        weekdaysShort : 'nie_pon_wt_śr_czw_pt_sb'.split('_'),
	        weekdaysMin : 'N_Pn_Wt_Śr_Cz_Pt_So'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Dziś o] LT',
	            nextDay: '[Jutro o] LT',
	            nextWeek: '[W] dddd [o] LT',
	            lastDay: '[Wczoraj o] LT',
	            lastWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[W zeszłą niedzielę o] LT';
	                case 3:
	                    return '[W zeszłą środę o] LT';
	                case 6:
	                    return '[W zeszłą sobotę o] LT';
	                default:
	                    return '[W zeszły] dddd [o] LT';
	                }
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'za %s',
	            past : '%s temu',
	            s : 'kilka sekund',
	            m : translate,
	            mm : translate,
	            h : translate,
	            hh : translate,
	            d : '1 dzień',
	            dd : '%d dni',
	            M : 'miesiąc',
	            MM : translate,
	            y : 'rok',
	            yy : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 139 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : brazilian portuguese (pt-br)
	// author : Caio Ribeiro Pereira : https://github.com/caio-ribeiro-pereira

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('pt-br', {
	        months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
	        monthsShort : 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
	        weekdays : 'domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado'.split('_'),
	        weekdaysShort : 'dom_seg_ter_qua_qui_sex_sáb'.split('_'),
	        weekdaysMin : 'dom_2ª_3ª_4ª_5ª_6ª_sáb'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D [de] MMMM [de] YYYY',
	            LLL : 'D [de] MMMM [de] YYYY [às] LT',
	            LLLL : 'dddd, D [de] MMMM [de] YYYY [às] LT'
	        },
	        calendar : {
	            sameDay: '[Hoje às] LT',
	            nextDay: '[Amanhã às] LT',
	            nextWeek: 'dddd [às] LT',
	            lastDay: '[Ontem às] LT',
	            lastWeek: function () {
	                return (this.day() === 0 || this.day() === 6) ?
	                    '[Último] dddd [às] LT' : // Saturday + Sunday
	                    '[Última] dddd [às] LT'; // Monday - Friday
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'em %s',
	            past : '%s atrás',
	            s : 'segundos',
	            m : 'um minuto',
	            mm : '%d minutos',
	            h : 'uma hora',
	            hh : '%d horas',
	            d : 'um dia',
	            dd : '%d dias',
	            M : 'um mês',
	            MM : '%d meses',
	            y : 'um ano',
	            yy : '%d anos'
	        },
	        ordinal : '%dº'
	    });
	}));


/***/ },
/* 140 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : portuguese (pt)
	// author : Jefferson : https://github.com/jalex79

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('pt', {
	        months : 'janeiro_fevereiro_março_abril_maio_junho_julho_agosto_setembro_outubro_novembro_dezembro'.split('_'),
	        monthsShort : 'jan_fev_mar_abr_mai_jun_jul_ago_set_out_nov_dez'.split('_'),
	        weekdays : 'domingo_segunda-feira_terça-feira_quarta-feira_quinta-feira_sexta-feira_sábado'.split('_'),
	        weekdaysShort : 'dom_seg_ter_qua_qui_sex_sáb'.split('_'),
	        weekdaysMin : 'dom_2ª_3ª_4ª_5ª_6ª_sáb'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D [de] MMMM [de] YYYY',
	            LLL : 'D [de] MMMM [de] YYYY LT',
	            LLLL : 'dddd, D [de] MMMM [de] YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Hoje às] LT',
	            nextDay: '[Amanhã às] LT',
	            nextWeek: 'dddd [às] LT',
	            lastDay: '[Ontem às] LT',
	            lastWeek: function () {
	                return (this.day() === 0 || this.day() === 6) ?
	                    '[Último] dddd [às] LT' : // Saturday + Sunday
	                    '[Última] dddd [às] LT'; // Monday - Friday
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'em %s',
	            past : 'há %s',
	            s : 'segundos',
	            m : 'um minuto',
	            mm : '%d minutos',
	            h : 'uma hora',
	            hh : '%d horas',
	            d : 'um dia',
	            dd : '%d dias',
	            M : 'um mês',
	            MM : '%d meses',
	            y : 'um ano',
	            yy : '%d anos'
	        },
	        ordinal : '%dº',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 141 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : romanian (ro)
	// author : Vlad Gurdiga : https://github.com/gurdiga
	// author : Valentin Agachi : https://github.com/avaly

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function relativeTimeWithPlural(number, withoutSuffix, key) {
	        var format = {
	                'mm': 'minute',
	                'hh': 'ore',
	                'dd': 'zile',
	                'MM': 'luni',
	                'yy': 'ani'
	            },
	            separator = ' ';
	        if (number % 100 >= 20 || (number >= 100 && number % 100 === 0)) {
	            separator = ' de ';
	        }

	        return number + separator + format[key];
	    }

	    return moment.defineLocale('ro', {
	        months : 'ianuarie_februarie_martie_aprilie_mai_iunie_iulie_august_septembrie_octombrie_noiembrie_decembrie'.split('_'),
	        monthsShort : 'ian._febr._mart._apr._mai_iun._iul._aug._sept._oct._nov._dec.'.split('_'),
	        weekdays : 'duminică_luni_marți_miercuri_joi_vineri_sâmbătă'.split('_'),
	        weekdaysShort : 'Dum_Lun_Mar_Mie_Joi_Vin_Sâm'.split('_'),
	        weekdaysMin : 'Du_Lu_Ma_Mi_Jo_Vi_Sâ'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY H:mm',
	            LLLL : 'dddd, D MMMM YYYY H:mm'
	        },
	        calendar : {
	            sameDay: '[azi la] LT',
	            nextDay: '[mâine la] LT',
	            nextWeek: 'dddd [la] LT',
	            lastDay: '[ieri la] LT',
	            lastWeek: '[fosta] dddd [la] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'peste %s',
	            past : '%s în urmă',
	            s : 'câteva secunde',
	            m : 'un minut',
	            mm : relativeTimeWithPlural,
	            h : 'o oră',
	            hh : relativeTimeWithPlural,
	            d : 'o zi',
	            dd : relativeTimeWithPlural,
	            M : 'o lună',
	            MM : relativeTimeWithPlural,
	            y : 'un an',
	            yy : relativeTimeWithPlural
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 142 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : russian (ru)
	// author : Viktorminator : https://github.com/Viktorminator
	// Author : Menelion Elensúle : https://github.com/Oire

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function plural(word, num) {
	        var forms = word.split('_');
	        return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
	    }

	    function relativeTimeWithPlural(number, withoutSuffix, key) {
	        var format = {
	            'mm': withoutSuffix ? 'минута_минуты_минут' : 'минуту_минуты_минут',
	            'hh': 'час_часа_часов',
	            'dd': 'день_дня_дней',
	            'MM': 'месяц_месяца_месяцев',
	            'yy': 'год_года_лет'
	        };
	        if (key === 'm') {
	            return withoutSuffix ? 'минута' : 'минуту';
	        }
	        else {
	            return number + ' ' + plural(format[key], +number);
	        }
	    }

	    function monthsCaseReplace(m, format) {
	        var months = {
	            'nominative': 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
	            'accusative': 'января_февраля_марта_апреля_мая_июня_июля_августа_сентября_октября_ноября_декабря'.split('_')
	        },

	        nounCase = (/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/).test(format) ?
	            'accusative' :
	            'nominative';

	        return months[nounCase][m.month()];
	    }

	    function monthsShortCaseReplace(m, format) {
	        var monthsShort = {
	            'nominative': 'янв_фев_мар_апр_май_июнь_июль_авг_сен_окт_ноя_дек'.split('_'),
	            'accusative': 'янв_фев_мар_апр_мая_июня_июля_авг_сен_окт_ноя_дек'.split('_')
	        },

	        nounCase = (/D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/).test(format) ?
	            'accusative' :
	            'nominative';

	        return monthsShort[nounCase][m.month()];
	    }

	    function weekdaysCaseReplace(m, format) {
	        var weekdays = {
	            'nominative': 'воскресенье_понедельник_вторник_среда_четверг_пятница_суббота'.split('_'),
	            'accusative': 'воскресенье_понедельник_вторник_среду_четверг_пятницу_субботу'.split('_')
	        },

	        nounCase = (/\[ ?[Вв] ?(?:прошлую|следующую)? ?\] ?dddd/).test(format) ?
	            'accusative' :
	            'nominative';

	        return weekdays[nounCase][m.day()];
	    }

	    return moment.defineLocale('ru', {
	        months : monthsCaseReplace,
	        monthsShort : monthsShortCaseReplace,
	        weekdays : weekdaysCaseReplace,
	        weekdaysShort : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
	        weekdaysMin : 'вс_пн_вт_ср_чт_пт_сб'.split('_'),
	        monthsParse : [/^янв/i, /^фев/i, /^мар/i, /^апр/i, /^ма[й|я]/i, /^июн/i, /^июл/i, /^авг/i, /^сен/i, /^окт/i, /^ноя/i, /^дек/i],
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY г.',
	            LLL : 'D MMMM YYYY г., LT',
	            LLLL : 'dddd, D MMMM YYYY г., LT'
	        },
	        calendar : {
	            sameDay: '[Сегодня в] LT',
	            nextDay: '[Завтра в] LT',
	            lastDay: '[Вчера в] LT',
	            nextWeek: function () {
	                return this.day() === 2 ? '[Во] dddd [в] LT' : '[В] dddd [в] LT';
	            },
	            lastWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[В прошлое] dddd [в] LT';
	                case 1:
	                case 2:
	                case 4:
	                    return '[В прошлый] dddd [в] LT';
	                case 3:
	                case 5:
	                case 6:
	                    return '[В прошлую] dddd [в] LT';
	                }
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'через %s',
	            past : '%s назад',
	            s : 'несколько секунд',
	            m : relativeTimeWithPlural,
	            mm : relativeTimeWithPlural,
	            h : 'час',
	            hh : relativeTimeWithPlural,
	            d : 'день',
	            dd : relativeTimeWithPlural,
	            M : 'месяц',
	            MM : relativeTimeWithPlural,
	            y : 'год',
	            yy : relativeTimeWithPlural
	        },

	        meridiemParse: /ночи|утра|дня|вечера/i,
	        isPM : function (input) {
	            return /^(дня|вечера)$/.test(input);
	        },

	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'ночи';
	            } else if (hour < 12) {
	                return 'утра';
	            } else if (hour < 17) {
	                return 'дня';
	            } else {
	                return 'вечера';
	            }
	        },

	        ordinal: function (number, period) {
	            switch (period) {
	            case 'M':
	            case 'd':
	            case 'DDD':
	                return number + '-й';
	            case 'D':
	                return number + '-го';
	            case 'w':
	            case 'W':
	                return number + '-я';
	            default:
	                return number;
	            }
	        },

	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 143 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : slovak (sk)
	// author : Martin Minka : https://github.com/k2s
	// based on work of petrbela : https://github.com/petrbela

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var months = 'január_február_marec_apríl_máj_jún_júl_august_september_október_november_december'.split('_'),
	        monthsShort = 'jan_feb_mar_apr_máj_jún_júl_aug_sep_okt_nov_dec'.split('_');

	    function plural(n) {
	        return (n > 1) && (n < 5);
	    }

	    function translate(number, withoutSuffix, key, isFuture) {
	        var result = number + ' ';
	        switch (key) {
	        case 's':  // a few seconds / in a few seconds / a few seconds ago
	            return (withoutSuffix || isFuture) ? 'pár sekúnd' : 'pár sekundami';
	        case 'm':  // a minute / in a minute / a minute ago
	            return withoutSuffix ? 'minúta' : (isFuture ? 'minútu' : 'minútou');
	        case 'mm': // 9 minutes / in 9 minutes / 9 minutes ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'minúty' : 'minút');
	            } else {
	                return result + 'minútami';
	            }
	            break;
	        case 'h':  // an hour / in an hour / an hour ago
	            return withoutSuffix ? 'hodina' : (isFuture ? 'hodinu' : 'hodinou');
	        case 'hh': // 9 hours / in 9 hours / 9 hours ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'hodiny' : 'hodín');
	            } else {
	                return result + 'hodinami';
	            }
	            break;
	        case 'd':  // a day / in a day / a day ago
	            return (withoutSuffix || isFuture) ? 'deň' : 'dňom';
	        case 'dd': // 9 days / in 9 days / 9 days ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'dni' : 'dní');
	            } else {
	                return result + 'dňami';
	            }
	            break;
	        case 'M':  // a month / in a month / a month ago
	            return (withoutSuffix || isFuture) ? 'mesiac' : 'mesiacom';
	        case 'MM': // 9 months / in 9 months / 9 months ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'mesiace' : 'mesiacov');
	            } else {
	                return result + 'mesiacmi';
	            }
	            break;
	        case 'y':  // a year / in a year / a year ago
	            return (withoutSuffix || isFuture) ? 'rok' : 'rokom';
	        case 'yy': // 9 years / in 9 years / 9 years ago
	            if (withoutSuffix || isFuture) {
	                return result + (plural(number) ? 'roky' : 'rokov');
	            } else {
	                return result + 'rokmi';
	            }
	            break;
	        }
	    }

	    return moment.defineLocale('sk', {
	        months : months,
	        monthsShort : monthsShort,
	        monthsParse : (function (months, monthsShort) {
	            var i, _monthsParse = [];
	            for (i = 0; i < 12; i++) {
	                // use custom parser to solve problem with July (červenec)
	                _monthsParse[i] = new RegExp('^' + months[i] + '$|^' + monthsShort[i] + '$', 'i');
	            }
	            return _monthsParse;
	        }(months, monthsShort)),
	        weekdays : 'nedeľa_pondelok_utorok_streda_štvrtok_piatok_sobota'.split('_'),
	        weekdaysShort : 'ne_po_ut_st_št_pi_so'.split('_'),
	        weekdaysMin : 'ne_po_ut_st_št_pi_so'.split('_'),
	        longDateFormat : {
	            LT: 'H:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[dnes o] LT',
	            nextDay: '[zajtra o] LT',
	            nextWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[v nedeľu o] LT';
	                case 1:
	                case 2:
	                    return '[v] dddd [o] LT';
	                case 3:
	                    return '[v stredu o] LT';
	                case 4:
	                    return '[vo štvrtok o] LT';
	                case 5:
	                    return '[v piatok o] LT';
	                case 6:
	                    return '[v sobotu o] LT';
	                }
	            },
	            lastDay: '[včera o] LT',
	            lastWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[minulú nedeľu o] LT';
	                case 1:
	                case 2:
	                    return '[minulý] dddd [o] LT';
	                case 3:
	                    return '[minulú stredu o] LT';
	                case 4:
	                case 5:
	                    return '[minulý] dddd [o] LT';
	                case 6:
	                    return '[minulú sobotu o] LT';
	                }
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'za %s',
	            past : 'pred %s',
	            s : translate,
	            m : translate,
	            mm : translate,
	            h : translate,
	            hh : translate,
	            d : translate,
	            dd : translate,
	            M : translate,
	            MM : translate,
	            y : translate,
	            yy : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 144 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : slovenian (sl)
	// author : Robert Sedovšek : https://github.com/sedovsek

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function translate(number, withoutSuffix, key) {
	        var result = number + ' ';
	        switch (key) {
	        case 'm':
	            return withoutSuffix ? 'ena minuta' : 'eno minuto';
	        case 'mm':
	            if (number === 1) {
	                result += 'minuta';
	            } else if (number === 2) {
	                result += 'minuti';
	            } else if (number === 3 || number === 4) {
	                result += 'minute';
	            } else {
	                result += 'minut';
	            }
	            return result;
	        case 'h':
	            return withoutSuffix ? 'ena ura' : 'eno uro';
	        case 'hh':
	            if (number === 1) {
	                result += 'ura';
	            } else if (number === 2) {
	                result += 'uri';
	            } else if (number === 3 || number === 4) {
	                result += 'ure';
	            } else {
	                result += 'ur';
	            }
	            return result;
	        case 'dd':
	            if (number === 1) {
	                result += 'dan';
	            } else {
	                result += 'dni';
	            }
	            return result;
	        case 'MM':
	            if (number === 1) {
	                result += 'mesec';
	            } else if (number === 2) {
	                result += 'meseca';
	            } else if (number === 3 || number === 4) {
	                result += 'mesece';
	            } else {
	                result += 'mesecev';
	            }
	            return result;
	        case 'yy':
	            if (number === 1) {
	                result += 'leto';
	            } else if (number === 2) {
	                result += 'leti';
	            } else if (number === 3 || number === 4) {
	                result += 'leta';
	            } else {
	                result += 'let';
	            }
	            return result;
	        }
	    }

	    return moment.defineLocale('sl', {
	        months : 'januar_februar_marec_april_maj_junij_julij_avgust_september_oktober_november_december'.split('_'),
	        monthsShort : 'jan._feb._mar._apr._maj._jun._jul._avg._sep._okt._nov._dec.'.split('_'),
	        weekdays : 'nedelja_ponedeljek_torek_sreda_četrtek_petek_sobota'.split('_'),
	        weekdaysShort : 'ned._pon._tor._sre._čet._pet._sob.'.split('_'),
	        weekdaysMin : 'ne_po_to_sr_če_pe_so'.split('_'),
	        longDateFormat : {
	            LT : 'H:mm',
	            L : 'DD. MM. YYYY',
	            LL : 'D. MMMM YYYY',
	            LLL : 'D. MMMM YYYY LT',
	            LLLL : 'dddd, D. MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay  : '[danes ob] LT',
	            nextDay  : '[jutri ob] LT',

	            nextWeek : function () {
	                switch (this.day()) {
	                case 0:
	                    return '[v] [nedeljo] [ob] LT';
	                case 3:
	                    return '[v] [sredo] [ob] LT';
	                case 6:
	                    return '[v] [soboto] [ob] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[v] dddd [ob] LT';
	                }
	            },
	            lastDay  : '[včeraj ob] LT',
	            lastWeek : function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                case 6:
	                    return '[prejšnja] dddd [ob] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[prejšnji] dddd [ob] LT';
	                }
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'čez %s',
	            past   : '%s nazaj',
	            s      : 'nekaj sekund',
	            m      : translate,
	            mm     : translate,
	            h      : translate,
	            hh     : translate,
	            d      : 'en dan',
	            dd     : translate,
	            M      : 'en mesec',
	            MM     : translate,
	            y      : 'eno leto',
	            yy     : translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 145 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Albanian (sq)
	// author : Flakërim Ismani : https://github.com/flakerimi
	// author: Menelion Elensúle: https://github.com/Oire (tests)
	// author : Oerd Cukalla : https://github.com/oerd (fixes)

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('sq', {
	        months : 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split('_'),
	        monthsShort : 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),
	        weekdays : 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split('_'),
	        weekdaysShort : 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),
	        weekdaysMin : 'D_H_Ma_Më_E_P_Sh'.split('_'),
	        meridiem : function (hours, minutes, isLower) {
	            return hours < 12 ? 'PD' : 'MD';
	        },
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[Sot në] LT',
	            nextDay : '[Nesër në] LT',
	            nextWeek : 'dddd [në] LT',
	            lastDay : '[Dje në] LT',
	            lastWeek : 'dddd [e kaluar në] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'në %s',
	            past : '%s më parë',
	            s : 'disa sekonda',
	            m : 'një minutë',
	            mm : '%d minuta',
	            h : 'një orë',
	            hh : '%d orë',
	            d : 'një ditë',
	            dd : '%d ditë',
	            M : 'një muaj',
	            MM : '%d muaj',
	            y : 'një vit',
	            yy : '%d vite'
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 146 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Serbian-cyrillic (sr-cyrl)
	// author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var translator = {
	        words: { //Different grammatical cases
	            m: ['један минут', 'једне минуте'],
	            mm: ['минут', 'минуте', 'минута'],
	            h: ['један сат', 'једног сата'],
	            hh: ['сат', 'сата', 'сати'],
	            dd: ['дан', 'дана', 'дана'],
	            MM: ['месец', 'месеца', 'месеци'],
	            yy: ['година', 'године', 'година']
	        },
	        correctGrammaticalCase: function (number, wordKey) {
	            return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
	        },
	        translate: function (number, withoutSuffix, key) {
	            var wordKey = translator.words[key];
	            if (key.length === 1) {
	                return withoutSuffix ? wordKey[0] : wordKey[1];
	            } else {
	                return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
	            }
	        }
	    };

	    return moment.defineLocale('sr-cyrl', {
	        months: ['јануар', 'фебруар', 'март', 'април', 'мај', 'јун', 'јул', 'август', 'септембар', 'октобар', 'новембар', 'децембар'],
	        monthsShort: ['јан.', 'феб.', 'мар.', 'апр.', 'мај', 'јун', 'јул', 'авг.', 'сеп.', 'окт.', 'нов.', 'дец.'],
	        weekdays: ['недеља', 'понедељак', 'уторак', 'среда', 'четвртак', 'петак', 'субота'],
	        weekdaysShort: ['нед.', 'пон.', 'уто.', 'сре.', 'чет.', 'пет.', 'суб.'],
	        weekdaysMin: ['не', 'по', 'ут', 'ср', 'че', 'пе', 'су'],
	        longDateFormat: {
	            LT: 'H:mm',
	            L: 'DD. MM. YYYY',
	            LL: 'D. MMMM YYYY',
	            LLL: 'D. MMMM YYYY LT',
	            LLLL: 'dddd, D. MMMM YYYY LT'
	        },
	        calendar: {
	            sameDay: '[данас у] LT',
	            nextDay: '[сутра у] LT',

	            nextWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[у] [недељу] [у] LT';
	                case 3:
	                    return '[у] [среду] [у] LT';
	                case 6:
	                    return '[у] [суботу] [у] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[у] dddd [у] LT';
	                }
	            },
	            lastDay  : '[јуче у] LT',
	            lastWeek : function () {
	                var lastWeekDays = [
	                    '[прошле] [недеље] [у] LT',
	                    '[прошлог] [понедељка] [у] LT',
	                    '[прошлог] [уторка] [у] LT',
	                    '[прошле] [среде] [у] LT',
	                    '[прошлог] [четвртка] [у] LT',
	                    '[прошлог] [петка] [у] LT',
	                    '[прошле] [суботе] [у] LT'
	                ];
	                return lastWeekDays[this.day()];
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'за %s',
	            past   : 'пре %s',
	            s      : 'неколико секунди',
	            m      : translator.translate,
	            mm     : translator.translate,
	            h      : translator.translate,
	            hh     : translator.translate,
	            d      : 'дан',
	            dd     : translator.translate,
	            M      : 'месец',
	            MM     : translator.translate,
	            y      : 'годину',
	            yy     : translator.translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 147 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Serbian-latin (sr)
	// author : Milan Janačković<milanjanackovic@gmail.com> : https://github.com/milan-j

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var translator = {
	        words: { //Different grammatical cases
	            m: ['jedan minut', 'jedne minute'],
	            mm: ['minut', 'minute', 'minuta'],
	            h: ['jedan sat', 'jednog sata'],
	            hh: ['sat', 'sata', 'sati'],
	            dd: ['dan', 'dana', 'dana'],
	            MM: ['mesec', 'meseca', 'meseci'],
	            yy: ['godina', 'godine', 'godina']
	        },
	        correctGrammaticalCase: function (number, wordKey) {
	            return number === 1 ? wordKey[0] : (number >= 2 && number <= 4 ? wordKey[1] : wordKey[2]);
	        },
	        translate: function (number, withoutSuffix, key) {
	            var wordKey = translator.words[key];
	            if (key.length === 1) {
	                return withoutSuffix ? wordKey[0] : wordKey[1];
	            } else {
	                return number + ' ' + translator.correctGrammaticalCase(number, wordKey);
	            }
	        }
	    };

	    return moment.defineLocale('sr', {
	        months: ['januar', 'februar', 'mart', 'april', 'maj', 'jun', 'jul', 'avgust', 'septembar', 'oktobar', 'novembar', 'decembar'],
	        monthsShort: ['jan.', 'feb.', 'mar.', 'apr.', 'maj', 'jun', 'jul', 'avg.', 'sep.', 'okt.', 'nov.', 'dec.'],
	        weekdays: ['nedelja', 'ponedeljak', 'utorak', 'sreda', 'četvrtak', 'petak', 'subota'],
	        weekdaysShort: ['ned.', 'pon.', 'uto.', 'sre.', 'čet.', 'pet.', 'sub.'],
	        weekdaysMin: ['ne', 'po', 'ut', 'sr', 'če', 'pe', 'su'],
	        longDateFormat: {
	            LT: 'H:mm',
	            L: 'DD. MM. YYYY',
	            LL: 'D. MMMM YYYY',
	            LLL: 'D. MMMM YYYY LT',
	            LLLL: 'dddd, D. MMMM YYYY LT'
	        },
	        calendar: {
	            sameDay: '[danas u] LT',
	            nextDay: '[sutra u] LT',

	            nextWeek: function () {
	                switch (this.day()) {
	                case 0:
	                    return '[u] [nedelju] [u] LT';
	                case 3:
	                    return '[u] [sredu] [u] LT';
	                case 6:
	                    return '[u] [subotu] [u] LT';
	                case 1:
	                case 2:
	                case 4:
	                case 5:
	                    return '[u] dddd [u] LT';
	                }
	            },
	            lastDay  : '[juče u] LT',
	            lastWeek : function () {
	                var lastWeekDays = [
	                    '[prošle] [nedelje] [u] LT',
	                    '[prošlog] [ponedeljka] [u] LT',
	                    '[prošlog] [utorka] [u] LT',
	                    '[prošle] [srede] [u] LT',
	                    '[prošlog] [četvrtka] [u] LT',
	                    '[prošlog] [petka] [u] LT',
	                    '[prošle] [subote] [u] LT'
	                ];
	                return lastWeekDays[this.day()];
	            },
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'za %s',
	            past   : 'pre %s',
	            s      : 'nekoliko sekundi',
	            m      : translator.translate,
	            mm     : translator.translate,
	            h      : translator.translate,
	            hh     : translator.translate,
	            d      : 'dan',
	            dd     : translator.translate,
	            M      : 'mesec',
	            MM     : translator.translate,
	            y      : 'godinu',
	            yy     : translator.translate
	        },
	        ordinal : '%d.',
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 148 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : swedish (sv)
	// author : Jens Alm : https://github.com/ulmus

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('sv', {
	        months : 'januari_februari_mars_april_maj_juni_juli_augusti_september_oktober_november_december'.split('_'),
	        monthsShort : 'jan_feb_mar_apr_maj_jun_jul_aug_sep_okt_nov_dec'.split('_'),
	        weekdays : 'söndag_måndag_tisdag_onsdag_torsdag_fredag_lördag'.split('_'),
	        weekdaysShort : 'sön_mån_tis_ons_tor_fre_lör'.split('_'),
	        weekdaysMin : 'sö_må_ti_on_to_fr_lö'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'YYYY-MM-DD',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Idag] LT',
	            nextDay: '[Imorgon] LT',
	            lastDay: '[Igår] LT',
	            nextWeek: 'dddd LT',
	            lastWeek: '[Förra] dddd[en] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'om %s',
	            past : 'för %s sedan',
	            s : 'några sekunder',
	            m : 'en minut',
	            mm : '%d minuter',
	            h : 'en timme',
	            hh : '%d timmar',
	            d : 'en dag',
	            dd : '%d dagar',
	            M : 'en månad',
	            MM : '%d månader',
	            y : 'ett år',
	            yy : '%d år'
	        },
	        ordinal : function (number) {
	            var b = number % 10,
	                output = (~~(number % 100 / 10) === 1) ? 'e' :
	                (b === 1) ? 'a' :
	                (b === 2) ? 'a' :
	                (b === 3) ? 'e' : 'e';
	            return number + output;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 149 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : tamil (ta)
	// author : Arjunkumar Krishnamoorthy : https://github.com/tk120404

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    /*var symbolMap = {
	            '1': '௧',
	            '2': '௨',
	            '3': '௩',
	            '4': '௪',
	            '5': '௫',
	            '6': '௬',
	            '7': '௭',
	            '8': '௮',
	            '9': '௯',
	            '0': '௦'
	        },
	        numberMap = {
	            '௧': '1',
	            '௨': '2',
	            '௩': '3',
	            '௪': '4',
	            '௫': '5',
	            '௬': '6',
	            '௭': '7',
	            '௮': '8',
	            '௯': '9',
	            '௦': '0'
	        }; */

	    return moment.defineLocale('ta', {
	        months : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
	        monthsShort : 'ஜனவரி_பிப்ரவரி_மார்ச்_ஏப்ரல்_மே_ஜூன்_ஜூலை_ஆகஸ்ட்_செப்டெம்பர்_அக்டோபர்_நவம்பர்_டிசம்பர்'.split('_'),
	        weekdays : 'ஞாயிற்றுக்கிழமை_திங்கட்கிழமை_செவ்வாய்கிழமை_புதன்கிழமை_வியாழக்கிழமை_வெள்ளிக்கிழமை_சனிக்கிழமை'.split('_'),
	        weekdaysShort : 'ஞாயிறு_திங்கள்_செவ்வாய்_புதன்_வியாழன்_வெள்ளி_சனி'.split('_'),
	        weekdaysMin : 'ஞா_தி_செ_பு_வி_வெ_ச'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY, LT',
	            LLLL : 'dddd, D MMMM YYYY, LT'
	        },
	        calendar : {
	            sameDay : '[இன்று] LT',
	            nextDay : '[நாளை] LT',
	            nextWeek : 'dddd, LT',
	            lastDay : '[நேற்று] LT',
	            lastWeek : '[கடந்த வாரம்] dddd, LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s இல்',
	            past : '%s முன்',
	            s : 'ஒரு சில விநாடிகள்',
	            m : 'ஒரு நிமிடம்',
	            mm : '%d நிமிடங்கள்',
	            h : 'ஒரு மணி நேரம்',
	            hh : '%d மணி நேரம்',
	            d : 'ஒரு நாள்',
	            dd : '%d நாட்கள்',
	            M : 'ஒரு மாதம்',
	            MM : '%d மாதங்கள்',
	            y : 'ஒரு வருடம்',
	            yy : '%d ஆண்டுகள்'
	        },
	/*        preparse: function (string) {
	            return string.replace(/[௧௨௩௪௫௬௭௮௯௦]/g, function (match) {
	                return numberMap[match];
	            });
	        },
	        postformat: function (string) {
	            return string.replace(/\d/g, function (match) {
	                return symbolMap[match];
	            });
	        },*/
	        ordinal : function (number) {
	            return number + 'வது';
	        },


	        // refer http://ta.wikipedia.org/s/1er1

	        meridiem : function (hour, minute, isLower) {
	            if (hour >= 6 && hour <= 10) {
	                return ' காலை';
	            } else if (hour >= 10 && hour <= 14) {
	                return ' நண்பகல்';
	            } else if (hour >= 14 && hour <= 18) {
	                return ' எற்பாடு';
	            } else if (hour >= 18 && hour <= 20) {
	                return ' மாலை';
	            } else if (hour >= 20 && hour <= 24) {
	                return ' இரவு';
	            } else if (hour >= 0 && hour <= 6) {
	                return ' வைகறை';
	            }
	        },
	        week : {
	            dow : 0, // Sunday is the first day of the week.
	            doy : 6  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 150 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : thai (th)
	// author : Kridsada Thanabulpong : https://github.com/sirn

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('th', {
	        months : 'มกราคม_กุมภาพันธ์_มีนาคม_เมษายน_พฤษภาคม_มิถุนายน_กรกฎาคม_สิงหาคม_กันยายน_ตุลาคม_พฤศจิกายน_ธันวาคม'.split('_'),
	        monthsShort : 'มกรา_กุมภา_มีนา_เมษา_พฤษภา_มิถุนา_กรกฎา_สิงหา_กันยา_ตุลา_พฤศจิกา_ธันวา'.split('_'),
	        weekdays : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัสบดี_ศุกร์_เสาร์'.split('_'),
	        weekdaysShort : 'อาทิตย์_จันทร์_อังคาร_พุธ_พฤหัส_ศุกร์_เสาร์'.split('_'), // yes, three characters difference
	        weekdaysMin : 'อา._จ._อ._พ._พฤ._ศ._ส.'.split('_'),
	        longDateFormat : {
	            LT : 'H นาฬิกา m นาที',
	            L : 'YYYY/MM/DD',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY เวลา LT',
	            LLLL : 'วันddddที่ D MMMM YYYY เวลา LT'
	        },
	        meridiem : function (hour, minute, isLower) {
	            if (hour < 12) {
	                return 'ก่อนเที่ยง';
	            } else {
	                return 'หลังเที่ยง';
	            }
	        },
	        calendar : {
	            sameDay : '[วันนี้ เวลา] LT',
	            nextDay : '[พรุ่งนี้ เวลา] LT',
	            nextWeek : 'dddd[หน้า เวลา] LT',
	            lastDay : '[เมื่อวานนี้ เวลา] LT',
	            lastWeek : '[วัน]dddd[ที่แล้ว เวลา] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'อีก %s',
	            past : '%sที่แล้ว',
	            s : 'ไม่กี่วินาที',
	            m : '1 นาที',
	            mm : '%d นาที',
	            h : '1 ชั่วโมง',
	            hh : '%d ชั่วโมง',
	            d : '1 วัน',
	            dd : '%d วัน',
	            M : '1 เดือน',
	            MM : '%d เดือน',
	            y : '1 ปี',
	            yy : '%d ปี'
	        }
	    });
	}));


/***/ },
/* 151 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Tagalog/Filipino (tl-ph)
	// author : Dan Hagman

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('tl-ph', {
	        months : 'Enero_Pebrero_Marso_Abril_Mayo_Hunyo_Hulyo_Agosto_Setyembre_Oktubre_Nobyembre_Disyembre'.split('_'),
	        monthsShort : 'Ene_Peb_Mar_Abr_May_Hun_Hul_Ago_Set_Okt_Nob_Dis'.split('_'),
	        weekdays : 'Linggo_Lunes_Martes_Miyerkules_Huwebes_Biyernes_Sabado'.split('_'),
	        weekdaysShort : 'Lin_Lun_Mar_Miy_Huw_Biy_Sab'.split('_'),
	        weekdaysMin : 'Li_Lu_Ma_Mi_Hu_Bi_Sab'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'MM/D/YYYY',
	            LL : 'MMMM D, YYYY',
	            LLL : 'MMMM D, YYYY LT',
	            LLLL : 'dddd, MMMM DD, YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Ngayon sa] LT',
	            nextDay: '[Bukas sa] LT',
	            nextWeek: 'dddd [sa] LT',
	            lastDay: '[Kahapon sa] LT',
	            lastWeek: 'dddd [huling linggo] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'sa loob ng %s',
	            past : '%s ang nakalipas',
	            s : 'ilang segundo',
	            m : 'isang minuto',
	            mm : '%d minuto',
	            h : 'isang oras',
	            hh : '%d oras',
	            d : 'isang araw',
	            dd : '%d araw',
	            M : 'isang buwan',
	            MM : '%d buwan',
	            y : 'isang taon',
	            yy : '%d taon'
	        },
	        ordinal : function (number) {
	            return number;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 152 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : turkish (tr)
	// authors : Erhan Gundogan : https://github.com/erhangundogan,
	//           Burak Yiğit Kaya: https://github.com/BYK

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    var suffixes = {
	        1: '\'inci',
	        5: '\'inci',
	        8: '\'inci',
	        70: '\'inci',
	        80: '\'inci',

	        2: '\'nci',
	        7: '\'nci',
	        20: '\'nci',
	        50: '\'nci',

	        3: '\'üncü',
	        4: '\'üncü',
	        100: '\'üncü',

	        6: '\'ncı',

	        9: '\'uncu',
	        10: '\'uncu',
	        30: '\'uncu',

	        60: '\'ıncı',
	        90: '\'ıncı'
	    };

	    return moment.defineLocale('tr', {
	        months : 'Ocak_Şubat_Mart_Nisan_Mayıs_Haziran_Temmuz_Ağustos_Eylül_Ekim_Kasım_Aralık'.split('_'),
	        monthsShort : 'Oca_Şub_Mar_Nis_May_Haz_Tem_Ağu_Eyl_Eki_Kas_Ara'.split('_'),
	        weekdays : 'Pazar_Pazartesi_Salı_Çarşamba_Perşembe_Cuma_Cumartesi'.split('_'),
	        weekdaysShort : 'Paz_Pts_Sal_Çar_Per_Cum_Cts'.split('_'),
	        weekdaysMin : 'Pz_Pt_Sa_Ça_Pe_Cu_Ct'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd, D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay : '[bugün saat] LT',
	            nextDay : '[yarın saat] LT',
	            nextWeek : '[haftaya] dddd [saat] LT',
	            lastDay : '[dün] LT',
	            lastWeek : '[geçen hafta] dddd [saat] LT',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : '%s sonra',
	            past : '%s önce',
	            s : 'birkaç saniye',
	            m : 'bir dakika',
	            mm : '%d dakika',
	            h : 'bir saat',
	            hh : '%d saat',
	            d : 'bir gün',
	            dd : '%d gün',
	            M : 'bir ay',
	            MM : '%d ay',
	            y : 'bir yıl',
	            yy : '%d yıl'
	        },
	        ordinal : function (number) {
	            if (number === 0) {  // special case for zero
	                return number + '\'ıncı';
	            }
	            var a = number % 10,
	                b = number % 100 - a,
	                c = number >= 100 ? 100 : null;

	            return number + (suffixes[a] || suffixes[b] || suffixes[c]);
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 153 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Morocco Central Atlas Tamaziɣt in Latin (tzm-latn)
	// author : Abdel Said : https://github.com/abdelsaid

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('tzm-latn', {
	        months : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
	        monthsShort : 'innayr_brˤayrˤ_marˤsˤ_ibrir_mayyw_ywnyw_ywlywz_ɣwšt_šwtanbir_ktˤwbrˤ_nwwanbir_dwjnbir'.split('_'),
	        weekdays : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
	        weekdaysShort : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
	        weekdaysMin : 'asamas_aynas_asinas_akras_akwas_asimwas_asiḍyas'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[asdkh g] LT',
	            nextDay: '[aska g] LT',
	            nextWeek: 'dddd [g] LT',
	            lastDay: '[assant g] LT',
	            lastWeek: 'dddd [g] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'dadkh s yan %s',
	            past : 'yan %s',
	            s : 'imik',
	            m : 'minuḍ',
	            mm : '%d minuḍ',
	            h : 'saɛa',
	            hh : '%d tassaɛin',
	            d : 'ass',
	            dd : '%d ossan',
	            M : 'ayowr',
	            MM : '%d iyyirn',
	            y : 'asgas',
	            yy : '%d isgasn'
	        },
	        week : {
	            dow : 6, // Saturday is the first day of the week.
	            doy : 12  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 154 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : Morocco Central Atlas Tamaziɣt (tzm)
	// author : Abdel Said : https://github.com/abdelsaid

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('tzm', {
	        months : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
	        monthsShort : 'ⵉⵏⵏⴰⵢⵔ_ⴱⵕⴰⵢⵕ_ⵎⴰⵕⵚ_ⵉⴱⵔⵉⵔ_ⵎⴰⵢⵢⵓ_ⵢⵓⵏⵢⵓ_ⵢⵓⵍⵢⵓⵣ_ⵖⵓⵛⵜ_ⵛⵓⵜⴰⵏⴱⵉⵔ_ⴽⵟⵓⴱⵕ_ⵏⵓⵡⴰⵏⴱⵉⵔ_ⴷⵓⵊⵏⴱⵉⵔ'.split('_'),
	        weekdays : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
	        weekdaysShort : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
	        weekdaysMin : 'ⴰⵙⴰⵎⴰⵙ_ⴰⵢⵏⴰⵙ_ⴰⵙⵉⵏⴰⵙ_ⴰⴽⵔⴰⵙ_ⴰⴽⵡⴰⵙ_ⴰⵙⵉⵎⵡⴰⵙ_ⴰⵙⵉⴹⵢⴰⵙ'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'dddd D MMMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[ⴰⵙⴷⵅ ⴴ] LT',
	            nextDay: '[ⴰⵙⴽⴰ ⴴ] LT',
	            nextWeek: 'dddd [ⴴ] LT',
	            lastDay: '[ⴰⵚⴰⵏⵜ ⴴ] LT',
	            lastWeek: 'dddd [ⴴ] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'ⴷⴰⴷⵅ ⵙ ⵢⴰⵏ %s',
	            past : 'ⵢⴰⵏ %s',
	            s : 'ⵉⵎⵉⴽ',
	            m : 'ⵎⵉⵏⵓⴺ',
	            mm : '%d ⵎⵉⵏⵓⴺ',
	            h : 'ⵙⴰⵄⴰ',
	            hh : '%d ⵜⴰⵙⵙⴰⵄⵉⵏ',
	            d : 'ⴰⵙⵙ',
	            dd : '%d oⵙⵙⴰⵏ',
	            M : 'ⴰⵢoⵓⵔ',
	            MM : '%d ⵉⵢⵢⵉⵔⵏ',
	            y : 'ⴰⵙⴳⴰⵙ',
	            yy : '%d ⵉⵙⴳⴰⵙⵏ'
	        },
	        week : {
	            dow : 6, // Saturday is the first day of the week.
	            doy : 12  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 155 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : ukrainian (uk)
	// author : zemlanin : https://github.com/zemlanin
	// Author : Menelion Elensúle : https://github.com/Oire

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    function plural(word, num) {
	        var forms = word.split('_');
	        return num % 10 === 1 && num % 100 !== 11 ? forms[0] : (num % 10 >= 2 && num % 10 <= 4 && (num % 100 < 10 || num % 100 >= 20) ? forms[1] : forms[2]);
	    }

	    function relativeTimeWithPlural(number, withoutSuffix, key) {
	        var format = {
	            'mm': 'хвилина_хвилини_хвилин',
	            'hh': 'година_години_годин',
	            'dd': 'день_дні_днів',
	            'MM': 'місяць_місяці_місяців',
	            'yy': 'рік_роки_років'
	        };
	        if (key === 'm') {
	            return withoutSuffix ? 'хвилина' : 'хвилину';
	        }
	        else if (key === 'h') {
	            return withoutSuffix ? 'година' : 'годину';
	        }
	        else {
	            return number + ' ' + plural(format[key], +number);
	        }
	    }

	    function monthsCaseReplace(m, format) {
	        var months = {
	            'nominative': 'січень_лютий_березень_квітень_травень_червень_липень_серпень_вересень_жовтень_листопад_грудень'.split('_'),
	            'accusative': 'січня_лютого_березня_квітня_травня_червня_липня_серпня_вересня_жовтня_листопада_грудня'.split('_')
	        },

	        nounCase = (/D[oD]? *MMMM?/).test(format) ?
	            'accusative' :
	            'nominative';

	        return months[nounCase][m.month()];
	    }

	    function weekdaysCaseReplace(m, format) {
	        var weekdays = {
	            'nominative': 'неділя_понеділок_вівторок_середа_четвер_п’ятниця_субота'.split('_'),
	            'accusative': 'неділю_понеділок_вівторок_середу_четвер_п’ятницю_суботу'.split('_'),
	            'genitive': 'неділі_понеділка_вівторка_середи_четверга_п’ятниці_суботи'.split('_')
	        },

	        nounCase = (/(\[[ВвУу]\]) ?dddd/).test(format) ?
	            'accusative' :
	            ((/\[?(?:минулої|наступної)? ?\] ?dddd/).test(format) ?
	                'genitive' :
	                'nominative');

	        return weekdays[nounCase][m.day()];
	    }

	    function processHoursFunction(str) {
	        return function () {
	            return str + 'о' + (this.hours() === 11 ? 'б' : '') + '] LT';
	        };
	    }

	    return moment.defineLocale('uk', {
	        months : monthsCaseReplace,
	        monthsShort : 'січ_лют_бер_квіт_трав_черв_лип_серп_вер_жовт_лист_груд'.split('_'),
	        weekdays : weekdaysCaseReplace,
	        weekdaysShort : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
	        weekdaysMin : 'нд_пн_вт_ср_чт_пт_сб'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD.MM.YYYY',
	            LL : 'D MMMM YYYY р.',
	            LLL : 'D MMMM YYYY р., LT',
	            LLLL : 'dddd, D MMMM YYYY р., LT'
	        },
	        calendar : {
	            sameDay: processHoursFunction('[Сьогодні '),
	            nextDay: processHoursFunction('[Завтра '),
	            lastDay: processHoursFunction('[Вчора '),
	            nextWeek: processHoursFunction('[У] dddd ['),
	            lastWeek: function () {
	                switch (this.day()) {
	                case 0:
	                case 3:
	                case 5:
	                case 6:
	                    return processHoursFunction('[Минулої] dddd [').call(this);
	                case 1:
	                case 2:
	                case 4:
	                    return processHoursFunction('[Минулого] dddd [').call(this);
	                }
	            },
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : 'за %s',
	            past : '%s тому',
	            s : 'декілька секунд',
	            m : relativeTimeWithPlural,
	            mm : relativeTimeWithPlural,
	            h : 'годину',
	            hh : relativeTimeWithPlural,
	            d : 'день',
	            dd : relativeTimeWithPlural,
	            M : 'місяць',
	            MM : relativeTimeWithPlural,
	            y : 'рік',
	            yy : relativeTimeWithPlural
	        },

	        // M. E.: those two are virtually unused but a user might want to implement them for his/her website for some reason

	        meridiem : function (hour, minute, isLower) {
	            if (hour < 4) {
	                return 'ночі';
	            } else if (hour < 12) {
	                return 'ранку';
	            } else if (hour < 17) {
	                return 'дня';
	            } else {
	                return 'вечора';
	            }
	        },

	        ordinal: function (number, period) {
	            switch (period) {
	            case 'M':
	            case 'd':
	            case 'DDD':
	            case 'w':
	            case 'W':
	                return number + '-й';
	            case 'D':
	                return number + '-го';
	            default:
	                return number;
	            }
	        },

	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 1st is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 156 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : uzbek (uz)
	// author : Sardor Muminov : https://github.com/muminoff

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('uz', {
	        months : 'январь_февраль_март_апрель_май_июнь_июль_август_сентябрь_октябрь_ноябрь_декабрь'.split('_'),
	        monthsShort : 'янв_фев_мар_апр_май_июн_июл_авг_сен_окт_ноя_дек'.split('_'),
	        weekdays : 'Якшанба_Душанба_Сешанба_Чоршанба_Пайшанба_Жума_Шанба'.split('_'),
	        weekdaysShort : 'Якш_Душ_Сеш_Чор_Пай_Жум_Шан'.split('_'),
	        weekdaysMin : 'Як_Ду_Се_Чо_Па_Жу_Ша'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM YYYY',
	            LLL : 'D MMMM YYYY LT',
	            LLLL : 'D MMMM YYYY, dddd LT'
	        },
	        calendar : {
	            sameDay : '[Бугун соат] LT [да]',
	            nextDay : '[Эртага] LT [да]',
	            nextWeek : 'dddd [куни соат] LT [да]',
	            lastDay : '[Кеча соат] LT [да]',
	            lastWeek : '[Утган] dddd [куни соат] LT [да]',
	            sameElse : 'L'
	        },
	        relativeTime : {
	            future : 'Якин %s ичида',
	            past : 'Бир неча %s олдин',
	            s : 'фурсат',
	            m : 'бир дакика',
	            mm : '%d дакика',
	            h : 'бир соат',
	            hh : '%d соат',
	            d : 'бир кун',
	            dd : '%d кун',
	            M : 'бир ой',
	            MM : '%d ой',
	            y : 'бир йил',
	            yy : '%d йил'
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 7  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 157 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : vietnamese (vi)
	// author : Bang Nguyen : https://github.com/bangnk

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('vi', {
	        months : 'tháng 1_tháng 2_tháng 3_tháng 4_tháng 5_tháng 6_tháng 7_tháng 8_tháng 9_tháng 10_tháng 11_tháng 12'.split('_'),
	        monthsShort : 'Th01_Th02_Th03_Th04_Th05_Th06_Th07_Th08_Th09_Th10_Th11_Th12'.split('_'),
	        weekdays : 'chủ nhật_thứ hai_thứ ba_thứ tư_thứ năm_thứ sáu_thứ bảy'.split('_'),
	        weekdaysShort : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
	        weekdaysMin : 'CN_T2_T3_T4_T5_T6_T7'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            L : 'DD/MM/YYYY',
	            LL : 'D MMMM [năm] YYYY',
	            LLL : 'D MMMM [năm] YYYY LT',
	            LLLL : 'dddd, D MMMM [năm] YYYY LT',
	            l : 'DD/M/YYYY',
	            ll : 'D MMM YYYY',
	            lll : 'D MMM YYYY LT',
	            llll : 'ddd, D MMM YYYY LT'
	        },
	        calendar : {
	            sameDay: '[Hôm nay lúc] LT',
	            nextDay: '[Ngày mai lúc] LT',
	            nextWeek: 'dddd [tuần tới lúc] LT',
	            lastDay: '[Hôm qua lúc] LT',
	            lastWeek: 'dddd [tuần rồi lúc] LT',
	            sameElse: 'L'
	        },
	        relativeTime : {
	            future : '%s tới',
	            past : '%s trước',
	            s : 'vài giây',
	            m : 'một phút',
	            mm : '%d phút',
	            h : 'một giờ',
	            hh : '%d giờ',
	            d : 'một ngày',
	            dd : '%d ngày',
	            M : 'một tháng',
	            MM : '%d tháng',
	            y : 'một năm',
	            yy : '%d năm'
	        },
	        ordinal : function (number) {
	            return number;
	        },
	        week : {
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 158 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : chinese (zh-cn)
	// author : suupic : https://github.com/suupic
	// author : Zeno Zeng : https://github.com/zenozeng

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('zh-cn', {
	        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
	        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
	        weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
	        weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
	        weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
	        longDateFormat : {
	            LT : 'Ah点mm',
	            L : 'YYYY-MM-DD',
	            LL : 'YYYY年MMMD日',
	            LLL : 'YYYY年MMMD日LT',
	            LLLL : 'YYYY年MMMD日ddddLT',
	            l : 'YYYY-MM-DD',
	            ll : 'YYYY年MMMD日',
	            lll : 'YYYY年MMMD日LT',
	            llll : 'YYYY年MMMD日ddddLT'
	        },
	        meridiem : function (hour, minute, isLower) {
	            var hm = hour * 100 + minute;
	            if (hm < 600) {
	                return '凌晨';
	            } else if (hm < 900) {
	                return '早上';
	            } else if (hm < 1130) {
	                return '上午';
	            } else if (hm < 1230) {
	                return '中午';
	            } else if (hm < 1800) {
	                return '下午';
	            } else {
	                return '晚上';
	            }
	        },
	        calendar : {
	            sameDay : function () {
	                return this.minutes() === 0 ? '[今天]Ah[点整]' : '[今天]LT';
	            },
	            nextDay : function () {
	                return this.minutes() === 0 ? '[明天]Ah[点整]' : '[明天]LT';
	            },
	            lastDay : function () {
	                return this.minutes() === 0 ? '[昨天]Ah[点整]' : '[昨天]LT';
	            },
	            nextWeek : function () {
	                var startOfWeek, prefix;
	                startOfWeek = moment().startOf('week');
	                prefix = this.unix() - startOfWeek.unix() >= 7 * 24 * 3600 ? '[下]' : '[本]';
	                return this.minutes() === 0 ? prefix + 'dddAh点整' : prefix + 'dddAh点mm';
	            },
	            lastWeek : function () {
	                var startOfWeek, prefix;
	                startOfWeek = moment().startOf('week');
	                prefix = this.unix() < startOfWeek.unix()  ? '[上]' : '[本]';
	                return this.minutes() === 0 ? prefix + 'dddAh点整' : prefix + 'dddAh点mm';
	            },
	            sameElse : 'LL'
	        },
	        ordinal : function (number, period) {
	            switch (period) {
	            case 'd':
	            case 'D':
	            case 'DDD':
	                return number + '日';
	            case 'M':
	                return number + '月';
	            case 'w':
	            case 'W':
	                return number + '周';
	            default:
	                return number;
	            }
	        },
	        relativeTime : {
	            future : '%s内',
	            past : '%s前',
	            s : '几秒',
	            m : '1分钟',
	            mm : '%d分钟',
	            h : '1小时',
	            hh : '%d小时',
	            d : '1天',
	            dd : '%d天',
	            M : '1个月',
	            MM : '%d个月',
	            y : '1年',
	            yy : '%d年'
	        },
	        week : {
	            // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	}));


/***/ },
/* 159 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// moment.js locale configuration
	// locale : traditional chinese (zh-tw)
	// author : Ben : https://github.com/ben-lin

	(function (factory) {
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(46)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); // AMD
	    } else if (typeof exports === 'object') {
	        module.exports = factory(require('../moment')); // Node
	    } else {
	        factory(window.moment); // Browser global
	    }
	}(function (moment) {
	    return moment.defineLocale('zh-tw', {
	        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
	        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
	        weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
	        weekdaysShort : '週日_週一_週二_週三_週四_週五_週六'.split('_'),
	        weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
	        longDateFormat : {
	            LT : 'Ah點mm',
	            L : 'YYYY年MMMD日',
	            LL : 'YYYY年MMMD日',
	            LLL : 'YYYY年MMMD日LT',
	            LLLL : 'YYYY年MMMD日ddddLT',
	            l : 'YYYY年MMMD日',
	            ll : 'YYYY年MMMD日',
	            lll : 'YYYY年MMMD日LT',
	            llll : 'YYYY年MMMD日ddddLT'
	        },
	        meridiem : function (hour, minute, isLower) {
	            var hm = hour * 100 + minute;
	            if (hm < 900) {
	                return '早上';
	            } else if (hm < 1130) {
	                return '上午';
	            } else if (hm < 1230) {
	                return '中午';
	            } else if (hm < 1800) {
	                return '下午';
	            } else {
	                return '晚上';
	            }
	        },
	        calendar : {
	            sameDay : '[今天]LT',
	            nextDay : '[明天]LT',
	            nextWeek : '[下]ddddLT',
	            lastDay : '[昨天]LT',
	            lastWeek : '[上]ddddLT',
	            sameElse : 'L'
	        },
	        ordinal : function (number, period) {
	            switch (period) {
	            case 'd' :
	            case 'D' :
	            case 'DDD' :
	                return number + '日';
	            case 'M' :
	                return number + '月';
	            case 'w' :
	            case 'W' :
	                return number + '週';
	            default :
	                return number;
	            }
	        },
	        relativeTime : {
	            future : '%s內',
	            past : '%s前',
	            s : '幾秒',
	            m : '一分鐘',
	            mm : '%d分鐘',
	            h : '一小時',
	            hh : '%d小時',
	            d : '一天',
	            dd : '%d天',
	            M : '一個月',
	            MM : '%d個月',
	            y : '一年',
	            yy : '%d年'
	        }
	    });
	}));


/***/ },
/* 160 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<nav role="navigation" ng-controller="NavbarCtrl" class="navbar"><div class="mainnav"><div class="container"><div class="navbar-header"><div class="navbar-toggle snapper-toggle"><a href="" class="fa fa-bars"></a></div><a id="logo" href="#/" title="Ripple" class="navbar-brand hidden-xs"></a></div><div class="collapse navbar-collapse"><ul class="nav navbar-nav topMenu"><li id="nav-wallet" ng-class="{active: $route.current.mainMenu == \'wallet\'}"><a href="#/balance">Overview</a></li><li id="nav-send" ng-class="{active: $route.current.mainMenu == \'send\'}"><a href="#/send">Odoslať</a></li><li id="nav-exchange" ng-class="{active: $route.current.mainMenu == \'exchange\' || $route.current.mainMenu == \'trade\'}" ng-show="!ripple_exchange_selection_trade"><a href="#/exchange">Obchod</a></li><li id="nav-exchange" ng-class="{active: $route.current.mainMenu == \'exchange\' || $route.current.mainMenu == \'trade\'}" ng-show="ripple_exchange_selection_trade"><a href="#/trade">Obchod</a></li><li id="nav-fund" ng-class="{active: $route.current.mainMenu == \'fund\'}"><a href="#/xrp">Fund</a></li></ul><ul class="nav navbar-nav navbar-right"><li><span ng-switch="serverStatus" class="serverStatus {{connected ? \'online\' : \'offline\'}} {{serverLoad}}"><span ng-switch-when="disconnected" rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-trigger="hover" rp-popover-delay="rp-popover-delay" rp-popover-content="Disconnected from the Ripple network"></span><span ng-switch-when="highLoad" rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-trigger="hover" rp-popover-delay="rp-popover-delay" rp-popover-content="Network fees are currently higher than your maximum. Fee: {{ fee | rpamount }} XRP. &lt;a href=\'#/advanced\'&gt;Change fees&lt;/a&gt;"></span><span ng-switch-when="mediumLoad" rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-trigger="hover" rp-popover-delay="rp-popover-delay" rp-popover-content="\'Network fees are currently higher than normal. Fee: {{ fee | rpamount }} XRP\'"></span><span ng-switch-when="lowLoad" rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-trigger="hover" rp-popover-delay="rp-popover-delay" rp-popover-content="Connected to the Ripple network. Fee: {{ fee | rpamount }} XRP"></span><span ng-switch-when="connected" rp-popover="rp-popover" rp-popover-placement="bottom" rp-popover-trigger="hover" rp-popover-delay="rp-popover-delay" rp-popover-content="Connected to the Ripple network."></span></span></li><li><p class="navbar-text">{{userCredentials.account}}</p></li><li class="dropdown notifications-dropdown"><a ng-click="read()" class="dropdown-toggle fa fa-bell"><div ng-show="unseenNotifications.count" class="number">{{unseenNotifications.count}}</div></a><ul id="notifications" class="dropdown-menu"><li ng-hide="loadState.transactions" class="message">Načítanie...</li><li ng-show="loadState.transactions &amp;&amp; !notifications.length" class="message">There are no recent notifications.</li><li ng-repeat="entry in notifications" ng-class="{unseen: entry.unseen}" rp-link-tx="entry.hash" ng-show="notifications.length" class="notification"><div ng-switch on="entry.transaction.type" class="desc"><div ng-switch-when="sent" class="transaction"><span>Odoslali ste <strong class="nowrap"> {{entry.transaction.amount | rpamount}} {{entry.transaction.amount | rpcurrency}}</strong> na adresu <span title="{{entry.transaction.counterparty}}" class="address"> {{entry.transaction.counterparty | rpcontactnamefull }}</span></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="received" class="transaction"><span title="{{entry.transaction.counterparty}}" class="address"><span>{{entry.transaction.counterparty | rpcontactnamefull }}</span> sent you<strong class="nowrap"> {{entry.transaction.amount | rpamount:{reference_date:entry.dateRaw} }} {{entry.transaction.amount | rpcurrency}}</strong></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="exchange" class="transaction">');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="trusted" class="transaction"><span title="{{entry.transaction.counterparty}}" class="address">{{entry.transaction.counterparty | rpcontactname}} vám poskytol úver vo výške</span><strong class="nowrap"> {{entry.transaction.amount | rpamount}}\n{{entry.transaction.amount | rpcurrency}}</strong>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="trusting" class="transaction"><span>You have now connected to the gateway&#32;<span title="{{entry.transaction.counterparty}}" class="address">{{entry.transaction.counterparty | rpcontactname}}</span><span l10n-inc="l10n-inc">&#32;for&#32;</span><strong class="nowrap">{{entry.transaction.amount | rpamount:{reference_date:entry.dateRaw} }}\n{{entry.transaction.amount | rpcurrency}}</strong>.</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="offernew" class="transaction">');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="offercancel" class="transaction"><span>You cancelled an order accepting&#32;<strong class="nowrap">{{entry.transaction.pays | rpamount}}\n{{entry.transaction.pays | rpcurrency}}</strong> for&#32;<strong class="nowrap">{{entry.transaction.gets | rpamount}}\n{{entry.transaction.gets | rpcurrency}}</strong></span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="accountset" class="transaction">Informácie o účte boli zmenené</div><div ng-switch-when="rippling" class="transaction"><span>Rippling</span>');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div><div ng-switch-when="failed" class="transaction">Transakcia neúspešná</div><div ng-switch-default="ng-switch-default" class="transaction">');
	var __val__ = __webpack_require__(161)()
	buf.push(null == __val__ ? "" : __val__);
	buf.push('</div></div><div class="date">{{entry.date | rpfromnow}}</div></li><li ng-show="notifications.length" class="history"><a href="#/history">View Full History</a></li></ul></li><li class="settings"><a class="dropdown-toggle fa fa-cog"></a><ul class="dropdown-menu"><li class="divider"></li><li><a href="#/security"><i class="icon-settings"></i> Settings</a></li><li class="divider"></li><li><a ng-click="logout()" class="logout"><i class="icon-logout"></i> Log Out</a></li></ul></li></ul></div></div></div><div ng-show="$route.current.mainMenu == \'wallet\'" class="subnav"><div class="container"><ul><li ng-class="{active: $route.current.tabName == \'balance\'}"><a href="#/balance">Zostatok</a></li><li ng-class="{active: $route.current.tabName == \'history\'}"><a href="#/history">História</a></li><li ng-class="{active: $route.current.tabName == \'contacts\'}"><a href="#/contacts">Kontakty</a></li></ul></div></div><div ng-show="$route.current.mainMenu == \'exchange\' || $route.current.mainMenu == \'trade\'" class="subnav"><div class="container"><ul><li ng-class="{active: $route.current.tabName == \'exchange\'}"><a href="#/exchange">Simple</a></li><li ng-class="{active: $route.current.tabName == \'trade\'}"><a href="#/trade">Advanced</a></li></ul></div></div></nav>');
	}
	return buf.join("");
	}

/***/ },
/* 161 */
/***/ function(module, exports, __webpack_require__) {

	var jade = __webpack_require__(163);

	module.exports = function anonymous(locals, attrs, escape, rethrow, merge
	/**/) {
	attrs = attrs || jade.attrs; escape = escape || jade.escape; rethrow = rethrow || jade.rethrow; merge = merge || jade.merge;
	var buf = [];
	with (locals || {}) {
	var interp;
	buf.push('<ul ng-show="entry.effects" class="effects"><li ng-repeat="effect in entry.showEffects" ng-switch on="effect.type"><span ng-switch-when="offer_funded"><span ng-show="effect.sell" rp-span-spacing="rp-span-spacing">You sold<span rp-pretty-amount="effect.gets" class="amount"></span>for<span rp-pretty-amount="effect.pays" class="amount"></span></span><span ng-hide="effect.sell" rp-span-spacing="rp-span-spacing">You bought<span rp-pretty-amount="effect.pays" class="amount"></span>for<span rp-pretty-amount="effect.gets" class="amount"></span></span>(<span>cena</span><span>:<strong> {{effect.price | rpamount:{precision: 4} }}</strong></span>).<span>Tento príkaz bol dokončený.</span></span><span ng-switch-when="offer_partially_funded"><span ng-show="effect.sell" rp-span-spacing="rp-span-spacing">You sold<span rp-pretty-amount="effect.got" class="amount"></span>for<span rp-pretty-amount="effect.paid" class="amount"></span></span><span ng-hide="effect.sell" rp-span-spacing="rp-span-spacing">You bought<span rp-pretty-amount="effect.paid" class="amount"></span>for<span rp-pretty-amount="effect.got" class="amount"></span></span>(<span>cena</span><span>:<strong> {{effect.price | rpamount:{precision: 4} }}</strong></span>).<span ng-show="effect.cancelled">Zostatok bol zrušený kvôli nedostatku prostriedkov.</span><span ng-hide="effect.deleted" rp-span-spacing="rp-span-spacing">This order has<span rp-pretty-amount="effect.remaining"></span>remaining.</span></span><span ng-switch-when="offer_cancelled">Order (<span rp-pretty-amount="effect.pays" class="amount"></span> for&#32;<span rp-pretty-amount="effect.gets" class="amount"></span>) has been cancelled due to lack of funds.</span><span ng-switch-when="offer_created"><span ng-show="effect.sell" rp-span-spacing="rp-span-spacing">You created an order to sell<span rp-pretty-amount="effect.pays" class="amount"></span>for<span rp-pretty-amount="effect.pays" class="amount"></span></span><span ng-hide="effect.sell" rp-span-spacing="rp-span-spacing">You created an order to buy<span rp-pretty-amount="effect.pays" class="amount"></span>for<span rp-pretty-amount="effect.pays" class="amount"></span></span></span><span ng-switch-when="offer_bought" rp-span-spacing="rp-span-spacing">You bought<span rp-pretty-amount="effect.got" class="amount"></span>for<span rp-pretty-amount="effect.paid" class="amount"></span>(<span l10n-inc="l10n-inc">price</span><span>:<strong> {{effect.price | rpamount:{precision: 4} }}</strong></span>).</span><span ng-switch-when="trust_create_local">You have now connected to the gateway&#32;<span rp-pretty-identity="effect.counterparty"></span><span l10n-inc="l10n-inc">&#32;for&#32;</span><span rp-pretty-amount="effect.limit"></span>.</span><span ng-switch-when="trust_create_remote" rp-span-spacing="rp-span-spacing"><span rp-pretty-identity="effect.counterparty"></span>is trusting you for<span rp-pretty-amount="effect.limit"></span>.</span><span ng-switch-when="trust_change_local" rp-span-spacing="rp-span-spacing">You have changed<span> {{effect.limit | rpcurrency}}</span>trust for<span rp-pretty-identity="effect.counterparty"></span>from<span>{{effect.prevLimit | rpamount:{reference_date: entry.dateRaw} }}</span>to<span>{{effect.limit | rpamount:{reference_date: entry.dateRaw} }}</span>.</span><span ng-switch-when="trust_change_remote" rp-span-spacing="rp-span-spacing"><span rp-pretty-identity="effect.counterparty"></span>changed the<span>{{effect.limit | rpcurrency}}</span>trust from<span>{{effect.prevLimit | rpamount:{reference_date: entry.dateRaw} }}</span>to<span>{{effect.limit | rpamount:{reference_date: entry.dateRaw} }}</span>.</span><span ng-switch-when="trust_change_balance" rp-span-spacing="rp-span-spacing">Trust balance between you and<span rp-pretty-identity="effect.counterparty"></span>has been changed by<span rp-pretty-amount="effect.amount"></span>.</span><span ng-switch-when="balance_change" rp-span-spacing="rp-span-spacing">Your balance has been changed by<span rp-pretty-amount="effect.amount"></span>.</span></li></ul>');
	}
	return buf.join("");
	}

/***/ },
/* 162 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = function(module) {
		if(!module.webpackPolyfill) {
			module.deprecate = function() {};
			module.paths = [];
			// module.parent = undefined by default
			module.children = [];
			module.webpackPolyfill = 1;
		}
		return module;
	}


/***/ },
/* 163 */
/***/ function(module, exports, __webpack_require__) {

	
	/*!
	 * Jade - runtime
	 * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
	 * MIT Licensed
	 */

	/**
	 * Lame Array.isArray() polyfill for now.
	 */

	if (!Array.isArray) {
	  Array.isArray = function(arr){
	    return '[object Array]' == Object.prototype.toString.call(arr);
	  };
	}

	/**
	 * Lame Object.keys() polyfill for now.
	 */

	if (!Object.keys) {
	  Object.keys = function(obj){
	    var arr = [];
	    for (var key in obj) {
	      if (obj.hasOwnProperty(key)) {
	        arr.push(key);
	      }
	    }
	    return arr;
	  }
	}

	/**
	 * Merge two attribute objects giving precedence
	 * to values in object `b`. Classes are special-cased
	 * allowing for arrays and merging/joining appropriately
	 * resulting in a string.
	 *
	 * @param {Object} a
	 * @param {Object} b
	 * @return {Object} a
	 * @api private
	 */

	exports.merge = function merge(a, b) {
	  var ac = a['class'];
	  var bc = b['class'];

	  if (ac || bc) {
	    ac = ac || [];
	    bc = bc || [];
	    if (!Array.isArray(ac)) ac = [ac];
	    if (!Array.isArray(bc)) bc = [bc];
	    ac = ac.filter(nulls);
	    bc = bc.filter(nulls);
	    a['class'] = ac.concat(bc).join(' ');
	  }

	  for (var key in b) {
	    if (key != 'class') {
	      a[key] = b[key];
	    }
	  }

	  return a;
	};

	/**
	 * Filter null `val`s.
	 *
	 * @param {Mixed} val
	 * @return {Mixed}
	 * @api private
	 */

	function nulls(val) {
	  return val != null;
	}

	/**
	 * Render the given attributes object.
	 *
	 * @param {Object} obj
	 * @param {Object} escaped
	 * @return {String}
	 * @api private
	 */

	exports.attrs = function attrs(obj, escaped){
	  var buf = []
	    , terse = obj.terse;

	  delete obj.terse;
	  var keys = Object.keys(obj)
	    , len = keys.length;

	  if (len) {
	    buf.push('');
	    for (var i = 0; i < len; ++i) {
	      var key = keys[i]
	        , val = obj[key];

	      if ('boolean' == typeof val || null == val) {
	        if (val) {
	          terse
	            ? buf.push(key)
	            : buf.push(key + '="' + key + '"');
	        }
	      } else if (0 == key.indexOf('data') && 'string' != typeof val) {
	        buf.push(key + "='" + JSON.stringify(val) + "'");
	      } else if ('class' == key && Array.isArray(val)) {
	        buf.push(key + '="' + exports.escape(val.join(' ')) + '"');
	      } else if (escaped && escaped[key]) {
	        buf.push(key + '="' + exports.escape(val) + '"');
	      } else {
	        buf.push(key + '="' + val + '"');
	      }
	    }
	  }

	  return buf.join(' ');
	};

	/**
	 * Escape the given string of `html`.
	 *
	 * @param {String} html
	 * @return {String}
	 * @api private
	 */

	exports.escape = function escape(html){
	  return String(html)
	    .replace(/&(?!(\w+|\#\d+);)/g, '&amp;')
	    .replace(/</g, '&lt;')
	    .replace(/>/g, '&gt;')
	    .replace(/"/g, '&quot;');
	};

	/**
	 * Re-throw the given `err` in context to the
	 * the jade in `filename` at the given `lineno`.
	 *
	 * @param {Error} err
	 * @param {String} filename
	 * @param {String} lineno
	 * @api private
	 */

	exports.rethrow = function rethrow(err, filename, lineno){
	  if (!filename) throw err;

	  var context = 3
	    , str = __webpack_require__(49).readFileSync(filename, 'utf8')
	    , lines = str.split('\n')
	    , start = Math.max(lineno - context, 0)
	    , end = Math.min(lines.length, lineno + context);

	  // Error context
	  var context = lines.slice(start, end).map(function(line, i){
	    var curr = i + start + 1;
	    return (curr == lineno ? '  > ' : '    ')
	      + curr
	      + '| '
	      + line;
	  }).join('\n');

	  // Alter exception message
	  err.path = filename;
	  err.message = (filename || 'Jade') + ':' + lineno
	    + '\n' + context + '\n\n' + err.message;
	  throw err;
	};


/***/ }
/******/ ])