/******/
 (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 = "/assets/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
	
	__webpack_require__(118);
	
	var _utils = __webpack_require__(119);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	var _header = __webpack_require__(224);
	
	var _header2 = _interopRequireDefault(_header);
	
	var _footer = __webpack_require__(248);
	
	var _footer2 = _interopRequireDefault(_footer);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	__webpack_require__(254);
	__webpack_require__(255);
	__webpack_require__(256);
	__webpack_require__(257);
	__webpack_require__(39);
	
	
	if (!global._babelPolyfill) {
	  __webpack_require__(258);
	}
	
	try {
	  angular.module('templates');
	} catch (e) {
	  angular.module('templates', []);
	}
	
	(0, _utils2.default)(angular.module('utils', ['ui.select', 'mgcrea.ngStrap', 'ngCookies', 'vcRecaptcha', 'angular-uri', 'templates', 'angulartics', 'angulartics.google.analytics', 'angulartics.igg.theta', 'LocalStorageModule']).config(['$analyticsProvider', function ($analyticsProvider) {
	  $analyticsProvider.virtualPageviews(false);
	}]));
	
	angular.module('adminBar', []);
	
	(0, _header2.default)(angular.module('header', ['ngAnimate', 'utils', 'adminBar', 'indiegogo.components.leftNavToggler']));
	
	(0, _footer2.default)(angular.module('footer', ['utils']));
	
	angular.module('lite', ['header', 'footer', 'utils']);
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 1 */,
/* 2 */,
/* 3 */,
/* 4 */,
/* 5 */,
/* 6 */,
/* 7 */,
/* 8 */,
/* 9 */,
/* 10 */,
/* 11 */,
/* 12 */,
/* 13 */,
/* 14 */,
/* 15 */,
/* 16 */,
/* 17 */,
/* 18 */,
/* 19 */,
/* 20 */,
/* 21 */,
/* 22 */,
/* 23 */,
/* 24 */,
/* 25 */,
/* 26 */,
/* 27 */,
/* 28 */,
/* 29 */,
/* 30 */,
/* 31 */,
/* 32 */,
/* 33 */,
/* 34 */,
/* 35 */,
/* 36 */,
/* 37 */,
/* 38 */,
/* 39 */
/***/ function(module, exports) {

	angular.module('angular-clipboard', [])
	    .directive('clipboard', ['$document', function ($document) {
	        return {
	            restrict: 'A',
	            scope: {
	                onCopied: '&',
	                onError: '&',
	                text: '='
	            },
	            link: function (scope, element) {
	                function createNode(text) {
	                    var node = $document[0].createElement('textarea');
	                    node.style.position = 'absolute';
	                    node.style.left = '-10000px';
	                    node.textContent = text;
	                    return node;
	                }
	
	                function copyNode(node) {
	                    // Set inline style to override css styles
	                    $document[0].body.style.webkitUserSelect = 'initial';
	
	                    var selection = $document[0].getSelection();
	                    selection.removeAllRanges();
	                    node.select();
	
	                    if(!$document[0].execCommand('copy')) {
	                      throw('failure copy');
	                    }
	                    selection.removeAllRanges();
	
	                    // Reset inline style
	                    $document[0].body.style.webkitUserSelect = '';
	                }
	
	                function copyText(text) {
	                    var node = createNode(text);
	                    $document[0].body.appendChild(node);
	                    copyNode(node);
	                    $document[0].body.removeChild(node);
	                }
	
	                element.on('click', function (event) {
	                    try {
	                        copyText(scope.text);
	                        if (angular.isFunction(scope.onCopied)) {
	                            scope.$evalAsync(scope.onCopied());
	                        }
	                    } catch (err) {
	                        if (angular.isFunction(scope.onError)) {
	                            scope.$evalAsync(scope.onError({err: err}));
	                        }
	                    }
	                });
	            }
	        };
	    }]);


/***/ },
/* 40 */,
/* 41 */,
/* 42 */,
/* 43 */,
/* 44 */,
/* 45 */,
/* 46 */,
/* 47 */,
/* 48 */,
/* 49 */,
/* 50 */,
/* 51 */,
/* 52 */,
/* 53 */,
/* 54 */,
/* 55 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.activatePreOrderPrivateApiCampaignPath = activatePreOrderPrivateApiCampaignPath;
	exports.analyticsPrivateApiPaymentsContributionPath = analyticsPrivateApiPaymentsContributionPath;
	exports.approveProductStagePrivateApiAdminProjectPath = approveProductStagePrivateApiAdminProjectPath;
	exports.batchUpdatePrivateApiCampaignOrdersPath = batchUpdatePrivateApiCampaignOrdersPath;
	exports.campaignSharePrivateApiPaymentsContributionPath = campaignSharePrivateApiPaymentsContributionPath;
	exports.campaignsPrivateApiPartnerDashboardPath = campaignsPrivateApiPartnerDashboardPath;
	exports.canMessagePrivateApiProjectsCampaignMessagesPath = canMessagePrivateApiProjectsCampaignMessagesPath;
	exports.changeTopPerkPrivateApiCommandCenterPerkPath = changeTopPerkPrivateApiCommandCenterPerkPath;
	exports.clearTopPerkPrivateApiCommandCenterPerksPath = clearTopPerkPrivateApiCommandCenterPerksPath;
	exports.contributionsPrivateApiPartnerDashboardPath = contributionsPrivateApiPartnerDashboardPath;
	exports.createReplyPrivateApiCampaignCommentsPath = createReplyPrivateApiCampaignCommentsPath;
	exports.currentAccountFollowingPrivateApiCampaignCollectionPath = currentAccountFollowingPrivateApiCampaignCollectionPath;
	exports.deactivatePreOrderPrivateApiCampaignPath = deactivatePreOrderPrivateApiCampaignPath;
	exports.deleteReplyPrivateApiCampaignCommentsPath = deleteReplyPrivateApiCampaignCommentsPath;
	exports.demotePrivateApiPartnerTeamMemberPath = demotePrivateApiPartnerTeamMemberPath;
	exports.descriptionPrivateApiCampaignPath = descriptionPrivateApiCampaignPath;
	exports.disablePreviewPrivateApiCampaignPath = disablePreviewPrivateApiCampaignPath;
	exports.disinvitePrivateApiCampaignPath = disinvitePrivateApiCampaignPath;
	exports.editPrivateApiAccountPath = editPrivateApiAccountPath;
	exports.editPrivateApiExternalCampaignPath = editPrivateApiExternalCampaignPath;
	exports.editPrivateApiProjectsPath = editPrivateApiProjectsPath;
	exports.enablePreviewPrivateApiCampaignPath = enablePreviewPrivateApiCampaignPath;
	exports.exportPrivateApiCampaignContributionsPath = exportPrivateApiCampaignContributionsPath;
	exports.findPartnerNameByEinPrivateApiCampaignPath = findPartnerNameByEinPrivateApiCampaignPath;
	exports.followPrivateApiCampaignCollectionPath = followPrivateApiCampaignCollectionPath;
	exports.followPrivateApiProjectsPath = followPrivateApiProjectsPath;
	exports.fulfillmentPrivateApiPartnerDashboardPath = fulfillmentPrivateApiPartnerDashboardPath;
	exports.importPrivateApiExternalCampaignsPath = importPrivateApiExternalCampaignsPath;
	exports.invitePrivateApiCampaignPath = invitePrivateApiCampaignPath;
	exports.markRefundedPrivateApiCampaignContributionPath = markRefundedPrivateApiCampaignContributionPath;
	exports.mePrivateApiCredentialsPath = mePrivateApiCredentialsPath;
	exports.newPrivateApiAccountPath = newPrivateApiAccountPath;
	exports.newPrivateApiExternalCampaignPath = newPrivateApiExternalCampaignPath;
	exports.newPrivateApiProjectsPath = newPrivateApiProjectsPath;
	exports.previewPrivateApiCampaignUpdatesPath = previewPrivateApiCampaignUpdatesPath;
	exports.privateApiAccountPath = privateApiAccountPath;
	exports.privateApiAccountAddressPath = privateApiAccountAddressPath;
	exports.privateApiAccountAddressesPath = privateApiAccountAddressesPath;
	exports.privateApiAccountContributionPath = privateApiAccountContributionPath;
	exports.privateApiAccountCreditCardPath = privateApiAccountCreditCardPath;
	exports.privateApiAccountCreditCardsPath = privateApiAccountCreditCardsPath;
	exports.privateApiAccountsPath = privateApiAccountsPath;
	exports.privateApiAdminAccountRolePath = privateApiAdminAccountRolePath;
	exports.privateApiAdminCampaignStrategistPath = privateApiAdminCampaignStrategistPath;
	exports.privateApiAdminCampaignStrategistIndexPath = privateApiAdminCampaignStrategistIndexPath;
	exports.privateApiAdminProjectSponsorPath = privateApiAdminProjectSponsorPath;
	exports.privateApiAdminProjectSponsorsPath = privateApiAdminProjectSponsorsPath;
	exports.privateApiAdminSearchAnythingIndexPath = privateApiAdminSearchAnythingIndexPath;
	exports.privateApiAdminSponsorPath = privateApiAdminSponsorPath;
	exports.privateApiAdminSponsorLevelsPath = privateApiAdminSponsorLevelsPath;
	exports.privateApiAdminSponsorsPath = privateApiAdminSponsorsPath;
	exports.privateApiCampaignPath = privateApiCampaignPath;
	exports.privateApiCampaignBankAccountsPath = privateApiCampaignBankAccountsPath;
	exports.privateApiCampaignBankInfosPath = privateApiCampaignBankInfosPath;
	exports.privateApiCampaignCollectionPath = privateApiCampaignCollectionPath;
	exports.privateApiCampaignCollectionCampaignsPath = privateApiCampaignCollectionCampaignsPath;
	exports.privateApiCampaignCollectionsPath = privateApiCampaignCollectionsPath;
	exports.privateApiCampaignComingSoonPath = privateApiCampaignComingSoonPath;
	exports.privateApiCampaignCommentPath = privateApiCampaignCommentPath;
	exports.privateApiCampaignCommentsPath = privateApiCampaignCommentsPath;
	exports.privateApiCampaignContributionPath = privateApiCampaignContributionPath;
	exports.privateApiCampaignContributionsPath = privateApiCampaignContributionsPath;
	exports.privateApiCampaignDisbursementsPath = privateApiCampaignDisbursementsPath;
	exports.privateApiCampaignEditorPerkPath = privateApiCampaignEditorPerkPath;
	exports.privateApiCampaignEditorPerksPath = privateApiCampaignEditorPerksPath;
	exports.privateApiCampaignEmailSubscribersPath = privateApiCampaignEmailSubscribersPath;
	exports.privateApiCampaignFundsPath = privateApiCampaignFundsPath;
	exports.privateApiCampaignGalleryPath = privateApiCampaignGalleryPath;
	exports.privateApiCampaignIdentityVerificationPath = privateApiCampaignIdentityVerificationPath;
	exports.privateApiCampaignOrderPath = privateApiCampaignOrderPath;
	exports.privateApiCampaignOrdersPath = privateApiCampaignOrdersPath;
	exports.privateApiCampaignPayoutRecordsPath = privateApiCampaignPayoutRecordsPath;
	exports.privateApiCampaignPerkItemPath = privateApiCampaignPerkItemPath;
	exports.privateApiCampaignPerkItemsPath = privateApiCampaignPerkItemsPath;
	exports.privateApiCampaignPerksPath = privateApiCampaignPerksPath;
	exports.privateApiCampaignPledgesPath = privateApiCampaignPledgesPath;
	exports.privateApiCampaignSubscribePath = privateApiCampaignSubscribePath;
	exports.privateApiCampaignUpdatePath = privateApiCampaignUpdatePath;
	exports.privateApiCampaignUpdatesPath = privateApiCampaignUpdatesPath;
	exports.privateApiCampaignsPath = privateApiCampaignsPath;
	exports.privateApiCommandCenterAnalyticsPath = privateApiCommandCenterAnalyticsPath;
	exports.privateApiCommandCenterCountriesPath = privateApiCommandCenterCountriesPath;
	exports.privateApiCommandCenterDomainsPath = privateApiCommandCenterDomainsPath;
	exports.privateApiCommandCenterFundsPath = privateApiCommandCenterFundsPath;
	exports.privateApiCommandCenterPerksPath = privateApiCommandCenterPerksPath;
	exports.privateApiCommandCenterReferrersPath = privateApiCommandCenterReferrersPath;
	exports.privateApiCommandCenterStatsPath = privateApiCommandCenterStatsPath;
	exports.privateApiContactsPath = privateApiContactsPath;
	exports.privateApiEmailContactsPath = privateApiEmailContactsPath;
	exports.privateApiExperimentPath = privateApiExperimentPath;
	exports.privateApiExperimentsFetchAndUpdatePath = privateApiExperimentsFetchAndUpdatePath;
	exports.privateApiExplorePath = privateApiExplorePath;
	exports.privateApiExploreCollectionsPath = privateApiExploreCollectionsPath;
	exports.privateApiExploreStatsPath = privateApiExploreStatsPath;
	exports.privateApiExternalCampaignPath = privateApiExternalCampaignPath;
	exports.privateApiExternalCampaignsPath = privateApiExternalCampaignsPath;
	exports.privateApiFacebookCountPath = privateApiFacebookCountPath;
	exports.privateApiFbDynamicProductAdPath = privateApiFbDynamicProductAdPath;
	exports.privateApiFbDynamicProductAdsPath = privateApiFbDynamicProductAdsPath;
	exports.privateApiFundraiserDashboardDisbursementInfoPath = privateApiFundraiserDashboardDisbursementInfoPath;
	exports.privateApiHomePath = privateApiHomePath;
	exports.privateApiHomePerksPath = privateApiHomePerksPath;
	exports.privateApiHomeSlotsPath = privateApiHomeSlotsPath;
	exports.privateApiJobStatusPath = privateApiJobStatusPath;
	exports.privateApiPartnerTeamInvitationPath = privateApiPartnerTeamInvitationPath;
	exports.privateApiPartnerTeamInvitationsPath = privateApiPartnerTeamInvitationsPath;
	exports.privateApiPartnerTeamMemberPath = privateApiPartnerTeamMemberPath;
	exports.privateApiPaymentsCreditCardsNewPath = privateApiPaymentsCreditCardsNewPath;
	exports.privateApiPaymentsCreditCardsSavedPath = privateApiPaymentsCreditCardsSavedPath;
	exports.privateApiPaymentsGuestSignupsPath = privateApiPaymentsGuestSignupsPath;
	exports.privateApiPaymentsPaypalPath = privateApiPaymentsPaypalPath;
	exports.privateApiPaymentsProjectPath = privateApiPaymentsProjectPath;
	exports.privateApiProfilePath = privateApiProfilePath;
	exports.privateApiProfileCommentsPath = privateApiProfileCommentsPath;
	exports.privateApiProfileEmailPreferencesPath = privateApiProfileEmailPreferencesPath;
	exports.privateApiProfileFacebooksPath = privateApiProfileFacebooksPath;
	exports.privateApiProfileLinkedinsPath = privateApiProfileLinkedinsPath;
	exports.privateApiProjectsPath = privateApiProjectsPath;
	exports.privateApiProjectsAutomaticFacebookPostsPath = privateApiProjectsAutomaticFacebookPostsPath;
	exports.privateApiProjectsCampaignMessagesPath = privateApiProjectsCampaignMessagesPath;
	exports.privateApiSearchPath = privateApiSearchPath;
	exports.privateApiSimpleCampaignPath = privateApiSimpleCampaignPath;
	exports.productStagesPrivateApiAdminProjectPath = productStagesPrivateApiAdminProjectPath;
	exports.projectTodoItemsPrivateApiProjectsPath = projectTodoItemsPrivateApiProjectsPath;
	exports.promotePrivateApiPartnerTeamMemberPath = promotePrivateApiPartnerTeamMemberPath;
	exports.publishPrivateApiCampaignPath = publishPrivateApiCampaignPath;
	exports.publishPrivateApiExternalCampaignPath = publishPrivateApiExternalCampaignPath;
	exports.publishPrivateApiSimpleCampaignPath = publishPrivateApiSimpleCampaignPath;
	exports.recommendationsPrivateApiCampaignPath = recommendationsPrivateApiCampaignPath;
	exports.refundPrivateApiCampaignContributionPath = refundPrivateApiCampaignContributionPath;
	exports.resendConfirmationEmailPrivateApiAccountPath = resendConfirmationEmailPrivateApiAccountPath;
	exports.resendConfirmationEmailPrivateApiCampaignOrderPath = resendConfirmationEmailPrivateApiCampaignOrderPath;
	exports.resendPrivateApiPartnerTeamInvitationPath = resendPrivateApiPartnerTeamInvitationPath;
	exports.scheduleNextPostDatePrivateApiProjectsAutomaticFacebookPostsPath = scheduleNextPostDatePrivateApiProjectsAutomaticFacebookPostsPath;
	exports.searchPrivateApiTagsPath = searchPrivateApiTagsPath;
	exports.sendAllConfirmationEmailsPrivateApiCampaignOrdersPath = sendAllConfirmationEmailsPrivateApiCampaignOrdersPath;
	exports.sendEmailPrivateApiContactsPath = sendEmailPrivateApiContactsPath;
	exports.sendPreviewPrivateApiCampaignUpdatesPath = sendPreviewPrivateApiCampaignUpdatesPath;
	exports.setFeePrivateApiExternalCampaignPath = setFeePrivateApiExternalCampaignPath;
	exports.setTopPerkPrivateApiCampaignEditorPerksPath = setTopPerkPrivateApiCampaignEditorPerksPath;
	exports.splitBucketPrivateApiCampaignPath = splitBucketPrivateApiCampaignPath;
	exports.submitForApprovalPrivateApiCampaignPath = submitForApprovalPrivateApiCampaignPath;
	exports.toggleSpamPrivateApiCampaignCommentsPath = toggleSpamPrivateApiCampaignCommentsPath;
	exports.unfollowPrivateApiCampaignCollectionPath = unfollowPrivateApiCampaignCollectionPath;
	exports.unfollowPrivateApiProjectsPath = unfollowPrivateApiProjectsPath;
	exports.updateCloudinaryImagePrivateApiProfilePath = updateCloudinaryImagePrivateApiProfilePath;
	exports.updateDeadlinePrivateApiCampaignPath = updateDeadlinePrivateApiCampaignPath;
	exports.verifyPaypalPrivateApiCampaignPath = verifyPaypalPrivateApiCampaignPath;
	function activatePreOrderPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/activate_pre_order";
	}
	function analyticsPrivateApiPaymentsContributionPath(args) {
	  return "/private_api/payments/contributions/" + args.id + "/analytics";
	}
	function approveProductStagePrivateApiAdminProjectPath(args) {
	  return "/private_api/admin/projects/" + args.id + "/approve_product_stage";
	}
	function batchUpdatePrivateApiCampaignOrdersPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/orders/batch_update";
	}
	function campaignSharePrivateApiPaymentsContributionPath(args) {
	  return "/private_api/payments/contributions/" + args.id + "/campaign_share";
	}
	function campaignsPrivateApiPartnerDashboardPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/dashboard/campaigns";
	}
	function canMessagePrivateApiProjectsCampaignMessagesPath(args) {
	  return "/private_api/projects/" + args.id + "/campaign_messages/can_message";
	}
	function changeTopPerkPrivateApiCommandCenterPerkPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/perks/" + args.id + "/change_top_perk";
	}
	function clearTopPerkPrivateApiCommandCenterPerksPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/perks/clear_top_perk";
	}
	function contributionsPrivateApiPartnerDashboardPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/dashboard/contributions";
	}
	function createReplyPrivateApiCampaignCommentsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/comments/create_reply";
	}
	function currentAccountFollowingPrivateApiCampaignCollectionPath(args) {
	  return "/private_api/campaign_collections/" + args.id + "/current_account_following";
	}
	function deactivatePreOrderPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/deactivate_pre_order";
	}
	function deleteReplyPrivateApiCampaignCommentsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/comments/delete_reply";
	}
	function demotePrivateApiPartnerTeamMemberPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/team_members/" + args.id + "/demote";
	}
	function descriptionPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/description";
	}
	function disablePreviewPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/disable_preview";
	}
	function disinvitePrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/disinvite";
	}
	function editPrivateApiAccountPath(args) {
	  return "/private_api/accounts/" + args.id + "/edit";
	}
	function editPrivateApiExternalCampaignPath(args) {
	  return "/private_api/external_campaigns/" + args.id + "/edit";
	}
	function editPrivateApiProjectsPath(args) {
	  return "/private_api/projects/" + args.id + "/edit";
	}
	function enablePreviewPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/enable_preview";
	}
	function exportPrivateApiCampaignContributionsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/contributions/export";
	}
	function findPartnerNameByEinPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/find_partner_name_by_ein";
	}
	function followPrivateApiCampaignCollectionPath(args) {
	  return "/private_api/campaign_collections/" + args.id + "/follow";
	}
	function followPrivateApiProjectsPath(args) {
	  return "/private_api/projects/" + args.id + "/follow";
	}
	function fulfillmentPrivateApiPartnerDashboardPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/dashboard/fulfillment";
	}
	function importPrivateApiExternalCampaignsPath() {
	  return "/private_api/external_campaigns/import";
	}
	function invitePrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/invite";
	}
	function markRefundedPrivateApiCampaignContributionPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/contributions/" + args.id + "/mark_refunded";
	}
	function mePrivateApiCredentialsPath() {
	  return "/private_api/me";
	}
	function newPrivateApiAccountPath() {
	  return "/private_api/accounts/new";
	}
	function newPrivateApiExternalCampaignPath() {
	  return "/private_api/external_campaigns/new";
	}
	function newPrivateApiProjectsPath(args) {
	  return "/private_api/projects/" + args.id + "/new";
	}
	function previewPrivateApiCampaignUpdatesPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/updates/preview";
	}
	function privateApiAccountPath(args) {
	  return "/private_api/accounts/" + args.id;
	}
	function privateApiAccountAddressPath(args) {
	  return "/private_api/accounts/" + args.accountId + "/addresses/" + args.id;
	}
	function privateApiAccountAddressesPath(args) {
	  return "/private_api/accounts/" + args.accountId + "/addresses";
	}
	function privateApiAccountContributionPath(args) {
	  return "/private_api/accounts/" + args.accountId + "/contributions/" + args.id;
	}
	function privateApiAccountCreditCardPath(args) {
	  return "/private_api/accounts/" + args.accountId + "/credit_cards/" + args.id;
	}
	function privateApiAccountCreditCardsPath(args) {
	  return "/private_api/accounts/" + args.accountId + "/credit_cards";
	}
	function privateApiAccountsPath() {
	  return "/private_api/accounts";
	}
	function privateApiAdminAccountRolePath(args) {
	  return "/private_api/admin/account_roles/" + args.id;
	}
	function privateApiAdminCampaignStrategistPath(args) {
	  return "/private_api/admin/campaign_strategist/" + args.id;
	}
	function privateApiAdminCampaignStrategistIndexPath() {
	  return "/private_api/admin/campaign_strategist";
	}
	function privateApiAdminProjectSponsorPath(args) {
	  return "/private_api/admin/projects/" + args.id + "/project_sponsors/" + args.projectSponsorId;
	}
	function privateApiAdminProjectSponsorsPath(args) {
	  return "/private_api/admin/projects/" + args.id + "/project_sponsors";
	}
	function privateApiAdminSearchAnythingIndexPath() {
	  return "/private_api/admin/search_anything";
	}
	function privateApiAdminSponsorPath(args) {
	  return "/private_api/admin/sponsors/" + args.id;
	}
	function privateApiAdminSponsorLevelsPath() {
	  return "/private_api/admin/sponsor_levels";
	}
	function privateApiAdminSponsorsPath() {
	  return "/private_api/admin/sponsors";
	}
	function privateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id;
	}
	function privateApiCampaignBankAccountsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/bank_accounts";
	}
	function privateApiCampaignBankInfosPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/bank_infos";
	}
	function privateApiCampaignCollectionPath(args) {
	  return "/private_api/campaign_collections/" + args.id;
	}
	function privateApiCampaignCollectionCampaignsPath(args) {
	  return "/private_api/campaign_collections/" + args.campaignCollectionId + "/campaigns";
	}
	function privateApiCampaignCollectionsPath() {
	  return "/private_api/campaign_collections";
	}
	function privateApiCampaignComingSoonPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/coming_soon";
	}
	function privateApiCampaignCommentPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/comments/" + args.id;
	}
	function privateApiCampaignCommentsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/comments";
	}
	function privateApiCampaignContributionPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/contributions/" + args.id;
	}
	function privateApiCampaignContributionsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/contributions";
	}
	function privateApiCampaignDisbursementsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/disbursements";
	}
	function privateApiCampaignEditorPerkPath(args) {
	  return "/private_api/campaign_editor/" + args.campaignEditorCampaignId + "/perks/" + args.id;
	}
	function privateApiCampaignEditorPerksPath(args) {
	  return "/private_api/campaign_editor/" + args.campaignEditorCampaignId + "/perks";
	}
	function privateApiCampaignEmailSubscribersPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/email_subscribers";
	}
	function privateApiCampaignFundsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/funds";
	}
	function privateApiCampaignGalleryPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/gallery";
	}
	function privateApiCampaignIdentityVerificationPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/identity_verification";
	}
	function privateApiCampaignOrderPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/orders/" + args.id;
	}
	function privateApiCampaignOrdersPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/orders";
	}
	function privateApiCampaignPayoutRecordsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/payout_records";
	}
	function privateApiCampaignPerkItemPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/perk_items/" + args.id;
	}
	function privateApiCampaignPerkItemsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/perk_items";
	}
	function privateApiCampaignPerksPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/perks";
	}
	function privateApiCampaignPledgesPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/pledges";
	}
	function privateApiCampaignSubscribePath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/subscribe";
	}
	function privateApiCampaignUpdatePath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/updates/" + args.id;
	}
	function privateApiCampaignUpdatesPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/updates";
	}
	function privateApiCampaignsPath() {
	  return "/private_api/campaigns";
	}
	function privateApiCommandCenterAnalyticsPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/analytics";
	}
	function privateApiCommandCenterCountriesPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/countries";
	}
	function privateApiCommandCenterDomainsPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/domains";
	}
	function privateApiCommandCenterFundsPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/funds";
	}
	function privateApiCommandCenterPerksPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/perks";
	}
	function privateApiCommandCenterReferrersPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/referrers";
	}
	function privateApiCommandCenterStatsPath(args) {
	  return "/private_api/command_center/" + args.commandCenterId + "/stats";
	}
	function privateApiContactsPath() {
	  return "/private_api/contacts";
	}
	function privateApiEmailContactsPath() {
	  return "/private_api/email_contacts";
	}
	function privateApiExperimentPath(args) {
	  return "/private_api/experiments/" + args.id;
	}
	function privateApiExperimentsFetchAndUpdatePath() {
	  return "/private_api/experiments/fetch_and_update";
	}
	function privateApiExplorePath() {
	  return "/private_api/explore";
	}
	function privateApiExploreCollectionsPath() {
	  return "/private_api/explore/collections";
	}
	function privateApiExploreStatsPath() {
	  return "/private_api/explore/stats";
	}
	function privateApiExternalCampaignPath(args) {
	  return "/private_api/external_campaigns/" + args.id;
	}
	function privateApiExternalCampaignsPath() {
	  return "/private_api/external_campaigns";
	}
	function privateApiFacebookCountPath(args) {
	  return "/private_api/facebook_count/" + args.id;
	}
	function privateApiFbDynamicProductAdPath(args) {
	  return "/private_api/fb_dynamic_product_ads/" + args.id;
	}
	function privateApiFbDynamicProductAdsPath() {
	  return "/private_api/fb_dynamic_product_ads";
	}
	function privateApiFundraiserDashboardDisbursementInfoPath(args) {
	  return "/private_api/fundraiser/" + args.fundraiserId + "/dashboard/disbursement_info";
	}
	function privateApiHomePath() {
	  return "/private_api/home";
	}
	function privateApiHomePerksPath() {
	  return "/private_api/home/perks";
	}
	function privateApiHomeSlotsPath() {
	  return "/private_api/home/slots";
	}
	function privateApiJobStatusPath(args) {
	  return "/private_api/job_statuses/" + args.id;
	}
	function privateApiPartnerTeamInvitationPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/team_invitations/" + args.id;
	}
	function privateApiPartnerTeamInvitationsPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/team_invitations";
	}
	function privateApiPartnerTeamMemberPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/team_members/" + args.id;
	}
	function privateApiPaymentsCreditCardsNewPath() {
	  return "/private_api/payments/credit_cards/new";
	}
	function privateApiPaymentsCreditCardsSavedPath() {
	  return "/private_api/payments/credit_cards/saved";
	}
	function privateApiPaymentsGuestSignupsPath() {
	  return "/private_api/payments/guest_signups";
	}
	function privateApiPaymentsPaypalPath() {
	  return "/private_api/payments/paypal";
	}
	function privateApiPaymentsProjectPath(args) {
	  return "/private_api/payments/projects/" + args.id;
	}
	function privateApiProfilePath(args) {
	  return "/private_api/profiles/" + args.id;
	}
	function privateApiProfileCommentsPath(args) {
	  return "/private_api/profiles/" + args.profileId + "/comments";
	}
	function privateApiProfileEmailPreferencesPath(args) {
	  return "/private_api/profiles/" + args.profileId + "/email_preferences";
	}
	function privateApiProfileFacebooksPath(args) {
	  return "/private_api/profiles/" + args.profileId + "/facebooks";
	}
	function privateApiProfileLinkedinsPath(args) {
	  return "/private_api/profiles/" + args.profileId + "/linkedins";
	}
	function privateApiProjectsPath(args) {
	  return "/private_api/projects/" + args.id;
	}
	function privateApiProjectsAutomaticFacebookPostsPath(args) {
	  return "/private_api/projects/" + args.id + "/automatic_facebook_posts";
	}
	function privateApiProjectsCampaignMessagesPath(args) {
	  return "/private_api/projects/" + args.id + "/campaign_messages";
	}
	function privateApiSearchPath() {
	  return "/private_api/search";
	}
	function privateApiSimpleCampaignPath(args) {
	  return "/private_api/simple_campaigns/" + args.id;
	}
	function productStagesPrivateApiAdminProjectPath(args) {
	  return "/private_api/admin/projects/" + args.id + "/product_stages";
	}
	function projectTodoItemsPrivateApiProjectsPath(args) {
	  return "/private_api/projects/" + args.id + "/todo_items/" + args.itemName;
	}
	function promotePrivateApiPartnerTeamMemberPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/team_members/" + args.id + "/promote";
	}
	function publishPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/publish";
	}
	function publishPrivateApiExternalCampaignPath(args) {
	  return "/private_api/external_campaigns/" + args.id + "/publish";
	}
	function publishPrivateApiSimpleCampaignPath(args) {
	  return "/private_api/simple_campaigns/" + args.id + "/publish";
	}
	function recommendationsPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/recommendations";
	}
	function refundPrivateApiCampaignContributionPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/contributions/" + args.id + "/refund";
	}
	function resendConfirmationEmailPrivateApiAccountPath(args) {
	  return "/private_api/accounts/" + args.id + "/resend_confirmation_email";
	}
	function resendConfirmationEmailPrivateApiCampaignOrderPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/orders/" + args.id + "/resend_confirmation_email";
	}
	function resendPrivateApiPartnerTeamInvitationPath(args) {
	  return "/private_api/partners/" + args.partnerId + "/team_invitations/" + args.id + "/resend";
	}
	function scheduleNextPostDatePrivateApiProjectsAutomaticFacebookPostsPath(args) {
	  return "/private_api/projects/" + args.id + "/automatic_facebook_posts/schedule_next_post_date";
	}
	function searchPrivateApiTagsPath() {
	  return "/private_api/tags/search";
	}
	function sendAllConfirmationEmailsPrivateApiCampaignOrdersPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/orders/send_all_confirmation_emails";
	}
	function sendEmailPrivateApiContactsPath() {
	  return "/private_api/contacts/send_email";
	}
	function sendPreviewPrivateApiCampaignUpdatesPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/updates/send_preview";
	}
	function setFeePrivateApiExternalCampaignPath(args) {
	  return "/private_api/external_campaigns/" + args.id + "/set_fee";
	}
	function setTopPerkPrivateApiCampaignEditorPerksPath(args) {
	  return "/private_api/campaign_editor/" + args.campaignEditorCampaignId + "/perks/set_top_perk";
	}
	function splitBucketPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/split_bucket";
	}
	function submitForApprovalPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/submit_for_approval";
	}
	function toggleSpamPrivateApiCampaignCommentsPath(args) {
	  return "/private_api/campaigns/" + args.campaignId + "/comments/toggle_spam";
	}
	function unfollowPrivateApiCampaignCollectionPath(args) {
	  return "/private_api/campaign_collections/" + args.id + "/unfollow";
	}
	function unfollowPrivateApiProjectsPath(args) {
	  return "/private_api/projects/" + args.id + "/unfollow";
	}
	function updateCloudinaryImagePrivateApiProfilePath(args) {
	  return "/private_api/profiles/" + args.id + "/update_cloudinary_image";
	}
	function updateDeadlinePrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/update_deadline";
	}
	function verifyPaypalPrivateApiCampaignPath(args) {
	  return "/private_api/campaigns/" + args.id + "/verify_paypal";
	}

/***/ },
/* 56 */,
/* 57 */,
/* 58 */,
/* 59 */,
/* 60 */,
/* 61 */,
/* 62 */,
/* 63 */,
/* 64 */,
/* 65 */
/***/ function(module, exports) {

	/*
		MIT License http://www.opensource.org/licenses/mit-license.php
		Author Tobias Koppers @sokra
	*/
	// css base code, injected by the css-loader
	module.exports = function() {
		var list = [];
	
		// return the list of modules as css string
		list.toString = function toString() {
			var result = [];
			for(var i = 0; i < this.length; i++) {
				var item = this[i];
				if(item[2]) {
					result.push("@media " + item[2] + "{" + item[1] + "}");
				} else {
					result.push(item[1]);
				}
			}
			return result.join("");
		};
	
		// import a list of modules into the list
		list.i = function(modules, mediaQuery) {
			if(typeof modules === "string")
				modules = [[null, modules, ""]];
			var alreadyImportedModules = {};
			for(var i = 0; i < this.length; i++) {
				var id = this[i][0];
				if(typeof id === "number")
					alreadyImportedModules[id] = true;
			}
			for(i = 0; i < modules.length; i++) {
				var item = modules[i];
				// skip already imported module
				// this implementation is not 100% perfect for weird media query combinations
				//  when a module is imported multiple times with different media queries.
				//  I hope this will never occur (Hey this way we have smaller bundles)
				if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
					if(mediaQuery && !item[2]) {
						item[2] = mediaQuery;
					} else if(mediaQuery) {
						item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
					}
					list.push(item);
				}
			}
		};
		return list;
	};


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

	/*
		MIT License http://www.opensource.org/licenses/mit-license.php
		Author Tobias Koppers @sokra
	*/
	var stylesInDom = {},
		memoize = function(fn) {
			var memo;
			return function () {
				if (typeof memo === "undefined") memo = fn.apply(this, arguments);
				return memo;
			};
		},
		isOldIE = memoize(function() {
			return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
		}),
		getHeadElement = memoize(function () {
			return document.head || document.getElementsByTagName("head")[0];
		}),
		singletonElement = null,
		singletonCounter = 0,
		styleElementsInsertedAtTop = [];
	
	module.exports = function(list, options) {
		if(false) {
			if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
		}
	
		options = options || {};
		// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
		// tags it will allow on a page
		if (typeof options.singleton === "undefined") options.singleton = isOldIE();
	
		// By default, add <style> tags to the bottom of <head>.
		if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
	
		var styles = listToStyles(list);
		addStylesToDom(styles, options);
	
		return function update(newList) {
			var mayRemove = [];
			for(var i = 0; i < styles.length; i++) {
				var item = styles[i];
				var domStyle = stylesInDom[item.id];
				domStyle.refs--;
				mayRemove.push(domStyle);
			}
			if(newList) {
				var newStyles = listToStyles(newList);
				addStylesToDom(newStyles, options);
			}
			for(var i = 0; i < mayRemove.length; i++) {
				var domStyle = mayRemove[i];
				if(domStyle.refs === 0) {
					for(var j = 0; j < domStyle.parts.length; j++)
						domStyle.parts[j]();
					delete stylesInDom[domStyle.id];
				}
			}
		};
	}
	
	function addStylesToDom(styles, options) {
		for(var i = 0; i < styles.length; i++) {
			var item = styles[i];
			var domStyle = stylesInDom[item.id];
			if(domStyle) {
				domStyle.refs++;
				for(var j = 0; j < domStyle.parts.length; j++) {
					domStyle.parts[j](item.parts[j]);
				}
				for(; j < item.parts.length; j++) {
					domStyle.parts.push(addStyle(item.parts[j], options));
				}
			} else {
				var parts = [];
				for(var j = 0; j < item.parts.length; j++) {
					parts.push(addStyle(item.parts[j], options));
				}
				stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
			}
		}
	}
	
	function listToStyles(list) {
		var styles = [];
		var newStyles = {};
		for(var i = 0; i < list.length; i++) {
			var item = list[i];
			var id = item[0];
			var css = item[1];
			var media = item[2];
			var sourceMap = item[3];
			var part = {css: css, media: media, sourceMap: sourceMap};
			if(!newStyles[id])
				styles.push(newStyles[id] = {id: id, parts: [part]});
			else
				newStyles[id].parts.push(part);
		}
		return styles;
	}
	
	function insertStyleElement(options, styleElement) {
		var head = getHeadElement();
		var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
		if (options.insertAt === "top") {
			if(!lastStyleElementInsertedAtTop) {
				head.insertBefore(styleElement, head.firstChild);
			} else if(lastStyleElementInsertedAtTop.nextSibling) {
				head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
			} else {
				head.appendChild(styleElement);
			}
			styleElementsInsertedAtTop.push(styleElement);
		} else if (options.insertAt === "bottom") {
			head.appendChild(styleElement);
		} else {
			throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
		}
	}
	
	function removeStyleElement(styleElement) {
		styleElement.parentNode.removeChild(styleElement);
		var idx = styleElementsInsertedAtTop.indexOf(styleElement);
		if(idx >= 0) {
			styleElementsInsertedAtTop.splice(idx, 1);
		}
	}
	
	function createStyleElement(options) {
		var styleElement = document.createElement("style");
		styleElement.type = "text/css";
		insertStyleElement(options, styleElement);
		return styleElement;
	}
	
	function createLinkElement(options) {
		var linkElement = document.createElement("link");
		linkElement.rel = "stylesheet";
		insertStyleElement(options, linkElement);
		return linkElement;
	}
	
	function addStyle(obj, options) {
		var styleElement, update, remove;
	
		if (options.singleton) {
			var styleIndex = singletonCounter++;
			styleElement = singletonElement || (singletonElement = createStyleElement(options));
			update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
			remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
		} else if(obj.sourceMap &&
			typeof URL === "function" &&
			typeof URL.createObjectURL === "function" &&
			typeof URL.revokeObjectURL === "function" &&
			typeof Blob === "function" &&
			typeof btoa === "function") {
			styleElement = createLinkElement(options);
			update = updateLink.bind(null, styleElement);
			remove = function() {
				removeStyleElement(styleElement);
				if(styleElement.href)
					URL.revokeObjectURL(styleElement.href);
			};
		} else {
			styleElement = createStyleElement(options);
			update = applyToTag.bind(null, styleElement);
			remove = function() {
				removeStyleElement(styleElement);
			};
		}
	
		update(obj);
	
		return function updateStyle(newObj) {
			if(newObj) {
				if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
					return;
				update(obj = newObj);
			} else {
				remove();
			}
		};
	}
	
	var replaceText = (function () {
		var textStore = [];
	
		return function (index, replacement) {
			textStore[index] = replacement;
			return textStore.filter(Boolean).join('\n');
		};
	})();
	
	function applyToSingletonTag(styleElement, index, remove, obj) {
		var css = remove ? "" : obj.css;
	
		if (styleElement.styleSheet) {
			styleElement.styleSheet.cssText = replaceText(index, css);
		} else {
			var cssNode = document.createTextNode(css);
			var childNodes = styleElement.childNodes;
			if (childNodes[index]) styleElement.removeChild(childNodes[index]);
			if (childNodes.length) {
				styleElement.insertBefore(cssNode, childNodes[index]);
			} else {
				styleElement.appendChild(cssNode);
			}
		}
	}
	
	function applyToTag(styleElement, obj) {
		var css = obj.css;
		var media = obj.media;
	
		if(media) {
			styleElement.setAttribute("media", media)
		}
	
		if(styleElement.styleSheet) {
			styleElement.styleSheet.cssText = css;
		} else {
			while(styleElement.firstChild) {
				styleElement.removeChild(styleElement.firstChild);
			}
			styleElement.appendChild(document.createTextNode(css));
		}
	}
	
	function updateLink(linkElement, obj) {
		var css = obj.css;
		var sourceMap = obj.sourceMap;
	
		if(sourceMap) {
			// http://stackoverflow.com/a/26603875
			css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
		}
	
		var blob = new Blob([css], { type: "text/css" });
	
		var oldSrc = linkElement.href;
	
		linkElement.href = URL.createObjectURL(blob);
	
		if(oldSrc)
			URL.revokeObjectURL(oldSrc);
	}


/***/ },
/* 67 */,
/* 68 */,
/* 69 */,
/* 70 */,
/* 71 */,
/* 72 */,
/* 73 */,
/* 74 */,
/* 75 */,
/* 76 */,
/* 77 */,
/* 78 */,
/* 79 */,
/* 80 */,
/* 81 */,
/* 82 */,
/* 83 */,
/* 84 */,
/* 85 */,
/* 86 */,
/* 87 */,
/* 88 */,
/* 89 */,
/* 90 */,
/* 91 */,
/* 92 */,
/* 93 */,
/* 94 */,
/* 95 */,
/* 96 */,
/* 97 */,
/* 98 */,
/* 99 */,
/* 100 */,
/* 101 */,
/* 102 */,
/* 103 */,
/* 104 */,
/* 105 */,
/* 106 */,
/* 107 */,
/* 108 */,
/* 109 */,
/* 110 */,
/* 111 */,
/* 112 */,
/* 113 */,
/* 114 */,
/* 115 */,
/* 116 */,
/* 117 */,
/* 118 */
/***/ function(module, exports) {

	'use strict';
	
	(function () {
	  'use strict';
	
	  angular.module('angulartics.igg.theta', ['angulartics', 'utils']).config(['$analyticsProvider', function ($analyticsProvider) {
	    $analyticsProvider.registerEventTrack(function (action, properties) {
	      this.$inject(function (gogoEvents, split) {
	
	        var thetaProperties = {};
	
	        // TODO: change back to:
	        // var event_name = properties.name;
	        var event_name = properties.name || action;
	
	        // Google Analytics sends an eventType that is not needed by Theta so we omit it here.
	        properties = _.omit(properties, ['eventType', 'name']);
	
	        // map Angular camelCase properties into snake case
	        // perhaps we should move this to the gogoEvents.captureEvent function
	        _.each(properties, function (value, key) {
	          var newKey = key.replace(/\.?([A-Z]+)/g, function (x, y) {
	            return "_" + y.toLowerCase();
	          }).replace(/^_/, "");
	          thetaProperties[newKey] = value;
	        });
	
	        // Google Analytics also manipulates the properties object and always adds a property.category: 'Event'
	        // if there is none
	        gogoEvents.captureEvent(event_name, thetaProperties);
	      });
	    });
	  }]);
	})();

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = utilsModule;
	
	var _svgSpriteInjector = __webpack_require__(120);
	
	var _svgSpriteInjector2 = _interopRequireDefault(_svgSpriteInjector);
	
	var _iggAffixDirectives = __webpack_require__(121);
	
	var _iggAffixDirectives2 = _interopRequireDefault(_iggAffixDirectives);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var requireables = [//$ ls ancillary/utils/*service.* | xargs -I {} basename {} '.js'
	'ckeditor-directive', 'cl-image-directive', 'cl-uploadable-image-directive', 'clamp-directive', 'compare-to-directive', 'copy-url-directive', 'cute-flash-directive', 'dotdotdot-directive', 'enter-keypress-directive', 'fb-tracking-pixel-directive', 'analytics/ga-content-group-directive', 'analytics/ga-raw-directive', 'igg-popover-directive', 'igg-project-card-directive', 'ignore-dirty-directive', 'individual-avatar-directive', 'info-message-directive', 'insights-contrib-awareness-message-notification-directive', 'konami-directive', 'link-to-unless-directive', 'pagination-directive', 'share-banner-directive', 'shared-economics-interest-message-notification-directive', 'shipping-info-directive', 'simple-image-upload-directive', 'split-directive', 'svg-icon-directive', 'page-title-section-directive', 'cloudinary-image-upload-directive', 'browser-factory', 'cache-factory', 'categories-factory', 'cloudinary-factory', 'csrf-token-factory', 'currencies-factory', 'data-store-factory', 'embedly-factory', 'embeddable-link-html-factory', 'fb-factory', 'flash-factory', 'froogaloop-factory', 'analytics/gogo-events-service', 'analytics/gamp-service', 'analytics/theta-service', 'gogo-location-factory', 'gplus-factory', 'igg-ckeditor-config-factory', 'igg-external-factory', 'job-status-api-factory', 'job-status-poller-factory', 'project-card-factory', 'regions-factory', 'split-factory', 'signup-factory', 'starts-with-factory', 'strip-tags-factory', 'twitter-factory', 'typeahead-utils-factory', 'user-service-config-factory', 'youtube-factory', 'abbrev-num-fmt-filter', 'char-counter-filter', 'currency-display-filter', 'html-wrapped-filter', 'igg-currency-filter', 'search-expression-filter', 'truncate-filter']; /* global console */
	
	
	function configureUtils(utils) {
	  utils.config(['$logProvider', '$httpProvider', function ($logProvider, $httpProvider) {
	    $logProvider.debugEnabled(false); // Set to true to see debug statements
	
	    var csrfToken = $('meta[name=csrf-token]').attr('content');
	    $httpProvider.defaults.headers.post['X-CSRF-Token'] = csrfToken;
	    $httpProvider.defaults.headers.put['X-CSRF-Token'] = csrfToken;
	    $httpProvider.defaults.headers.patch['X-CSRF-Token'] = csrfToken;
	    $httpProvider.defaults.headers.delete = { 'X-CSRF-Token': csrfToken };
	  }]).config(['$httpProvider', function ($httpProvider) {
	    $httpProvider.interceptors.push('cache');
	  }]).run(['$window', 'gon', function ($window, gon) {
	    $window.igg = $window.igg || {};
	    $window.igg.externalService = $window.igg.externalService || function (callback) {
	      callback.apply(this, arguments);
	    };
	    if (gon.domain !== 'generosity') {
	      (function () {
	        var assetUrl = $('link[rel=svg]').attr('href');
	        if (assetUrl) {
	          $window.igg.externalService(function () {
	            return (0, _svgSpriteInjector2.default)(assetUrl);
	          });
	        }
	      })();
	    }
	  }]).constant('lodash', window._).constant('_', window._).value('gon', window.gon || {}).value('ga', function () {
	    window.ga.apply(this, arguments);
	  }).value('fbq', function () {
	    window.fbq.apply(this, arguments);
	  }).value('CKEDITOR', window.CKEDITOR).constant('I18nRails', window.I18n).constant('serverHost', window.location.host);
	}
	
	function utilsModule(utils) {
	  configureUtils(utils);
	  var requireContext = __webpack_require__(122);
	  requireables.forEach(function (requireable) {
	    var moduleName = _.camelCase(requireable.replace(/-(service|directive|filter|factory)$/, '').split('/').slice(-1).pop());
	    var invokeMatch = requireable.match(/(service|directive|filter|factory)/);
	    if (!invokeMatch) {
	      console.warn('No service, directory, or factory inferred from ' + requireable);
	    }
	    var invokeFnName = invokeMatch[0];
	    var required = requireContext('./' + requireable + '.js').default;
	    var fn = utils[invokeFnName];
	    fn(moduleName, required);
	  });
	
	  (0, _iggAffixDirectives2.default)(utils);
	
	  utils.factory('i18n', __webpack_require__(170).default).factory('EmailSubscriber', __webpack_require__(156).default).factory('dateService', __webpack_require__(154).default).factory('pledgeShareService', __webpack_require__(200).default).factory('iggCKEditorConfig', __webpack_require__(173).default).service('userService', __webpack_require__(222).default).service('countriesService', __webpack_require__(147).default).service('backupBeforeUnloadService', __webpack_require__(132).default).service('safeGa', __webpack_require__(130).default).factory('iggAirbrake', __webpack_require__(171).default).directive('gaEventOn', __webpack_require__(129).default).directive('eventOn', __webpack_require__(124).default).directive('i18n', __webpack_require__(169).default).filter('htmlCharCounter', __webpack_require__(167).default).factory('$exceptionHandler', ["iggAirbrake", function (iggAirbrake) {
	    return iggAirbrake.handle;
	  }]);
	}

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

	;(function(window, document) {
		'use strict';
	
		var isSvg = document.createElementNS && document.createElementNS( 'http://www.w3.org/2000/svg', 'svg' ).createSVGRect;
		var localStorage = 'localStorage' in window && window['localStorage'] !== null ? window.localStorage : false;
	
		function svgSpriteInjector(source, opts) {
			var file;
			opts = opts || {};
	
			if (source instanceof Node) {
				file = source.getAttribute('data-svg-sprite');
				opts.revision = source.getAttribute('data-svg-sprite-revision') || opts.revision;
			} else if (typeof source === 'string') {
				file = source;
			}
	
			if (isSvg) {
				if (file) {
					injector(file, opts);
				} else {
					console.error('svg-sprite-injector: undefined sprite filename!');
				}
			} else {
				console.error('svg-sprite-injector require ie9 or greater!');
			}
		};
	
		function injector(filepath, opts) {
			var name = 'injectedSVGSprite' + filepath,
				revision = opts.revision,
				request;
	
			// localStorage cache
			if (revision !== undefined && localStorage && localStorage[name + 'Rev'] == revision) {
				return injectOnLoad(localStorage[name]);
			}
	
			// Async load
			request = new XMLHttpRequest();
			request.open('GET', filepath, true);
			request.onreadystatechange = function (e) {
				var data;
	
				if (request.readyState === 4 && request.status >= 200 && request.status < 400) {
					injectOnLoad(data = request.responseText);
					if (revision !== undefined && localStorage) {
						localStorage[name] = data;
						localStorage[name + 'Rev'] = revision;
					}
				}
			};
			request.send();
		}
	
		function injectOnLoad(data) {
			if (data) {
				if (document.body) {
					injectData(data);
				} else {
					document.addEventListener('DOMContentLoaded', injectData.bind(null, data));
				}
			}
		}
	
		function injectData(data) {
			var body = document.body;
			body.insertAdjacentHTML('afterbegin', data);
			if (body.firstChild.tagName === 'svg') {
				body.firstChild.style.display = 'none';
			}
		}
	
		if (true) {
			module.exports = svgSpriteInjector;
		} else {
			window.svgSpriteInjector = svgSpriteInjector;
		}
	
	} (window, document));


/***/ },
/* 121 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = iggAffixDirectives;
	function iggAffixDirectives(utilities) {
	  utilities.directive('iggAffixContainer', function () {
	    return {
	      restrict: 'A',
	      controller: ['$scope', '$element', function (scope, element) {
	        this.element = element;
	      }]
	    };
	  });
	
	  utilities.directive('iggAffix', ['$window', '$interval', 'lodash', function ($window, $interval, _) {
	    return {
	      restrict: 'A',
	      scope: {
	        showOnScroll: "@iggAffixShowOnScroll",
	        minParentHeight: "@iggAffixMinParentHeight"
	      },
	      require: '^iggAffixContainer',
	      link: function link(scope, element, attrs, iggAffixContainerCtrl) {
	        var win = angular.element($window),
	            affixed;
	
	        scope.containerEl = iggAffixContainerCtrl.element;
	
	        function checkPosition() {
	          scope.offsetTop = scope.containerEl.offset().top;
	          scope.offsetBottom = scope.offsetTop + scope.containerEl.height();
	
	          var scrollTop = $window.pageYOffset,
	              scrollBottom = scrollTop + element.outerHeight();
	
	          if (scrollTop >= scope.offsetTop && scrollBottom <= scope.offsetBottom) {
	            affixed = true;
	            element.css({ position: 'fixed', top: '0px', bottom: '' });
	          } else if (scrollBottom > scope.offsetBottom) {
	            affixed = true;
	            var bottom = win.height() - (scope.offsetBottom - scrollTop);
	            element.css({ position: 'fixed', bottom: bottom + 'px', top: '' });
	          } else {
	            affixed = false;
	            element.css({ position: '', bottom: '', top: '' });
	          }
	
	          var isParentTallEnough = _.isUndefined(scope.minParentHeight) || scope.containerEl.height() >= scope.minParentHeight;
	
	          element.toggle(isParentTallEnough && (affixed || !scope.showOnScroll));
	          element.toggleClass('igg-affix', affixed);
	        }
	
	        win.bind('resize', checkPosition);
	        win.bind('scroll', checkPosition);
	        win.bind('click', checkPosition);
	
	        $interval(checkPosition, 100);
	      }
	    };
	  }]);
	}

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

	var map = {
		"./abbrev-num-fmt-filter.js": 123,
		"./analytics/event-directive.js": 124,
		"./analytics/ga-content-group-directive.js": 125,
		"./analytics/ga-raw-directive.js": 126,
		"./analytics/gamp-service.js": 127,
		"./analytics/gogo-events-service.js": 128,
		"./analytics/google-analytics-directive.js": 129,
		"./analytics/safe-ga-service.js": 130,
		"./analytics/theta-service.js": 131,
		"./backup-before-unload-service.js": 132,
		"./browser-factory.js": 133,
		"./cache-factory.js": 134,
		"./categories-factory.js": 135,
		"./char-counter-filter.js": 136,
		"./ckeditor-directive.js": 137,
		"./cl-image-directive.js": 138,
		"./cl-uploadable-image-directive.js": 139,
		"./clamp-directive.js": 141,
		"./cloudinary-factory.js": 143,
		"./cloudinary-image-upload-directive.js": 144,
		"./compare-to-directive.js": 145,
		"./copy-url-directive.js": 146,
		"./countries-service.js": 147,
		"./csrf-token-factory.js": 148,
		"./currencies-factory.js": 149,
		"./currency-display-filter.js": 150,
		"./cute-flash-directive.js": 151,
		"./data-store-factory.js": 153,
		"./date-factory.js": 154,
		"./dotdotdot-directive.js": 155,
		"./email-subscriber-factory.js": 156,
		"./embeddable-link-html-factory.js": 157,
		"./embedly-factory.js": 158,
		"./enter-keypress-directive.js": 159,
		"./fb-factory.js": 160,
		"./fb-tracking-pixel-directive.js": 161,
		"./flash-factory.js": 163,
		"./froogaloop-factory.js": 164,
		"./gogo-location-factory.js": 165,
		"./gplus-factory.js": 166,
		"./html-char-counter-filter.js": 167,
		"./html-wrapped-filter.js": 168,
		"./i18n-directive.js": 169,
		"./i18n-factory.js": 170,
		"./igg-airbrake-service.js": 171,
		"./igg-ckeditor-config-factory.js": 173,
		"./igg-currency-filter.js": 175,
		"./igg-external-factory.js": 176,
		"./igg-popover-directive.js": 177,
		"./igg-project-card-directive.js": 181,
		"./ignore-dirty-directive.js": 182,
		"./individual-avatar-directive.js": 183,
		"./info-message-directive.js": 185,
		"./insights-contrib-awareness-message-notification-directive.js": 187,
		"./job-status-api-factory.js": 189,
		"./job-status-poller-factory.js": 190,
		"./konami-directive.js": 191,
		"./link-to-unless-directive.js": 192,
		"./page-title-section-directive.js": 194,
		"./pagination-directive.js": 198,
		"./pledge-share-service.js": 200,
		"./project-card-factory.js": 201,
		"./regions-factory.js": 202,
		"./search-expression-filter.js": 203,
		"./share-banner-directive.js": 204,
		"./shared-economics-interest-message-notification-directive.js": 206,
		"./shipping-info-directive.js": 208,
		"./signup-factory.js": 210,
		"./simple-image-upload-directive.js": 211,
		"./split-directive.js": 213,
		"./split-factory.js": 214,
		"./starts-with-factory.js": 215,
		"./strip-tags-factory.js": 216,
		"./svg-icon-directive.js": 217,
		"./truncate-filter.js": 218,
		"./twitter-factory.js": 219,
		"./typeahead-utils-factory.js": 220,
		"./user-service-config-factory.js": 221,
		"./user-service.js": 222,
		"./youtube-factory.js": 223
	};
	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;
	webpackContext.id = 122;


/***/ },
/* 123 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = abbrevNumFmt;
	/*@ngInject*/
	function abbrevNumFmt() {
	  return function (input) {
	    var num_after_decimal = 1;
	    var million = 1000000;
	    var thousand = 1000;
	
	    if (input >= million) {
	      if (input / million >= 100 || input % million < 50000) {
	        num_after_decimal = 0;
	      }
	      return (input / million).toFixed(num_after_decimal) + 'M';
	    } else if (input >= thousand) {
	      if (input / thousand >= 100 || input % 1000 < 50) {
	        num_after_decimal = 0;
	      }
	      return (input / thousand).toFixed(num_after_decimal) + 'k';
	    } else if (input === null) {
	      return '';
	    } else if (input <= 0) {
	      return '0';
	    } else {
	      return '' + input;
	    }
	  };
	}

/***/ },
/* 124 */
/***/ function(module, exports) {

	'use strict';
	
	event.$inject = ["gogoEvents"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = event;
	/*@ngInject*/
	function event(gogoEvents) {
	  function isCommand(element) {
	    return ['a:', 'button:', 'button:button', 'button:submit', 'input:button', 'input:submit'].indexOf(element.tagName.toLowerCase() + ':' + (element.type || '')) >= 0;
	  }
	
	  function inferEventName(element) {
	    if (isCommand(element)) return element.innerText || element.value;
	    return element.id || element.name || element.tagName;
	  }
	
	  function isProperty(name) {
	    return name.substr(0, 5) === 'event' && ['On', 'If', 'Tags', 'Name'].indexOf(name.substr(5)) === -1;
	  }
	
	  function extractPropertyName(name) {
	    // slice off the 'event' prefix, lower case first letter
	    return name.slice(5, 6).toLowerCase() + name.slice(6);
	  }
	
	  return {
	    restrict: 'A',
	    link: function link($scope, $element, $attrs) {
	
	      var eventType = $attrs.eventOn;
	      var trackingData = {};
	
	      angular.forEach($attrs.$attr, function (attr, name) {
	        if (isProperty(name)) {
	          trackingData[extractPropertyName(name)] = $attrs[name];
	          $attrs.$observe(name, function (value) {
	            trackingData[extractPropertyName(name)] = value;
	          });
	        }
	      });
	
	      angular.element($element[0]).bind(eventType, function ($event) {
	        var eventName = $attrs.eventName || inferEventName($element[0]);
	
	        if ($attrs.eventIf) {
	          if (!$scope.$eval($attrs.eventIf)) {
	            return; // Cancel this event if we don't pass the event-if condition
	          }
	        }
	        // Allow components to pass through an expression that gets merged on to the event properties
	        // eg. event-tags='{{eventTags()}}'
	        if ($attrs.eventTags) {
	          angular.extend(trackingData, $scope.$eval($attrs.eventTags));
	        }
	
	        gogoEvents.track(_.merge(trackingData, { thetaName: eventName }));
	      });
	    }
	  };
	}

/***/ },
/* 125 */
/***/ function(module, exports) {

	'use strict';
	
	gaContentGroup.$inject = ["ga"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = gaContentGroup;
	/*@ngInject*/
	function gaContentGroup(ga) {
	  return {
	    scope: {},
	    link: function link(scope, element, attrs) {
	      // TODO EVENTS: id=qua6f fixtype=infra subsystem=analytics . maybe move gaContentGroup to superproperties
	      ga('set', 'contentGroup1', attrs.gaContentGroup);
	    }
	  };
	}

/***/ },
/* 126 */
/***/ function(module, exports) {

	'use strict';
	
	gaRaw.$inject = ["$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = gaRaw;
	/*@ngInject*/
	function gaRaw($window) {
	  return {
	    scope: {
	      'gaRawOn': '@',
	      'gaRaw': '@'
	    },
	    link: function link($scope, $element, $attrs) {
	      $element.on($attrs.gaRawOn || 'click', function () {
	        var args = $scope.$eval($scope.gaRaw);
	        $window.ga.apply(ga, args);
	      });
	    }
	  };
	}

/***/ },
/* 127 */
/***/ function(module, exports) {

	'use strict';
	
	gamp.$inject = ["ga", "$http", "iggAirbrake", "gogoEvents", "$cookies", "$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
	
	exports.default = gamp;
	/*@ngInject*/
	function gamp(ga, $http, iggAirbrake, gogoEvents, $cookies, $window) {
	  // Google Analytics Measurement Protocol
	  // https://developers.google.com/analytics/devguides/collection/protocol/v1/reference
	
	  var DEBUG_MISSING_GA_EVENTS = $window.location.search.indexOf('debug_missing_ga_events=1') > -1;
	
	  function debugMissingGaEventsLog() {
	    if (DEBUG_MISSING_GA_EVENTS) {
	      console.log('debugMissingGaEvents from gamp: ', arguments);
	    }
	  }
	
	  var service = {};
	
	  var endpoint = "https://www.google-analytics.com/collect";
	  var debugEndpoint = "https://www.google-analytics.com/debug/collect";
	
	  // http://stackoverflow.com/questions/1714786/querystring-encoding-of-a-javascript-object
	  function serialize(obj, prefix) {
	    var str = [];
	    for (var p in obj) {
	      if (obj.hasOwnProperty(p)) {
	        var k = prefix ? prefix + "[" + p + "]" : p,
	            v = obj[p];
	        str.push((typeof v === 'undefined' ? 'undefined' : _typeof(v)) == "object" ? serialize(v, k) : encodeURIComponent(k) + "=" + encodeURIComponent(v));
	      }
	    }
	    return str.join("&");
	  }
	
	  function couponName(campaign_title, perk_name, perk_is_secret) {
	    if (!perk_name) {
	      return 'No Perk';
	    }
	    return (perk_is_secret ? 'Secret Perk' : 'Perk') + ' | ' + campaign_title + ' | ' + perk_name;
	  }
	
	  service.enhancedEcommerce = {};
	
	  var requiredParams = {
	    t: 'pageview',
	    dh: document.location.hostname,
	    dt: window.document.title,
	    tid: 'UA-53458201-2', // Javascript GAMP
	    v: 1
	  };
	
	  function paramsForPurchaseFrom(analyticsData, googleAnalyticsData) {
	    var otherParams = {
	      dp: googleAnalyticsData.analytics_friendly_url // analytics friendly url /projects/art/my-awesome/payments/1/thank_you
	    };
	    var transactionParams = {
	      ti: analyticsData.id,
	      tr: analyticsData.amt_gross,
	      ta: analyticsData.campaign_title
	    };
	    var productParams = { pa: "purchase" };
	    // http://stackoverflow.com/questions/30483756/enhanced-e-commerce-with-measurement-protocol
	    // apparently the number of products in the current transaction, not too much GA documentation on this
	    var productIndex = 1; //Product index must be a positive integer between 1 and 200, inclusive.
	    productParams["pr" + productIndex + "id"] = analyticsData.campaign_id;
	    //productParams["pr" + productIndex + "va"] = ???
	    productParams["pr" + productIndex + "nm"] = analyticsData.campaign_title;
	
	    return _.merge(otherParams, transactionParams, productParams);
	  }
	
	  function paramsForAddFrom(analyticsData, googleAnalyticsData) {
	    var otherParams = {
	      cd1: 'Contributor',
	      dp: googleAnalyticsData.analytics_friendly_url
	    };
	    var productParams = { pa: "add" };
	    var productIndex = 1; //Product index must be a positive integer between 1 and 200, inclusive.
	    productParams["pr" + productIndex + "id"] = analyticsData.campaign.id;
	    productParams["pr" + productIndex + "ca"] = analyticsData.campaign.category && analyticsData.campaign.category.name;
	    productParams["pr" + productIndex + "br"] = analyticsData.campaign.owner_type;
	    productParams["pr" + productIndex + "va"] = analyticsData.campaign.funding_type;
	    productParams["pr" + productIndex + "nm"] = analyticsData.campaign.title;
	    productParams["pr" + productIndex + "qt"] = 1;
	    productParams["pr" + productIndex + "cc"] = couponName(analyticsData.campaign.title, analyticsData.perk.name, analyticsData.perk.isSecret);
	    return _.merge(otherParams, productParams);
	  }
	
	  // sample responses from GA debug endpoint
	
	  // sample good response
	  //"hitParsingResult": [
	  //  {
	  //    "hit": "/debug/collect?...",
	  //    "parserMessage": [],
	  //    "valid": true
	  //  }
	  //],
	  //  "parserMessage": [
	  //  {
	  //    "description": "Found 1 hit in the request.",
	  //    "messageType": "INFO"
	  //  }
	  //]
	
	  // sample bad response
	  //{
	  //  "hitParsingResult": [ {
	  //  "valid": false,
	  //  "parserMessage": [ {
	  //    "messageType": "ERROR",
	  //    "description": "A value is required for parameter 'v'. Please see http://goo.gl/a8d4RP#v for details.",
	  //    "messageCode": "VALUE_REQUIRED",
	  //    "parameter": "v"
	  //  } ],
	  //  "hit": "/debug/collect?..."
	  //} ],
	  //  "parserMessage": [ {
	  //  "messageType": "INFO",
	  //  "description": "Found 1 hit in the request."
	  //} ]
	  //}
	  function handleDebugEndpointResponse(response) {
	    var message;
	    if (response && response.code == 200) {
	      var responseData = response && response.data;
	      var parsingResult = responseData && responseData.hitParsingResult && responseData.hitParsingResult[0];
	
	      var isValid = parsingResult && parsingResult.valid;
	      var isValidText = isValid ? 'valid' : 'exception';
	
	      var parsingMessageLengthMessage = '';
	      try {
	        var parsingMessage = parsingResult.parserMessage;
	        if (parsingMessage.length > 0) {
	          parsingMessageLengthMessage = 'parserMessage ' + parsingMessage.length;
	          gogoEvents.track({
	            thetaName: 'gamp_debug',
	            debugData: response.data
	          }, {
	            skipGa: true
	          });
	        }
	      } catch (err) {}
	
	      message = '[ga debug] ' + response.code + ' ' + isValidText + ' ' + parsingMessageLengthMessage;
	      iggAirbrake.logError(message, Object.assign(_.pick(response, ['data', 'status', 'statusText', 'response']), {
	        url: response.config.url,
	        config: response.config
	      }));
	    } else if (response && response.code) {
	      message = '[ga debug] ' + response.code;
	      iggAirbrake.logError(message, Object.assign(_.pick(response, ['data', 'status', 'statusText', 'response']), {
	        url: response.config.url,
	        config: response.config
	      }));
	    }
	  }
	
	  service.enhancedEcommerce.productPurchase = function (analyticsData, googleAnalyticsData) {
	    var customParams = paramsForPurchaseFrom(analyticsData, googleAnalyticsData);
	    var clientId = $cookies.get('_ga').substring('GA1.2.'.length);
	    var trackerId = 'UA-53458201-7'; // Javascript No GA GAMP
	    var data = _.merge(customParams, requiredParams, { cid: clientId, tid: trackerId });
	    var encoded_data = serialize(data);
	
	    debugMissingGaEventsLog('issuing GET request w/GAMP Protocol to /collect, not GA dependent', endpoint + "?" + encoded_data);
	    $http.get(endpoint + "?" + encoded_data);
	
	    ga(function (tracker) {
	      var customParams = paramsForPurchaseFrom(analyticsData, googleAnalyticsData);
	      var clientId = tracker.get('clientId');
	      var data = _.merge(customParams, requiredParams, { cid: clientId });
	      var encoded_data = serialize(data);
	
	      debugMissingGaEventsLog('issuing GET request w/GAMP Protocol to /collect, GA dependent', endpoint + "?" + encoded_data);
	      $http.get(endpoint + "?" + encoded_data);
	
	      debugMissingGaEventsLog('issuing GET request w/GAMP Protocol to /debug/collect, GA dependent', debugEndpoint + "?" + encoded_data);
	      $http.get(debugEndpoint + "?" + encoded_data).then(handleDebugEndpointResponse, handleDebugEndpointResponse);
	
	      data.tid = 'UA-53458201-3'; // Javascript-Ruby GAMP
	      debugMissingGaEventsLog('calling: gogoEvents.track with thetaName: gamp_ruby_product_purchase');
	      gogoEvents.track({
	        thetaName: 'gamp_ruby_product_purchase',
	        projectId: analyticsData.campaign_id,
	        pledgeId: analyticsData.id,
	        trackerId: 'UA-53458201-3', // Indiegogo Staging / Interim/temp production (2), for testing after staging
	        payload: serialize(data),
	        userAgent: navigator.userAgent
	      }, {
	        skipGa: true
	      });
	    });
	  };
	
	  service.enhancedEcommerce.productAdd = function (analyticsData, googleAnalyticsData) {
	    var customParams = paramsForAddFrom(analyticsData, googleAnalyticsData);
	    ga(function (tracker) {
	      var clientId = tracker.get('clientId');
	      var data = _.merge(customParams, requiredParams, { cid: clientId });
	      var encoded_data = serialize(data);
	      $http.get(endpoint + "?" + encoded_data);
	
	      data.tid = 'UA-53458201-3'; // Javascript-Ruby GAMP
	      gogoEvents.track({
	        thetaName: 'gamp_ruby_product_add',
	        payload: serialize(data),
	        userAgent: navigator.userAgent
	      }, {
	        skipGa: true
	      });
	    });
	  };
	
	  return service;
	}

/***/ },
/* 128 */
/***/ function(module, exports) {

	'use strict';
	
	gogoEvents.$inject = ["$http", "$q", "$timeout", "gon", "ga", "theta", "iggAirbrake", "split", "_"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = gogoEvents;
	/*@ngInject*/
	
	function gogoEvents($http, $q, $timeout, gon, ga, theta, iggAirbrake, split, _) {
	  var service = {};
	  var defaultAnnotations = ['request_remote_ip', 'request_user_agent', 'request_host', 'source_bot', 'source_locale', 'source_country', 'source_region', 'source_browser', 'source_mobile', 'visitor_id', 'session_id'];
	  var DEFAULT_TIMEOUT = 2000;
	
	  service._overrideSubmit = false;
	
	  var defaultEventTags = function defaultEventTags() {
	    var tags = _.clone(gon.default_event_tags) || {};
	    if (split.appVersion !== '') {
	      tags = _.merge(tags, { app_version: split.appVersion });
	    }
	    return tags;
	  };
	
	  service.captureEvent = function (eventName, properties) {
	    if (typeof eventName === 'undefined') {
	      throw new Error('Theta event name is undefined. You must specify an analytics-name on your DOM element.');
	    }
	    var eventProperties = angular.extend(defaultEventTags(), properties);
	
	    return theta.send({
	      event_types: [eventName],
	      event_data: eventProperties,
	      annotations: defaultAnnotations
	    }, defaultEventTags()).then(function () {
	      return true;
	    }, function () {
	      return false;
	    });
	  };
	
	  service.track = function () {
	    var properties = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
	
	    var _ref = arguments.length <= 1 || arguments[1] === undefined ? { timeout: DEFAULT_TIMEOUT, skipGa: false } : arguments[1];
	
	    var timeout = _ref.timeout;
	    var skipGa = _ref.skipGa;
	
	    var options = { timeout: timeout, skipGa: skipGa };
	    var promises = {};
	    promises.ga = sendGaEvent(properties, options);
	    promises.theta = sendThetaEvent(properties, options);
	    return $q.all(promises);
	  };
	
	  var sendGaEvent = function sendGaEvent(properties, options) {
	    var deferred = $q.defer();
	
	    if (options.skipGa) {
	      deferred.resolve();
	      return deferred.promise;
	    }
	
	    if (properties && (!properties.gaEventCategory || !properties.gaEventAction)) {
	      var context = { properties: properties, options: options };
	      throwAnalyticsException('Google Analytics requires both a gaEventCategory and a gaEventAction.', context);
	      deferred.resolve();
	      return deferred.promise;
	    }
	
	    var eventOptions = {
	      eventCategory: properties.gaEventCategory,
	      eventAction: properties.gaEventAction,
	      eventLabel: properties.gaEventLabel,
	      eventValue: properties.gaEventValue
	    };
	
	    var listOfErrors = validateGaEvent(properties);
	    if (listOfErrors.length !== 0) {
	      throwAnalyticsException(listOfErrors.join('\n'), { properties: properties, options: options });
	    }
	
	    if (ga && ga.loaded) {
	      ga('send', 'event', _.extend(eventOptions, { hitCallback: deferred.resolve }));
	    } else {
	      deferred.resolve();
	    }
	
	    $timeout(deferred.resolve('timeout'), options.timeout);
	
	    return deferred.promise;
	  };
	
	  var submitThetaHttp = function submitThetaHttp(thetaName, thetaProperties, defaultAnnotations, deferred) {
	    theta.send({
	      event_types: [thetaName],
	      event_data: thetaProperties,
	      annotations: defaultAnnotations
	    }, defaultEventTags()).finally(function () {
	      deferred.resolve();
	    });
	  };
	
	  var sendThetaEvent = function sendThetaEvent(properties, options) {
	    var deferred = $q.defer();
	
	    properties = stripEmptyValuedKeys(properties);
	
	    if (!properties.thetaName) {
	      var context = { properties: properties, options: options };
	      throwAnalyticsException('Theta event name is undefined. You must specify a theta name in your track properties.', context);
	      deferred.resolve();
	      return deferred.promise;
	    }
	
	    var listOfInvalidations = validateThetaEvent(properties);
	    if (listOfInvalidations.length !== 0) {
	      throwAnalyticsException(listOfInvalidations.join('\n'), { properties: properties, options: options });
	    }
	
	    var thetaName = properties.thetaName;
	    var inputProperties = convertKeysToSnakeCase(_.omit(properties, 'thetaName'));
	    var thetaProperties = _.extend(defaultEventTags(), inputProperties);
	
	    if (service._overrideSubmit) {
	      submitThetaHttp(thetaName, thetaProperties, defaultAnnotations, deferred);
	    } else {
	      igg.externalService(function () {
	        submitThetaHttp(thetaName, thetaProperties, defaultAnnotations, deferred);
	      });
	    }
	
	    $timeout(deferred.resolve('timeout'), options.timeout);
	
	    return deferred.promise;
	  };
	
	  var validateThetaEvent = function validateThetaEvent(properties) {
	    return errorList(thetaValidations(properties));
	  };
	  var validateGaEvent = function validateGaEvent(properties) {
	    return errorList(gaValidations(properties));
	  };
	
	  var errorList = function errorList(validations) {
	    return validations.filter(function (validation) {
	      return validation.condition === true;
	    }).map(function (validation) {
	      return validation.message;
	    });
	  };
	
	  var throwAnalyticsException = function throwAnalyticsException(errorMessage, context) {
	    var exception = new Error('[invalid event] ' + errorMessage);
	    iggAirbrake.handle(exception, null, { errorMessage: errorMessage, context: context });
	  };
	
	  var hasUnderscore = function hasUnderscore(string) {
	    return (/_/g.test(string)
	    );
	  };
	
	  var keysWithUnderscores = function keysWithUnderscores(properties) {
	    return Object.keys(properties).filter(hasUnderscore);
	  };
	
	  var hasKeysWithUnderscores = function hasKeysWithUnderscores(properties) {
	    return keysWithUnderscores(properties).length > 0;
	  };
	
	  var convertKeysToSnakeCase = function convertKeysToSnakeCase(properties) {
	    return _.reduce(properties, function (result, value, key) {
	      result[_.snakeCase(key)] = value;
	      return result;
	    }, {});
	  };
	
	  var isEmpty = function isEmpty(object) {
	    if (_.isFinite(object)) {
	      return false;
	    }
	
	    if (typeof object === 'boolean') {
	      return false;
	    }
	
	    return !object;
	  };
	
	  var stripEmptyValuedKeys = function stripEmptyValuedKeys(properties) {
	    return _.reduce(properties, function (result, value, key) {
	      if (!isEmpty(value)) {
	        result[key] = value;
	      }
	      return result;
	    }, {});
	  };
	
	  var sharedValidations = function sharedValidations(properties) {
	    return [{
	      condition: hasKeysWithUnderscores(properties),
	      message: 'Event properties cannot be formatted in snake_case. Offending properties include: [ ' + keysWithUnderscores(properties).join(", ") + ' ]'
	    }];
	  };
	
	  var gaValidations = function gaValidations(properties) {
	    return [{
	      condition: properties.gaEventValue && !Number.isInteger(properties.gaEventValue),
	      message: 'GA value must be an integer.'
	    }].concat(sharedValidations(properties));
	  };
	
	  var thetaValidations = function thetaValidations(properties) {
	    return [{
	      condition: properties.hasOwnProperty('projectId') && !Number.isInteger(properties.projectId),
	      message: 'Theta Event projectId must be an integer.'
	    }, {
	      condition: properties.hasOwnProperty('pledgeId') && !Number.isInteger(properties.pledgeId),
	      message: 'Theta Event pledgeId must be an integer.'
	    }, {
	      condition: properties.hasOwnProperty('perkId') && !Number.isInteger(properties.perkId),
	      message: 'Theta Event perkId must be an integer.'
	    }, {
	      condition: properties.hasOwnProperty('accountId') && !Number.isInteger(properties.accountId),
	      message: 'Theta Event accountId must be an integer.'
	    }].concat(sharedValidations(properties));
	  };
	
	  return service;
	}

/***/ },
/* 129 */
/***/ function(module, exports) {

	'use strict';
	
	googleAnalytics.$inject = ["ga"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = googleAnalytics;
	/*@ngInject*/
	function googleAnalytics(ga) {
	  function sendGAEvent(scope, ga, target) {
	    var params = ['category', 'action', 'label', 'value'];
	    var gaArgs = ['send', 'event'];
	
	    var perform = scope.performIf();
	    if (perform === undefined) {
	      // if not present, perform unconditionally
	      perform = true;
	    }
	    if (!perform) {
	      // skip submitting this event because criteria aren't right
	      return;
	    }
	
	    // Add Category, Action, Label, and Value GA parameters, in this order.
	    // Stop looking and proceed when any of the four are not present.
	    for (var i = 0; i < params.length; i++) {
	      var val = scope.$eval(params[i]);
	
	      if (!val) {
	        // skip if parameter not present
	        break;
	      }
	
	      gaArgs.push(val);
	    }
	
	    // only send events that have a category (3rd argument)
	    if (gaArgs.length > 2) {
	      ga.apply(target, gaArgs);
	    }
	  }
	
	  return {
	    restrict: 'A',
	    scope: {
	      category: '@gaEventCategory',
	      action: '@gaEventAction',
	      label: '@gaEventLabel',
	      value: '@gaEventValue',
	      performIf: '&gaEventIf'
	    },
	    link: function link(scope, element, attrs) {
	      // jQuery DOM event like click, blur, hover
	      var onEvent = attrs.gaEventOn.toLowerCase();
	      if (onEvent === 'load') {
	        sendGAEvent(scope, ga, this);
	      } else {
	        element.bind(onEvent, function () {
	          sendGAEvent(scope, ga, this);
	        });
	      }
	    }
	  };
	}

/***/ },
/* 130 */
/***/ function(module, exports) {

	'use strict';
	
	safeGa.$inject = ["ga", "$timeout"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = safeGa;
	/*@ngInject*/
	// TODO EVENTS: id=ooc6b fixtype=infra subsystem=analytics . safeGa functionality stays but is less exposed
	function safeGa(ga, $timeout) {
	  this.sendEvent = function (action, category, label, callback) {
	    if (typeof callback === 'undefined') {
	      callback = angular.noop;
	    }
	
	    // wrap the callback https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#hitCallback
	    var alreadyCalled = false;
	    function callMeOnce() {
	      if (alreadyCalled) return;
	      alreadyCalled = true;
	      callback();
	    }
	
	    // make sure the callback gets triggered even when ga is not loaded
	    if (typeof ga !== 'undefined' && ga.loaded) {
	      ga('send', 'event', action, category, label, {
	        hitCallback: callMeOnce
	      });
	    } else {
	      callMeOnce();
	    }
	
	    // make sure callback happens after 2 seconds even if something with ga went catastrophically wrong
	    $timeout(callMeOnce, 2000);
	  };
	}

/***/ },
/* 131 */
/***/ function(module, exports) {

	'use strict';
	
	theta.$inject = ["$http", "$cookies", "$log", "$q"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = theta;
	/*@ngInject*/
	function theta($http, $cookies, $log, $q) {
	  var service = {};
	
	  //event = {
	  //  event_types: [string1, string2, ...],
	  //  event_data: {key1: value1, key2: value2, ...},
	  //  annotations: [string1, string2, ... ]
	  //};
	  service.send = function (event, eventTags) {
	    var deferred = $q.defer();
	    var thetaName = event.event_types[0];
	    logThetaEvent(thetaName, event.event_data, eventTags);
	    $http.post('/analytics/events/batch', { events: [event] }).then(function () {
	      logThetaSuccess(thetaName);
	      deferred.resolve('success');
	    }, function () {
	      logThetaFailure(thetaName);
	      deferred.reject('failure');
	    });
	    return deferred.promise;
	  };
	
	  var logThetaEvent = function logThetaEvent(thetaName, properties, eventTags) {
	    logAnalytics(function () {
	      console.group("Sending Theta Event: " + thetaName);
	      console.group("Input Properties");
	      var inputProperties = stripDefaultEventTags(properties, eventTags);
	      _.forEach(inputProperties, function (value, key) {
	        $log.info("%c" + key, "font-weight:bold;", "\n" + value);
	      });
	      console.groupEnd();
	      console.groupCollapsed("Default Events and Annotations");
	      _.forEach(eventTags, function (value, key) {
	        $log.info("%c" + key, "font-weight:bold;", "\n" + value);
	      });
	      console.groupEnd();
	      console.groupEnd();
	    });
	  };
	
	  var stripDefaultEventTags = function stripDefaultEventTags(properties, eventTags) {
	    return _.reduce(properties, function (result, value, key) {
	      if (!_.keys(eventTags).includes(key)) {
	        result[key] = value;
	      }
	      return result;
	    }, {});
	  };
	
	  var logThetaFailure = function logThetaFailure(thetaName) {
	    logAnalytics(function () {
	      $log.info("%cTheta Event: " + thetaName + " - Failed", "color: Red");
	    });
	  };
	
	  var logThetaSuccess = function logThetaSuccess(thetaName) {
	    logAnalytics(function () {
	      $log.info("%cTheta Event: " + thetaName + " - Succeeded", "color: Green");
	    });
	  };
	
	  var analyticsDebug = function analyticsDebug() {
	    return $cookies.get('analytics_debug') === '1';
	  };
	
	  var logAnalytics = function logAnalytics(func) {
	    if (analyticsDebug()) {
	      func();
	    }
	  };
	
	  return service;
	}

/***/ },
/* 132 */
/***/ function(module, exports) {

	'use strict';
	
	backupBeforeUnloadService.$inject = ["_", "$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = backupBeforeUnloadService;
	/*@ngInject*/
	function backupBeforeUnloadService(_, $window) {
	  var self = this;
	  var _objects = {};
	  var storageElement = angular.element('#contribution-backup input');
	
	  function setStorageElement(element) {
	    storageElement = element;
	  }
	
	  function saveJson(json) {
	    return storageElement.val(json);
	  }
	
	  function loadJson() {
	    return storageElement.val();
	  }
	
	  function saveState() {
	    var current = {};
	
	    _.each(_.keys(_objects), function (objectName) {
	      var objectToBackup;
	      if (typeof _objects[objectName] === 'function') {
	        objectToBackup = _objects[objectName]();
	      } else {
	        objectToBackup = _objects[objectName];
	      }
	
	      if (!_.isUndefined(objectToBackup.campaign)) {
	        //TODO: make backupservice smart enough to not save certain unwanted attributes.
	        delete objectToBackup.campaign;
	      }
	
	      current[objectName] = objectToBackup;
	    });
	    var json = JSON.stringify(current);
	    self.saveJson(json);
	  }
	
	  function restoreStateIfSaved(objectName, object) {
	    try {
	      var data = JSON.parse(self.loadJson());
	      var objectToRestore = data[objectName];
	      if (!_.isUndefined(objectToRestore.campaign)) {
	        //TODO: make backupservice smart enough to not save certain unwanted attributes.
	        delete objectToRestore.campaign;
	      }
	      _.merge(object, objectToRestore);
	      return true;
	    } catch (e) {
	      return false;
	    }
	  }
	
	  function register(obj) {
	    _.merge(_objects, obj);
	  }
	
	  function pointerRegister(obj) {
	    for (var key in obj) {
	      _objects[key] = obj[key];
	    }
	  }
	
	  _.merge(self, {
	    objects: function objects() {
	      return _objects;
	    },
	    setStorageElement: setStorageElement,
	    saveState: saveState,
	    saveJson: saveJson,
	    loadJson: loadJson,
	    restoreStateIfSaved: restoreStateIfSaved,
	    pointerRegister: pointerRegister,
	    register: register
	  });
	
	  $window.onbeforeunload = function () {
	    self.saveState();
	  };
	}

/***/ },
/* 133 */
/***/ function(module, exports) {

	"use strict";
	
	browser.$inject = ["$window", "$cookies", "gon"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = browser;
	/*@ngInject*/
	function browser($window, $cookies, gon) {
	  return {
	    isDesktopPlus: function isDesktopPlus() {
	      return $window.innerWidth >= 1280;
	    },
	    isDesktop: function isDesktop() {
	      return $window.innerWidth >= 1002;
	    },
	    isTabletPlus: function isTabletPlus() {
	      return $window.innerWidth >= 768;
	    },
	    isMobile: function isMobile() {
	      return $window.innerWidth < 768;
	    },
	    isMobilePortrait: function isMobilePortrait() {
	      return $window.innerWidth < 480;
	    },
	    height: function height() {
	      return $window.innerHeight;
	    },
	    onResize: function onResize(callback) {
	      angular.element($window).on("resize", callback);
	    },
	    onLoad: function onLoad(callback) {
	      angular.element($window).on("load", callback);
	    },
	    isAndroid: function isAndroid() {
	      var ua = $window.navigator.userAgent.toLowerCase();
	      return ua.indexOf("android") > -1;
	    },
	    isIOS: function isIOS() {
	      return !!window.navigator.userAgent.match(/iPhone|iPod|iPad/g);
	    },
	    isMacOS: function isMacOS() {
	      return $window.navigator.userAgent.includes('Mac OS');
	    },
	    isIphone: function isIphone() {
	      return !!($window.navigator.userAgent.match(/iPhone|iPod/g) && !$window.navigator.userAgent.match(/iPad/g));
	    },
	    isEmbeddedInNativeMobileApp: function isEmbeddedInNativeMobileApp() {
	      return $cookies.get('embedded_in_native_mobile_app') === '1';
	    },
	    isNativeMobile: function isNativeMobile() {
	      return gon.is_native_mobile;
	    },
	    currentPath: function currentPath() {
	      return $window.location.pathname;
	    },
	    scrollToTop: function scrollToTop(element) {
	      var elementToScroll = element || angular.element('html,body');
	      elementToScroll.animate({ scrollTop: 0 });
	    },
	    currentHref: function currentHref() {
	      return $window.location.href;
	    },
	    redirectTo: function redirectTo(url) {
	      $window.location.href = url;
	    },
	    refreshPage: function refreshPage() {
	      $window.location.reload();
	    },
	    refreshWithoutParams: function refreshWithoutParams() {
	      $window.location = $window.location.pathname;
	    },
	    openTab: function openTab(url) {
	      $window.open(url, '_blank');
	    },
	    openWindow: function openWindow(url, name, options) {
	      options = options || {};
	      var width = options.width || 670;
	      var height = options.height || 400;
	      var size = 'width=' + width + ',height=' + height + ',' + 'top=' + (screen.height / 2 - height / 2) + ',' + 'left=' + (screen.width / 2 - width / 2);
	
	      $window.open(url, name, size);
	    },
	    close: function close() {
	      $window.close();
	    },
	
	    scrollY: function scrollY() {
	      return $window.pageYOffset;
	    },
	
	    onScroll: function onScroll(callback) {
	      angular.element($window).bind("scroll", function () {
	        /* callback with no arguments to prevent exposing the $window directly */
	        callback();
	      });
	    },
	    getDevicefromScreenSize: function getDevicefromScreenSize() {
	      if (this.isDesktop()) {
	        return 'desktop';
	      } else if (this.isTabletPlus()) {
	        return 'tablet';
	      } else if (this.isMobile()) {
	        return 'mobile';
	      }
	    }
	  };
	}

/***/ },
/* 134 */
/***/ function(module, exports) {

	'use strict';
	
	cache.$inject = ["serverHost", "URI", "$cookies", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = cache;
	/*@ngInject*/
	function cache(serverHost, URI, $cookies, i18n) {
	  function isRequestToCurrentServer(requestURL) {
	    var uri = new URI(requestURL);
	    return uri.is("relative") || uri.host() == serverHost;
	  }
	
	  var request = function request(config) {
	    if (isRequestToCurrentServer(config.url)) {
	      if ($cookies.get('has_account') == 'true') {
	        config.headers['X-Has-Account'] = 'true';
	      }
	      config.headers['X-Locale'] = i18n.locale;
	    }
	
	    return config;
	  };
	
	  return {
	    request: request
	  };
	}

/***/ },
/* 135 */
/***/ function(module, exports) {

	'use strict';
	
	categories.$inject = ["gon", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = categories;
	/*@ngInject*/
	function categories(gon, i18n) {
	  function CategoriesService(initialCategories) {
	    var categories;
	
	    this.setCategories = function (cats) {
	      categories = cats;
	      this.initializeI18n();
	    };
	
	    this.getCategories = function () {
	      return categories;
	    };
	
	    this.asOptions = function () {
	      return _.map(categories, function (category) {
	        return { value: category.id, text: category.name };
	      });
	    };
	
	    this.asUiSelectItems = function () {
	      this.initializeI18n();
	      return _.map(categories, function (category) {
	        return { value: category.id, text: category.name, label: category.label };
	      });
	    };
	
	    this.forId = function (id) {
	      return _.find(categories, { id: parseInt(id) });
	    };
	
	    this.initializeI18n = function () {
	      _.each(categories, function (category) {
	        category.label = i18n.t(category.slug);
	
	        if (i18n.locale === 'en') {
	          category.tagline = i18n.t('explorepage.taglines.' + category.slug);
	        } else {
	          category.tagline = i18n.t(category.slug);
	        }
	      });
	    };
	
	    this.setCategories(initialCategories);
	  }
	
	  return new CategoriesService(gon && gon.services && gon.services.categories || []);
	}

/***/ },
/* 136 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = charCounter;
	/*@ngInject*/
	function charCounter() {
	  return function (input, maxLength, delimiter) {
	    delimiter = delimiter ? " " + delimiter + " " : " / ";
	    var charsLeft = input ? maxLength - input.length : maxLength;
	    return charsLeft.toString() + delimiter + maxLength;
	  };
	}

/***/ },
/* 137 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (CKEDITOR, iggCKEditorConfig, $timeout, $q) {
	  return {
	    require: 'ngModel',
	    scope: {
	      onCkReady: '&'
	    },
	
	    /*
	     * most of this is borrowed from the angular-ckeditor project. the most
	     * important change is the actual creation of the editor. this directive
	     * gives us control over the exact configuration data, where the
	     * angular-ckeditor instance required a json object literal to be passed as
	     * an html attribute.
	     */
	    link: function link(scope, element, attrs, controller) {
	      var editor = CKEDITOR.replace(element[0], iggCKEditorConfig.defaultOptions);
	      var ready = $q.defer();
	
	      function editorReady() {
	        return ready.promise;
	      }
	
	      function onCkEvent(event, listener) {
	        editor.on(event, function () {
	          var args = arguments;
	          /*
	           * $timeout ensures that we call $apply in the background, and not
	           * during an active $apply cycle
	           */
	          $timeout(function () {
	            scope.$apply(function () {
	              listener.apply(null, args);
	            });
	          });
	        });
	      }
	
	      // Set editor data when view data change.
	      controller.$render = function () {
	        editorReady().then(function () {
	          editor.setData(controller.$viewValue || '', {
	            noSnapshot: true,
	            callback: function callback() {
	              editor.fire('updateSnapshot');
	            }
	          });
	        });
	      };
	
	      editorReady().then(function () {
	        // manually sync model on certain ckeditor events
	        ['change', 'saveSnapshot'].forEach(function (event) {
	          onCkEvent(event, function () {
	            controller.$setViewValue(editor.getData() || '');
	          });
	        });
	
	        // make ckeditor readonly when the element is readonly
	        editor.setReadOnly(!!attrs.readonly);
	        attrs.$observe('readonly', function (readonly) {
	          editor.setReadOnly(!!readonly);
	        });
	
	        /*
	         * invoke the onCkReady callback referenced in the element attributes
	         * the $timeout trick ensures this happens in the background, and not
	         * during an active $apply cycle
	         */
	        $timeout(function () {
	          iggCKEditorConfig.onReady(editor, scope.onCkReady(scope));
	        });
	      });
	
	      scope.$on('$destroy', function () {
	        editorReady().then(function () {
	          editor.destroy(false);
	        });
	      });
	
	      onCkEvent('instanceReady', function () {
	        ready.resolve(true);
	      });
	    }
	  };
	};

/***/ },
/* 138 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = clImage;
	/*@ngInject*/
	function clImage() {
	  return {
	    restrict: 'A',
	    scope: {
	      publicId: "=",
	      placeholderPath: "@",
	      width: '@',
	      height: '@',
	      crop: '@',
	      background: '@'
	    },
	
	    link: function link(scope, element) {
	      scope.$watch('publicId', function (newPublicId) {
	        if (newPublicId) {
	          element.webpify(_.extend({ 'width': scope.width, 'height': scope.height, 'crop': scope.crop, 'background': scope.background }, { 'src': newPublicId + '.jpg' }, { 'secure': true }));
	        } else if (scope.placeholderPath) {
	          element.attr('src', scope.placeholderPath);
	        }
	      });
	      scope.$on('imageReceived', function (event, imageModel) {
	        element.webpify(_.extend({ width: scope.width,
	          height: scope.height,
	          crop: scope.crop,
	          background: scope.background
	        }, { src: imageModel.public_id + '.jpg' }, { secure: true }));
	      });
	    }
	  };
	}

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

	"use strict";
	
	uploadableImage.$inject = ["i18n", "cloudinary", "$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = uploadableImage;
	/*@ngInject*/
	function uploadableImage(i18n, cloudinary, $window) {
	  return {
	    restrict: 'A',
	    scope: {
	      imageModel: "=",
	      missingImagePath: "@",
	      showDelete: '=',
	      showError: '=',
	      showUploadIcon: '=?',
	      dirtyOnUpload: '=',
	      width: '@',
	      height: '@',
	      crop: '@'
	    },
	    template: __webpack_require__(140),
	    link: function link(scope, element) {
	      scope.testOverride = $window.test_override;
	      if (typeof scope.showDelete === 'undefined') {
	        scope.showDelete = true;
	      }
	      if (typeof scope.showUploadIcon === 'undefined') {
	        scope.showUploadIcon = true;
	      }
	      scope.i18n = i18n;
	      scope.showSpinner = false;
	      scope.cloudinaryError = null;
	      scope.triggerFileUpload = function () {
	        element.find('.cloudinary-fileupload').trigger('click');
	      };
	      scope.setImage = function (imageJson) {
	        scope.imageModel = imageJson;
	        if (scope.dirtyOnUpload !== false) {
	          scope.$emit('setFormDirty');
	        }
	      };
	      scope.triggerUploadIfBlankImage = function () {
	        if (scope.imageModel === null) {
	          scope.triggerFileUpload();
	        }
	      };
	      scope.resetImageFile = function (clickEvent) {
	        scope.setImage(null);
	        if (clickEvent) clickEvent.stopPropagation();
	      };
	
	      var $dropZone = element.find("img");
	      cloudinary.forFileInput(element.find('.cloudinary-fileupload'), $dropZone).onUploadStart(function () {
	        scope.showSpinner = true;
	      }).onUploadComplete(function (result) {
	        if (result) {
	          result.publicId = result.public_id;
	          scope.setImage(result);
	          scope.$apply();
	        }
	        scope.cloudinaryError = null;
	        scope.showSpinner = false;
	      }).onUploadFail(function (response) {
	        scope.showSpinner = false;
	        if (response && response.files) {
	          var fileType = response.files[0].name.split('.').pop();
	          if (fileType && fileType != 'jpg' && fileType != 'png') {
	            scope.cloudinaryError = i18n.t('campaign_editor.misc.error.cloudinary_file_type');
	            return;
	          }
	        }
	        scope.cloudinaryError = i18n.t('campaign_editor.misc.error.cloudinary_generic');
	      });
	    }
	  };
	}

/***/ },
/* 140 */
/***/ function(module, exports) {

	module.exports = "<div class=\"image-container\" ng-click=\"triggerUploadIfBlankImage()\"\n     ng-class=\"{'not-empty': imageModel !== null, 'i-field-error': showError || cloudinaryError}\">\n  <div ng-if=\"imageModel == undefined && missingImagePath == undefined\" class=\"clImageUploader-placeholder\"><svg><use xlink:href=\"#icon-icon-create-photo\"></use></svg></div>\n  <img cl-image width=\"{{width}}\" height=\"{{height}}\" crop=\"{{crop}}\"\n       public-id=\"imageModel.publicId\" alt=\"{{i18n.t('upload_an_image')}}\"\n       placeholder-path=\"{{missingImagePath}}\"/>\n\n  <i class=\"i-fa-centered i-fa-gogenta fa fa-spinner fa-4x fa-spin\" ng-show=\"showSpinner\"></i>\n\n  <div ng-if=\"imageModel !== null\">\n    <a ng-if=\"showDelete\" ng-click=\"resetImageFile($event)\" class=\"miniBtnAction miniBtnAction--delete miniBtnTopRight\"><svg><use xlink:href=\"#icon-icon-close\"></use></svg></a>\n    <a ng-if=\"showUploadIcon\" ng-click=\"triggerFileUpload()\" class=\"miniBtnAction miniBtnAction--edit miniBtn2ndFromRight\"><svg><use xlink:href=\"#icon-icon-edit\"></use></svg></a>\n  </div>\n</div>\n\n<div class=\"i-uploader-button\" ng-show=\"imageModel === null || testOverride\">\n  <button type=\"button\" ng-click=\"triggerFileUpload()\" class=\"i-cta-1 btn-upload\">{{::i18n.t('campaign_editor.buttons.upload_an_image')}}</button>\n  <input class=\"cloudinary-fileupload\" name=\"file\" type=\"file\" data-cloudinary-field=\"image_id\"/>\n</div>\n<div class=\"i-error-text\" ng-show=\"cloudinaryError\">{{cloudinaryError}}</div>\n";

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function () {
	  return {
	    restrict: 'A',
	    scope: {
	      'clamp': '@'
	    },
	    link: function link($scope, elem, attrs) {
	      var lineLimit = $scope.clamp || 'auto';
	      (0, _clampJs2.default)(elem[0], { clamp: lineLimit });
	    }
	  };
	};
	
	var _clampJs = __webpack_require__(142);
	
	var _clampJs2 = _interopRequireDefault(_clampJs);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
	 * Clamp.js 0.7.0
	 *
	 * Copyright 2011-2013, Joseph Schmitt http://joe.sh
	 * Released under the WTFPL license
	 * http://sam.zoy.org/wtfpl/
	 */
	
	(function(root, factory) {
	  if (true) {
	    // AMD
	    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __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__));
	  } else if (typeof exports === 'object') {
	    // Node, CommonJS-like
	    module.exports = factory();
	  } else {
	    // Browser globals
	    root.$clamp = factory();
	  }
	}(this, function() {
	  /**
	   * Clamps a text node.
	   * @param {HTMLElement} element. Element containing the text node to clamp.
	   * @param {Object} options. Options to pass to the clamper.
	   */
	  function clamp(element, options) {
	    options = options || {};
	
	    var self = this,
	      win = window,
	      opt = {
	        clamp: options.clamp || 2,
	        useNativeClamp: typeof(options.useNativeClamp) != 'undefined' ? options.useNativeClamp : true,
	        splitOnChars: options.splitOnChars || ['.', '-', '–', '—', ' '], //Split on sentences (periods), hypens, en-dashes, em-dashes, and words (spaces).
	        animate: options.animate || false,
	        truncationChar: options.truncationChar || '…',
	        truncationHTML: options.truncationHTML
	      },
	
	      sty = element.style,
	      originalText = element.innerHTML,
	
	      supportsNativeClamp = typeof(element.style.webkitLineClamp) != 'undefined',
	      clampValue = opt.clamp,
	      isCSSValue = clampValue.indexOf && (clampValue.indexOf('px') > -1 || clampValue.indexOf('em') > -1),
	      truncationHTMLContainer;
	
	    if (opt.truncationHTML) {
	      truncationHTMLContainer = document.createElement('span');
	      truncationHTMLContainer.innerHTML = opt.truncationHTML;
	    }
	
	
	    // UTILITY FUNCTIONS __________________________________________________________
	
	    /**
	     * Return the current style for an element.
	     * @param {HTMLElement} elem The element to compute.
	     * @param {string} prop The style property.
	     * @returns {number}
	     */
	    function computeStyle(elem, prop) {
	      if (!win.getComputedStyle) {
	        win.getComputedStyle = function(el, pseudo) {
	          this.el = el;
	          this.getPropertyValue = function(prop) {
	            var re = /(\-([a-z]){1})/g;
	            if (prop == 'float') prop = 'styleFloat';
	            if (re.test(prop)) {
	              prop = prop.replace(re, function() {
	                return arguments[2].toUpperCase();
	              });
	            }
	            return el.currentStyle && el.currentStyle[prop] ? el.currentStyle[prop] : null;
	          };
	          return this;
	        };
	      }
	
	      return win.getComputedStyle(elem, null).getPropertyValue(prop);
	    }
	
	    /**
	     * Returns the maximum number of lines of text that should be rendered based
	     * on the current height of the element and the line-height of the text.
	     */
	    function getMaxLines(height) {
	      var availHeight = height || element.clientHeight,
	        lineHeight = getLineHeight(element);
	
	      return Math.max(Math.floor(availHeight / lineHeight), 0);
	    }
	
	    /**
	     * Returns the maximum height a given element should have based on the line-
	     * height of the text and the given clamp value.
	     */
	    function getMaxHeight(clmp) {
	      var lineHeight = getLineHeight(element);
	      return lineHeight * clmp;
	    }
	
	    /**
	     * Returns the line-height of an element as an integer.
	     */
	    function getLineHeight(elem) {
	      var lh = computeStyle(elem, 'line-height');
	      if (lh == 'normal') {
	        // Normal line heights vary from browser to browser. The spec recommends
	        // a value between 1.0 and 1.2 of the font size. Using 1.1 to split the diff.
	        lh = parseInt(computeStyle(elem, 'font-size')) * 1.2;
	      }
	      return parseInt(lh);
	    }
	
	
	    // MEAT AND POTATOES (MMMM, POTATOES...) ______________________________________
	    var splitOnChars = opt.splitOnChars.slice(0),
	      splitChar = splitOnChars[0],
	      chunks,
	      lastChunk;
	
	    /**
	     * Gets an element's last child. That may be another node or a node's contents.
	     */
	    function getLastChild(elem) {
	      //Current element has children, need to go deeper and get last child as a text node
	      if (elem.lastChild.children && elem.lastChild.children.length > 0) {
	        return getLastChild(Array.prototype.slice.call(elem.children).pop());
	      }
	      //This is the absolute last child, a text node, but something's wrong with it. Remove it and keep trying
	      else if (!elem.lastChild || !elem.lastChild.nodeValue || elem.lastChild.nodeValue === '' || elem.lastChild.nodeValue == opt.truncationChar) {
	        elem.lastChild.parentNode.removeChild(elem.lastChild);
	        return getLastChild(element);
	      }
	      //This is the last child we want, return it
	      else {
	        return elem.lastChild;
	      }
	    }
	
	    /**
	     * Removes one character at a time from the text until its width or
	     * height is beneath the passed-in max param.
	     */
	    function truncate(target, maxHeight) {
	      if (!maxHeight) {
	        return;
	      }
	
	      /**
	       * Resets global variables.
	       */
	      function reset() {
	        splitOnChars = opt.splitOnChars.slice(0);
	        splitChar = splitOnChars[0];
	        chunks = null;
	        lastChunk = null;
	      }
	
	      var nodeValue = target.nodeValue.replace(opt.truncationChar, '');
	
	      //Grab the next chunks
	      if (!chunks) {
	        //If there are more characters to try, grab the next one
	        if (splitOnChars.length > 0) {
	          splitChar = splitOnChars.shift();
	        }
	        //No characters to chunk by. Go character-by-character
	        else {
	          splitChar = '';
	        }
	
	        chunks = nodeValue.split(splitChar);
	      }
	
	      //If there are chunks left to remove, remove the last one and see if
	      // the nodeValue fits.
	      if (chunks.length > 1) {
	        // console.log('chunks', chunks);
	        lastChunk = chunks.pop();
	        // console.log('lastChunk', lastChunk);
	        applyEllipsis(target, chunks.join(splitChar));
	      }
	      //No more chunks can be removed using this character
	      else {
	        chunks = null;
	      }
	
	      //Insert the custom HTML before the truncation character
	      if (truncationHTMLContainer) {
	        target.nodeValue = target.nodeValue.replace(opt.truncationChar, '');
	        element.innerHTML = target.nodeValue + ' ' + truncationHTMLContainer.innerHTML + opt.truncationChar;
	      }
	
	      //Search produced valid chunks
	      if (chunks) {
	        //It fits
	        if (element.clientHeight <= maxHeight) {
	          //There's still more characters to try splitting on, not quite done yet
	          if (splitOnChars.length >= 0 && splitChar !== '') {
	            applyEllipsis(target, chunks.join(splitChar) + splitChar + lastChunk);
	            chunks = null;
	          }
	          //Finished!
	          else {
	            return element.innerHTML;
	          }
	        }
	      }
	      //No valid chunks produced
	      else {
	        //No valid chunks even when splitting by letter, time to move
	        //on to the next node
	        if (splitChar === '') {
	          applyEllipsis(target, '');
	          target = getLastChild(element);
	
	          reset();
	        }
	      }
	
	      //If you get here it means still too big, let's keep truncating
	      if (opt.animate) {
	        setTimeout(function() {
	          truncate(target, maxHeight);
	        }, opt.animate === true ? 10 : opt.animate);
	      } else {
	        return truncate(target, maxHeight);
	      }
	    }
	
	    function applyEllipsis(elem, str) {
	      elem.nodeValue = str + opt.truncationChar;
	    }
	
	
	    // CONSTRUCTOR ________________________________________________________________
	
	    if (clampValue == 'auto') {
	      clampValue = getMaxLines();
	    } else if (isCSSValue) {
	      clampValue = getMaxLines(parseInt(clampValue));
	    }
	
	    var clampedText;
	    if (supportsNativeClamp && opt.useNativeClamp) {
	      sty.overflow = 'hidden';
	      sty.textOverflow = 'ellipsis';
	      sty.webkitBoxOrient = 'vertical';
	      sty.display = '-webkit-box';
	      sty.webkitLineClamp = clampValue;
	
	      if (isCSSValue) {
	        sty.height = opt.clamp + 'px';
	      }
	    } else {
	      var height = getMaxHeight(clampValue);
	      if (height <= element.clientHeight) {
	        clampedText = truncate(getLastChild(element), height);
	      }
	    }
	
	    return {
	      'original': originalText,
	      'clamped': clampedText
	    };
	  }
	
	  return clamp;
	}));


/***/ },
/* 143 */
/***/ function(module, exports) {

	"use strict";
	
	cloudinary.$inject = ["gon"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = cloudinary;
	/*@ngInject*/
	function cloudinary(gon) {
	
	  var cloudinaryOptions = {};
	  if (gon && gon.services && gon.services.cloudinary) {
	    cloudinaryOptions = {
	      url: gon.services.cloudinary.data.url,
	      cloudName: gon.services.cloudinary.data.cloud_name,
	      formData: gon.services.cloudinary.data.form_data
	    };
	  }
	
	  return {
	    setCloudinaryOptions: function setCloudinaryOptions(options) {
	      cloudinaryOptions = options;
	    },
	    forFileInput: function forFileInput($fileInput, $dropzone) {
	      $fileInput.cloudinary_fileupload(angular.extend({ headers: { "X-Requested-With": "XMLHttpRequest" }, dropZone: $dropzone, pasteZone: $dropzone }, cloudinaryOptions));
	      return {
	        onUploadStart: function onUploadStart(callback) {
	          $fileInput.on('cloudinarystart', callback);
	          return this;
	        },
	        onUploadComplete: function onUploadComplete(callback) {
	          $fileInput.on('cloudinarydone', function (e, response) {
	            callback(response.result);
	          });
	          return this;
	        },
	        onUploadFail: function onUploadFail(callback) {
	          $fileInput.on('cloudinaryfail', function (e, response) {
	            callback(response);
	          });
	          return this;
	        }
	      };
	    }
	  };
	}

/***/ },
/* 144 */
/***/ function(module, exports) {

	"use strict";
	
	cloudinaryImageUploadDirective.$inject = ["cloudinary"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = cloudinaryImageUploadDirective;
	/*@ngInject*/
	
	function cloudinaryImageUploadDirective(cloudinary) {
	  return {
	    scope: {
	      onCompleteFn: "&onCompleteFn",
	      status: "=imageUploadStatus"
	    },
	    transclude: true,
	    template: '<div ng-transclude ng-click="status.loading || clickPhoto()"></div><input type="file" name="file" class="i-hide-offscreen" data-cloudinary-field="image_id" />',
	    link: function link(scope, element) {
	      var fileInput = element.find("input");
	      var fileUploader = cloudinary.forFileInput(fileInput, element);
	
	      fileUploader.onUploadStart(function () {
	        scope.status.loading = true;
	        scope.$apply();
	      }).onUploadComplete(function (result) {
	        scope.status.loading = false;
	        scope.status.publicId = result.public_id;
	        fileInput = element.find("input");
	        scope.onCompleteFn()(result);
	        scope.$apply();
	      }).onUploadFail(function () {
	        scope.status.loading = false;
	        fileInput = element.find("input");
	      });
	
	      scope.clickPhoto = function () {
	        fileInput.trigger('click');
	      };
	    }
	  };
	}

/***/ },
/* 145 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = compareTo;
	/*@ngInject*/
	function compareTo() {
	  return {
	    require: "ngModel",
	    scope: {
	      otherModelValue: "=compareTo"
	    },
	    link: function link(scope, element, attributes, ngModel) {
	
	      ngModel.$validators.compareTo = function (modelValue) {
	        return modelValue == scope.otherModelValue;
	      };
	
	      scope.$watch("otherModelValue", function () {
	        ngModel.$validate();
	      });
	    }
	  };
	}

/***/ },
/* 146 */
/***/ function(module, exports) {

	'use strict';
	
	copyUrl.$inject = ["$http", "gon", "i18n", "fb", "twitter", "gplus", "$timeout", "$window", "browser"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = copyUrl;
	/*@ngInject*/
	function copyUrl($http, gon, i18n, fb, twitter, gplus, $timeout, $window, browser) {
	
	  return {
	    restrict: 'A',
	    link: function link(scope, element, attrs) {
	      element.on('click', function () {
	        $window.prompt("Copy link, then click OK.", attrs.copyUrl);
	      });
	    }
	  };
	}

/***/ },
/* 147 */
/***/ function(module, exports) {

	"use strict";
	
	countriesService.$inject = ["lodash", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/*@ngInject*/
	function countriesService(lodash, i18n) {
	  var _ = lodash;
	  var localizedCountries = _.map(countries, function (country) {
	    return {
	      "country_code_alpha_2": country.alpha_2,
	      "country_code": 'CTRY_' + country.alpha_2,
	      "text": country.locales[i18n.locale || 'en'],
	      "common": _.include(country.tags, "common"),
	      "tags": country.tags,
	      "european": _.include(country.tags, "european_union")
	    };
	  });
	  var sortedCountries = _.sortBy(localizedCountries, function (country) {
	    return country.country_code_alpha_2 === 'US' ? '' : country.text;
	  });
	  var commonChoices = _.select(sortedCountries, function (country) {
	    return country.common;
	  });
	  var remainingChoices = _.select(sortedCountries, function (country) {
	    return !country.common;
	  });
	  var europeanCountries = _.select(sortedCountries, function (country) {
	    return country.european;
	  });
	
	  var self = this;
	  var divider = {
	    "country_code_alpha_2": null,
	    "text": "—",
	    ships_to: false,
	    isDisabled: true,
	    tags: ["divider"]
	  };
	
	  function all() {
	    return _.union(commonChoices, remainingChoices);
	  }
	
	  function asUiSelectItems(options) {
	    if (options && options.grouped) {
	      return all();
	    } else {
	      return _.union(commonChoices, [divider], remainingChoices);
	    }
	  }
	
	  function countryGrouping(item) {
	    return item.common ? i18n.t('country_groups.common') : i18n.t('country_groups.other');
	  }
	
	  function findByAlpha2(alpha2) {
	    return _.find(all(), function (country) {
	      return alpha2 === country.country_code_alpha_2;
	    });
	  }
	
	  function findByText(text) {
	    return _.find(all(), function (country) {
	      return country.text.toLowerCase() === text.toLowerCase();
	    });
	  }
	
	  function findByCode(code) {
	    return _.find(all(), function (country) {
	      return code === 'CTRY_' + country.country_code_alpha_2;
	    });
	  }
	
	  function findByTwoLetterCode(twoLetter) {
	    return findByCode('CTRY_' + twoLetter);
	  }
	
	  function europeanUnion() {
	    return _.map(europeanCountries, function (country) {
	      return country.country_code_alpha_2;
	    });
	  }
	
	  function alpha2InEU(code) {
	    return !!_.contains(this.europeanUnion(), code);
	  }
	
	  function alphabetized() {
	    return _.sortBy(localizedCountries, function (ctry) {
	      return ctry.text;
	    });
	  }
	
	  function zipCodeLabelKey(countryCode) {
	    if (countryCode === '' || countryCode === 'CTRY_US') {
	      return 'zip_code';
	    } else if (countryCode === 'CTRY_CA') {
	      return 'postal_code';
	    } else {
	      var postalCodeOverrides = {
	        CTRY_GB: 'post_code',
	        CTRY_PH: 'zip_code',
	        CTRY_IN: 'pin_code'
	      };
	      return postalCodeOverrides[countryCode] || 'postal_code';
	    }
	  }
	
	  function simplifyForTests(optionalAlpha2s) {
	    var alpha2s = optionalAlpha2s || ['AD', 'JP', 'IT', 'LI'];
	    remainingChoices = _.select(remainingChoices, function (choice) {
	      return _.include(alpha2s, choice.country_code_alpha_2);
	    });
	  }
	
	  _.merge(self, {
	    all: all,
	    asUiSelectItems: asUiSelectItems,
	    countryGrouping: countryGrouping,
	    findByText: findByText,
	    findByAlpha2: findByAlpha2,
	    findByCode: findByCode,
	    findByTwoLetterCode: findByTwoLetterCode,
	    europeanUnion: europeanUnion,
	    alpha2InEU: alpha2InEU,
	    alphabetized: alphabetized,
	    zipCodeLabelKey: zipCodeLabelKey,
	    simplifyForTests: simplifyForTests
	  });
	}
	
	/* To refresh, open up a Rails console and type "puts JSON.pretty_generate(Country.in_order.map(&:as_country_service_json))" */
	var countries = [{
	  "alpha_2": "US",
	  "locales": {
	    "en": "United States",
	    "fr": "Etats-Unis",
	    "de": "Vereinigte Staaten",
	    "es": "Estados Unidos"
	  },
	  "tags": ["common"]
	}, {
	  "alpha_2": "AU",
	  "locales": {
	    "en": "Australia",
	    "fr": "Australie",
	    "de": "Australien",
	    "es": "Australia"
	  },
	  "tags": ["common"]
	}, {
	  "alpha_2": "CA",
	  "locales": {
	    "en": "Canada",
	    "fr": "Canada",
	    "de": "Kanada",
	    "es": "Canadá"
	  },
	  "tags": ["common"]
	}, {
	  "alpha_2": "DE",
	  "locales": {
	    "en": "Germany",
	    "fr": "Allemagne",
	    "de": "Deutschland",
	    "es": "Alemania"
	  },
	  "tags": ["common", "european_union"]
	}, {
	  "alpha_2": "GB",
	  "locales": {
	    "en": "United Kingdom",
	    "fr": "Royaume-Uni",
	    "de": "Großbritannien",
	    "es": "Reino Unido"
	  },
	  "tags": ["common", "european_union"]
	}, {
	  "alpha_2": "AF",
	  "locales": {
	    "en": "Afghanistan",
	    "fr": "Afghanistan",
	    "de": "Afghanistan",
	    "es": "Afganistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AX",
	  "locales": {
	    "en": "Aland Islands",
	    "fr": "Aland",
	    "de": "Alandinseln",
	    "es": "Islas Aland"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AL",
	  "locales": {
	    "en": "Albania",
	    "fr": "Albanie",
	    "de": "Albanien",
	    "es": "Albania"
	  },
	  "tags": []
	}, {
	  "alpha_2": "DZ",
	  "locales": {
	    "en": "Algeria",
	    "fr": "Algérie",
	    "de": "Algerien",
	    "es": "Argelia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AS",
	  "locales": {
	    "en": "American Samoa",
	    "fr": "Samoa américaines",
	    "de": "Amerikanisch-Samoa",
	    "es": "Samoa Americana"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AD",
	  "locales": {
	    "en": "Andorra",
	    "fr": "Andorre",
	    "de": "Andorra",
	    "es": "Andorra"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AO",
	  "locales": {
	    "en": "Angola",
	    "fr": "Angola",
	    "de": "Angola",
	    "es": "Angola"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AI",
	  "locales": {
	    "en": "Anguilla",
	    "fr": "Anguilla",
	    "de": "Anguilla",
	    "es": "Anguila"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AQ",
	  "locales": {
	    "en": "Antarctica",
	    "fr": "Antarctique",
	    "de": "Antarktis",
	    "es": "Antártida"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AG",
	  "locales": {
	    "en": "Antigua and Barbuda",
	    "fr": "Antigua-et-Barbuda",
	    "de": "Antigua und Barbuda",
	    "es": "Antigua y Barbuda"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AR",
	  "locales": {
	    "en": "Argentina",
	    "fr": "Argentine",
	    "de": "Argentinien",
	    "es": "Argentina"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AM",
	  "locales": {
	    "en": "Armenia",
	    "fr": "Arménie",
	    "de": "Armenien",
	    "es": "Armenia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AW",
	  "locales": {
	    "en": "Aruba",
	    "fr": "Aruba",
	    "de": "Aruba",
	    "es": "Aruba"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AT",
	  "locales": {
	    "en": "Austria",
	    "fr": "Autriche",
	    "de": "Österreich",
	    "es": "Austria"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "AZ",
	  "locales": {
	    "en": "Azerbaijan",
	    "fr": "Azerbaïdjan",
	    "de": "Aserbaidschan",
	    "es": "Azerbaiyán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BS",
	  "locales": {
	    "en": "Bahamas",
	    "fr": "Bahams",
	    "de": "Bahamas",
	    "es": "Bahamas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BH",
	  "locales": {
	    "en": "Bahrain",
	    "fr": "Bahreïn",
	    "de": "Bahrain",
	    "es": "Bahréin"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BD",
	  "locales": {
	    "en": "Bangladesh",
	    "fr": "Bangladesh",
	    "de": "Bangladesh",
	    "es": "Bangladesh"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BB",
	  "locales": {
	    "en": "Barbados",
	    "fr": "Barbade",
	    "de": "Barbados",
	    "es": "Barbados"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BY",
	  "locales": {
	    "en": "Belarus",
	    "fr": "Biélorussie",
	    "de": "Belarus",
	    "es": "Belarús"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BE",
	  "locales": {
	    "en": "Belgium",
	    "fr": "Belgique",
	    "de": "Belgien",
	    "es": "Bélgica"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "BZ",
	  "locales": {
	    "en": "Belize",
	    "fr": "Belize",
	    "de": "Belize",
	    "es": "Belice"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BJ",
	  "locales": {
	    "en": "Benin",
	    "fr": "Bénin",
	    "de": "Benin",
	    "es": "Benín"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BM",
	  "locales": {
	    "en": "Bermuda",
	    "fr": "Bermudes",
	    "de": "Bermuda",
	    "es": "Bermudas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BT",
	  "locales": {
	    "en": "Bhutan",
	    "fr": "Bhoutan",
	    "de": "Bhutan",
	    "es": "Bután"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BO",
	  "locales": {
	    "en": "Bolivia",
	    "fr": "Bolivie",
	    "de": "Bolivien",
	    "es": "Bolivia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BA",
	  "locales": {
	    "en": "Bosnia and Herzegovina",
	    "fr": "Bosnie-Herzégovine",
	    "de": "Bosnien-Herzegowina",
	    "es": "Bosnia y Herzegovina"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BW",
	  "locales": {
	    "en": "Botswana",
	    "fr": "Botswana",
	    "de": "Botswana",
	    "es": "Botsuana"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BV",
	  "locales": {
	    "en": "Bouvet Island",
	    "fr": "Île Bouvet",
	    "de": "Bouvetinsel",
	    "es": "Isla Bouvet"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BR",
	  "locales": {
	    "en": "Brazil",
	    "fr": "Brésil",
	    "de": "Brasilien",
	    "es": "Brasil"
	  },
	  "tags": []
	}, {
	  "alpha_2": "IO",
	  "locales": {
	    "en": "British Indian Ocean Territory",
	    "fr": "Territoire britannique de l'océan Indien",
	    "de": "Britisches Territorium im Indischen Ozean",
	    "es": "Territorio Británico del Océano Índico"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BN",
	  "locales": {
	    "en": "Brunei Darussalam",
	    "fr": "Brunei",
	    "de": "Brunei Darussalam",
	    "es": "Brunei Darussalam"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BG",
	  "locales": {
	    "en": "Bulgaria",
	    "fr": "Bulgarie",
	    "de": "Bulgarien",
	    "es": "Bulgaria"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "BF",
	  "locales": {
	    "en": "Burkina Faso",
	    "fr": "Burkina Faso",
	    "de": "Burkina Faso",
	    "es": "Burkina Faso"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BI",
	  "locales": {
	    "en": "Burundi",
	    "fr": "Burundi",
	    "de": "Burundi",
	    "es": "Burundi"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KH",
	  "locales": {
	    "en": "Cambodia",
	    "fr": "Cambodge",
	    "de": "Kambodscha",
	    "es": "Camboya"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CM",
	  "locales": {
	    "en": "Cameroon",
	    "fr": "Cameroun",
	    "de": "Kamerun",
	    "es": "Camerún"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CV",
	  "locales": {
	    "en": "Cape Verde",
	    "fr": "Cap-Vert",
	    "de": "Kap Verde",
	    "es": "Cabo Verde"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KY",
	  "locales": {
	    "en": "Cayman Islands",
	    "fr": "Îles Caïman",
	    "de": "Kaimaninseln",
	    "es": "Islas Caimán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CF",
	  "locales": {
	    "en": "Central African Republic",
	    "fr": "Centrafrique",
	    "de": "Zentralafrikanische Republik",
	    "es": "República Centroafricana"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TD",
	  "locales": {
	    "en": "Chad",
	    "fr": "Tchad",
	    "de": "Tschad",
	    "es": "Chad"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CL",
	  "locales": {
	    "en": "Chile",
	    "fr": "Chili",
	    "de": "Chile",
	    "es": "Chile"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CN",
	  "locales": {
	    "en": "China",
	    "fr": "Chine",
	    "de": "China",
	    "es": "China"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CX",
	  "locales": {
	    "en": "Christmas Island",
	    "fr": "Île Christmas",
	    "de": "Weihnachtsinsel",
	    "es": "Isla de Navidad"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CC",
	  "locales": {
	    "en": "Cocos (Keeling) Islands",
	    "fr": "Îles Cocos",
	    "de": "Cocosinseln",
	    "es": "Islas Cocos (Keeling)"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CO",
	  "locales": {
	    "en": "Colombia",
	    "fr": "Colombie",
	    "de": "Kolumbien",
	    "es": "Colombia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KM",
	  "locales": {
	    "en": "Comoros",
	    "fr": "Comores",
	    "de": "Komoren",
	    "es": "Comoras"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CG",
	  "locales": {
	    "en": "Congo",
	    "fr": "Congo",
	    "de": "Kongo",
	    "es": "Congo"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CD",
	  "locales": {
	    "en": "Congo, the Democratic Republic of the",
	    "fr": "République Démocratique du Congo",
	    "de": "Kongo, demokratische Republik",
	    "es": "República Democrática del Congo"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CK",
	  "locales": {
	    "en": "Cook Islands",
	    "fr": "Îles Cook",
	    "de": "Cookinseln",
	    "es": "Islas Cook"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CR",
	  "locales": {
	    "en": "Costa Rica",
	    "fr": "Costa Rica",
	    "de": "Costa Rica",
	    "es": "Costa Rica"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CI",
	  "locales": {
	    "en": "Cote d'Ivoire",
	    "fr": "Côte d'Ivoire",
	    "de": "Elfenbeinküste",
	    "es": "Costa de Marfil"
	  },
	  "tags": []
	}, {
	  "alpha_2": "HR",
	  "locales": {
	    "en": "Croatia",
	    "fr": "Croatie",
	    "de": "Kroatien",
	    "es": "Croacia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "CW",
	  "locales": {
	    "en": "Curacao",
	    "fr": "Curaçao",
	    "de": "Curacao",
	    "es": "Curacao"
	  },
	  "tags": []
	}, {
	  "alpha_2": "CY",
	  "locales": {
	    "en": "Cyprus",
	    "fr": "Chypre",
	    "de": "Zypern",
	    "es": "Chipre"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "CZ",
	  "locales": {
	    "en": "Czech Republic",
	    "fr": "République Tchèque",
	    "de": "Tschechische Republik",
	    "es": "República Checa"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "DK",
	  "locales": {
	    "en": "Denmark",
	    "fr": "Danemark",
	    "de": "Dänemark",
	    "es": "Dinamarca"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "DJ",
	  "locales": {
	    "en": "Djibouti",
	    "fr": "Djibouti",
	    "de": "Dschibuti",
	    "es": "Yibuti"
	  },
	  "tags": []
	}, {
	  "alpha_2": "DM",
	  "locales": {
	    "en": "Dominica",
	    "fr": "Dominique",
	    "de": "Dominica",
	    "es": "Dominica"
	  },
	  "tags": []
	}, {
	  "alpha_2": "DO",
	  "locales": {
	    "en": "Dominican Republic",
	    "fr": "République Dominicaine",
	    "de": "Dominikanische Republik",
	    "es": "República Dominicana"
	  },
	  "tags": []
	}, {
	  "alpha_2": "EC",
	  "locales": {
	    "en": "Ecuador",
	    "fr": "Equateur",
	    "de": "Ecuador",
	    "es": "Ecuador"
	  },
	  "tags": []
	}, {
	  "alpha_2": "EG",
	  "locales": {
	    "en": "Egypt",
	    "fr": "Egypte",
	    "de": "Ägypten",
	    "es": "Egipto"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SV",
	  "locales": {
	    "en": "El Salvador",
	    "fr": "El Salvador",
	    "de": "El Salvador",
	    "es": "El Salvador"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GQ",
	  "locales": {
	    "en": "Equatorial Guinea",
	    "fr": "Guinée équatoriale",
	    "de": "Äquatorialguinea",
	    "es": "Guinea Ecuatorial"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ER",
	  "locales": {
	    "en": "Eritrea",
	    "fr": "Erythrée",
	    "de": "Eritrea",
	    "es": "Eritrea"
	  },
	  "tags": []
	}, {
	  "alpha_2": "EE",
	  "locales": {
	    "en": "Estonia",
	    "fr": "Estonie",
	    "de": "Estland",
	    "es": "Estonia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "ET",
	  "locales": {
	    "en": "Ethiopia",
	    "fr": "Ethiopie",
	    "de": "Äthiopien",
	    "es": "Etiopía"
	  },
	  "tags": []
	}, {
	  "alpha_2": "FK",
	  "locales": {
	    "en": "Falkland Islands (Malvinas)",
	    "fr": "Îles Falkland (Malouines)",
	    "de": "Falklandinseln (Malwinen)",
	    "es": "Islas Malvinas (Falkland)"
	  },
	  "tags": []
	}, {
	  "alpha_2": "FO",
	  "locales": {
	    "en": "Faroe Islands",
	    "fr": "Îles Faroe",
	    "de": "Färöer Inseln",
	    "es": "Islas Feroe"
	  },
	  "tags": []
	}, {
	  "alpha_2": "FJ",
	  "locales": {
	    "en": "Fiji",
	    "fr": "Fidji",
	    "de": "Fidschi",
	    "es": "Fiji"
	  },
	  "tags": []
	}, {
	  "alpha_2": "FI",
	  "locales": {
	    "en": "Finland",
	    "fr": "Finlande",
	    "de": "Finnland",
	    "es": "Finlandia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "FR",
	  "locales": {
	    "en": "France",
	    "fr": "France",
	    "de": "Frankreich",
	    "es": "Francia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "GF",
	  "locales": {
	    "en": "French Guiana",
	    "fr": "Guyane",
	    "de": "Französisch-Guayana",
	    "es": "Guayana Francesa"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PF",
	  "locales": {
	    "en": "French Polynesia",
	    "fr": "Polynésie française",
	    "de": "Französisch-Polynesien",
	    "es": "Polinesia Francesa"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TF",
	  "locales": {
	    "en": "French Southern Territories",
	    "fr": "Terres australes et antarctiques françaises",
	    "de": "Französische Südpolar-Territorien",
	    "es": "Territorios Australes Franceses"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GA",
	  "locales": {
	    "en": "Gabon",
	    "fr": "Gabon",
	    "de": "Gabun",
	    "es": "Gabón"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GM",
	  "locales": {
	    "en": "Gambia",
	    "fr": "Gambie",
	    "de": "Gambia",
	    "es": "Gambia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GE",
	  "locales": {
	    "en": "Georgia",
	    "fr": "Géorgie",
	    "de": "Georgien",
	    "es": "Georgia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GH",
	  "locales": {
	    "en": "Ghana",
	    "fr": "Ghana",
	    "de": "Ghana",
	    "es": "Ghana"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GI",
	  "locales": {
	    "en": "Gibraltar",
	    "fr": "Gibraltar",
	    "de": "Gibraltar",
	    "es": "Gibraltar"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GR",
	  "locales": {
	    "en": "Greece",
	    "fr": "Grèce",
	    "de": "Griechenland",
	    "es": "Grecia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "GL",
	  "locales": {
	    "en": "Greenland",
	    "fr": "Groenland",
	    "de": "Grönland",
	    "es": "Groenlandia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GD",
	  "locales": {
	    "en": "Grenada",
	    "fr": "Grenade",
	    "de": "Grenada",
	    "es": "Granada"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GP",
	  "locales": {
	    "en": "Guadeloupe",
	    "fr": "Guadeloupe",
	    "de": "Guadeloupe",
	    "es": "Guadalupe"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GU",
	  "locales": {
	    "en": "Guam",
	    "fr": "Guam",
	    "de": "Guam",
	    "es": "Guam"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GT",
	  "locales": {
	    "en": "Guatemala",
	    "fr": "Guatemala",
	    "de": "Guatemala",
	    "es": "Guatemala"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GN",
	  "locales": {
	    "en": "Guinea",
	    "fr": "Guinée",
	    "de": "Guinea",
	    "es": "Guinea"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GW",
	  "locales": {
	    "en": "Guinea-Bissau",
	    "fr": "Guinée-Bissau",
	    "de": "Guinea-Bissau",
	    "es": "Guinea-Bissau"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GY",
	  "locales": {
	    "en": "Guyana",
	    "fr": "Guyana",
	    "de": "Guyana",
	    "es": "Guayana"
	  },
	  "tags": []
	}, {
	  "alpha_2": "HT",
	  "locales": {
	    "en": "Haiti",
	    "fr": "Haïti",
	    "de": "Haiti",
	    "es": "Haití"
	  },
	  "tags": []
	}, {
	  "alpha_2": "HM",
	  "locales": {
	    "en": "Heard Island and McDonald Islands",
	    "fr": "Îles Heard-et-MacDonald",
	    "de": "Heard-Insel und McDonald-Inseln",
	    "es": "Islas Heard y McDonald"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VA",
	  "locales": {
	    "en": "Holy See (Vatican City State)",
	    "fr": "Saint-Siège (Etat du Vatican)",
	    "de": "Vatikanstadt",
	    "es": "Santa Sede (Ciudad del Vaticano)"
	  },
	  "tags": []
	}, {
	  "alpha_2": "HN",
	  "locales": {
	    "en": "Honduras",
	    "fr": "Honduras",
	    "de": "Honduras",
	    "es": "Honduras"
	  },
	  "tags": []
	}, {
	  "alpha_2": "HK",
	  "locales": {
	    "en": "Hong Kong",
	    "fr": "Hong Kong",
	    "de": "Hong Kong",
	    "es": "Hong Kong"
	  },
	  "tags": []
	}, {
	  "alpha_2": "HU",
	  "locales": {
	    "en": "Hungary",
	    "fr": "Hongrie",
	    "de": "Ungarn",
	    "es": "Hungría"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "IS",
	  "locales": {
	    "en": "Iceland",
	    "fr": "Islande",
	    "de": "Island",
	    "es": "Islandia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "IN",
	  "locales": {
	    "en": "India",
	    "fr": "Inde",
	    "de": "Indien",
	    "es": "India"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ID",
	  "locales": {
	    "en": "Indonesia",
	    "fr": "Indonésie",
	    "de": "Indonesien",
	    "es": "Indonesia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "IQ",
	  "locales": {
	    "en": "Iraq",
	    "fr": "Irak",
	    "de": "Irak",
	    "es": "Iraq"
	  },
	  "tags": []
	}, {
	  "alpha_2": "IE",
	  "locales": {
	    "en": "Ireland",
	    "fr": "Irlande",
	    "de": "Irland",
	    "es": "Irlanda"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "IL",
	  "locales": {
	    "en": "Israel",
	    "fr": "Israël",
	    "de": "Israel",
	    "es": "Israel"
	  },
	  "tags": []
	}, {
	  "alpha_2": "IT",
	  "locales": {
	    "en": "Italy",
	    "fr": "Italie",
	    "de": "Italien",
	    "es": "Italia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "JM",
	  "locales": {
	    "en": "Jamaica",
	    "fr": "Jamaïque",
	    "de": "Jamaica",
	    "es": "Jamaica"
	  },
	  "tags": []
	}, {
	  "alpha_2": "JP",
	  "locales": {
	    "en": "Japan",
	    "fr": "Japon",
	    "de": "Japan",
	    "es": "Japón"
	  },
	  "tags": []
	}, {
	  "alpha_2": "JO",
	  "locales": {
	    "en": "Jordan",
	    "fr": "Jordanie",
	    "de": "Jordanien",
	    "es": "Jordania"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KZ",
	  "locales": {
	    "en": "Kazakhstan",
	    "fr": "Kazakhstan",
	    "de": "Kasachstan",
	    "es": "Kazajistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KE",
	  "locales": {
	    "en": "Kenya",
	    "fr": "Kenya",
	    "de": "Kenia",
	    "es": "Kenia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KI",
	  "locales": {
	    "en": "Kiribati",
	    "fr": "Kiribati",
	    "de": "Kiribati",
	    "es": "Kiribati"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KR",
	  "locales": {
	    "en": "Korea, Republic of",
	    "fr": "République de Corée",
	    "de": "Korea, Republik",
	    "es": "República de Corea"
	  },
	  "tags": []
	}, {
	  "alpha_2": "XK",
	  "locales": {
	    "en": "Kosovo",
	    "fr": "Kosovo",
	    "de": "Kosovo",
	    "es": "Kosovo"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KW",
	  "locales": {
	    "en": "Kuwait",
	    "fr": "Koweït",
	    "de": "Kuwait",
	    "es": "Kuwait"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KG",
	  "locales": {
	    "en": "Kyrgyzstan",
	    "fr": "Kirghizistan",
	    "de": "Kirgisistan",
	    "es": "Kirguistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LA",
	  "locales": {
	    "en": "Lao People's Democratic Republic",
	    "fr": "Laos",
	    "de": "Laos",
	    "es": "República Democrática Popular Lao"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LV",
	  "locales": {
	    "en": "Latvia",
	    "fr": "Lettonie",
	    "de": "Lettland",
	    "es": "Letonia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "LB",
	  "locales": {
	    "en": "Lebanon",
	    "fr": "Liban",
	    "de": "Libanon",
	    "es": "Líbano"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LS",
	  "locales": {
	    "en": "Lesotho",
	    "fr": "Lesotho",
	    "de": "Lesotho",
	    "es": "Lesoto"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LR",
	  "locales": {
	    "en": "Liberia",
	    "fr": "Liberia",
	    "de": "Liberien",
	    "es": "Liberia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LY",
	  "locales": {
	    "en": "Libya",
	    "fr": "Libye",
	    "de": "Libyen",
	    "es": "Libia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LI",
	  "locales": {
	    "en": "Liechtenstein",
	    "fr": "Liechtenstein",
	    "de": "Liechtenstein",
	    "es": "Liechtenstein"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LT",
	  "locales": {
	    "en": "Lithuania",
	    "fr": "Lituanie",
	    "de": "Litauen",
	    "es": "Lituania"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "LU",
	  "locales": {
	    "en": "Luxembourg",
	    "fr": "Luxembourg",
	    "de": "Luxembourg",
	    "es": "Luxemburgo"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "MO",
	  "locales": {
	    "en": "Macao",
	    "fr": "Macao",
	    "de": "Macau",
	    "es": "Macao"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MK",
	  "locales": {
	    "en": "Macedonia",
	    "fr": "Macédoine",
	    "de": "Mazedonien",
	    "es": "Macedonia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MG",
	  "locales": {
	    "en": "Madagascar",
	    "fr": "Madagascar",
	    "de": "Madagaskar",
	    "es": "Madagascar"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MW",
	  "locales": {
	    "en": "Malawi",
	    "fr": "Malawi",
	    "de": "Malawi",
	    "es": "Malawi"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MY",
	  "locales": {
	    "en": "Malaysia",
	    "fr": "Malaisie",
	    "de": "Malaysia",
	    "es": "Malasia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MV",
	  "locales": {
	    "en": "Maldives",
	    "fr": "Maldives",
	    "de": "Malediven",
	    "es": "Maldivas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ML",
	  "locales": {
	    "en": "Mali",
	    "fr": "Mali",
	    "de": "Mali",
	    "es": "Mali"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MT",
	  "locales": {
	    "en": "Malta",
	    "fr": "Malte",
	    "de": "Malta",
	    "es": "Malta"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "MH",
	  "locales": {
	    "en": "Marshall Islands",
	    "fr": "Îles Marshall",
	    "de": "Marshallinseln",
	    "es": "Islas Marshall"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MQ",
	  "locales": {
	    "en": "Martinique",
	    "fr": "Martinique",
	    "de": "Martinique",
	    "es": "Martinica"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MR",
	  "locales": {
	    "en": "Mauritania",
	    "fr": "Mauritanie",
	    "de": "Mauritanien",
	    "es": "Mauritania"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MU",
	  "locales": {
	    "en": "Mauritius",
	    "fr": "Île Maurice",
	    "de": "Mauritius",
	    "es": "Mauricio"
	  },
	  "tags": []
	}, {
	  "alpha_2": "YT",
	  "locales": {
	    "en": "Mayotte",
	    "fr": "Mayotte",
	    "de": "Mayotte",
	    "es": "Mayotte"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MX",
	  "locales": {
	    "en": "Mexico",
	    "fr": "Mexique",
	    "de": "Mexiko",
	    "es": "México"
	  },
	  "tags": []
	}, {
	  "alpha_2": "FM",
	  "locales": {
	    "en": "Micronesia, Federated States of",
	    "fr": "Micronésie (Etats fédéraux de)",
	    "de": "Mikronesien",
	    "es": "Estados Federados de Micronesia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MD",
	  "locales": {
	    "en": "Moldova, Republic of",
	    "fr": "Moldavie (République de)",
	    "de": "Moldawien",
	    "es": "Moldavia, República de"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MC",
	  "locales": {
	    "en": "Monaco",
	    "fr": "Monaco",
	    "de": "Monaco",
	    "es": "Mónaco"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MN",
	  "locales": {
	    "en": "Mongolia",
	    "fr": "Mongolie",
	    "de": "Mongolei",
	    "es": "Mongolia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ME",
	  "locales": {
	    "en": "Montenegro",
	    "fr": "Monténégro",
	    "de": "Montenegro",
	    "es": "Montenegro"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MS",
	  "locales": {
	    "en": "Montserrat",
	    "fr": "Montserrat",
	    "de": "Montserrat",
	    "es": "Montserrat"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MA",
	  "locales": {
	    "en": "Morocco",
	    "fr": "Maroc",
	    "de": "Marokko",
	    "es": "Marruecos"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MZ",
	  "locales": {
	    "en": "Mozambique",
	    "fr": "Mozambique",
	    "de": "Mosambik",
	    "es": "Mozambique"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MM",
	  "locales": {
	    "en": "Myanmar",
	    "fr": "Myanmar",
	    "de": "Myanmar",
	    "es": "Birmania"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NA",
	  "locales": {
	    "en": "Namibia",
	    "fr": "Namibie",
	    "de": "Namibia",
	    "es": "Namibia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NR",
	  "locales": {
	    "en": "Nauru",
	    "fr": "Nauru",
	    "de": "Nauru",
	    "es": "Nauru"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NP",
	  "locales": {
	    "en": "Nepal",
	    "fr": "Népal",
	    "de": "Nepal",
	    "es": "Nepal"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NL",
	  "locales": {
	    "en": "Netherlands",
	    "fr": "Pays-Bas",
	    "de": "Niederlande",
	    "es": "Países Bajos"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "AN",
	  "locales": {
	    "en": "Netherlands Antilles",
	    "fr": "Pays-Bas antillais",
	    "de": "Niederländische Antillen",
	    "es": "Antillas Neerlandesas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NC",
	  "locales": {
	    "en": "New Caledonia",
	    "fr": "Nouvelle-Calédonie",
	    "de": "Neukaledonien",
	    "es": "Nueva Caledonia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NZ",
	  "locales": {
	    "en": "New Zealand",
	    "fr": "Nouvelle-Zélande",
	    "de": "Neuseeland",
	    "es": "Nueva Zelandia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NI",
	  "locales": {
	    "en": "Nicaragua",
	    "fr": "Nicaragua",
	    "de": "Nicaragua",
	    "es": "Nicaragua"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NE",
	  "locales": {
	    "en": "Niger",
	    "fr": "Niger",
	    "de": "Niger",
	    "es": "Níger"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NG",
	  "locales": {
	    "en": "Nigeria",
	    "fr": "Nigeria",
	    "de": "Nigeria",
	    "es": "Nigeria"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NU",
	  "locales": {
	    "en": "Niue",
	    "fr": "Niue",
	    "de": "Niue",
	    "es": "Niue"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NF",
	  "locales": {
	    "en": "Norfolk Island",
	    "fr": "Île de Norfolk",
	    "de": "Norfolkinseln",
	    "es": "Isla Norfolk"
	  },
	  "tags": []
	}, {
	  "alpha_2": "MP",
	  "locales": {
	    "en": "Northern Mariana Islands",
	    "fr": "Îles Mariannes du Nord",
	    "de": "Nördliche Marianen",
	    "es": "Islas Marianas del Norte"
	  },
	  "tags": []
	}, {
	  "alpha_2": "NO",
	  "locales": {
	    "en": "Norway",
	    "fr": "Norvège",
	    "de": "Norwegen",
	    "es": "Noruega"
	  },
	  "tags": []
	}, {
	  "alpha_2": "OM",
	  "locales": {
	    "en": "Oman",
	    "fr": "Oman",
	    "de": "Oman",
	    "es": "Omán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PK",
	  "locales": {
	    "en": "Pakistan",
	    "fr": "Pakistan",
	    "de": "Pakistan",
	    "es": "Pakistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PW",
	  "locales": {
	    "en": "Palau",
	    "fr": "Palaos",
	    "de": "Palau",
	    "es": "Palau"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PS",
	  "locales": {
	    "en": "Palestine, State of",
	    "fr": "Etat de Palestine",
	    "de": "Staat Palästina",
	    "es": "Estado de Palestina"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PA",
	  "locales": {
	    "en": "Panama",
	    "fr": "Panama",
	    "de": "Panama",
	    "es": "Panamá"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PG",
	  "locales": {
	    "en": "Papua New Guinea",
	    "fr": "Papouasie-Nouvelle Guinée",
	    "de": "Papua-Neuguinea",
	    "es": "Papúa Nueva Guinea"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PY",
	  "locales": {
	    "en": "Paraguay",
	    "fr": "Paraguay",
	    "de": "Paraguay",
	    "es": "Paraguay"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PE",
	  "locales": {
	    "en": "Peru",
	    "fr": "Pérou",
	    "de": "Peru",
	    "es": "Perú"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PH",
	  "locales": {
	    "en": "Philippines",
	    "fr": "Philippines",
	    "de": "Philippinen",
	    "es": "Filipinas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PN",
	  "locales": {
	    "en": "Pitcairn",
	    "fr": "Île Pitcairn",
	    "de": "Pitcairninseln",
	    "es": "Islas Pitcairn"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PL",
	  "locales": {
	    "en": "Poland",
	    "fr": "Pologne",
	    "de": "Polen",
	    "es": "Polonia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "PT",
	  "locales": {
	    "en": "Portugal",
	    "fr": "Portugal",
	    "de": "Portugal",
	    "es": "Portugal"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "PR",
	  "locales": {
	    "en": "Puerto Rico",
	    "fr": "Porto Rico",
	    "de": "Puerto Rico",
	    "es": "Puerto Rico"
	  },
	  "tags": []
	}, {
	  "alpha_2": "QA",
	  "locales": {
	    "en": "Qatar",
	    "fr": "Qatar",
	    "de": "Katar",
	    "es": "Qatar"
	  },
	  "tags": []
	}, {
	  "alpha_2": "RO",
	  "locales": {
	    "en": "Romania",
	    "fr": "Roumanie",
	    "de": "Rumänien",
	    "es": "Rumania"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "RU",
	  "locales": {
	    "en": "Russian Federation",
	    "fr": "Russie (Fédération de)",
	    "de": "Russische Federation",
	    "es": "Federación Rusa"
	  },
	  "tags": []
	}, {
	  "alpha_2": "RW",
	  "locales": {
	    "en": "Rwanda",
	    "fr": "Rwanda",
	    "de": "Ruanda",
	    "es": "Ruanda"
	  },
	  "tags": []
	}, {
	  "alpha_2": "RE",
	  "locales": {
	    "en": "Réunion",
	    "fr": "La Réunion",
	    "de": "Réunion",
	    "es": "Reunión"
	  },
	  "tags": []
	}, {
	  "alpha_2": "BL",
	  "locales": {
	    "en": "Saint Barthélemy",
	    "fr": "Saint-Barthélemy",
	    "de": "Saint-Barthélemy",
	    "es": "San Bartolomé"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SH",
	  "locales": {
	    "en": "Saint Helena",
	    "fr": "Saint-Hélène",
	    "de": "St. Helena",
	    "es": "Santa Helena"
	  },
	  "tags": []
	}, {
	  "alpha_2": "KN",
	  "locales": {
	    "en": "Saint Kitts and Nevis",
	    "fr": "Saint-Christophe-et-Niévès",
	    "de": "St. Kitts und Nevis",
	    "es": "San Cristóbal y Nieves"
	  },
	  "tags": []
	}, {
	  "alpha_2": "LC",
	  "locales": {
	    "en": "Saint Lucia",
	    "fr": "Sainte-Lucie",
	    "de": "St. Lucia",
	    "es": "Santa Lucía"
	  },
	  "tags": []
	}, {
	  "alpha_2": "PM",
	  "locales": {
	    "en": "Saint Pierre and Miquelon",
	    "fr": "Saint-Pierre-et-Miquelon",
	    "de": "Saint Pierre und Miquelon",
	    "es": "San Pedro y Miquelón"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VC",
	  "locales": {
	    "en": "Saint Vincent and the Grenadines",
	    "fr": "Saint-Vincent-et-les-Grenadines",
	    "de": "St. Vincent und die Grenadinen",
	    "es": "San Vicente y las Granadinas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "WS",
	  "locales": {
	    "en": "Samoa",
	    "fr": "Samoa",
	    "de": "Samoa",
	    "es": "Samoa"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SM",
	  "locales": {
	    "en": "San Marino",
	    "fr": "Saint-Marin",
	    "de": "San Marino",
	    "es": "San Marino"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ST",
	  "locales": {
	    "en": "Sao Tome and Principe",
	    "fr": "Sao Tomé-et-Principe",
	    "de": "Sao Tome und Principe",
	    "es": "Santo Tomé y Príncipe"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SA",
	  "locales": {
	    "en": "Saudi Arabia",
	    "fr": "Arabie Saoudite",
	    "de": "Saudi Arabien",
	    "es": "Arabia Saudita"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SN",
	  "locales": {
	    "en": "Senegal",
	    "fr": "Sénégal",
	    "de": "Senegal",
	    "es": "Senegal"
	  },
	  "tags": []
	}, {
	  "alpha_2": "RS",
	  "locales": {
	    "en": "Serbia",
	    "fr": "Serbie",
	    "de": "Serbien",
	    "es": "Serbia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SC",
	  "locales": {
	    "en": "Seychelles",
	    "fr": "Seychelles",
	    "de": "Seychellen",
	    "es": "Seychelles"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SL",
	  "locales": {
	    "en": "Sierra Leone",
	    "fr": "Sierra Leone",
	    "de": "Sierra Leone",
	    "es": "Sierra Leona"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SG",
	  "locales": {
	    "en": "Singapore",
	    "fr": "Singapour",
	    "de": "Singapur",
	    "es": "Singapur"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SX",
	  "locales": {
	    "en": "Sint Maarten",
	    "fr": "Sint Maarten",
	    "de": "Sint Maarten",
	    "es": "Sint Maarten"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SK",
	  "locales": {
	    "en": "Slovakia",
	    "fr": "Slovaque",
	    "de": "Slowakei",
	    "es": "Eslovaquia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "SI",
	  "locales": {
	    "en": "Slovenia",
	    "fr": "Slovénie",
	    "de": "Slowenien",
	    "es": "Eslovenia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "SB",
	  "locales": {
	    "en": "Solomon Islands",
	    "fr": "Îles Salomon",
	    "de": "Salomoninseln",
	    "es": "Islas Salomón"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SO",
	  "locales": {
	    "en": "Somalia",
	    "fr": "Somalie",
	    "de": "Somalia",
	    "es": "Somalia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ZA",
	  "locales": {
	    "en": "South Africa",
	    "fr": "Afrique du Sud",
	    "de": "Südafrika",
	    "es": "Sudáfrica"
	  },
	  "tags": []
	}, {
	  "alpha_2": "GS",
	  "locales": {
	    "en": "South Georgia and the South Sandwich Islands",
	    "fr": "Géorgie du Sud-et-les Îles Sandwich du Sud",
	    "de": "Süd-Georgien und südliche Sandwichinseln",
	    "es": "Islas Georgia del Sur y Sandwich del Sur"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ES",
	  "locales": {
	    "en": "Spain",
	    "fr": "Espagne",
	    "de": "Spanien",
	    "es": "España"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "LK",
	  "locales": {
	    "en": "Sri Lanka",
	    "fr": "Sri Lanka",
	    "de": "Sri Lanka",
	    "es": "Sri Lanka"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SR",
	  "locales": {
	    "en": "Suriname",
	    "fr": "Surinam",
	    "de": "Suriname",
	    "es": "Surinam"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SJ",
	  "locales": {
	    "en": "Svalbard and Jan Mayen",
	    "fr": "Svalbard et île Jan Mayen",
	    "de": "Svalbard und Jan Mayen Insel",
	    "es": "Svalbard y Jan Mayen"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SZ",
	  "locales": {
	    "en": "Swaziland",
	    "fr": "Swaziland",
	    "de": "Swaziland",
	    "es": "Swazilandia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "SE",
	  "locales": {
	    "en": "Sweden",
	    "fr": "Suède",
	    "de": "Schweden",
	    "es": "Suecia"
	  },
	  "tags": ["european_union"]
	}, {
	  "alpha_2": "CH",
	  "locales": {
	    "en": "Switzerland",
	    "fr": "Suisse",
	    "de": "Schweiz",
	    "es": "Suiza"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TW",
	  "locales": {
	    "en": "Taiwan",
	    "fr": "Taïwan",
	    "de": "Taiwan",
	    "es": "Taiwán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TJ",
	  "locales": {
	    "en": "Tajikistan",
	    "fr": "Tadjikistan",
	    "de": "Tadshikistan",
	    "es": "Tayikistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TZ",
	  "locales": {
	    "en": "Tanzania, United Republic of",
	    "fr": "Tanzanie (République unie de)",
	    "de": "Tansania",
	    "es": "República Unida de Tanzania"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TH",
	  "locales": {
	    "en": "Thailand",
	    "fr": "Thaïlande",
	    "de": "Thailand",
	    "es": "Tailandia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TL",
	  "locales": {
	    "en": "Timor-Leste",
	    "fr": "Timor-Oriental",
	    "de": "Timor-Leste",
	    "es": "Timor Oriental"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TG",
	  "locales": {
	    "en": "Togo",
	    "fr": "Togo",
	    "de": "Togo",
	    "es": "Togo"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TK",
	  "locales": {
	    "en": "Tokelau",
	    "fr": "Tokelau",
	    "de": "Tokelau",
	    "es": "Tokelau"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TO",
	  "locales": {
	    "en": "Tonga",
	    "fr": "Tonga",
	    "de": "Tonga",
	    "es": "Tonga"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TT",
	  "locales": {
	    "en": "Trinidad and Tobago",
	    "fr": "Trinidad-et-Tobago",
	    "de": "Trinidad und Tobago",
	    "es": "Trinidad y Tobago"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TN",
	  "locales": {
	    "en": "Tunisia",
	    "fr": "Tunisie",
	    "de": "Tunesien",
	    "es": "Túnez"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TR",
	  "locales": {
	    "en": "Turkey",
	    "fr": "Turquie",
	    "de": "Türkei",
	    "es": "Turquía"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TM",
	  "locales": {
	    "en": "Turkmenistan",
	    "fr": "Turkménistan",
	    "de": "Turkmenistan",
	    "es": "Turkmenistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TC",
	  "locales": {
	    "en": "Turks and Caicos Islands",
	    "fr": "Îles Turques-et-Caïques",
	    "de": "Turks- und Caicosinseln",
	    "es": "Islas Turcos y Caicos"
	  },
	  "tags": []
	}, {
	  "alpha_2": "TV",
	  "locales": {
	    "en": "Tuvalu",
	    "fr": "Tuvalu",
	    "de": "Tuvalu",
	    "es": "Tuvalu"
	  },
	  "tags": []
	}, {
	  "alpha_2": "UG",
	  "locales": {
	    "en": "Uganda",
	    "fr": "Ouganda",
	    "de": "Uganda",
	    "es": "Uganda"
	  },
	  "tags": []
	}, {
	  "alpha_2": "UA",
	  "locales": {
	    "en": "Ukraine",
	    "fr": "Ukraine",
	    "de": "Ukraine",
	    "es": "Ucrania"
	  },
	  "tags": []
	}, {
	  "alpha_2": "AE",
	  "locales": {
	    "en": "United Arab Emirates",
	    "fr": "Emirats Arabes Unis",
	    "de": "Vereinte Arabische Emirate",
	    "es": "Emiratos Árabes Unidos"
	  },
	  "tags": []
	}, {
	  "alpha_2": "UM",
	  "locales": {
	    "en": "United States Minor Outlying Islands",
	    "fr": "Îles mineures éloignées des Etats-Unis",
	    "de": "Amerikanisch-Ozeanien",
	    "es": "Islas Ultramarinas Menores de Estados Unidos"
	  },
	  "tags": []
	}, {
	  "alpha_2": "UY",
	  "locales": {
	    "en": "Uruguay",
	    "fr": "Uruguay",
	    "de": "Uruguay",
	    "es": "Uruguay"
	  },
	  "tags": []
	}, {
	  "alpha_2": "UZ",
	  "locales": {
	    "en": "Uzbekistan",
	    "fr": "Ouzbékistan",
	    "de": "Usbekistan",
	    "es": "Uzbekistán"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VU",
	  "locales": {
	    "en": "Vanuatu",
	    "fr": "Vanuatu",
	    "de": "Vanuatu",
	    "es": "Vanuatu"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VE",
	  "locales": {
	    "en": "Venezuela",
	    "fr": "Vénézuela",
	    "de": "Venezuela",
	    "es": "Venezuela"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VN",
	  "locales": {
	    "en": "Vietnam",
	    "fr": "Viêtnam",
	    "de": "Vietnam",
	    "es": "Vietnam"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VG",
	  "locales": {
	    "en": "Virgin Islands, British",
	    "fr": "Îles Vierges britanniques",
	    "de": "Britische Jungferninseln",
	    "es": "Islas Vírgenes Británicas"
	  },
	  "tags": []
	}, {
	  "alpha_2": "VI",
	  "locales": {
	    "en": "Virgin Islands, U.S.",
	    "fr": "Îles Vierges américaines",
	    "de": "US-Jungferninseln",
	    "es": "Islas Vírgenes de los EE.UU."
	  },
	  "tags": []
	}, {
	  "alpha_2": "WF",
	  "locales": {
	    "en": "Wallis and Futuna",
	    "fr": "Wallis-et-Futuna",
	    "de": "Wallis und Futuna",
	    "es": "Wallis y Futuna"
	  },
	  "tags": []
	}, {
	  "alpha_2": "EH",
	  "locales": {
	    "en": "Western Sahara",
	    "fr": "Sahara occidental",
	    "de": "Westsahara",
	    "es": "Sahara Occidental"
	  },
	  "tags": []
	}, {
	  "alpha_2": "YE",
	  "locales": {
	    "en": "Yemen",
	    "fr": "Yémen",
	    "de": "Jemen",
	    "es": "Yemen"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ZM",
	  "locales": {
	    "en": "Zambia",
	    "fr": "Zambie",
	    "de": "Sambia",
	    "es": "Zambia"
	  },
	  "tags": []
	}, {
	  "alpha_2": "ZW",
	  "locales": {
	    "en": "Zimbabwe",
	    "fr": "Zimbabwe",
	    "de": "Simbabwe",
	    "es": "Zimbabue"
	  },
	  "tags": []
	}];
	
	exports.default = countriesService;

/***/ },
/* 148 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = csrfToken;
	/*@ngInject*/
	function csrfToken() {
	  var csrfTokenService = {};
	  var _token = $('meta[name=csrf-token]').attr('content');
	
	  csrfTokenService.getToken = function () {
	    return _token;
	  };
	
	  csrfTokenService.headerConfig = function () {
	    return { headers: { 'X-CSRF-Token': _token } };
	  };
	
	  csrfTokenService.setToken = function (newToken) {
	    _token = newToken;
	  };
	
	  return csrfTokenService;
	}

/***/ },
/* 149 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = currencies;
	function currencies() {
	  function CurrenciesService() {
	    /* To refresh, open up a Rails console and type "puts JSON.pretty_generate(Currency.visible_list.map { |cur| CurrencySerializer.new(cur).serializable_hash })" */
	    var currencies = [{
	      "iso_num": 840,
	      "symbol": "$",
	      "iso_code": "USD"
	    }, {
	      "iso_num": 978,
	      "symbol": "€",
	      "iso_code": "EUR"
	    }, {
	      "iso_num": 826,
	      "symbol": "£",
	      "iso_code": "GBP"
	    }, {
	      "iso_num": 124,
	      "symbol": "$",
	      "iso_code": "CAD"
	    }, {
	      "iso_num": 36,
	      "symbol": "$",
	      "iso_code": "AUD"
	    }];
	
	    this.asOptions = function () {
	      return _.map(currencies, function (currency) {
	        return { value: currency.iso_num, text: currency.iso_code };
	      });
	    };
	
	    this.all = function () {
	      return currencies;
	    };
	
	    this.asPartnerOptions = function () {
	      return _.map(currencies, function (currency) {
	        return { value: currency.id, text: currency.iso_code + ' (' + currency.symbol + ')' };
	      });
	    };
	
	    this.asSimpleOptions = function () {
	      return _.select(this.asOptions(), function (currencyOption) {
	        return currencyOption.text === 'USD' || currencyOption.text === 'CAD' || currencyOption.text === 'GBP';
	      });
	    };
	
	    this.forIsoNum = function (isoNum) {
	      return _.find(currencies, { iso_num: parseInt(isoNum) });
	    };
	
	    this.forIsoCode = function (isoCode) {
	      return _.find(currencies, { iso_code: isoCode });
	    };
	  }
	
	  return new CurrenciesService();
	}

/***/ },
/* 150 */
/***/ function(module, exports) {

	'use strict';
	
	currencyDisplay.$inject = ["currencies"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = currencyDisplay;
	/*@ngInject*/
	function currencyDisplay(currencies) {
	  return function (input, property) {
	    var currentCurrency = currencies.forIsoNum(input.currency_iso_num);
	    return currentCurrency[property || 'symbol'];
	  };
	}

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

	'use strict';
	
	cuteFlash.$inject = ["$timeout", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = cuteFlash;
	/*@ngInject*/
	function cuteFlash($timeout, i18n) {
	  return {
	    restrict: 'A',
	    scope: {},
	    template: __webpack_require__(152),
	    link: function link(scope) {
	      scope.i18n = i18n;
	      scope.showFlash = false;
	      scope.flashSuccess = false;
	      scope.flashMessage = '';
	
	      var DISMISS_TIMEOUT = 3000;
	
	      scope.$on('flash', function (event, args) {
	        scope.showFlash = true;
	
	        scope.flashSuccess = args.status === 'success';
	        scope.flashMessage = args.message;
	
	        $timeout(function () {
	          scope.showFlash = false;
	          scope.flashSuccess = true;
	        }, DISMISS_TIMEOUT);
	      });
	    }
	  };
	}

/***/ },
/* 152 */
/***/ function(module, exports) {

	module.exports = "<div class=\"cute-flash-relative-container am-fade\" ng-if=\"showFlash\">\n  <div class=\"cute-flash-absolute-container\">\n    <div class=\"messageNotification cute-flash\" ng-class=\"{'messageNotification--success': flashSuccess, 'messageNotification--error': !flashSuccess}\">\n      <div class=\"messageNotification-header\">{{flashMessage}}</div>\n    </div>\n  </div>\n</div>\n";

/***/ },
/* 153 */
/***/ function(module, exports) {

	"use strict";
	
	dataStore.$inject = ["$cookies"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = dataStore;
	/*@ngInject*/
	
	function dataStore($cookies) {
	  return {
	    getValueForKey: function getValueForKey(key) {
	      return $cookies.get(key);
	    },
	    setValueForKey: function setValueForKey(key, value) {
	      return $cookies.put(key, value);
	    }
	  };
	}

/***/ },
/* 154 */
/***/ function(module, exports) {

	'use strict';
	
	date.$inject = ["$rootScope", "_", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = date;
	/*@ngInject*/
	function date($rootScope, _, i18n) {
	  var today = new Date();
	  var months = [{ id: '', text: i18n.t('campaign_editor.misc.month'), days: 0 }, { id: 0, text: i18n.t('campaign_editor.misc.date_options.january'), days: 31 }, { id: 1, text: i18n.t('campaign_editor.misc.date_options.february'), days: 28 }, { id: 2, text: i18n.t('campaign_editor.misc.date_options.march'), days: 31 }, { id: 3, text: i18n.t('campaign_editor.misc.date_options.april'), days: 30 }, { id: 4, text: i18n.t('campaign_editor.misc.date_options.may'), days: 31 }, { id: 5, text: i18n.t('campaign_editor.misc.date_options.june'), days: 30 }, { id: 6, text: i18n.t('campaign_editor.misc.date_options.july'), days: 31 }, { id: 7, text: i18n.t('campaign_editor.misc.date_options.august'), days: 31 }, { id: 8, text: i18n.t('campaign_editor.misc.date_options.september'), days: 30 }, { id: 9, text: i18n.t('campaign_editor.misc.date_options.october'), days: 31 }, { id: 10, text: i18n.t('campaign_editor.misc.date_options.november'), days: 30 }, { id: 11, text: i18n.t('campaign_editor.misc.date_options.december'), days: 31 }];
	
	  var monthById = function monthById(id) {
	    return _.find(months, function (m) {
	      return m.id === id;
	    });
	  };
	
	  return {
	    today: today,
	    years: function years(range) {
	      var years = [{ id: '', text: i18n.t('campaign_editor.misc.year') }];
	      var startYear = today.getFullYear();
	      var endYear = startYear;
	
	      if (range > 0) endYear += range;else startYear += range;
	
	      for (var i = startYear; i <= endYear; i++) {
	        years.push({ id: i, text: i.toString() });
	      }return years;
	    },
	    months: months,
	    days: function days(month, year) {
	      var days = [{ id: '', text: i18n.t('campaign_editor.misc.day') }];
	      var startOfNextMonth = new Date(year, month + 1, 1);
	      startOfNextMonth.setDate(-1);
	      for (var i = 1; i <= startOfNextMonth.getDate() + 1; i++) {
	        days.push({ id: i, text: i.toString() });
	      }return days;
	    },
	    daysWithoutText: function daysWithoutText(monthId, year) {
	      var month = monthById(monthId);
	
	      var numberOfDays = month && month.days || 31;
	      if (year && year % 4 === 0 && month && month.id === 1) {
	        //leap years
	        numberOfDays++;
	      }
	      return _.range(1, numberOfDays + 1);
	    },
	    isNull: function isNull(option) {
	      return _.isNull(option) || _.isUndefined(option) || option.id === '';
	    },
	    dayById: function dayById(id, days) {
	      return _.find(days, function (d) {
	        return d.id === id;
	      });
	    },
	    dayByDate: function dayByDate(d, days) {
	      return this.dayById(d.getDate(), days);
	    },
	    monthById: monthById,
	    monthByDate: function monthByDate(d) {
	      return this.monthById(d.getMonth());
	    },
	    yearById: function yearById(id, years) {
	      return _.find(years, function (y) {
	        return y.id === id;
	      });
	    },
	    yearByDate: function yearByDate(d, year) {
	      return this.yearById(d.getFullYear(), year);
	    }
	  };
	}

/***/ },
/* 155 */
/***/ function(module, exports) {

	'use strict';
	
	dotdotdot.$inject = ["$timeout"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = dotdotdot;
	/*@ngInject*/
	function dotdotdot($timeout) {
	  return {
	    restrict: 'A',
	    scope: {
	      numLines: '=dotdotdotNumLines'
	    },
	    link: function link(scope, element) {
	      if (typeof scope.numLines === 'undefined') {
	        element.dotdotdot();
	      } else {
	        $timeout(function () {
	          var desiredTotalHeight = parseInt(element.css("line-height")) * scope.numLines;
	          element.dotdotdot({
	            height: desiredTotalHeight,
	            wrap: "letter",
	            watch: "window"
	          });
	        });
	      }
	    }
	  };
	}

/***/ },
/* 156 */
/***/ function(module, exports) {

	'use strict';
	
	emailSubscriber.$inject = ["$rootScope", "$http", "$window", "browser", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = emailSubscriber;
	/*@ngInject*/
	function emailSubscriber($rootScope, $http, $window, browser, i18n) {
	  var campaignSlug = $window.location.pathname.split('/')[2];
	  var baseUrl = '/private_api/campaigns/' + campaignSlug;
	
	  var button_text = i18n.t('email_subscriber.sign_up');
	  var placeholder = i18n.t('email_subscriber.your_email_address');
	
	  function setOptions(options) {
	    button_text = options.button_text || button_text;
	    placeholder = options.placeholder || placeholder;
	    $rootScope.$broadcast('EmailOptionsUpdated');
	  }
	
	  function getOptions() {
	    return {
	      button_text: button_text,
	      placeholder: placeholder
	    };
	  }
	
	  function getEmails() {
	    var csvUrl = baseUrl + '/email_subscribers';
	    browser.redirectTo(csvUrl);
	  }
	
	  function subscribeEmail(subscriber, source) {
	    source = source || 'unknown';
	    subscriber.source = source;
	    return $http.post(baseUrl + '/subscribe', { email_subscriber: subscriber });
	  }
	
	  return {
	    subscribeEmail: subscribeEmail,
	    getEmails: getEmails,
	    setOptions: setOptions,
	    getOptions: getOptions
	  };
	}

/***/ },
/* 157 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = embeddableLinkHtml;
	/*@ngInject*/
	function embeddableLinkHtml() {
	  return function (linkText, href) {
	    var wrapperDiv = $('<div><a target="_blank"></a></div>');
	    var link = wrapperDiv.find('a');
	    link.attr('href', href);
	    link.text(linkText);
	    return wrapperDiv.html();
	  };
	}

/***/ },
/* 158 */
/***/ function(module, exports) {

	'use strict';
	
	embedly.$inject = ["gon", "$http", "$q"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = embedly;
	/*@ngInject*/
	function embedly(gon, $http, $q) {
	
	  var embedlyConf = {
	    apiKey: gon && gon.embedly_conf && gon.embedly_conf.api_key,
	    apiUrl: "https://api.embed.ly/1/oembed"
	  };
	
	  return {
	    fetchVideoHtml: function fetchVideoHtml(videoUrl, width, height) {
	      var params = {
	        'key': embedlyConf.apiKey,
	        'url': videoUrl,
	        'width': width,
	        'height': height
	      };
	
	      var deferred = $q.defer();
	      $http.get(embedlyConf.apiUrl, { params: params }).success(function (response) {
	        if (_.isUndefined(response.html)) {
	          deferred.reject();
	        } else {
	          deferred.resolve(response);
	        }
	      }).error(function () {
	        deferred.reject();
	      });
	      return deferred.promise;
	    }
	  };
	}

/***/ },
/* 159 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = keys;
	/*@ngInject*/
	function keys() {
	  return {
	    restrict: 'A',
	    link: function link(scope, element, attrs) {
	      element.bind("keyup", function (event) {
	        if (event.which === 13) {
	          scope.$apply(function () {
	            scope.$eval(attrs.enterKeypress);
	          });
	          event.preventDefault();
	        }
	      });
	    }
	  };
	}

/***/ },
/* 160 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function ($http, $q, gon, $timeout) {
	  var fb = {
	    shareCount: null
	  };
	
	  var shareCountFetched = false;
	  var shareCountUrl = null;
	
	  fb.setUrls = function (urls) {
	    shareCountUrl = urls.shareCount;
	  };
	
	  fb.login = function (args) {
	    var deferred = $q.defer();
	    FB.login(function (response) {
	      deferred.resolve(response);
	    }, args);
	    return deferred.promise;
	  };
	
	  fb.share = function (uri, options) {
	    options = options || {};
	    var queryPrefix = '?';
	    if (uri.includes('?')) {
	      queryPrefix = '&';
	    }
	    var ref = queryPrefix.concat('ref=gogo__', options.iggref || 'fblk');
	    ref = options.account_id ? ref.concat('__', options.account_id) : ref;
	    var utms = options.utm_query_string ? '&'.concat(options.utm_query_string) : '';
	    var params = {
	      method: 'share',
	      href: uri + ref + utms,
	      redirect_uri: uri
	    };
	    return fb.ui(params);
	  };
	
	  fb.ui = function (params) {
	    var deferred = $q.defer();
	    $timeout(function () {
	      // http://stackoverflow.com/a/18996042
	      FB.ui(params, function (response) {
	        if (response && !response.error_code) {
	          deferred.resolve(response);
	        } else {
	          deferred.reject(response);
	        }
	      });
	    });
	    return deferred.promise;
	  };
	
	  fb.fetchShareCount = function () {
	    if (!shareCountFetched) {
	      /* lets remove the gon dependency from this service by allowing
	       * shareCountUrl to be specified from the outside. For now,
	       * fallback to looking on the gon when that's not present
	       */
	      var url = shareCountUrl || gon.urls && gon.urls.fb_share_count_url;
	      $http.get(url).then(function (res) {
	        fb.shareCount = res.data.fb_share_count;
	      });
	    }
	
	    shareCountFetched = true;
	  };
	
	  fb.refreshAllWidgets = function () {
	    try {
	      FB.XFBML.parse();
	    } catch (ex) {}
	  };
	
	  return fb;
	};

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	function fbTrackingPixel($window, $log, gon) {
	  return {
	    restrict: 'E',
	    scope: {},
	    template: __webpack_require__(162),
	    link: function link(scope, element, attrs) {
	      scope.shouldTrack = gon.tracking_info && gon.tracking_info.fb_pixel_id && (gon.tracking_info.amount || gon.tracking_info.amount === 0) && gon.tracking_info.currency_iso_code;
	
	      angular.element(document).ready(function () {
	        if (scope.shouldTrack) {
	          var _fbq;
	          if (!$window._fbq) {
	            $window._fbq = [];
	          }
	          _fbq = $window._fbq;
	          if (!_fbq.loaded) {
	            var fbds = void 0;
	            fbds = document.createElement('script');
	            fbds.async = true;
	            fbds.src = '//connect.facebook.net/en_US/fbds.js';
	            var s = document.getElementsByTagName('script')[0];
	            s.parentNode.insertBefore(fbds, s);
	            _fbq.loaded = true;
	          }
	          $window._fbq = $window._fbq || [];
	          _fbq.push(['track', gon.tracking_info.fb_pixel_id, {
	            'value': gon.tracking_info.amount,
	            'currency': gon.tracking_info.currency_iso_code
	          }]);
	        } else {
	          $log.debug('fbTrackingPixel directive rendered without required attributes: pixel-id, amount, currencyIsoCode');
	        }
	      });
	
	      scope.fbTrackingPixelUrl = function () {
	        return "https://www.facebook.com/tr?ev=" + gon.tracking_info.fb_pixel_id + "&cd[value]=" + gon.tracking_info.amount + "&cd[currency]=" + gon.tracking_info.currency_iso_code + "&noscript=1";
	      };
	    }
	  };
	}
	fbTrackingPixel.$inject = ['$window', '$log', 'gon'];
	
	exports.default = fbTrackingPixel;

/***/ },
/* 162 */
/***/ function(module, exports) {

	module.exports = "<noscript ng-if=\"shouldTrack\"><img height=\"1\" width=\"1\" alt=\"\" style=\"display:none\" src=\"{{fbTrackingPixelUrl()}}\"></noscript>\n";

/***/ },
/* 163 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (browser, $sce, $rootScope, $window, $cookies) {
	  var flashService = {};
	  flashService.flashes = [];
	
	  flashService.replaceMessage = function (alertLevel, message, options) {
	    _.remove(flashService.flashes, function () {
	      return true;
	    });
	    flashService.addMessage(alertLevel, message, options);
	  };
	
	  flashService.addMessage = function (alertLevel, message, options) {
	    options = _.merge({}, options);
	    if (options.html) {
	      flashService.flashes.push({
	        messageHtml: $sce.trustAsHtml(message),
	        alertLevel: alertLevel
	      });
	    } else {
	      flashService.flashes.push({
	        messageText: message,
	        alertLevel: alertLevel
	      });
	    }
	    if (options.fromOutsideAngular) {
	      $rootScope.$digest();
	    }
	    browser.scrollToTop();
	  };
	
	  flashService.addMessageForAfterRedirect = function (alertLevel, message, options) {
	    $cookies.putObject('flash', { alertLevel: alertLevel, messageText: message, options: options });
	  };
	
	  flashService.getMessageForAfterRedirect = function () {
	    var previousFlash = $cookies.getObject('flash');
	
	    if (previousFlash !== undefined) {
	      $cookies.remove('flash');
	    }
	
	    return previousFlash;
	  };
	
	  $window.showFlashMessage = function (args) {
	    flashService.addMessage(args.alertLevel, args.messageText, { fromOutsideAngular: true, html: args.html });
	  };
	
	  var previousFlash = flashService.getMessageForAfterRedirect();
	
	  if (previousFlash !== undefined) {
	    flashService.addMessage(previousFlash.alertLevel, previousFlash.messageText, previousFlash.options);
	  }
	
	  return flashService;
	};

/***/ },
/* 164 */
/***/ function(module, exports) {

	"use strict";
	
	froogaloop.$inject = ["$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = froogaloop;
	/*@ngInject*/
	function froogaloop($window) {
	  return function (sel) {
	    return $window.$f(sel);
	  };
	}

/***/ },
/* 165 */
/***/ function(module, exports) {

	"use strict";
	
	gogoLocation.$inject = ["$window"];
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.default = gogoLocation;
	/*@ngInject*/
	function gogoLocation($window) {
	    return $window.location;
	}

/***/ },
/* 166 */
/***/ function(module, exports) {

	'use strict';
	
	gplus.$inject = ["$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = gplus;
	/*@ngInject*/
	function gplus($window) {
	  return {
	    refreshAllWidgets: function refreshAllWidgets() {
	      var gapi = $window.gapi;
	      if (typeof gapi !== 'undefined') {
	        gapi.plusone.go();
	      }
	    }
	  };
	}

/***/ },
/* 167 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = htmlCharCounter;
	/*@ngInject*/
	function htmlCharCounter() {
	  function stripTags(html) {
	    return $('<div>' + html + '</div>').text().replace(/\t+/g, " ").replace(/\n/g, "").replace(/^\s/g, "");
	  }
	
	  return function (input, maxLength, delimiter) {
	    var charsLeft = maxLength;
	
	    if (input) {
	      charsLeft = maxLength - stripTags(input).length;
	    }
	
	    return charsLeft.toString() + " " + (delimiter ? delimiter : "/") + " " + maxLength;
	  };
	}

/***/ },
/* 168 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = htmlWrapped;
	/*@ngInject*/
	function htmlWrapped() {
	  return function (text, tag) {
	    var tagEl = $(tag);
	    tagEl.text(text);
	    var wrapperEl = $("<div>");
	    wrapperEl.append(tagEl);
	    return wrapperEl.html();
	  };
	}

/***/ },
/* 169 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (i18n) {
	  return {
	    scope: true,
	    link: function link($scope) {
	      $scope.i18n = i18n;
	    }
	  };
	};

/***/ },
/* 170 */
/***/ function(module, exports) {

	'use strict';
	
	i18n.$inject = ["$sce", "gon", "I18nRails", "$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = i18n;
	/*@ngInject*/
	function i18n($sce, gon, I18nRails, $window) {
	  var currentLocale = I18nRails.locale;
	  if ($window.moment) {
	    $window.moment.locale(currentLocale);
	  }
	  var domain = gon.domain;
	
	  function translateAdjustingKeyForGenerosity(key, options) {
	    if (typeof gon !== 'undefined' && domain === 'generosity') {
	      return generosityTranslate(key, options);
	    } else {
	      return translate(key, options);
	    }
	  }
	
	  function generosityTranslate(key, options) {
	    var genKey = 'generosity.' + key;
	    return translate(genKey, options);
	  }
	
	  function localeGlobalSafe(func) {
	    var oldLocale = I18nRails.locale;
	    var returnVal = null;
	    I18nRails.locale = currentLocale;
	    try {
	      returnVal = func();
	    } finally {
	      I18nRails.locale = oldLocale;
	    }
	    return returnVal;
	  }
	
	  function translate(key, options) {
	    return localeGlobalSafe(function () {
	      var translation = I18nRails.t(key, options);
	      if (key.match(/html$/)) {
	        return $sce.trustAsHtml(translation);
	      } else {
	        return translation;
	      }
	    });
	  }
	
	  function strftime(object, format) {
	    return localeGlobalSafe(function () {
	      return I18nRails.strftime(object, format);
	    });
	  }
	
	  function setLocale(newLocale) {
	    currentLocale = newLocale || I18nRails.defaultLocale;
	    this.locale = currentLocale;
	    $window.moment.locale(currentLocale);
	  }
	
	  function localize(date, options) {
	    return localeGlobalSafe(function () {
	      var format = I18nRails.lookup('date.formats.' + options.format);
	      return strftime(date, format);
	    });
	  }
	
	  return {
	    locale: currentLocale,
	    setLocale: setLocale,
	    strftime: strftime,
	    t: translate,
	    l: localize,
	    pt: translateAdjustingKeyForGenerosity
	  };
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	   value: true
	});
	
	exports.default = function ($log, $window, gon) {
	   var iggAirbrake = new _iggAirbrake2.default($log, $window, gon);
	   iggAirbrake.addExceptionFilter(/interpolate:interr/);
	   iggAirbrake.addExceptionFilter(/compile:multidir/);
	   return iggAirbrake;
	};
	
	var _iggAirbrake = __webpack_require__(172);
	
	var _iggAirbrake2 = _interopRequireDefault(_iggAirbrake);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ },
/* 172 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var isProduction = function isProduction(hostname) {
	  return (/.com$/g.test(hostname)
	  );
	};
	var isStaging = function isStaging(hostname) {
	  return (/.net$/g.test(hostname)
	  );
	};
	
	var IggAirbrake = function () {
	  function IggAirbrake($log, $window, gon) {
	    _classCallCheck(this, IggAirbrake);
	
	    this.$window = $window;
	    this.$log = $log;
	    this.gon = gon;
	    this.filteredExceptionPatterns = [];
	    this.handle = this.handle.bind(this);
	  }
	
	  _createClass(IggAirbrake, [{
	    key: 'shouldLogErrors',
	    value: function shouldLogErrors() {
	      try {
	        var hostname = this.$window.location.hostname;
	        return isProduction(hostname) || isStaging(hostname);
	      } catch (err) {
	        return false;
	      }
	    }
	  }, {
	    key: 'canLogErrors',
	    value: function canLogErrors() {
	      return this.gon.airbrake_conf && this.gon.airbrake_conf.javascript_api_key && this.$window.airbrakeJs;
	    }
	  }, {
	    key: '_client',
	    value: function _client() {
	      var _this = this;
	
	      var client = new this.$window.airbrakeJs.Client({
	        projectId: this.gon.airbrake_conf.javascript_project_id,
	        projectKey: this.gon.airbrake_conf.javascript_api_key
	      });
	      client.addFilter(function (notice) {
	        notice.context.environment = _this.gon.airbrake_conf.environment;
	        return notice;
	      });
	      client.addFilter(function (notice) {
	        var error = notice.errors[0];
	        var errorMessage = error.toString();
	        var matchingFilters = _this.filteredExceptionPatterns.filter(function (pattern) {
	          return pattern.test(errorMessage);
	        });
	        if (matchingFilters.length > 0) {
	          return null;
	        }
	        return notice;
	      });
	      return client;
	    }
	  }, {
	    key: 'addExceptionFilter',
	    value: function addExceptionFilter(regex) {
	      this.filteredExceptionPatterns.push(regex);
	    }
	  }, {
	    key: '_notifyClient',
	    value: function _notifyClient(error, params) {
	      this.$log.error(error.message);
	      try {
	        this._client().notify({
	          error: error,
	          params: params
	        });
	      } catch (e) {
	        this.$log.error('Failed to notify Airbrake due to the following error');
	        this.$log.error(e);
	      }
	    }
	  }, {
	    key: 'handle',
	    value: function handle(exception, cause) {
	      var notificationParams = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
	
	      if (this.canLogErrors() && this.shouldLogErrors()) {
	        var params = notificationParams;
	        if (cause) {
	          params.angular_cause = cause;
	        }
	        if (this.gon.current_user) {
	          params.current_user_id = this.gon.current_user.id;
	        }
	        this._notifyClient(exception, params);
	      } else if (this.$window.skipExceptions !== true) {
	        throw exception;
	      }
	    }
	  }, {
	    key: 'logError',
	    value: function logError(message) {
	      var errorParams = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	
	      if (message && this.canLogErrors() && this.shouldLogErrors()) {
	        var error = new Error(message);
	        this._notifyClient(error, errorParams);
	      }
	    }
	  }]);
	
	  return IggAirbrake;
	}();
	
	exports.default = IggAirbrake;

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (CKEDITOR, csrfToken) {
	  if (_.isUndefined(CKEDITOR)) {
	    return {};
	  }
	  return {
	    defaultOptions: {
	      language: 'en',
	      allowedContent: true,
	      entities: false,
	      forcePasteAsPlainText: true,
	      uploadUrl: (0, _metal.ckeditorUploadImagePath)(),
	      filebrowserImageUploadUrl: (0, _metal.ckeditorUploadDialogImagePath)(),
	      removeDialogTabs: 'image:advanced;link:advanced;image:Link',
	      removeButtons: 'Subscript,Superscript',
	      toolbarGroups: [{ name: 'clipboard', groups: ['clipboard', 'undo'] }, { name: 'editing', groups: ['find', 'selection', 'spellchecker'] }, { name: 'links' }, { name: 'insert' }, { name: 'forms' }, { name: 'tools' }, { name: 'document', groups: ['mode', 'document', 'doctools'] }, { name: 'others' }, '/', { name: 'basicstyles', groups: ['basicstyles', 'cleanup'] }, { name: 'paragraph', groups: ['list', 'indent', 'blocks', 'align', 'bidi'] }, { name: 'styles' }, { name: 'colors' }, { name: 'about' }],
	      toolbar: [{ name: 'basicstyles', items: ['Bold', 'Italic', 'Underline'] }, { name: 'styles', items: ['Format'] }, { name: 'links', items: ['Link', 'Unlink'] }, { name: 'paragraph', items: ['NumberedList', 'BulletedList', '-', 'Outdent', 'Indent', '-', 'Blockquote', 'JustifyLeft', 'JustifyCenter', 'JustifyRight'] }, { name: 'insert', items: ['Image', 'VideoDetector'] }, { name: 'source', items: ['Source'] }],
	      format_tags: 'p;h2;h3',
	      enterMode: CKEDITOR.ENTER_P,
	      extraPlugins: 'videodetector,image,filebrowser,popup,sourcearea',
	      coreStyles_italic: {
	        element: 'i',
	        attributes: { 'class': 'cke_italic' }
	      }
	    },
	
	    onReady: function onReady(editor, onReadyCallback) {
	      editor.uploadRepository.editor.on('fileUploadRequest', function (event) {
	        event.data.fileLoader.xhr.setRequestHeader('X-CSRF-Token', csrfToken.getToken());
	      });
	
	      CKEDITOR.lang.en.format.tag_p = 'Paragraph';
	      CKEDITOR.lang.en.format.tag_h2 = 'Header 1';
	      CKEDITOR.lang.en.format.tag_h3 = 'Header 2';
	
	      if (onReadyCallback) {
	        onReadyCallback(editor);
	      }
	    }
	  };
	};
	
	var _metal = __webpack_require__(174);

/***/ },
/* 174 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.ckeditorUploadDialogImagePath = ckeditorUploadDialogImagePath;
	exports.ckeditorUploadImagePath = ckeditorUploadImagePath;
	exports.redactorEmbedPath = redactorEmbedPath;
	exports.redactorUploadImagePath = redactorUploadImagePath;
	function ckeditorUploadDialogImagePath() {
	  return "/ckeditor/upload_dialog_image";
	}
	function ckeditorUploadImagePath() {
	  return "/ckeditor/upload_image";
	}
	function redactorEmbedPath() {
	  return "/redactor/embed";
	}
	function redactorUploadImagePath() {
	  return "/redactor/upload_image";
	}

/***/ },
/* 175 */
/***/ function(module, exports) {

	"use strict";
	
	iggCurrency.$inject = ["currencies", "numberFilter", "$sce"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = iggCurrency;
	/*@ngInject*/
	function iggCurrency(currencies, numberFilter, $sce) {
	  return function (input, isoNumber, optionsString) {
	    var options = (optionsString || '').split(",");
	    var currentCurrency = currencies.forIsoNum(isoNumber);
	
	    var precision = options.indexOf("cents") >= 0 ? 2 : 0;
	    var value = numberFilter(input || 0, precision);
	    var symbolicValue = currentCurrency.symbol + value;
	    var isoCode = currentCurrency.iso_code;
	
	    if (options.indexOf("html") >= 0) {
	      var markup = '<span class="currency"><span>' + symbolicValue + '</span><em>' + isoCode + '</em></span>';
	      return $sce.trustAsHtml(markup);
	    } else if (options.indexOf("separated") >= 0) {
	      return { "symbolicValue": symbolicValue, "isoCode": isoCode };
	    } else if (options.indexOf('noIso') >= 0) {
	      return symbolicValue;
	    } else {
	      return symbolicValue + " " + isoCode;
	    }
	  };
	}

/***/ },
/* 176 */
/***/ function(module, exports) {

	"use strict";
	
	iggExternal.$inject = ["callback"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = iggExternal;
	/*@ngInject*/
	function iggExternal(callback) {
	  callback.apply(this, arguments);
	}

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

	'use strict';
	
	iggPopover.$inject = ["$popover", "$sce", "$compile", "$timeout"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = iggPopover;
	/*@ngInject*/
	function iggPopover($popover, $sce, $compile, $timeout) {
	  return {
	    restrict: 'A',
	    transclude: true,
	    replace: true,
	    template: function template(elem, attrs) {
	      if (attrs.text) {
	        return __webpack_require__(178);
	      } else if (attrs.html) {
	        return __webpack_require__(179);
	      } else {
	        return __webpack_require__(180);
	      }
	    },
	    scope: {
	      placement: '@',
	      text: '@',
	      entre: '='
	    },
	    link: function link(scope, element, attributes, controller, transclude) {
	      var placement = scope.placement || 'right';
	      if (attributes.html) {
	        scope.trustedHtml = $sce.trustAsHtml(attributes.html);
	      }
	      transclude(function (clone) {
	        var ctx = $("<div></div>");
	        clone.appendTo(ctx);
	        var compiledElement = $compile(ctx)(scope);
	        element.show();
	        $timeout(function () {
	          var popoverOptions = {
	            content: $sce.trustAsHtml(compiledElement.html()),
	            trigger: 'hover click',
	            html: true,
	            placement: placement,
	            autoClose: true
	          };
	          if (typeof attributes.closeDelay !== 'undefined') {
	            popoverOptions.delay = { show: 0, hide: 1500 };
	          }
	          $popover(element, popoverOptions);
	        });
	      });
	    }
	  };
	}

/***/ },
/* 178 */
/***/ function(module, exports) {

	module.exports = "<span class=\"iggPopoverText\" ng-class=\"{ 'entreTooltip' : entre }\">{{text}}</span>\n";

/***/ },
/* 179 */
/***/ function(module, exports) {

	module.exports = "<span class=\"iggPopoverHtml\" ng-class=\"{ 'entreTooltip' : entre }\" ng-bind-html=\"trustedHtml\"></span>\n";

/***/ },
/* 180 */
/***/ function(module, exports) {

	module.exports = "<span class=\"infoBubble\" ng-class=\"{ 'entreTooltip' : entre }\">\n  <svg-icon icon=\"icon-icon-help\" ng-if=\"!entre\"></svg-icon>\n  <svg-icon icon=\"icon-tooltip-question\" ng-if=\"entre\"></svg-icon>\n</span>\n";

/***/ },
/* 181 */
/***/ function(module, exports) {

	'use strict';
	
	iggProjectCard.$inject = ["projectCard"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = iggProjectCard;
	/*@ngInject*/
	function iggProjectCard(projectCard) {
	  return {
	    restrict: 'A',
	    link: function link(scope, element) {
	      projectCard.setupDelayedImageLoad(element);
	      projectCard.ellipsizeProjectCardTagline(element);
	    }
	  };
	}

/***/ },
/* 182 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = ignoreDirty;
	/*@ngInject*/
	function ignoreDirty() {
	  return {
	    restrict: 'A',
	    require: 'ngModel',
	    link: function link(scope, element, attributes, ngModel) {
	      ngModel.$setPristine = function () {};
	      ngModel.$pristine = false;
	    }
	  };
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = individualAvatar;
	/*@ngInject*/
	function individualAvatar() {
	  return {
	    scope: {
	      individualAvatar: '@'
	    },
	    template: __webpack_require__(184),
	    restrict: 'A',
	    replace: true,
	    link: function link($scope, $element) {}
	  };
	}

/***/ },
/* 184 */
/***/ function(module, exports) {

	module.exports = "<div class=\"individualAvatar\">\n  <img ng-if=\"individualAvatar\" ng-src=\"{{individualAvatar}}\" />\n  <span class=\"missingAvatar\" ng-if=\"!individualAvatar\"></span>\n</div>\n";

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function () {
	  return {
	    scope: {
	      message: '@',
	      linkText: '@',
	      link: '@',
	      onGenerosity: '@'
	    },
	    template: __webpack_require__(186),
	    link: function link(scope, element) {
	      scope.hideMessage = function () {
	        element.addClass('hidden');
	      };
	    }
	  };
	};

/***/ },
/* 186 */
/***/ function(module, exports) {

	module.exports = "<div class=\"container i-info-message-container\">\n  <span class=\"info-message-text i-info-message-text\">\n    <span class=\"info-message-message\">{{::message}}</span> <a ng-href=\"{{::link}}\" class=\"info-message-link i-cta-1 i-cta-1--ghostWhite small-ghost-cta--dark\" ng-if=\"link\">{{::linkText}}</a>\n  </span>\n  <svg-icon icon=\"icon-icon-close\" ng-class=\"{'container': onGenerosity}\" ng-click=\"hideMessage()\"></svg-icon>\n</div>\n";

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

	'use strict';
	
	insightsContribAwarenessMessageNotification.$inject = ["$timeout", "i18n", "$cookies", "gogoEvents"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = insightsContribAwarenessMessageNotification;
	/*@ngInject*/
	function insightsContribAwarenessMessageNotification($timeout, i18n, $cookies, gogoEvents) {
	  return {
	    restrict: 'E',
	    scope: {
	      projectSlug: '@'
	    },
	    template: __webpack_require__(188),
	    transclude: true,
	    replace: true,
	    link: function link(scope) {
	      scope.i18n = i18n;
	      scope.hideBanner = false;
	      scope.messageHeader = i18n.t('insights_contrib_awareness.banner.did_you_know');
	      scope.messageDescription = i18n.t('insights_contrib_awareness.banner.description');
	
	      gogoEvents.track({
	        thetaName: 'command-center-insights.campaign-page-prompt/view',
	        gaEventCategory: 'Command Center Insights',
	        gaEventAction: 'Campaign Page Prompt',
	        gaEventLabel: 'View'
	      });
	
	      scope.goToDashboard = function () {
	        $cookies.put('insights_contrib_awareness_prompted', 'true'); // persist in a cookie since it's not in the db
	        gogoEvents.track({
	          thetaName: 'command-center-insights.campaign-page-prompt-view-dashboard/click',
	          gaEventCategory: 'Command Center Insights',
	          gaEventAction: 'Campaign Page Prompt View Dashboard',
	          gaEventLabel: 'Click'
	        });
	        window.location = "/command_center/" + scope.projectSlug + '#/insights?utm_source=igg&utm_medium=banner&utm_content=CTA&utm_campaign=dashboardnotification';
	      };
	
	      scope.gotIt = function () {
	        $cookies.put('insights_contrib_awareness_prompted', 'true'); // persist in a cookie since it's not in the db
	        gogoEvents.track({
	          thetaName: 'command-center-insights.campaign-page-prompt-got-it/click',
	          gaEventCategory: 'Command Center Insights',
	          gaEventAction: 'Campaign Page Prompt Got It',
	          gaEventLabel: 'Click'
	        });
	
	        scope.hideBanner = true;
	      };
	    }
	  };
	}

/***/ },
/* 188 */
/***/ function(module, exports) {

	module.exports = "<div ng-hide=\"hideBanner\">\n  <div class=\"messageNotification messageNotification--info messageNotification--raised messageNotification--fixedHeight\">\n    <div class=\"container\">\n      <div class=\"col-md-12\">\n        <div class=\"messageNotification-header\">{{messageHeader}}</div>\n        {{messageDescription}}\n        <div class=\"messageNotification-buttons\">\n          <button class=\"cta-4 cta-4--small cta-4--purple\" ng-click=\"goToDashboard()\">{{::i18n.t('view_dashboard')}}</button> <button class=\"cta-4 cta-4-secondary cta-4-secondary--purple cta-4-secondary--small\" ng-click=\"gotIt()\">{{::i18n.t('got_it')}}</button>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n";

/***/ },
/* 189 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function ($http, $interpolate) {
	  var urls = { show: null };
	
	  return {
	    setUrls: function setUrls(u) {
	      if (angular.isUndefined(u.show)) {
	        throw new Error('a show url is required');
	      }
	
	      urls.show = u.show;
	    },
	
	    get: function get(jobId) {
	      var url = $interpolate(urls.show)({ id: jobId });
	      return $http.get(url);
	    }
	  };
	};

/***/ },
/* 190 */
/***/ function(module, exports) {

	'use strict';
	
	jobStatusPoller.$inject = ["$timeout", "jobStatusApi"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = jobStatusPoller;
	/*@ngInject*/
	function jobStatusPoller($timeout, jobStatusApi) {
	  var canceled = false;
	
	  return {
	    poll: function poll(uuid, period, callback) {
	      if (typeof callback !== 'function') {
	        throw new Error('a callback function is required');
	      }
	
	      function onSuccess(response) {
	        if (response.data.status === 'queued' || response.data.status === 'working') {
	          $timeout(function () {
	            if (!canceled) {
	              jobStatusApi.get(uuid).then(onSuccess, onFailure);
	            }
	          }, period);
	        }
	        callback(response);
	      }
	
	      function onFailure(response) {
	        callback(null);
	      }
	
	      jobStatusApi.get(uuid).then(onSuccess, onFailure);
	    },
	    cancel: function cancel() {
	      canceled = true;
	    },
	    reset: function reset() {
	      canceled = false;
	    }
	  };
	}

/***/ },
/* 191 */
/***/ function(module, exports) {

	'use strict';
	
	konami.$inject = ["browser"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = konami;
	/*@ngInject*/
	function konami(browser) {
	  return {
	    restrict: 'A',
	    link: function link(scope, element, attrs) {
	      var konamiSequence = [38, 38, 40, 40, 37, 39, 37, 39, 66, 65];
	      var sequenceIndex = 0;
	
	      $(element).on('keydown', function (ev) {
	        if (ev.keyCode === konamiSequence[sequenceIndex]) {
	          sequenceIndex += 1;
	          if (sequenceIndex === konamiSequence.length) {
	            browser.redirectTo('https://www.indiegogo.com/explore/gaming');
	          }
	        } else {
	          sequenceIndex = 0;
	        }
	      });
	    }
	  };
	}

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

	"use strict";
	
	linkToUnless.$inject = ["browser"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = linkToUnless;
	/*@ngInject*/
	function linkToUnless(browser) {
	  return {
	    restrict: 'A',
	    scope: {
	      redirectLink: "=",
	      displayText: "@"
	    },
	    template: __webpack_require__(193),
	    link: function link(scope) {
	      scope.redirect = browser.currentPath().includes(scope.redirectLink) ? false : true;
	    }
	  };
	}

/***/ },
/* 193 */
/***/ function(module, exports) {

	module.exports = "<a ng-if=\"redirect\" ng-href=\"{{ redirectLink }}\">\n  {{ displayText }}\n</a>\n<span ng-if=\"!redirect\" class=\"dashboard--selected\" >\n  {{ displayText  }}\n</span>\n";

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = pageTitleSection;
	
	__webpack_require__(195);
	
	function pageTitleSection(i18n) {
	  return {
	    scope: {
	      titleTranslationKey: '@',
	      subtitleTranslationKey: '@'
	    },
	    template: __webpack_require__(197),
	    link: function link(scope) {
	      scope.i18n = i18n;
	    }
	  };
	}

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

	// style-loader: Adds some css to the DOM by adding a <style> tag
	
	// load the styles
	var content = __webpack_require__(196);
	if(typeof content === 'string') content = [[module.id, content, '']];
	// add the styles to the DOM
	var update = __webpack_require__(66)(content, {});
	if(content.locals) module.exports = content.locals;
	// Hot Module Replacement
	if(false) {
		// When the styles change, update the <style> tags
		if(!content.locals) {
			module.hot.accept("!!./../../../node_modules/css-loader/index.js!./../../../node_modules/less-loader/index.js!./_page-title-section.less", function() {
				var newContent = require("!!./../../../node_modules/css-loader/index.js!./../../../node_modules/less-loader/index.js!./_page-title-section.less");
				if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
				update(newContent);
			});
		}
		// When the module is disposed, remove the <style> tags
		module.hot.dispose(function() { update(); });
	}

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

	exports = module.exports = __webpack_require__(65)();
	// imports
	
	
	// module
	exports.push([module.id, "/* Antenna Font Family Variations */\n/* Benton Font Family Variations */\n/** Perk Store mobile header text **/\n/** Only mobile campaign/contributions **/\n/* We can define top-left-dimple or left-top-dimple etc as necessary */\n.titleSection-header {\n  color: #000000;\n  padding-top: 20px;\n  padding-bottom: 20px;\n}\n@media (min-width: 768px) {\n  .titleSection-header {\n    padding-top: 50px;\n    padding-bottom: 50px;\n    text-align: center;\n  }\n}\n.titleSection-title {\n  font-family: \"Benton Sans\", \"Helvetica\", \"sans-serif\";\n  font-size: 18px;\n  font-weight: bold;\n  line-height: 26px;\n  letter-spacing: normal;\n}\n@media (min-width: 768px) {\n  .titleSection-title {\n    font-family: \"Antenna Cond Black\", \"Helvetica\", \"sans-serif\";\n    font-size: 50px;\n    line-height: 58px;\n    letter-spacing: 1px;\n    margin-bottom: 5px;\n  }\n}\n.titleSection-subtitle {\n  font-family: \"Benton Sans\", \"Helvetica\", \"sans-serif\";\n  font-size: 14px;\n  font-weight: normal;\n  line-height: 20px;\n}\n@media (min-width: 768px) {\n  .titleSection-subtitle {\n    font-family: \"Benton Sans\", \"Helvetica\", \"sans-serif\";\n    font-size: 16px;\n    font-weight: bold;\n    line-height: 26px;\n    letter-spacing: 0;\n  }\n}\n", ""]);
	
	// exports


/***/ },
/* 197 */
/***/ function(module, exports) {

	module.exports = "<div class=\"titleSection-header i-mobile-container--15\">\n  <h1 class=\"titleSection-title\">\n    {{ ::i18n.t(titleTranslationKey) }}\n  </h1>\n  <div class=\"titleSection-subtitle\">\n    {{ ::i18n.t(subtitleTranslationKey) }}\n  </div>\n</div>\n";

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

	'use strict';
	
	pagination.$inject = ["i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = pagination;
	/*@ngInject*/
	function pagination(i18n) {
	  return {
	    restrict: 'A',
	    scope: {
	      pagination: "="
	    },
	    transclude: false,
	    replace: false,
	    template: __webpack_require__(199),
	    link: function link(scope, element, attrs, nullController, transclude) {
	      scope.i18n = i18n;
	      var MAX_PAGES = 9;
	      var SURROUNDING_PAGES = Math.floor(MAX_PAGES / 2);
	
	      var inMiddle = function inMiddle(pagination) {
	        // there are more than 4 pages to either side of the current page
	        return pagination.data.current - SURROUNDING_PAGES >= 1 && pagination.data.current + SURROUNDING_PAGES <= pagination.data.pages;
	      };
	
	      var morePages = function morePages(pagination) {
	        return pagination.data.pages > MAX_PAGES;
	      };
	
	      var atEnd = function atEnd(pagination) {
	        return pagination.data.current >= pagination.data.pages - SURROUNDING_PAGES;
	      };
	
	      scope.generatePageRange = function (pagination) {
	        if (inMiddle(pagination)) {
	          // the current page can fit comfortably in the middle of all pages
	          // (as defined by SURROUNDING_PAGES, so there need to be 4 pages on either side)
	          var start = pagination.data.current - SURROUNDING_PAGES;
	          var end = pagination.data.current + SURROUNDING_PAGES;
	          return _.range(start, end + 1);
	        } else if (atEnd(pagination) && morePages(pagination)) {
	          return _.range(pagination.data.pages - MAX_PAGES + 1, pagination.data.pages + 1);
	        }
	
	        // the normal case is to just return the number of pages we have, starting at 1.
	        return _.range(1, Math.min(MAX_PAGES, pagination.data.pages) + 1);
	      };
	
	      scope.isCurrentPage = function (pageNumber) {
	        return scope.pagination.data.current === pageNumber;
	      };
	
	      scope.showBeginningPageGap = function (pagination) {
	        return scope.generatePageRange(pagination)[0] != 1;
	      };
	
	      scope.showEndingPageGap = function (pagination) {
	        var range = scope.generatePageRange(pagination);
	        return range[range.length - 1] != pagination.data.pages;
	      };
	    }
	  };
	}

/***/ },
/* 199 */
/***/ function(module, exports) {

	module.exports = "<div class=\"js-pagination-links i-pagination-directive-links\" ng-if=\"pagination.data.pages > 1\">\n  <div class=\"pagination-previous\" ng-if=\"pagination.data.previous\" class=\"pagination-previous\">\n    <a class=\"first-link unselected\" ng-click=\"pagination.getPage({ page: 1 })\">{{i18n.t('will_paginate.first_label')}}</a>\n    <a class=\"previous-link unselected\" ng-click=\"pagination.getPage({ page: pagination.data.previous })\">{{i18n.t('will_paginate.previous_label')}}</a><span class=\"page-gap\" ng-if=\"showBeginningPageGap(pagination)\">{{i18n.t('will_paginate.page_gap')}}</span>\n  </div>\n  <div ng-class=\"{'selected-page-number': isCurrentPage(pageNumber), 'page-number': true}\" ng-repeat=\"pageNumber in generatePageRange(pagination)\">\n    <div ng-if=\"!isCurrentPage(pageNumber)\">\n      <a class=\"page-link page-{{pageNumber}} unselected\" ng-click=\"pagination.getPage({page: pageNumber})\">{{ pageNumber}}</a>\n    </div>\n    <div ng-if=\"isCurrentPage(pageNumber)\">\n      <span class=\"current selected\">{{pageNumber}}</span>\n    </div>\n  </div>\n  <div ng-class=\"{'pagination-next': true, 'i-hidden' : !pagination.data.next}\">\n    <span class=\"page-gap\" ng-if=\"showEndingPageGap(pagination)\">{{i18n.t('will_paginate.page_gap')}}</span>\n    <a class=\"next-link unselected\" ng-click=\"pagination.getPage({page: pagination.data.next})\">{{i18n.t('will_paginate.next_label')}}</a>\n    <a class=\"last-link unselected\" ng-click=\"pagination.getPage({page: pagination.data.pages})\">{{i18n.t('will_paginate.last_label')}}</a>\n  </div>\n</div>\n";

/***/ },
/* 200 */
/***/ function(module, exports) {

	'use strict';
	
	pledgeShareService.$inject = ["gon", "i18n", "fb"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = pledgeShareService;
	/*@ngInject*/
	function pledgeShareService(gon, i18n, fb) {
	  return {
	    postToFacebook: function postToFacebook(options) {
	      var namespaceAction = gon.domain === 'generosity' ? 'donate' : 'contribute';
	      var campaignActionProp = gon.domain === 'generosity' ? 'fundraiser' : 'campaign';
	      var actionProps = {};
	      actionProps[campaignActionProp] = options.url;
	      actionProps.contributor = options.contributor_url;
	
	      var params = {
	        method: 'share_open_graph',
	        display: 'popup',
	        name: i18n.t("help_make_it_happen_for_") + " " + options.title,
	        picture: options.picture_url,
	        caption: options.title,
	        description: options.tagline,
	        action_type: options.namespace + ':' + namespaceAction,
	        action_properties: JSON.stringify(actionProps)
	      };
	      return fb.ui(params);
	    },
	    twitterHref: function twitterHref(project) {
	      if (gon.domain === 'generosity') {
	        return "https://twitter.com/intent/tweet?text=" + encodeURIComponent(i18n.t("generosity.social.twitter", {
	          fundraiser_title: project.title,
	          fundraiser_url: project.url
	        })) + "&counturl=" + encodeURIComponent(project.counturl);
	      } else {
	        return "https://twitter.com/intent/tweet?url=" + encodeURIComponent(project.url) + "&text=" + encodeURIComponent(i18n.t("help_make_it_happen_for_") + " " + project.title) + "&via=indiegogo&related=indiegogo&hashtags=indiegogo&counturl=" + encodeURIComponent(project.counturl);
	      }
	    },
	    emailHref: function emailHref(project) {
	      var body, subject;
	      if (gon.domain === 'generosity') {
	        body = i18n.t('generosity.social.email', {
	          fundraiser_url: project.url,
	          fundraiser_title: project.title
	        });
	        subject = i18n.t('generosity.social.email_subject', { project_title: project.title });
	      } else {
	        body = i18n.t('email_share_body', {
	          project_title: project.title,
	          project_url: project.url
	        });
	        subject = i18n.t('email_share_subject', { project_title: project.title });
	      }
	      return "mailto:?body=" + encodeURIComponent(body) + "&subject=" + encodeURIComponent(subject);
	    }
	  };
	}

/***/ },
/* 201 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = projectCard;
	/*@ngInject*/
	function projectCard() {
	  function setupDelayedImageLoad(element) {
	    var $imgContainer = element.find(".i-img");
	    if ($imgContainer.length > 0) {
	      var $img = $("<img />");
	      $img.attr("src", $imgContainer.data("src"));
	      $imgContainer.replaceWith($img);
	    }
	  }
	
	  function ellipsizeProjectCardTagline(element) {
	    var $content = element.find(".i-content");
	    var $title = $content.find(".i-title");
	    var titleLineHeight = parseInt($title.css("line-height"));
	    $title.dotdotdot({
	      height: titleLineHeight * 3,
	      wrap: "letter",
	      watch: "window"
	    });
	
	    var $tagline = $content.find(".i-tagline");
	    var taglineHeight = $content.height() - $title.height();
	
	    var $partner = $content.find(".i-partner-name");
	    if ($partner.length > 0) {
	      var partnerLineHeight = parseInt($partner.css("line-height"));
	      $partner.dotdotdot({
	        height: partnerLineHeight * 1,
	        watch: "window"
	      });
	      taglineHeight = taglineHeight - $partner.height() - parseInt($partner.css("margin-top"));
	    }
	    $tagline.css("max-height", taglineHeight);
	    $tagline.dotdotdot({
	      watch: 'window'
	    });
	  }
	
	  return {
	    setupDelayedImageLoad: setupDelayedImageLoad,
	    ellipsizeProjectCardTagline: ellipsizeProjectCardTagline
	  };
	}

/***/ },
/* 202 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = regions;
	/*@ngInject*/
	function regions() {
	  function RegionsService() {
	    /* To refresh, open up a Rails console and type "puts JSON.pretty_generate(Code.region_service_json_hash)" */
	    var regions = [{
	      "code": "STTE_CAAB",
	      "text": "Alberta",
	      "two_letter": "AB",
	      "country": "ca"
	    }, {
	      "code": "STTE_CABC",
	      "text": "British Columbia",
	      "two_letter": "BC",
	      "country": "ca"
	    }, {
	      "code": "STTE_CAMB",
	      "text": "Manitoba",
	      "two_letter": "MB",
	      "country": "ca"
	    }, {
	      "code": "STTE_CANB",
	      "text": "New Brunswick",
	      "two_letter": "NB",
	      "country": "ca"
	    }, {
	      "code": "STTE_CANL",
	      "text": "Newfoundland and Labrador",
	      "two_letter": "NL",
	      "country": "ca"
	    }, {
	      "code": "STTE_CANS",
	      "text": "Nova Scotia",
	      "two_letter": "NS",
	      "country": "ca"
	    }, {
	      "code": "STTE_CANT",
	      "text": "Northwest Territories",
	      "two_letter": "NT",
	      "country": "ca"
	    }, {
	      "code": "STTE_CANU",
	      "text": "Nunavut",
	      "two_letter": "NU",
	      "country": "ca"
	    }, {
	      "code": "STTE_CAON",
	      "text": "Ontario",
	      "two_letter": "ON",
	      "country": "ca"
	    }, {
	      "code": "STTE_CAPE",
	      "text": "Prince Edward Island",
	      "two_letter": "PE",
	      "country": "ca"
	    }, {
	      "code": "STTE_CAQC",
	      "text": "Quebec",
	      "two_letter": "QC",
	      "country": "ca"
	    }, {
	      "code": "STTE_CASK",
	      "text": "Saskatchewan",
	      "two_letter": "SK",
	      "country": "ca"
	    }, {
	      "code": "STTE_CAYT",
	      "text": "Yukon",
	      "two_letter": "YT",
	      "country": "ca"
	    }, {
	      "code": "STTE_USAK",
	      "text": "Alaska",
	      "two_letter": "AK",
	      "country": "us"
	    }, {
	      "code": "STTE_USAL",
	      "text": "Alabama",
	      "two_letter": "AL",
	      "country": "us"
	    }, {
	      "code": "STTE_USAR",
	      "text": "Arkansas",
	      "two_letter": "AR",
	      "country": "us"
	    }, {
	      "code": "STTE_USAZ",
	      "text": "Arizona",
	      "two_letter": "AZ",
	      "country": "us"
	    }, {
	      "code": "STTE_USCA",
	      "text": "California",
	      "two_letter": "CA",
	      "country": "us"
	    }, {
	      "code": "STTE_USCO",
	      "text": "Colorado",
	      "two_letter": "CO",
	      "country": "us"
	    }, {
	      "code": "STTE_USCT",
	      "text": "Connecticut",
	      "two_letter": "CT",
	      "country": "us"
	    }, {
	      "code": "STTE_USDC",
	      "text": "District of Columbia",
	      "two_letter": "DC",
	      "country": "us"
	    }, {
	      "code": "STTE_USDE",
	      "text": "Delaware",
	      "two_letter": "DE",
	      "country": "us"
	    }, {
	      "code": "STTE_USFL",
	      "text": "Florida",
	      "two_letter": "FL",
	      "country": "us"
	    }, {
	      "code": "STTE_USGA",
	      "text": "Georgia",
	      "two_letter": "GA",
	      "country": "us"
	    }, {
	      "code": "STTE_USHI",
	      "text": "Hawaii",
	      "two_letter": "HI",
	      "country": "us"
	    }, {
	      "code": "STTE_USIA",
	      "text": "Iowa",
	      "two_letter": "IA",
	      "country": "us"
	    }, {
	      "code": "STTE_USID",
	      "text": "Idaho",
	      "two_letter": "ID",
	      "country": "us"
	    }, {
	      "code": "STTE_USIL",
	      "text": "Illinois",
	      "two_letter": "IL",
	      "country": "us"
	    }, {
	      "code": "STTE_USIN",
	      "text": "Indiana",
	      "two_letter": "IN",
	      "country": "us"
	    }, {
	      "code": "STTE_USKS",
	      "text": "Kansas",
	      "two_letter": "KS",
	      "country": "us"
	    }, {
	      "code": "STTE_USKY",
	      "text": "Kentucky",
	      "two_letter": "KY",
	      "country": "us"
	    }, {
	      "code": "STTE_USLA",
	      "text": "Louisiana",
	      "two_letter": "LA",
	      "country": "us"
	    }, {
	      "code": "STTE_USMA",
	      "text": "Massachusetts",
	      "two_letter": "MA",
	      "country": "us"
	    }, {
	      "code": "STTE_USMD",
	      "text": "Maryland",
	      "two_letter": "MD",
	      "country": "us"
	    }, {
	      "code": "STTE_USME",
	      "text": "Maine",
	      "two_letter": "ME",
	      "country": "us"
	    }, {
	      "code": "STTE_USMI",
	      "text": "Michigan",
	      "two_letter": "MI",
	      "country": "us"
	    }, {
	      "code": "STTE_USMN",
	      "text": "Minnesota",
	      "two_letter": "MN",
	      "country": "us"
	    }, {
	      "code": "STTE_USMO",
	      "text": "Missouri",
	      "two_letter": "MO",
	      "country": "us"
	    }, {
	      "code": "STTE_USMS",
	      "text": "Mississippi",
	      "two_letter": "MS",
	      "country": "us"
	    }, {
	      "code": "STTE_USMT",
	      "text": "Montana",
	      "two_letter": "MT",
	      "country": "us"
	    }, {
	      "code": "STTE_USNC",
	      "text": "North Carolina",
	      "two_letter": "NC",
	      "country": "us"
	    }, {
	      "code": "STTE_USND",
	      "text": "North Dakota",
	      "two_letter": "ND",
	      "country": "us"
	    }, {
	      "code": "STTE_USNE",
	      "text": "Nebraska",
	      "two_letter": "NE",
	      "country": "us"
	    }, {
	      "code": "STTE_USNH",
	      "text": "New Hampshire",
	      "two_letter": "NH",
	      "country": "us"
	    }, {
	      "code": "STTE_USNJ",
	      "text": "New Jersey",
	      "two_letter": "NJ",
	      "country": "us"
	    }, {
	      "code": "STTE_USNM",
	      "text": "New Mexico",
	      "two_letter": "NM",
	      "country": "us"
	    }, {
	      "code": "STTE_USNV",
	      "text": "Nevada",
	      "two_letter": "NV",
	      "country": "us"
	    }, {
	      "code": "STTE_USNY",
	      "text": "New York",
	      "two_letter": "NY",
	      "country": "us"
	    }, {
	      "code": "STTE_USOH",
	      "text": "Ohio",
	      "two_letter": "OH",
	      "country": "us"
	    }, {
	      "code": "STTE_USOK",
	      "text": "Oklahoma",
	      "two_letter": "OK",
	      "country": "us"
	    }, {
	      "code": "STTE_USOR",
	      "text": "Oregon",
	      "two_letter": "OR",
	      "country": "us"
	    }, {
	      "code": "STTE_USPA",
	      "text": "Pennsylvania",
	      "two_letter": "PA",
	      "country": "us"
	    }, {
	      "code": "STTE_USRI",
	      "text": "Rhode Island",
	      "two_letter": "RI",
	      "country": "us"
	    }, {
	      "code": "STTE_USSC",
	      "text": "South Carolina",
	      "two_letter": "SC",
	      "country": "us"
	    }, {
	      "code": "STTE_USSD",
	      "text": "South Dakota",
	      "two_letter": "SD",
	      "country": "us"
	    }, {
	      "code": "STTE_USTN",
	      "text": "Tennessee",
	      "two_letter": "TN",
	      "country": "us"
	    }, {
	      "code": "STTE_USTX",
	      "text": "Texas",
	      "two_letter": "TX",
	      "country": "us"
	    }, {
	      "code": "STTE_USUT",
	      "text": "Utah",
	      "two_letter": "UT",
	      "country": "us"
	    }, {
	      "code": "STTE_USVA",
	      "text": "Virginia",
	      "two_letter": "VA",
	      "country": "us"
	    }, {
	      "code": "STTE_USVT",
	      "text": "Vermont",
	      "two_letter": "VT",
	      "country": "us"
	    }, {
	      "code": "STTE_USWA",
	      "text": "Washington",
	      "two_letter": "WA",
	      "country": "us"
	    }, {
	      "code": "STTE_USWI",
	      "text": "Wisconsin",
	      "two_letter": "WI",
	      "country": "us"
	    }, {
	      "code": "STTE_USWV",
	      "text": "West Virginia",
	      "two_letter": "WV",
	      "country": "us"
	    }, {
	      "code": "STTE_USWY",
	      "text": "Wyoming",
	      "two_letter": "WY",
	      "country": "us"
	    }];
	    var states = _.select(regions, function (region) {
	      return region.country === 'us';
	    });
	    var provinces = _.select(regions, function (region) {
	      return region.country === 'ca';
	    });
	
	    function regionsAsOptions(regions) {
	      return _.map(regions, function (region) {
	        return { value: region.code, text: region.text, two_letter: region.two_letter };
	      });
	    }
	
	    this.all = function () {
	      return regions;
	    };
	
	    this.getStates = function () {
	      return states;
	    };
	
	    this.getProvinces = function () {
	      return provinces;
	    };
	
	    this.statesAsOptions = function () {
	      return regionsAsOptions(states);
	    };
	    this.provincesAsOptions = function () {
	      return regionsAsOptions(provinces);
	    };
	    this.byCode = function (code) {
	      return _.find(regions, { code: code });
	    };
	
	    this.byTwoLetterCode = function (code) {
	      if (code && code.match(/^STTE_/)) {
	        return _.find(regions, { code: code });
	      }
	      return _.find(regions, { two_letter: code });
	    };
	
	    this.byText = function (text) {
	      return _.find(regions, function (region) {
	        return region.text.toLowerCase() === text.toLowerCase();
	      });
	    };
	
	    this.toCode = function (region, country) {
	      return ["STTE_", country, region].join('');
	    };
	  }
	
	  return new RegionsService();
	}

/***/ },
/* 203 */
/***/ function(module, exports) {

	'use strict';
	
	searchExpression.$inject = ["i18n", "countriesService"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = searchExpression;
	/*@ngInject*/
	function searchExpression(i18n, countriesService) {
	  var countries = countriesService;
	  function addFilter(filterList, text, whenToAdd) {
	    if (whenToAdd) {
	      filterList.push(text);
	    }
	  }
	
	  function quotedList(filterList) {
	    var finalList = [];
	    filterList.forEach(function (item) {
	      if (item && !_.isEmpty(item)) {
	        finalList.push('"' + item + '"');
	      }
	    });
	    return finalList.join(", ");
	  }
	
	  function notBlank(field) {
	    return field && !_.isEmpty(field);
	  }
	
	  return function (searchParams) {
	    var filterList = [];
	    addFilter(filterList, searchParams.filter_category, !!searchParams.filter_category);
	    var location = [];
	    if (notBlank(searchParams.filter_city)) {
	      location.push(searchParams.filter_city);
	    }
	    if (notBlank(searchParams.filter_country)) {
	      var country = countries.findByCode(searchParams.filter_country).text;
	      if (country) {
	        location.push(country);
	      }
	    }
	    if (location.length > 0) {
	      filterList.push(location.join(", "));
	    }
	    addFilter(filterList, '50% - 75%', searchParams.filter_percent_funded === '50_to_75');
	    addFilter(filterList, '75% - 100+%', searchParams.filter_percent_funded === '75_to_100_plus');
	    addFilter(filterList, i18n.t('adv_search.funding_open'), searchParams.filter_status === 'open');
	    addFilter(filterList, i18n.t('adv_search.funding_ended'), searchParams.filter_status === 'ended');
	    addFilter(filterList, i18n.t('flexible'), searchParams.filter_funding === 'flexible');
	    addFilter(filterList, i18n.t('fixed'), searchParams.filter_funding === 'fixed');
	    addFilter(filterList, i18n.t('verified_nonprofit'), searchParams.filter_nonprofit === 'nonprofit');
	    addFilter(filterList, i18n.t('in_demand_label'), !!searchParams.filter_forever_funding_active);
	
	    if (notBlank(searchParams.search_text)) {
	      var quotedTitle = '"' + searchParams.search_text + '"';
	      if (filterList.length > 0) {
	        return i18n.t('x_in_category', { x: quotedTitle, category: quotedList(filterList) });
	      } else {
	        return quotedTitle;
	      }
	    } else {
	      if (notBlank(searchParams.filter_quick)) {
	        var quickKey = searchParams.filter_quick;
	        if (quickKey === 'popular_all') {
	          quickKey = 'trending';
	        }
	        filterList.push(i18n.t("quick_pick_filters." + quickKey));
	      }
	      return quotedList(filterList);
	    }
	  };
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = shareBanner;
	/*@ngInject*/
	function shareBanner() {
	  return {
	    scope: {
	      labelText: '@',
	      labelHoverText: '@',
	      variant: '@',
	      hideLabel: '='
	    },
	    template: __webpack_require__(205),
	    restrict: 'A',
	    link: function link(scope, element, attrs) {
	      scope.xhref = '#' + attrs.icon;
	    }
	  };
	}

/***/ },
/* 205 */
/***/ function(module, exports) {

	module.exports = "<div class=\"shareBanner\" ng-class=\"variant ? 'shareBanner--' + variant : null\">\n  <div class=\"shareBanner-icon\">\n    <svg><use xlink:href=\"{{xhref}}\"></use></svg>\n  </div>\n  <div ng-if=\"!hideLabel\" class=\"shareBanner-label shareBanner-label--hoverable\">\n    <div class=\"shareBanner-labelDimple\">\n      <svg><use xlink:href=\"#dimple\"></use></svg>\n    </div>\n    <div class=\"shareBanner-labelText\">{{labelText}}</div>\n  </div>\n  <div ng-if=\"!hideLabel\" class=\"shareBanner-label shareBanner-label--hover\">\n    <div class=\"shareBanner-labelDimple\">\n      <svg><use xlink:href=\"#dimple\"></use></svg>\n    </div>\n    <div class=\"shareBanner-labelText\">{{labelHoverText || labelText}}</div>\n  </div>\n</div>\n";

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

	'use strict';
	
	sharedEconomicsInterestMessageNotification.$inject = ["$timeout", "i18n", "$cookies", "gogoEvents"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = sharedEconomicsInterestMessageNotification;
	/*@ngInject*/
	function sharedEconomicsInterestMessageNotification($timeout, i18n, $cookies, gogoEvents) {
	  return {
	    restrict: 'E',
	    template: __webpack_require__(207),
	    transclude: true,
	    replace: true,
	    link: function link(scope) {
	      scope.showAny = true;
	      scope.showButtons = true;
	      scope.messageHeader = i18n.t('shared_economics_interest_prompt_header');
	      scope.messageDescription = i18n.t('shared_economics_interest_prompt_description');
	
	      gogoEvents.track({
	        thetaName: 'campaign_page_shared_economics_interest_prompt',
	        gaEventCategory: 'Campaign Page',
	        gaEventAction: 'Prompt',
	        gaEventLabel: 'Shared Economics Interest'
	      });
	
	      scope.indicateSharedEconomicsInterest = function (interestValue) {
	        var charValue, intValue;
	
	        if (interestValue) {
	          scope.showButtons = false;
	          scope.messageHeader = i18n.t('shared_economics_interest_confirmation_header');
	          scope.messageDescription = i18n.t('shared_economics_interest_confirmation_description');
	          $timeout(function () {
	            scope.showAny = false;
	          }, 3000); // disappear after a delay
	          charValue = 'true';
	          intValue = 1;
	        } else {
	          scope.showAny = false; // disappear immediately
	          charValue = 'false';
	          intValue = 0;
	        }
	
	        $cookies.put('shared_economics_interest', charValue); // persist in a cookie since it's not in the db
	        gogoEvents.track({
	          thetaName: 'campaign_page_shared_economics_interest_click_' + charValue,
	          gaEventCategory: 'Campaign Page',
	          gaEventAction: 'Click',
	          gaEventLabel: 'Shared Economics Interest',
	          gaEventValue: intValue
	        });
	      };
	    }
	  };
	}

/***/ },
/* 207 */
/***/ function(module, exports) {

	module.exports = "<div>\n  <div class=\"messageNotification messageNotification--info messageNotification--raised messageNotification--fixedHeight\">\n    <div class=\"container\">\n      <div class=\"col-md-12\">\n        <div class=\"messageNotification-header\">{{messageHeader}}</div>\n        {{messageDescription}}\n        <div class=\"messageNotification-buttons\" ng-show=\"showButtons\">\n          <button id=\"enable-shared-economics-interest-yes\" ng-click=\"indicateSharedEconomicsInterest(true)\" class=\"cta-4 cta-4--small cta-4--purple\">{{::i18n.t('shared_economics_interest_prompt_yes')}}</button> <button id=\"enable-shared-economics-interest-no\" ng-click=\"indicateSharedEconomicsInterest(false)\" class=\"cta-4 cta-4-secondary cta-4-secondary--small cta-4-secondary--purple\">{{::i18n.t('shared_economics_interest_prompt_no')}}</button>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n";

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

	'use strict';
	
	shippingInfo.$inject = ["countriesService", "regions"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = shippingInfo;
	/*@ngInject*/
	function shippingInfo(countriesService, regions) {
	  return {
	    restrict: 'E',
	    scope: {
	      shipping: '='
	    },
	    template: __webpack_require__(209),
	    link: function link(scope, element, attrs, nullController) {
	      scope.countries = countriesService;
	      scope.regions = regions;
	    }
	  };
	}

/***/ },
/* 209 */
/***/ function(module, exports) {

	module.exports = "<span>{{shipping.name}}</span><br />\n<span> {{shipping.address}}</span> <br />\n<span ng-if=\"shipping.address2\"> {{shipping.address2}}<br /></span>\n<span>{{shipping.city}}</span><span ng-if=\"shipping.state\">, {{regions.byTwoLetterCode(shipping.state).two_letter}}</span> <span>{{shipping.zipcode}}</span><br />\n<span>{{countries.findByTwoLetterCode(shipping.country).text}}</span>\n";

/***/ },
/* 210 */
/***/ function(module, exports) {

	'use strict';
	
	signup.$inject = ["i18n", "gon", "$sce", "$http", "embeddableLinkHtml"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
	
	exports.default = signup;
	/*@ngInject*/
	function signup(i18n, gon, $sce, $http, embeddableLinkHtml) {
	  function safeBasicSignupParams(account) {
	    var params = {
	      timestamp: gon.negative_captcha.timestamp,
	      spinner: gon.negative_captcha.spinner,
	      email: null,
	      password: null
	    };
	    params[gon.negative_captcha.fields.email] = account.email;
	    params[gon.negative_captcha.fields.password] = account.password;
	    return params;
	  }
	
	  return {
	    submitSignup: function submitSignup(account, domainCode) {
	      var params = safeBasicSignupParams(account);
	      params.domain_code = domainCode;
	      params.account = {
	        firstname: account.firstname,
	        lastname: account.lastname,
	        general_opt_in: account.general_opt_in
	      };
	      return $http.post(gon.session_modal.signup_url, params);
	    },
	    termsHtml: function termsHtml(sentenceKey) {
	      if (!gon.session_modal) {
	        return null;
	      }
	      var rawText = i18n.t(sentenceKey, {
	        terms_of_service_url: embeddableLinkHtml(i18n.t('content_for_title.terms_of_use'), gon.session_modal.terms_url),
	        privacy_policy_link: embeddableLinkHtml(i18n.t('content_for_title.privacy_policy'), gon.session_modal.privacy_policy_url)
	      });
	      if ((typeof rawText === 'undefined' ? 'undefined' : _typeof(rawText)) === 'object') {
	        return rawText;
	      } else {
	        return $sce.trustAsHtml(rawText);
	      }
	    }
	  };
	}

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

	'use strict';
	
	simpleImageUpload.$inject = ["cloudinary", "$http", "i18n"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = simpleImageUpload;
	/*@ngInject*/
	function simpleImageUpload(cloudinary, $http, i18n) {
	  return {
	    restrict: 'A',
	    scope: {
	      imagePublicId: '@',
	      updateImagePath: '@',
	      placeholderPath: '@',
	      attr: '@',
	      width: '@',
	      height: '@',
	      crop: '@'
	    },
	    template: __webpack_require__(212),
	    link: function link(scope, element) {
	      scope.i18n = i18n;
	      var fileInput = element.find("input");
	      scope.status = { loading: false, publicId: scope.imagePublicId };
	
	      function setupFileUpload() {
	        var fileUploader = cloudinary.forFileInput(fileInput, element);
	
	        fileUploader.onUploadStart(function () {
	          scope.status.loading = true;
	        }).onUploadComplete(function (result) {
	          scope.status.loading = false;
	          scope.status.publicId = result.public_id;
	          scope.$apply();
	          var data = { image_params: result };
	          if (scope.attr) {
	            data.attr = scope.attr;
	          }
	          $http.post(scope.updateImagePath, data);
	          fileInput = element.find("input");
	        }).onUploadFail(function () {
	          scope.status.loading = false;
	          fileInput = element.find("input");
	        });
	      }
	      setupFileUpload();
	
	      scope.clickPhoto = function () {
	        fileInput.trigger('click');
	      };
	    }
	  };
	}

/***/ },
/* 212 */
/***/ function(module, exports) {

	module.exports = "<div class=\"i-cloudinaryUploader-image\" ng-click=\"clickPhoto()\">\n  <img ng-if=\"placeholderPath && !status.publicId\" ng-src=\"{{placeholderPath}}\" width=\"{{width}}\" height=\"{{height}}\" />\n  <img ng-if=\"status.publicId\" cl-image width=\"{{width}}\" height=\"{{height}}\" crop=\"{{crop}}\" public-id=\"status.publicId\" />\n  <div ng-if=\"!placeholderPath && !status.publicId\" class=\"i-cloudinaryUploader-placeholder\" ng-style=\"{width: width + 'px', height: height + 'px'}\"></div>\n  <i class=\"i-fa-centered i-fa-gogenta fa fa-spinner fa-4x fa-spin\" ng-show=\"status.loading\"></i>\n</div><input type=\"file\" name=\"file\" class=\"i-hide-offscreen\" data-cloudinary-field=\"image_id\" />\n<button type=\"button\" ng-click=\"clickPhoto()\" class=\"i-cta-1 i-cloudinaryUploader-button\">\n  <span ng-if=\"status.publicId\">{{::i18n.t('change_image')}}</span>\n  <span ng-if=\"!status.publicId\">{{::i18n.t('add_image')}}</span>\n</button>\n";

/***/ },
/* 213 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (split) {
	  return {
	    /*@ngInject*/
	    scope: {
	      experiment: '@',
	      variant: '@',
	      variants: '='
	    },
	    transclude: true,
	    template: '<div ng-transclude ng-if="variantActive"></div>',
	    link: function link($scope) {
	      $scope.variantActive = false;
	      var variants;
	      if ($scope.variant) {
	        variants = [$scope.variant];
	      } else if ($scope.variants) {
	        variants = $scope.variants;
	      }
	      $scope.$watch(function () {
	        return split.checkVariantState($scope.experiment);
	      }, function (state) {
	        $scope.variantActive = _.includes(variants, state);
	      });
	    }
	  };
	};

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

	'use strict';
	
	split.$inject = ["$http", "$q"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = split;
	
	var _privateApi = __webpack_require__(55);
	
	/*@ngInject*/
	function split($http, $q) {
	  var service = {
	    experimentBuckets: {},
	    appVersion: ""
	  };
	
	  service.checkVariantState = function (name) {
	    if (!service.experimentBuckets[name]) {
	      service.experimentBuckets[name] = '$loading';
	      $http.put((0, _privateApi.privateApiExperimentsFetchAndUpdatePath)(), { name: name }).then(function (_response_) {
	        if (!_response_.data.response) {
	          return $q.reject();
	        }
	        var response = _response_.data.response;
	        return { buckets: response.buckets, app_version: response.app_version };
	      }).then(function (response) {
	        service.experimentBuckets = _.merge(service.experimentBuckets, response.buckets);
	        service.appVersion = response.app_version;
	      }).catch(function (error) {
	        service.experimentBuckets[name] = 'control';
	      });
	    }
	    return service.experimentBuckets[name];
	  };
	
	  service.variantStatePromise = function (name) {
	    var deferred = $q.defer();
	    var variant = service.experimentBuckets[name];
	    if (!variant || variant === '$loading') {
	      service.fetchVariantState(name).then(function (fetchedVariant) {
	        deferred.resolve(fetchedVariant);
	      });
	    } else {
	      deferred.resolve(variant);
	    }
	    return deferred.promise;
	  };
	
	  service.fetchVariantState = function (name) {
	    return $http.put((0, _privateApi.privateApiExperimentsFetchAndUpdatePath)(), { name: name }).then(function (response) {
	      var buckets = response.data.response.buckets;
	      return buckets[name];
	    });
	  };
	
	  service.getVariantState = function (name) {
	    return $http.get((0, _privateApi.privateApiExperimentPath)({ id: name })).then(function (response) {
	      return response.data.response.bucket;
	    });
	  };
	
	  function projectVariant(name, projectId) {
	    return $http({
	      url: (0, _privateApi.splitBucketPrivateApiCampaignPath)({ id: projectId }),
	      method: 'GET',
	      params: { name: name }
	    });
	  }
	  service.projectVariant = projectVariant;
	
	  return service;
	}

/***/ },
/* 215 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = startsWith;
	/*@ngInject*/
	function startsWith() {
	  return function (actual, expected) {
	    var lowerStr = (actual + "").toLowerCase();
	    return lowerStr.indexOf(expected.toLowerCase()) === 0;
	  };
	}

/***/ },
/* 216 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = stripTags;
	/*@ngInject*/
	function stripTags() {
	  return function (html) {
	    return $('<div>' + html + '</div>').text().replace(/\t+/g, " ").replace(/\n/g, "").replace(/^\s/g, "");
	  };
	}

/***/ },
/* 217 */
/***/ function(module, exports) {

	'use strict';
	
	svgIcon.$inject = ["$sce"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = svgIcon;
	/*@ngInject*/
	function svgIcon($sce) {
	  return {
	    template: '<svg><use xlink:href="{{iconName}}"></svg>',
	    scope: { icon: '@' },
	    link: function link(scope) {
	      scope.iconName = $sce.trustAsResourceUrl('#' + scope.icon);
	    }
	  };
	}

/***/ },
/* 218 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = truncateFilter;
	/*@ngInject*/
	function truncateFilter() {
	  return function (text, length, end) {
	    if (isNaN(length)) {
	      length = 10;
	    }
	
	    if (_.isNull(text) || _.isUndefined(text)) {
	      return text;
	    }
	
	    if (end === undefined) {
	      end = '…';
	    }
	
	    if (text.length <= length || text.length - end.length <= length) {
	      return text;
	    } else {
	      return String(text).substring(0, length - end.length) + end;
	    }
	  };
	}

/***/ },
/* 219 */
/***/ function(module, exports) {

	'use strict';
	
	twitter.$inject = ["$window", "$http", "$timeout"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = twitter;
	/*@ngInject*/
	function twitter($window, $http, $timeout) {
	  return {
	    onTweet: function onTweet(callback) {
	      $window.twttr.ready(function (twttr) {
	        twttr.events.bind('tweet', callback);
	      });
	    },
	    refreshAllWidgets: function refreshAllWidgets() {
	      $window.twttr.ready(function (twttr) {
	        twttr.widgets.load();
	      });
	    },
	    countForUrl: function countForUrl(url) {
	      return $http.jsonp('https://urls.api.twitter.com/1/urls/count.json?url=' + $window.escape(url) + '&callback=JSON_CALLBACK').then(function (response) {
	        return response.data.count;
	      });
	    },
	    shareTwitter: function shareTwitter(url, text, from) {
	      var originalReferrer = from || $window.location.toString();
	      var escapedOriginalReferrer = $window.escape(originalReferrer);
	      var escapedUrl = $window.escape(url);
	      var shareUrl = 'https://twitter.com/intent/tweet?original_referer=' + escapedOriginalReferrer + '&text=' + text + '&url=' + escapedUrl + '&related=indiegogo%3AIndiegogo';
	
	      $timeout(function () {
	        // http://stackoverflow.com/a/18996042
	        $window.open(shareUrl, 'twitter_share', 'height=450, width=550');
	      });
	    }
	  };
	}

/***/ },
/* 220 */
/***/ function(module, exports) {

	'use strict';
	
	typeaheadUtils.$inject = ["startsWith"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = typeaheadUtils;
	/*@ngInject*/
	function typeaheadUtils(startsWith) {
	  return {
	    startsWith: {
	      country: function country(actual, expected) {
	        if (!_.isString(actual)) {
	          return false;
	        }
	        if (_.isString(actual) && actual.indexOf('CTRY_') === 0) {
	          return false;
	        }
	        if (actual === 'common') {
	          return false;
	        }
	        return startsWith(actual, expected);
	      },
	      region: function region(actual, expected) {
	        if (_.isString(actual) && actual.indexOf('STTE_') === 0) {
	          return false;
	        }
	        if (actual === 'us' || actual === 'ca') {
	          return false;
	        }
	        return startsWith(actual, expected);
	      },
	      basic: startsWith
	    }
	  };
	}

/***/ },
/* 221 */
/***/ function(module, exports) {

	"use strict";
	
	userConfig.$inject = ["gon"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = userConfig;
	/*@ngInject*/
	function userConfig(gon) {
	  if (gon && gon.services && gon.services.user_service) {
	    return _.cloneDeep(gon.services.user_service);
	  } else {
	    return { urls: {} };
	  }
	}

/***/ },
/* 222 */
/***/ function(module, exports) {

	'use strict';
	
	userService.$inject = ["$http", "$q", "$log", "userServiceConfig", "backupBeforeUnloadService", "gon", "fb"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = userService;
	/*@ngInject*/
	function userService($http, $q, $log, userServiceConfig, backupBeforeUnloadService, gon, fb) {
	  var oauthServiceEndpoint = userServiceConfig.urls.oauth_service + '/oauth/token';
	  var token = '';
	  var user = {};
	
	  function load() {
	    backupBeforeUnloadService.restoreStateIfSaved('user', user);
	    if (_.isEmpty(user) && gon.contribution && gon.contribution.contributor) {
	      setUser(gon.contribution.contributor.account_privileged);
	    }
	  }
	
	  function oauthLogInPromise(email, password) {
	    var deferred = $q.defer();
	
	    $http.post(oauthServiceEndpoint, {
	      credential_type: 'email',
	      grant_type: 'password',
	      email: email,
	      password: password
	    }).success(function (data) {
	      token = data.access_token;
	      $http.get(userServiceConfig.urls.current_user + '?access_token=' + token).success(function (data) {
	        setUser(data.response);
	        deferred.resolve(user);
	      }).error(function (data) {
	        deferred.reject('Rejected in credentials: ', data);
	      });
	    }).error(function (data) {
	      deferred.reject(data.error);
	    });
	
	    return deferred.promise;
	  }
	
	  function logInPromise(email, password) {
	    var deferred = $q.defer();
	
	    $http.post(userServiceConfig.urls.signin, {
	      account: {
	        email: email,
	        password: password
	      }
	    }).success(function success(data) {
	      setUser(data.account);
	      deferred.resolve(user);
	    }).error(function error(data) {
	      deferred.reject(data.error);
	    });
	
	    return deferred.promise;
	  }
	
	  function logOut() {
	    var oauthDeferred = $q.defer();
	    if (token) {
	      $http.post(userServiceConfig.urls.oauth_service + '/oauth/revoke', {
	        token: token,
	        access_token: token
	      }).success(function (data) {
	        oauthDeferred.resolve(data);
	      }).error(function (error) {
	        $log.debug('revoke error');
	        oauthDeferred.reject(error);
	      });
	    } else {
	      oauthDeferred.resolve('No oauth credentials');
	    }
	
	    var sessionDeferred = $q.defer();
	    $http.delete(userServiceConfig.urls.signout).success(function (data) {
	      setUser(null);
	      token = null;
	      sessionDeferred.resolve(data);
	    }).error(function (error) {
	      $log.debug('logout rejected', error);
	      sessionDeferred.reject(error);
	    });
	
	    return $q.all([oauthDeferred.promise, sessionDeferred.promise]);
	  }
	
	  function signUp(firstname, lastname, email, password, newsletterOptIn) {
	    var deferred = $q.defer();
	
	    $http.post(userServiceConfig.urls.signup + '?api_token=' + userServiceConfig.api_token, {
	      account: {
	        fullname: [firstname, lastname].join(' '),
	        email: email,
	        password: password,
	        general_opt_in: newsletterOptIn
	      }
	    }).success(function () {
	      oauthLogInPromise(email, password).then(deferred.resolve(user));
	    }).error(function (data) {
	      deferred.reject(data.messages);
	    });
	
	    return deferred.promise;
	  }
	
	  function facebookLogin() {
	    var deferred = $q.defer();
	
	    fb.login({ scope: 'email', state: 'abc123' }).then(function (response) {
	      if (response.authResponse) {
	        var callbackUrl = userServiceConfig.urls.facebook_callback;
	        $log.debug('Connected! Hitting OmniAuth callback (GET ' + callbackUrl + ')...');
	        // since we have cookies enabled, this request will allow omniauth to parse
	        // out the auth code from the signed request in the fbsr_XXX cookie
	        $http.get(userServiceConfig.urls.facebook_callback, { headers: { Accept: 'application/json' } }).success(function (json) {
	          $log.debug('Connected! Callback complete.');
	          $log.debug(JSON.stringify(json));
	          setUser(json.account_privileged);
	          deferred.resolve(json.account_privileged);
	        }).error(function (error) {
	          $log.debug('error getting ' + callbackUrl);
	          $log.debug(error);
	          deferred.reject(error);
	        });
	      }
	    });
	
	    return deferred.promise;
	  }
	
	  function resetPassword(resetPasswordToken, password, passwordConfirmation) {
	    var deferred = $q.defer();
	
	    $http.put(userServiceConfig.urls.change_password, {
	      account: {
	        reset_password_token: resetPasswordToken,
	        password: password,
	        password_confirmation: passwordConfirmation
	      }
	    }).then(function (successResponse) {
	      deferred.resolve(successResponse);
	    }, function (failureResponse) {
	      deferred.reject(failureResponse);
	    });
	
	    return deferred.promise;
	  }
	
	  function setUser(data) {
	    if (data === null) {
	      _.each(_.keys(user), function (k) {
	        delete user[k];
	      });
	    } else {
	      var displayName = data.display_for_feed || data.firstname || data.email;
	      user.id = data.id;
	      user.firstname = data.firstname;
	      user.lastname = data.lastname;
	      user.email = data.email;
	      user.avatarUrl = data.avatar_url;
	      user.displayName = displayName;
	    }
	  }
	
	  function current() {
	    return user;
	  }
	
	  function authToken() {
	    return token;
	  }
	
	  _.merge(this, {
	    oauthLogIn: oauthLogInPromise,
	    logIn: logInPromise,
	    logOut: logOut,
	    signUp: signUp,
	    facebookLogin: facebookLogin,
	    resetPassword: resetPassword,
	    current: current,
	    authToken: authToken,
	    setUser: setUser,
	    load: load
	  });
	
	  load();
	
	  backupBeforeUnloadService.register({ user: this.current });
	}

/***/ },
/* 223 */
/***/ function(module, exports) {

	'use strict';
	
	youtube.$inject = ["$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = youtube;
	/*@ngInject*/
	function youtube($window) {
	
	  $window.iframeAPIIncluded = false;
	
	  $window.onYouTubeIframeAPIReady = function () {
	    for (var i = 0; i < $window.youtubeIframeApiCallbacks.length; ++i) {
	      $window.youtubeIframeApiCallbacks[i]();
	    }
	    $window.youtubeApiReady = true;
	  };
	
	  return {
	    onReady: function onReady(callback, include) {
	      if (typeof include === 'undefined') {
	        include = true;
	      }
	
	      if (include && !$window.iframeAPIIncluded) {
	        // This code loads the IFrame Player API code asynchronously.
	        var tag = document.createElement('script');
	        tag.src = "https://www.youtube.com/iframe_api";
	        var firstScriptTag = document.getElementsByTagName('script')[0];
	        firstScriptTag.parentNode.insertBefore(tag, firstScriptTag);
	        $window.iframeAPIIncluded = true;
	      }
	
	      if ($window.youtubeApiReady) {
	        callback();
	      } else {
	        $window.youtubeIframeApiCallbacks = $window.youtubeIframeApiCallbacks || [];
	        $window.youtubeIframeApiCallbacks.push(function () {
	          $window.youtubeApiReady = true;
	        });
	        $window.youtubeIframeApiCallbacks.push(callback);
	      }
	    }
	  };
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = h;
	
	var _leftNavToggler = __webpack_require__(225);
	
	var _leftNavToggler2 = _interopRequireDefault(_leftNavToggler);
	
	var _deleteLinkDirective = __webpack_require__(227);
	
	var _deleteLinkDirective2 = _interopRequireDefault(_deleteLinkDirective);
	
	var _headerMainDirective = __webpack_require__(228);
	
	var _headerMainDirective2 = _interopRequireDefault(_headerMainDirective);
	
	var _headerSearchFormDirective = __webpack_require__(229);
	
	var _headerSearchFormDirective2 = _interopRequireDefault(_headerSearchFormDirective);
	
	var _loginFormDirective = __webpack_require__(242);
	
	var _loginFormDirective2 = _interopRequireDefault(_loginFormDirective);
	
	var _sessionModalDirective = __webpack_require__(244);
	
	var _sessionModalDirective2 = _interopRequireDefault(_sessionModalDirective);
	
	var _sessionModalLinkDirective = __webpack_require__(245);
	
	var _sessionModalLinkDirective2 = _interopRequireDefault(_sessionModalLinkDirective);
	
	var _signupFormDirective = __webpack_require__(246);
	
	var _signupFormDirective2 = _interopRequireDefault(_signupFormDirective);
	
	var _headerFlashDirectives = __webpack_require__(247);
	
	var _headerFlashDirectives2 = _interopRequireDefault(_headerFlashDirectives);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	(0, _leftNavToggler2.default)(angular);
	
	function h(header) {
	  (0, _headerFlashDirectives2.default)(header);
	  header.directive('deleteLink', _deleteLinkDirective2.default).directive('headerMain', _headerMainDirective2.default).directive('headerSearchForm', _headerSearchFormDirective2.default).directive('loginForm', _loginFormDirective2.default).directive('sessionModal', _sessionModalDirective2.default).directive('sessionModalLink', _sessionModalLinkDirective2.default).directive('signupForm', _signupFormDirective2.default);
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (angular) {
	  angular.module('indiegogo.components.leftNavToggler', ['utils']).factory('navState', _navStateService2.default);
	};
	
	var _navStateService = __webpack_require__(226);
	
	var _navStateService2 = _interopRequireDefault(_navStateService);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/***/ },
/* 226 */
/***/ function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = navStateService;
	/*@ngInject*/
	
	function navStateService() {
	  var service = {};
	
	  service.isShowing = true;
	
	  service.toggleShow = function () {
	    this.isShowing = !this.isShowing;
	  };
	
	  return service;
	}

/***/ },
/* 227 */
/***/ function(module, exports) {

	"use strict";
	
	deleteLink.$inject = ["$window", "$http"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = deleteLink;
	/*@ngInject*/
	function deleteLink($window, $http) {
	  return {
	    restrict: "A",
	    scope: {},
	    link: function link(scope, element, attrs) {
	      function performDeleteRequest() {
	        $http.delete(element.attr("href")).then(function () {
	          $window.location.href = attrs.deleteLinkHref || '/';
	        });
	      }
	
	      element.on("click", function (e) {
	        e.preventDefault();
	        e.stopImmediatePropagation();
	        if (attrs.deleteLinkConfirm) {
	          if ($window.confirm(attrs.deleteLinkConfirm)) {
	            performDeleteRequest();
	          }
	        } else {
	          performDeleteRequest();
	        }
	      });
	    }
	  };
	}

/***/ },
/* 228 */
/***/ function(module, exports) {

	"use strict";
	
	headerMain.$inject = ["navState"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = headerMain;
	/*@ngInject*/
	function headerMain(navState) {
	  return {
	    restrict: "A",
	    scope: false,
	    link: function link(scope) {
	      scope.navState = navState;
	      scope.inSearchMode = false;
	
	      scope.toggleSearchMode = function () {
	        scope.inSearchMode = !scope.inSearchMode;
	      };
	
	      scope.$on('dropdownOpen', function () {
	        scope.inSearchMode = false;
	        scope.$digest();
	      });
	
	      scope.eatTofurkeyBurger = function () {
	        navState.toggleShow();
	      };
	    }
	  };
	}

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

	'use strict';
	
	headerSearchForm.$inject = ["i18n", "browser", "$timeout"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = headerSearchForm;
	/*@ngInject*/
	function headerSearchForm(i18n, browser, $timeout) {
	  return {
	    restrict: 'A',
	    scope: true,
	    template: function template(elem, attrs) {
	      return __webpack_require__(230)("./" + attrs.template + '.html');
	    },
	    link: function link(scope, element, attrs) {
	      scope.$watch('inSearchMode', function (subsequent, last) {
	        if (!last && subsequent) {
	
	          // element is required to be visible before focusing.
	          $timeout(function () {
	            element.find('input').focus();
	          }, 100, false);
	        }
	      });
	
	      scope.i18n = i18n;
	      scope.searchTerm = attrs.term;
	      scope.inputName = attrs.inputName;
	      scope.reset = function () {
	        scope.searchTerm = '';
	        if (attrs.term && attrs.term.length > 0) {
	          browser.redirectTo(attrs.action);
	        }
	      };
	      scope.go = function () {
	        element.submit();
	      };
	    }
	  };
	}

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

	var map = {
		"./generosity-header-search-dropdown.html": 231,
		"./header-flash-container.html": 232,
		"./header-flash.html": 233,
		"./header-search-dropdown.html": 234,
		"./header-search-form.html": 235,
		"./login-form-generosity.html": 236,
		"./login-form-indiegogo.html": 237,
		"./session-modal-generosity.html": 238,
		"./session-modal-indiegogo.html": 239,
		"./signup-form-generosity.html": 240,
		"./signup-form-indiegogo.html": 241
	};
	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;
	webpackContext.id = 230;


/***/ },
/* 231 */
/***/ function(module, exports) {

	module.exports = "<input class=\"siteSearch-text\" type=\"text\" name=\"filter_title\" placeholder='{{::i18n.t(\"search_by_title\")}}' ng-model=\"searchTerm\" maxlength=\"300\" />\n<a class=\"small-cta siteSearch-cta\" ng-click=\"go()\">{{::i18n.t('go')}}</a>\n";

/***/ },
/* 232 */
/***/ function(module, exports) {

	module.exports = "<div ng-transclude></div>\n<div header-flash\n  header-flash-level=\"{{flash.alertLevel}}\"\n  ng-repeat=\"flash in flash.flashes\">\n    <span ng-if=\"::flash.messageHtml\" ng-bind-html=\"::flash.messageHtml\"></span>\n    <span ng-if=\"::flash.messageText\" ng-bind=\"::flash.messageText\"></span>\n</div>\n";

/***/ },
/* 233 */
/***/ function(module, exports) {

	module.exports = "<div class=\"messageNotification messageNotification--fullWidth\" ng-class=\"style\" ng-if=\"open\">\n  <div class=\"container\">\n    <div class=\"messageNotification--leftRight\" gogo-test=\"flash_message\">\n      <span ng-transclude />\n      <a class=\"messageNotification-close\" href=\"\" ng-click=\"closeFlash()\">\n        <svg><use xlink:href=\"#icon-icon-close\"></use></svg>\n      </a>\n    </div>\n  </div>\n</div>\n";

/***/ },
/* 234 */
/***/ function(module, exports) {

	module.exports = "<div class=\"i-search-box\">\n  <div class=\"i-search-cell\">\n    <div class=\"i-search-close\" ng-show=\"searchTerm.length > 0\" ng-click=\"reset()\">\n      <svg class=\"i-search-close-icon\"><use xlink:href=\"#icon-icon-close\"></use></svg>\n    </div>\n    <input type=\"text\" name=\"{{::inputName}}\" ng-model=\"searchTerm\" maxlength=\"300\" />\n  </div>\n  <div class=\"i-go-cell\">\n    <!-- TODO EVENTS: id=coaw4 fixtype=ga-event-dir action=Complete.Search category=Mobile.Web.Campaign.Page trigger=click dom=div subsystem=explore name-new=TBD . -->\n    <div class=\"i-search-go\"\n         ng-click=\"go()\"\n         ga-event-on=\"click\"\n         ga-event-category=\"Mobile Web Campaign Page\"\n         ga-event-action=\"Complete Search\">\n      <a href=\"\">{{::i18n.t('go')}}</a>\n    </div>\n  </div>\n</div>\n";

/***/ },
/* 235 */
/***/ function(module, exports) {

	module.exports = "<label class=\"visible-only-to-screenreader\" for=\"search_term\">{{i18n.t('search')}}</label>\n<input type=\"text\" name=\"{{::inputName}}\" id=\"search_term\" ng-model=\"searchTerm\" maxlength=\"300\" class=\"i-text-field i-text-field--searchBar\" />\n<svg class=\"siteHeader-search-icon\"><use xlink:href=\"#icon-icon-search\"></use></svg>\n<a class=\"siteHeader-search-close\" href=\"\" ng-click=\"reset()\" ng-show=\"searchTerm.length > 0\"><svg><use xlink:href=\"#icon-icon-close\"></use></svg></a>\n";

/***/ },
/* 236 */
/***/ function(module, exports) {

	module.exports = "<p class=\"sign-up-with-email divider\"><span class=\"divider-line\">{{::i18n.t('or_log_in_with_email') }}</span></p>\n<form name=\"loginForm\" novalidate ng-submit=\"submitLogin()\">\n  <p class=\"i-error\" ng-show=\"loginFailed\">{{::i18n.t('login_modal.invalid_email_or_password')}}</p>\n  <p class=\"i-error\" ng-show=\"securityMessage\">{{securityMessage}}</p>\n  <label class=\"hide i-error signup\"></label>\n\n  <input name=\"emailField\" id=\"account_email\" type=\"email\" class=\"i-text-field\" placeholder=\"{{::i18n.t('email_caps')}}\"\n         ng-model=\"loginAccount.email\" required />\n  <label for=\"account_email\" class=\"i-error\" ng-if=\"loginForm.emailField.$error.email\">{{::i18n.t('login_modal.please_enter_a_valid_email_address')}}</label>\n  <label for=\"account_email\" class=\"i-error\" ng-if=\"loginForm.emailField.$error.required && loginForm.emailField.$dirty\">{{::i18n.t('login_modal.this_field_is_required')}}</label>\n\n  <input name=\"passwordField\" id=\"account_password\" type=\"password\" ng-minlength=\"6\" class=\"i-text-field\" ng-model=\"loginAccount.password\" required placeholder=\"{{::i18n.t('password')}}\" autocomplete=\"off\" />\n  <label for=\"account_password\" class=\"i-error\" ng-if=\"loginForm.passwordField.$error.minlength\">{{::i18n.t('must_be_at_least_6_characters_long')}}</label>\n  <label for=\"account_password\" class=\"i-error\" ng-if=\"loginForm.passwordField.$error.required && loginForm.passwordField.$dirty\">{{::i18n.t('login_modal.this_field_is_required')}}</label>\n\n  <div class=\"i-field-row splitApart\">\n    <div class=\"i-checkbox-with-label\">\n      <input type=\"checkbox\" id=\"rememberme\" ng-model=\"loginAccount.rememberme\" />\n      <label for=\"rememberme\">{{::i18n.t('remember_me')}}</label>\n    </div>\n    <div class=\"i-forgot\">\n      <a ng-href=\"{{::forgotPasswordUrl}}\">{{::i18n.t('forgot_password')}}</a>\n    </div>\n  </div>\n\n  <input type=\"submit\" class=\"small-cta\" value=\"{{::i18n.t('log_in')}}\" />\n</form>\n";

/***/ },
/* 237 */
/***/ function(module, exports) {

	module.exports = "<p class=\"sign-up-with-email divider\"><span class=\"divider-line\">{{::i18n.t('or_log_in_with_email')}}</span></p>\n<form name=\"loginForm\" novalidate ng-submit=\"submitLogin()\">\n  <p class=\"i-error\" ng-show=\"loginFailed\">{{::i18n.t('login_modal.invalid_email_or_password')}}</p>\n  <p class=\"i-error\" ng-show=\"securityMessage\">{{securityMessage}}</p>\n  <label class=\"hide i-error signup\"></label>\n\n  <input name=\"emailField\" id=\"account_email\" type=\"email\" class=\"i-text-field\" placeholder=\"{{::i18n.t('email_caps')}}\"\n         ng-model=\"loginAccount.email\" required gogo-test=\"email\" />\n  <label for=\"account_email\" class=\"i-input-error-subtext i-error\" ng-if=\"loginForm.emailField.$error.email\">{{::i18n.t('login_modal.please_enter_a_valid_email_address')}}</label>\n  <label for=\"account_email\" class=\"i-input-error-subtext i-error\" ng-if=\"loginForm.emailField.$error.required && loginForm.emailField.$dirty\">{{::i18n.t('login_modal.this_field_is_required')}}</label>\n\n  <input name=\"passwordField\" id=\"account_password\" type=\"password\" ng-minlength=\"6\" class=\"i-text-field\" ng-model=\"loginAccount.password\" required placeholder=\"{{::i18n.t('password')}}\" autocomplete=\"off\" gogo-test=\"password\" />\n  <label for=\"account_password\" class=\"i-input-error-subtext i-error\" ng-if=\"loginForm.passwordField.$error.minlength\">{{::i18n.t('must_be_at_least_6_characters_long')}}</label>\n  <label for=\"account_password\" class=\"i-input-error-subtext i-error\" ng-if=\"loginForm.passwordField.$error.required && loginForm.passwordField.$dirty\">{{::i18n.t('login_modal.this_field_is_required')}}</label>\n\n  <div class=\"i-field-row\">\n    <div class=\"col-sm-6 i-checkbox-with-label\">\n      <input type=\"checkbox\" id=\"rememberme\" ng-model=\"loginAccount.rememberme\" />\n      <label for=\"rememberme\">{{::i18n.t('remember_me')}}</label>\n    </div>\n    <div class=\"col-sm-6 i-forgot\">\n      <a class=\"i-aqua-link\" ng-href=\"{{::forgotPasswordUrl}}\">{{::i18n.t('forgot_password')}}</a>\n    </div>\n  </div>\n\n  <input type=\"submit\" class=\"i-cta-1 login\" value=\"{{::i18n.t('log_in')}}\" gogo-test=\"log_in\" />\n</form>\n";

/***/ },
/* 238 */
/***/ function(module, exports) {

	module.exports = "<div id=\"session_modal\" class=\"modal i-session-modal\">\n  <div class=\"modal-dialog\">\n    <div class=\"modal-content auth-modal\">\n      <a class=\"modal-close\" data-dismiss=\"modal\" aria-hidden=\"true\" ng-click=\"$hide()\"><svg-icon icon=\"icon-icon-close\"></svg-icon></a>\n\n      <div class=\"i-security-message center-text\" ng-show=\"securityMessage\">\n        <svg-icon icon=\"icon-icon-lock\"></svg-icon>\n        <h4>{{::i18n.t('session_modal.check_your_email')}}</h4>\n        <div ng-bind=\"securityMessage\"></div>\n        <a class=\"primary-cta\" ng-href=\"{{securityUrl}}\">{{::i18n.t('learn_more')}}</a>\n      </div>\n      <div ng-hide=\"securityMessage\">\n        <div class=\"center-text fb-auth\">\n          <a href=\"#\" ng-click=\"attemptFbLogin()\" class=\"small-cta small-cta--fbConnect\">\n            <svg-icon icon=\"icon-icon-facebook\"></svg-icon>\n            <span>{{::i18n.t('continue_with_facebook')}}</span>\n          </a>\n          <p>{{::i18n.t(\"generosity.login_page.facebook_intro_2\")}}</p>\n        </div>\n\n        <div class=\"auth-fields\">\n          <div id=\"loginSession\" ng-if=\"currentForm === 'loginForm'\">\n            <login-form template-url=\"login-form-generosity.html\"\n                        modal=\"modal\"\n                        callbacks=\"sessionCallbacks\"\n            ></login-form>\n            <div class=\"topborder\">\n              {{::i18n.t('generosity.session_modal.new_to_generosity') }}\n              <a href=\"\" ng-click=\"switchForm('signupForm')\" class=\"toggler\">{{::i18n.t('sign_up')}}</a>\n            </div>\n          </div>\n          <div id=\"signUpSession\" ng-if=\"currentForm === 'signupForm'\">\n            <signup-form template-url=\"signup-form-generosity.html\"\n                         domain-code=\"generosity\"\n                         modal=\"modal\"\n                         callbacks=\"sessionCallbacks\"\n            ></signup-form>\n            <div class=\"topborder\">\n              {{::i18n.t('already_have_an_account')}}\n              <a href=\"\" ng-click=\"switchForm('loginForm')\" class=\"toggler\">{{::i18n.t('log_in')}}</a>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n";

/***/ },
/* 239 */
/***/ function(module, exports) {

	module.exports = "<div id=\"session_modal\" class=\"modal i-modal i-session-modal\" gogo-test=\"{{gogoTestModalLabel}}\">\n  <div class=\"modal-dialog\">\n    <div class=\"modal-content auth-modal\">\n      <a class=\"modal-close\" data-dismiss=\"modal\" aria-hidden=\"true\" ng-click=\"$hide()\"><svg><use xlink:href=\"#icon-icon-close\"></use></svg></a>\n      <div ng-if=\"banner\" class=\"modal-banner\">{{banner}}</div>\n\n      <div class=\"securityMessage\" ng-show=\"securityMessage\">\n        <svg class=\"securityMessage-lock\"><use xlink:href=\"#icon-icon-lock\"></use></svg>\n        <div class=\"securityMessage-header\">{{::i18n.t('session_modal.check_your_email')}}</div>\n        <div ng-bind=\"securityMessage\"></div>\n        <a class=\"i-cta-1 securityMessage-cta\" target=\"_blank\" ng-href=\"{{securityUrl}}\">{{::i18n.t('learn_more')}}</a>\n      </div>\n      <div ng-hide=\"securityMessage\">\n        <div class=\"center-text fb-auth\">\n          <a href=\"#\" ng-click=\"attemptFbLogin()\" class=\"i-cta-1 i-cta-1--iconed i-cta-1--facebook i-cta-1--fullWidth i-cta-1--authFacebook authModal-facebook\">\n            <svg class=\"i-cta-1-icon\"><use xlink:href=\"#icon-icon-facebook\"></use></svg>\n            <span>{{::i18n.t('continue_with_facebook')}}</span>\n          </a>\n          <p>{{::i18n.t(\"login_page.facebook_intro_2\") }}</p>\n        </div>\n\n        <div class=\"auth-fields\">\n          <div id=\"loginSession\" ng-if=\"currentForm === 'loginForm'\">\n            <login-form template-url=\"login-form-indiegogo.html\"\n                        modal=\"modal\"\n                        callbacks=\"sessionCallbacks\"\n                        login-status=\"authStatus\"\n              ></login-form>\n            <div class=\"topborder\">\n              {{::i18n.t('new_to_igg')}}\n              <a href=\"\" ng-click=\"switchForm('signupForm')\" class=\"toggler\">{{::i18n.t('sign_up')}}</a>\n            </div>\n          </div>\n\n          <div id=\"signUpSession\" ng-if=\"currentForm === 'signupForm'\">\n            <signup-form template-url=\"signup-form-indiegogo.html\"\n                         domain-code=\"www\"\n                         modal=\"modal\"\n                         callbacks=\"sessionCallbacks\"\n                         signup-status=\"authStatus\"\n              ></signup-form>\n            <div class=\"topborder\">\n              {{::i18n.t('already_have_an_account')}}\n              <a href=\"\" ng-click=\"switchForm('loginForm')\" class=\"toggler\">{{::i18n.t('log_in')}}</a>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  </div>\n</div>\n";

/***/ },
/* 240 */
/***/ function(module, exports) {

	module.exports = "<p class=\"sign-up-with-email divider\"><span class=\"divider-line\">{{::i18n.t('or_sign_up_with_email') }}</span></p>\n<form name=\"signupForm\" novalidate ng-submit=\"submitSignup()\">\n\n  <p class=\"i-error\" ng-if=\"errorMessage\" ng-bind=\"errorMessage\"></p>\n  <input type=\"text\" name=\"firstnameField\" id=\"account_firstname\" class=\"i-text-field\" placeholder=\"{{::i18n.t('first_name')}}\" ng-model=\"signupAccount.firstname\" required />\n  <label for=\"account_firstname\" class=\"i-error\" ng-if=\"signupForm.firstnameField.$error.required && signupForm.firstnameField.$dirty\">{{::i18n.t('signup_modal.this_field_is_required')}}</label>\n\n  <input type=\"text\" name=\"lastnameField\" id=\"account_lastname\" class=\"i-text-field\" placeholder=\"{{::i18n.t('last_name')}}\" ng-model=\"signupAccount.lastname\" required />\n  <label for=\"account_lastname\" class=\"i-error\" ng-if=\"signupForm.lastnameField.$error.required && signupForm['account[lastname]'].$dirty\">{{::i18n.t('signup_modal.this_field_is_required')}}</label>\n\n  <input type=\"text\" name=\"emailField\" id=\"account_email\" class=\"i-text-field\" placeholder=\"{{::i18n.t('email_caps')}}\" ng-model=\"signupAccount.email\" required />\n  <label for=\"account_email\" class=\"i-error\" ng-if=\"signupFailed && !signupAccount.emailValid()\">{{::i18n.t('signup_modal.please_enter_a_valid_email_address')}}</label>\n  <label for=\"account_email\" class=\"i-error\" ng-if=\"signupFailed && !signupAccount.email\">{{::i18n.t('signup_modal.this_field_is_required')}}</label>\n\n  <input type=\"password\" name=\"passwordField\" id=\"take\" class=\"i-text-field\" minlength=\"6\" autocomplete=\"off\" placeholder=\"{{::i18n.t('password')}}\" ng-model=\"signupAccount.password\" required />\n  <label for=\"take\" class=\"i-error\" ng-if=\"signupFailed && !signupAccount.passwordValid()\">{{::i18n.t('must_be_between_6_and_40_characters')}}</label>\n  <label for=\"take\" class=\"i-error\" ng-if=\"signupFailed && !signupAccount.password\">{{::i18n.t('signup_modal.invalid_password')}}</label>\n\n  <div class=\"i-field-row checkboxWithLabel\">\n    <input type=\"checkbox\" ng-model=\"signupAccount.general_opt_in\" id=\"optIn\" />\n    <label for=\"optIn\">{{::i18n.t('generosity.login_page.sign_me_up_for_newsletter')}}</label>\n  </div>\n  <input type=\"submit\" value=\"{{::i18n.t('create_an_account')}}\" class=\"small-cta\" />\n\n  <div class=\"finePrint\">\n    {{::i18n.t('generosity.session_modal.fee_signup_info')}}\n    <span ng-bind-html=\"boilerplateHtml\"></span>\n  </div>\n</form>\n";

/***/ },
/* 241 */
/***/ function(module, exports) {

	module.exports = "<p class=\"sign-up-with-email divider\"><span class=\"divider-line\">{{::i18n.t('or_sign_up_with_email') }}</span></p>\n<form name=\"signupForm\" novalidate ng-submit=\"submitSignup()\">\n\n  <p class=\"i-error\" ng-if=\"errorMessage\" ng-bind=\"errorMessage\"></p>\n  <input type=\"text\" name=\"firstnameField\" id=\"account_firstname\" class=\"i-text-field\" placeholder=\"{{::i18n.t('first_name')}}\" ng-model=\"signupAccount.firstname\" required />\n  <label for=\"account_firstname\" class=\"i-input-error-subtext i-error\" ng-if=\"signupForm.firstnameField.$error.required && (signupFailed || signupForm.firstnameField.$dirty)\">{{::i18n.t('signup_modal.this_field_is_required')}}</label>\n\n  <input type=\"text\" name=\"lastnameField\" id=\"account_lastname\" class=\"i-text-field\" placeholder=\"{{::i18n.t('last_name')}}\" ng-model=\"signupAccount.lastname\" required />\n  <label for=\"account_lastname\" class=\"i-input-error-subtext i-error\" ng-if=\"signupForm.lastnameField.$error.required && (signupFailed || signupForm.lastnameField.$dirty)\">{{::i18n.t('signup_modal.this_field_is_required')}}</label>\n\n  <input type=\"text\" name=\"emailField\" id=\"account_email\" class=\"i-text-field\" placeholder=\"{{::i18n.t('email_caps')}}\" ng-model=\"signupAccount.email\" required />\n  <label for=\"account_email\" class=\"i-input-error-subtext i-error\" ng-if=\"signupFailed && !signupAccount.emailValid()\">{{::i18n.t('signup_modal.please_enter_a_valid_email_address')}}</label>\n  <label for=\"account_email\" class=\"i-input-error-subtext i-error\" ng-if=\"signupFailed && !signupAccount.email\">{{::i18n.t('signup_modal.this_field_is_required')}}</label>\n\n  <input type=\"password\" name=\"passwordField\" id=\"take\" class=\"i-text-field\" minlength=\"6\" autocomplete=\"off\" placeholder=\"{{::i18n.t('password')}}\" ng-model=\"signupAccount.password\" required />\n  <label for=\"take\" class=\"i-input-error-subtext i-error\" ng-if=\"signupFailed && !signupAccount.passwordValid()\">{{::i18n.t('must_be_between_6_and_40_characters')}}</label>\n  <label for=\"take\" class=\"i-input-error-subtext i-error\" ng-if=\"signupFailed && !signupAccount.password\">{{::i18n.t('signup_modal.invalid_password')}}</label>\n\n  <div class=\"i-field-row i-checkbox-with-label\">\n    <input type=\"checkbox\" ng-model=\"signupAccount.general_opt_in\" id=\"optIn\" />\n    <label for=\"optIn\">{{::i18n.t('sign_me_up_for_newsletter')}}</label>\n  </div>\n  <input ng-disabled=\"disableSignUp\" type=\"submit\" value=\"{{::i18n.t('create_an_account')}}\" class=\"i-cta-1\" />\n\n  <div class=\"i-fine-print\">\n    <span ng-bind-html=\"boilerplateHtml\"></span>\n  </div>\n</form>\n";

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

	'use strict';
	
	loginForm.$inject = ["i18n", "csrfToken", "$http", "gon", "safeGa", "browser", "gogoEvents"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = loginForm;
	/*@ngInject*/
	function loginForm(i18n, csrfToken, $http, gon, safeGa, browser, gogoEvents) {
	  return {
	    scope: {
	      modal: '=modal',
	      callbacks: '=callbacks',
	      loginStatus: '=loginStatus'
	    },
	    template: function template(element, attrs) {
	      return __webpack_require__(243)('./' + attrs.templateUrl);
	    },
	    link: function link(scope) {
	      scope.loginAccount = {
	        password: null,
	        rememberme: true
	      };
	
	      function handleLoginSuccess(headerRedirect) {
	        var cb = function cb() {
	          return browser.refreshPage();
	        };
	
	        if (scope.callbacks && scope.callbacks.successCallback) {
	          cb = scope.callbacks.successCallback;
	        } else if (headerRedirect) {
	          cb = function cb() {
	            return browser.redirectTo(headerRedirect);
	          };
	        }
	
	        var beforeReloadCallback = scope.callbacks && scope.callbacks.beforeReloadCallback;
	        // TODO EVENTS: id=lie7a category=Account.Login action=login_complete subsystem=accounts label=dynamic fixtype=review name=login.complete name-new=account_login_complete . needs tests!
	        gogoEvents.track({
	          thetaName: 'login complete',
	          gaEventCategory: 'Account Login',
	          gaEventAction: 'login complete',
	          gaEventLabel: browser.currentHref()
	        }).then(beforeReloadCallback).then(cb);
	      }
	
	      function loginSuccess(response) {
	        if (scope.loginStatus) {
	          scope.loginStatus.success = true;
	        }
	        scope.modal.hide();
	        csrfToken.setToken(response.headers()['x-csrf-token']);
	        handleLoginSuccess(response.headers().location);
	      }
	
	      function loginError(response) {
	        scope.loginFailed = true;
	        var error = response && response.data && response.data.error;
	        // TODO EVENTS: id=ohw0a category=Account.Login action=error label=dynamic fixtype=safega-only subsystem=accounts name-new=TBD .
	        safeGa.sendEvent('Account Login', 'error', error);
	        if (error == "resource_owner_credentials_revoked") {
	          scope.loginFailed = false;
	          scope.securityMessage = response.data.error_description;
	        }
	      }
	
	      scope.i18n = i18n;
	      scope.forgotPasswordUrl = gon.session_modal.forgot_password_url;
	
	      scope.submitLogin = function () {
	        $http.post(gon.session_modal.login_url, {
	          from: gon.session_modal.from,
	          account: scope.loginAccount
	        }).then(loginSuccess, loginError);
	      };
	    }
	  };
	}

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

	var map = {
		"./generosity-header-search-dropdown.html": 231,
		"./header-flash-container.html": 232,
		"./header-flash.html": 233,
		"./header-search-dropdown.html": 234,
		"./header-search-form.html": 235,
		"./login-form-generosity.html": 236,
		"./login-form-indiegogo.html": 237,
		"./session-modal-generosity.html": 238,
		"./session-modal-indiegogo.html": 239,
		"./signup-form-generosity.html": 240,
		"./signup-form-indiegogo.html": 241
	};
	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;
	webpackContext.id = 243;


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

	'use strict';
	
	sessionModal.$inject = ["$modal", "gon", "gogoEvents", "safeGa", "$http", "browser", "i18n", "localStorageService", "$timeout", "$window"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = sessionModal;
	/*@ngInject*/
	function sessionModal($modal, gon, gogoEvents, safeGa, $http, browser, i18n, localStorageService, $timeout, $window) {
	  var modalTemplateUrl;
	  if (gon.domain === 'generosity') {
	    modalTemplateUrl = 'session-modal-generosity.html';
	  } else {
	    modalTemplateUrl = 'session-modal-indiegogo.html';
	  }
	
	  return {
	    restrict: 'E',
	    scope: {
	      status: '=',
	      banner: '=',
	      gogoTestModalLabel: '@'
	    },
	    link: function link(scope) {
	      scope.authStatus = { success: false };
	      scope.i18n = i18n;
	      scope.fbAuthUrl = gon && gon.session_modal && gon.session_modal.fb_auth_url;
	      scope.securityUrl = gon && gon.session_modal && gon.session_modal.security_url;
	
	      scope.switchForm = function (newForm) {
	        scope.currentForm = newForm;
	        sendGaForForm(scope.currentForm);
	      };
	
	      function sendGaForForm(currentForm) {
	        if (currentForm == 'loginForm') {
	          // TODO EVENTS: id=ieni2 fixtype=safega-only subsystem=accounts category=Account.Login action=view label=dynamic subsystem=accounts name-new=TBD .
	          safeGa.sendEvent('Account Login', 'view', browser.currentHref());
	        } else {
	          // TODO EVENTS: id=quou5 fixtype=safega-only subsystem=accounts category=Account.Sign-up action=view label=dynamic name-new=TBD subsystem=accounts name-new=TBD .
	          safeGa.sendEvent('Account Sign-up', 'view', browser.currentHref());
	        }
	      }
	
	      var afterReloadCallbackKey = "afterReloadCallback";
	      var afterReloadCallbackValue = $window.location.pathname;
	
	      var cancelCallback = function cancelCallback() {
	        return scope.status.callbacks && scope.status.callbacks.cancelCallback;
	      };
	      var afterReloadCallback = function afterReloadCallback() {
	        return scope.status.callbacks && scope.status.callbacks.afterReloadCallback;
	      };
	
	      function onLoginSuccessBeforeReload() {
	        if (afterReloadCallback()) {
	          localStorageService.set(afterReloadCallbackKey, afterReloadCallbackValue);
	        }
	      }
	
	      scope.attemptFbLogin = function () {
	        onLoginSuccessBeforeReload();
	        browser.redirectTo(scope.fbAuthUrl);
	      };
	
	      var afterReloadMarker = localStorageService.get(afterReloadCallbackKey);
	      $timeout(function () {
	        if (afterReloadMarker) {
	          var isLoggedIn = gon.current_user;
	          var loggedInFromCurrentPage = afterReloadMarker == afterReloadCallbackValue;
	          if (afterReloadCallback() && isLoggedIn && loggedInFromCurrentPage) {
	            afterReloadCallback()();
	          }
	          localStorageService.remove(afterReloadCallbackKey);
	        }
	      });
	
	      function openModal() {
	        scope.currentForm = scope.status.startingForm || 'loginForm';
	        sendGaForForm(scope.currentForm);
	        scope.modal = $modal({
	          template: __webpack_require__(243)('./' + modalTemplateUrl),
	          scope: scope
	        });
	      }
	
	      scope.$on('modal.hide', function () {
	        if (!scope.authStatus.success && cancelCallback()) {
	          cancelCallback()();
	        }
	      });
	
	      scope.$watch('status.open', function (newVal) {
	        if (newVal) {
	          openModal();
	          scope.status.open = false; // Since we're watching for status.open to change, we need to reset this to false every time we open the modal so that subsequent setting of status.open to true triggers the change. Without this line, the modal only ever opens once on the page.
	        }
	      });
	
	      scope.$watch('status.callbacks', function (newVal) {
	        scope.sessionCallbacks = _.merge({ beforeReloadCallback: onLoginSuccessBeforeReload }, newVal);
	      });
	    }
	  };
	}

/***/ },
/* 245 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = sessionModalLink;
	/*@ngInject*/
	function sessionModalLink() {
	  return {
	    scope: {
	      startingForm: '@',
	      gogoTestLinkLabel: '@',
	      gogoTestModalLabel: '@'
	    },
	    restrict: 'A',
	    template: '<a href="" class="siteHeader-link" ng-click="openModal()" ng-transclude gogo-test="{{gogoTestLinkLabel}}"></a><session-modal gogo-test-modal-label="{{gogoTestModalLabel}}" status="status"></session-modal>',
	    transclude: true,
	    link: function link(scope) {
	      scope.status = {
	        startingForm: scope.startingForm,
	        open: false
	      };
	
	      scope.openModal = function () {
	        scope.status.open = true;
	      };
	    }
	  };
	}

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

	'use strict';
	
	signupForm.$inject = ["i18n", "csrfToken", "$http", "gon", "safeGa", "browser", "gogoEvents", "signup"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = signupForm;
	/*@ngInject*/
	function signupForm(i18n, csrfToken, $http, gon, safeGa, browser, gogoEvents, signup) {
	  var EMAIL_REGEXP = /^[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i;
	
	  return {
	    scope: {
	      domainCode: '@domainCode',
	      modal: '=modal',
	      callbacks: '=callbacks',
	      signupStatus: '=signupStatus'
	    },
	    template: function template(element, attrs) {
	      return __webpack_require__(243)('./' + attrs.templateUrl);
	    },
	    link: function link(scope) {
	      scope.disableSignUp = false;
	
	      function sendGaForSignupSuccess(headerRedirect) {
	        var cb = function cb() {
	          return browser.refreshPage();
	        };
	
	        if (scope.callbacks && scope.callbacks.successCallback) {
	          cb = scope.callbacks.successCallback;
	        } else if (headerRedirect) {
	          cb = function cb() {
	            return browser.redirectTo(headerRedirect);
	          };
	        }
	
	        var beforeReloadCallback = scope.callbacks && scope.callbacks.beforeReloadCallback;
	        // TODO EVENTS: id=cei2b fixtype=review subsystem=accounts category=Account_Sign-up action=sign-up_complete label=dynamic name=sign-up!complete new-name=account_sign_up_complete .
	        gogoEvents.track({
	          thetaName: 'sign-up complete',
	          gaEventCategory: 'Account Sign-up',
	          gaEventAction: 'sign-up complete',
	          gaEventLabel: browser.currentHref()
	        }).then(beforeReloadCallback).then(cb);
	      }
	
	      function signupSuccess(response) {
	        if (scope.signupStatus) {
	          scope.signupStatus.success = true;
	        }
	        scope.modal.hide();
	        csrfToken.setToken(response.headers()['x-csrf-token']);
	        sendGaForSignupSuccess(response.headers().location);
	      }
	
	      function signupError(response) {
	        scope.signupFailed = false;
	        scope.errorMessage = response.data.error;
	        // TODO EVENTS: id=roo0r fixtype=safega-only subsystem=accounts category=Account_Sign-up action=error label=dynamic subsystem=accounts name-new=TBD .
	        safeGa.sendEvent('Account Sign-up', 'error', response.data.error);
	      }
	
	      scope.i18n = i18n;
	      scope.signupFailed = false;
	      scope.signupAccount = {
	        general_opt_in: true,
	        emailValid: function emailValid() {
	          if (_.isUndefined(this.email)) {
	            return true;
	          } else {
	            return EMAIL_REGEXP.test(this.email);
	          }
	        },
	
	        passwordValid: function passwordValid() {
	          if (_.isUndefined(this.password)) {
	            return true;
	          } else {
	            var length = this.password.length;
	            return length >= 6 && length <= 40;
	          }
	        },
	
	        allFieldsPresent: function allFieldsPresent() {
	          return !!(this.firstname && this.lastname && this.email && this.password);
	        }
	      };
	
	      scope.boilerplateHtml = signup.termsHtml('by_signing_up_html');
	      scope.submitSignup = function () {
	        var account = scope.signupAccount;
	        if (account.passwordValid() && account.emailValid() && account.allFieldsPresent()) {
	          scope.disableSignUp = true;
	          signup.submitSignup(account, scope.domainCode).then(signupSuccess, signupError).finally(function () {
	            scope.disableSignUp = false;
	          });
	        } else {
	          scope.signupFailed = true;
	        }
	      };
	    }
	  };
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = headerFlashDirectives;
	function headerFlashDirectives(headerModule) {
	  headerModule.directive("headerFlashContainer", ['flash', function (flash) {
	    return {
	      restrict: 'A',
	      scope: {},
	      template: __webpack_require__(232),
	      transclude: true,
	      link: function link(scope, element) {
	        element.removeClass("hidden");
	        scope.flash = flash;
	      }
	    };
	  }]);
	
	  headerModule.directive("headerFlash", function () {
	    return {
	      restrict: 'A',
	      scope: {
	        level: "@headerFlashLevel"
	      },
	      template: __webpack_require__(233),
	      transclude: true,
	      link: function link(scope) {
	        if (scope.level === "alert" || scope.level === "error") {
	          scope.style = "messageNotification--error";
	        } else {
	          scope.style = "messageNotification--success";
	        }
	
	        scope.open = true;
	        scope.closeFlash = function () {
	          scope.open = false;
	        };
	      }
	    };
	  });
	}

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (footer) {
	  footer.directive('footerLocaleDropdown', _footerLocaleDropdownDirective2.default).directive('footerNewsletterForm', _footerNewsletterFormDirective2.default).directive('footerTrustBbb', _footerTrustBbbDirective2.default);
	};
	
	var _footerLocaleDropdownDirective = __webpack_require__(249);
	
	var _footerLocaleDropdownDirective2 = _interopRequireDefault(_footerLocaleDropdownDirective);
	
	var _footerNewsletterFormDirective = __webpack_require__(251);
	
	var _footerNewsletterFormDirective2 = _interopRequireDefault(_footerNewsletterFormDirective);
	
	var _footerTrustBbbDirective = __webpack_require__(252);
	
	var _footerTrustBbbDirective2 = _interopRequireDefault(_footerTrustBbbDirective);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

	'use strict';
	
	footerLocaleDropdown.$inject = ["$window", "i18n", "browser"];
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = footerLocaleDropdown;
	/*@ngInject*/
	function footerLocaleDropdown($window, i18n, browser) {
	  return {
	    restrict: 'A',
	    template: __webpack_require__(250),
	    scope: {},
	    link: function link(scope, element, attrs) {
	      var localeHash = JSON.parse(attrs.localeOptions);
	      var localeOptions = [];
	      for (var localeKey in localeHash) {
	        localeOptions.push({ key: localeKey, value: localeHash[localeKey] });
	      }
	      scope.localeOptions = _.sortBy(localeOptions, 'key');
	      scope.currentLocale = localeHash[i18n.locale];
	
	      var localeUrl = function localeUrl(locale) {
	        var location = $window.location;
	        var queryParams = location.search === "" ? [] : location.search.substring(1).split("&");
	        queryParams = _.reject(queryParams, function (param) {
	          return param.indexOf("locale") != -1;
	        });
	        queryParams.push("locale=" + locale);
	        return location.protocol + "//" + location.host + location.pathname + "?" + queryParams.join("&");
	      };
	
	      scope.selectLocale = function (locale) {
	        browser.redirectTo(localeUrl(locale));
	      };
	    }
	  };
	}

/***/ },
/* 250 */
/***/ function(module, exports) {

	module.exports = "<a href=\"\" bs-dropdown>\n  <span>{{::currentLocale}}</span>\n  <svg-icon icon=\"down-caret\"></svg-icon>\n</a>\n<ul class=\"dropdown-menu\">\n  <li ng-repeat=\"localeOption in localeOptions\">\n    <a href=\"\" ng-click=\"selectLocale(localeOption.key)\">{{::localeOption.value}}</a>\n  </li>\n</ul>\n";

/***/ },
/* 251 */
/***/ function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function () {
	  return {
	    restrict: 'A',
	    link: function link(scope, element) {
	      scope.submitForm = function () {
	        element.submit();
	      };
	    }
	  };
	};

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

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports.default = function (i18n) {
	  return {
	    restrict: 'A',
	    template: __webpack_require__(253),
	    scope: {
	      bbbImageUrl: "@footerTrustBbbImageUrl"
	    },
	    link: function link(scope) {
	      igg.externalService(function () {
	        // TRUSTe logo in footer
	        var tl = document.createElement('script');
	        tl.type = 'text/javascript';
	        tl.src = '//privacy-policy.truste.com/privacy-seal/Indiegogo,-Inc-/asc?rid=f11cda4f-ffd6-4d45-b3c3-dea39f0b8194';
	        tl.async = true;
	        var s = document.getElementsByTagName('script')[0];
	        s.parentNode.insertBefore(tl, s);
	      });
	      scope.inEnglish = i18n.locale === 'en';
	    }
	  };
	};

/***/ },
/* 253 */
/***/ function(module, exports) {

	module.exports = "<a id=\"bbblink\" class=\"bbb sehzbus\" href=\"http://www.bbb.org/greater-san-francisco/business-reviews/internet-services/indiegogo-in-san-francisco-ca-372843#bbblogo\" target=\"_blank\"><img id=\"bbblinkimg\" ng-src=\"{{bbbImageUrl}}\" width=\"100\" height=\"38\" alt=\"{{::i18n.t('footer.bbb')}}\"/></a>\n<div ng-if=\"::inEnglish\" id=\"f11cda4f-ffd6-4d45-b3c3-dea39f0b8194\" class=\"truste\"><a href=\"//privacy.truste.com/privacy-seal/Indiegogo,-Inc-/validation?rid=6d279abc-bf79-4648-bbc3-ac58bb077a34\" title=\"TRUSTe European Safe Harbor certification\" target=\"_blank\"><img style=\"border: none\" src=\"//privacy-policy.truste.com/privacy-seal/Indiegogo,-Inc-/seal?rid=6d279abc-bf79-4648-bbc3-ac58bb077a34\" height=\"38\" alt=\"TRUSTe European Safe Harbor certification\"/></a></div>\n";

/***/ },
/* 254 */
/***/ function(module, exports) {

	/**
	 * @license Angulartics v0.19.2
	 * (c) 2013 Luis Farzati http://luisfarzati.github.io/angulartics
	 * License: MIT
	 */
	(function(angular, analytics) {
	'use strict';
	
	var angulartics = window.angulartics || (window.angulartics = {});
	angulartics.waitForVendorCount = 0;
	angulartics.waitForVendorApi = function (objectName, delay, containsField, registerFn, onTimeout) {
	  if (!onTimeout) { angulartics.waitForVendorCount++; }
	  if (!registerFn) { registerFn = containsField; containsField = undefined; }
	  if (!Object.prototype.hasOwnProperty.call(window, objectName) || (containsField !== undefined && window[objectName][containsField] === undefined)) {
	    setTimeout(function () { angulartics.waitForVendorApi(objectName, delay, containsField, registerFn, true); }, delay);
	  }
	  else {
	    angulartics.waitForVendorCount--;
	    registerFn(window[objectName]);
	  }
	};
	
	/**
	 * @ngdoc overview
	 * @name angulartics
	 */
	angular.module('angulartics', [])
	.provider('$analytics', function () {
	  var settings = {
	    pageTracking: {
	      autoTrackFirstPage: true,
	      autoTrackVirtualPages: true,
	      trackRelativePath: false,
	      autoBasePath: false,
	      basePath: ''
	    },
	    eventTracking: {},
	    bufferFlushDelay: 1000, // Support only one configuration for buffer flush delay to simplify buffering
	    developerMode: false // Prevent sending data in local/development environment
	  };
	
	  // List of known handlers that plugins can register themselves for
	  var knownHandlers = [
	    'pageTrack',
	    'eventTrack',
	    'setAlias',
	    'setUsername',
	    'setUserProperties',
	    'setUserPropertiesOnce',
	    'setSuperProperties',
	    'setSuperPropertiesOnce'
	  ];
	  // Cache and handler properties will match values in 'knownHandlers' as the buffering functons are installed.
	  var cache = {};
	  var handlers = {};
	
	  // General buffering handler
	  var bufferedHandler = function(handlerName){
	    return function(){
	      if(angulartics.waitForVendorCount){
	        if(!cache[handlerName]){ cache[handlerName] = []; }
	        cache[handlerName].push(arguments);
	      }
	    };
	  };
	
	  // As handlers are installed by plugins, they get pushed into a list and invoked in order.
	  var updateHandlers = function(handlerName, fn){
	    if(!handlers[handlerName]){
	      handlers[handlerName] = [];
	    }
	    handlers[handlerName].push(fn);
	    return function(){
	      var handlerArgs = arguments;
	      angular.forEach(handlers[handlerName], function(handler){
	        handler.apply(this, handlerArgs);
	      }, this);
	    };
	  };
	
	  // The api (returned by this provider) gets populated with handlers below.
	  var api = {
	    settings: settings
	  };
	
	  // Will run setTimeout if delay is > 0
	  // Runs immediately if no delay to make sure cache/buffer is flushed before anything else.
	  // Plugins should take care to register handlers by order of precedence.
	  var onTimeout = function(fn, delay){
	    if(delay){
	      setTimeout(fn, delay);
	    } else {
	      fn();
	    }
	  };
	
	  var provider = {
	    $get: function($injector) {
	      return apiWithInjector($injector);
	    },
	    api: api,
	    settings: settings,
	    virtualPageviews: function (value) { this.settings.pageTracking.autoTrackVirtualPages = value; },
	    firstPageview: function (value) { this.settings.pageTracking.autoTrackFirstPage = value; },
	    withBase: function (value) {
	      this.settings.pageTracking.basePath = (value) ? angular.element(document).find('base').attr('href') : '';
	    },
	    withAutoBase: function (value) { this.settings.pageTracking.autoBasePath = value; },
	    developerMode: function(value) { this.settings.developerMode = value; }
	  };
	
	  // General function to register plugin handlers. Flushes buffers immediately upon registration according to the specified delay.
	  var register = function(handlerName, fn){
	    api[handlerName] = updateHandlers(handlerName, fn);
	    var handlerSettings = settings[handlerName];
	    var handlerDelay = (handlerSettings) ? handlerSettings.bufferFlushDelay : null;
	    var delay = (handlerDelay !== null) ? handlerDelay : settings.bufferFlushDelay;
	    angular.forEach(cache[handlerName], function (args, index) {
	      onTimeout(function () { fn.apply(this, args); }, index * delay);
	    });
	  };
	
	  var capitalize = function (input) {
	      return input.replace(/^./, function (match) {
	          return match.toUpperCase();
	      });
	  };
	
	  //provide a method to inject services into handlers
	  var apiWithInjector = function(injector) {
	    return angular.extend(api, {
	      '$inject': injector.invoke
	    });
	  };
	
	  // Adds to the provider a 'register#{handlerName}' function that manages multiple plugins and buffer flushing.
	  var installHandlerRegisterFunction = function(handlerName){
	    var registerName = 'register'+capitalize(handlerName);
	    provider[registerName] = function(fn){
	      register(handlerName, fn);
	    };
	    api[handlerName] = updateHandlers(handlerName, bufferedHandler(handlerName));
	  };
	
	  // Set up register functions for each known handler
	  angular.forEach(knownHandlers, installHandlerRegisterFunction);
	  return provider;
	})
	
	.run(['$rootScope', '$window', '$analytics', '$injector', function ($rootScope, $window, $analytics, $injector) {
	  if ($analytics.settings.pageTracking.autoTrackFirstPage) {
	    $injector.invoke(['$location', function ($location) {
	      /* Only track the 'first page' if there are no routes or states on the page */
	      var noRoutesOrStates = true;
	      if ($injector.has('$route')) {
	         var $route = $injector.get('$route');
	         for (var route in $route.routes) {
	           noRoutesOrStates = false;
	           break;
	         }
	      } else if ($injector.has('$state')) {
	        var $state = $injector.get('$state');
	        for (var state in $state.get()) {
	          noRoutesOrStates = false;
	          break;
	        }
	      }
	      if (noRoutesOrStates) {
	        if ($analytics.settings.pageTracking.autoBasePath) {
	          $analytics.settings.pageTracking.basePath = $window.location.pathname;
	        }
	        if ($analytics.settings.pageTracking.trackRelativePath) {
	          var url = $analytics.settings.pageTracking.basePath + $location.url();
	          $analytics.pageTrack(url, $location);
	        } else {
	          $analytics.pageTrack($location.absUrl(), $location);
	        }
	      }
	    }]);
	  }
	
	  if ($analytics.settings.pageTracking.autoTrackVirtualPages) {
	    $injector.invoke(['$location', function ($location) {
	      if ($analytics.settings.pageTracking.autoBasePath) {
	        /* Add the full route to the base. */
	        $analytics.settings.pageTracking.basePath = $window.location.pathname + "#";
	      }
	      var noRoutesOrStates = true;
	      if ($injector.has('$route')) {
	        var $route = $injector.get('$route');
	        for (var route in $route.routes) {
	          noRoutesOrStates = false;
	          break;
	        }
	        $rootScope.$on('$routeChangeSuccess', function (event, current) {
	          if (current && (current.$$route||current).redirectTo) return;
	          var url = $analytics.settings.pageTracking.basePath + $location.url();
	          $analytics.pageTrack(url, $location);
	        });
	      }
	      if ($injector.has('$state')) {
	        noRoutesOrStates = false;
	        $rootScope.$on('$stateChangeSuccess', function (event, current) {
	          var url = $analytics.settings.pageTracking.basePath + $location.url();
	          $analytics.pageTrack(url, $location);
	        });
	      }
	      if (noRoutesOrStates) {
	        $rootScope.$on('$locationChangeSuccess', function (event, current) {
	          if (current && (current.$$route || current).redirectTo) return;
	          if ($analytics.settings.pageTracking.trackRelativePath) {
	            var url = $analytics.settings.pageTracking.basePath + $location.url();
	            $analytics.pageTrack(url, $location);
	          } else {
	            $analytics.pageTrack($location.absUrl(), $location);
	          }
	        });
	      }
	    }]);
	  }
	  if ($analytics.settings.developerMode) {
	    angular.forEach($analytics, function(attr, name) {
	      if (typeof attr === 'function') {
	        $analytics[name] = function(){};
	      }
	    });
	  }
	}])
	
	.directive('analyticsOn', ['$analytics', function ($analytics) {
	  function isCommand(element) {
	    return ['a:','button:','button:button','button:submit','input:button','input:submit'].indexOf(
	      element.tagName.toLowerCase()+':'+(element.type||'')) >= 0;
	  }
	
	  function inferEventType(element) {
	    if (isCommand(element)) return 'click';
	    return 'click';
	  }
	
	  function inferEventName(element) {
	    if (isCommand(element)) return element.innerText || element.value;
	    return element.id || element.name || element.tagName;
	  }
	
	  function isProperty(name) {
	    return name.substr(0, 9) === 'analytics' && ['On', 'Event', 'If', 'Properties', 'EventType'].indexOf(name.substr(9)) === -1;
	  }
	
	  function propertyName(name) {
	    var s = name.slice(9); // slice off the 'analytics' prefix
	    if (typeof s !== 'undefined' && s!==null && s.length > 0) {
	      return s.substring(0, 1).toLowerCase() + s.substring(1);
	    }
	    else {
	      return s;
	    }
	  }
	
	  return {
	    restrict: 'A',
	    link: function ($scope, $element, $attrs) {
	      var eventType = $attrs.analyticsOn || inferEventType($element[0]);
	      var trackingData = {};
	
	      angular.forEach($attrs.$attr, function(attr, name) {
	        if (isProperty(name)) {
	          trackingData[propertyName(name)] = $attrs[name];
	          $attrs.$observe(name, function(value){
	            trackingData[propertyName(name)] = value;
	          });
	        }
	      });
	
	      angular.element($element[0]).bind(eventType, function ($event) {
	        var eventName = $attrs.analyticsEvent || inferEventName($element[0]);
	        trackingData.eventType = $event.type;
	
	        if($attrs.analyticsIf){
	          if(! $scope.$eval($attrs.analyticsIf)){
	            return; // Cancel this event if we don't pass the analytics-if condition
	          }
	        }
	        // Allow components to pass through an expression that gets merged on to the event properties
	        // eg. analytics-properites='myComponentScope.someConfigExpression.$analyticsProperties'
	        if($attrs.analyticsProperties){
	          angular.extend(trackingData, $scope.$eval($attrs.analyticsProperties));
	        }
	        $analytics.eventTrack(eventName, trackingData);
	      });
	    }
	  };
	}]);
	})(angular);


/***/ },
/* 255 */
/***/ function(module, exports) {

	/**
	 * @license AngularJS v1.4.6
	 * (c) 2010-2015 Google, Inc. http://angularjs.org
	 * License: MIT
	 */
	(function(window, angular, undefined) {'use strict';
	
	var $resourceMinErr = angular.$$minErr('$resource');
	
	// Helper functions and regex to lookup a dotted path on an object
	// stopping at undefined/null.  The path must be composed of ASCII
	// identifiers (just like $parse)
	var MEMBER_NAME_REGEX = /^(\.[a-zA-Z_$@][0-9a-zA-Z_$@]*)+$/;
	
	function isValidDottedPath(path) {
	  return (path != null && path !== '' && path !== 'hasOwnProperty' &&
	      MEMBER_NAME_REGEX.test('.' + path));
	}
	
	function lookupDottedPath(obj, path) {
	  if (!isValidDottedPath(path)) {
	    throw $resourceMinErr('badmember', 'Dotted member path "@{0}" is invalid.', path);
	  }
	  var keys = path.split('.');
	  for (var i = 0, ii = keys.length; i < ii && angular.isDefined(obj); i++) {
	    var key = keys[i];
	    obj = (obj !== null) ? obj[key] : undefined;
	  }
	  return obj;
	}
	
	/**
	 * Create a shallow copy of an object and clear other fields from the destination
	 */
	function shallowClearAndCopy(src, dst) {
	  dst = dst || {};
	
	  angular.forEach(dst, function(value, key) {
	    delete dst[key];
	  });
	
	  for (var key in src) {
	    if (src.hasOwnProperty(key) && !(key.charAt(0) === '$' && key.charAt(1) === '$')) {
	      dst[key] = src[key];
	    }
	  }
	
	  return dst;
	}
	
	/**
	 * @ngdoc module
	 * @name ngResource
	 * @description
	 *
	 * # ngResource
	 *
	 * The `ngResource` module provides interaction support with RESTful services
	 * via the $resource service.
	 *
	 *
	 * <div doc-module-components="ngResource"></div>
	 *
	 * See {@link ngResource.$resource `$resource`} for usage.
	 */
	
	/**
	 * @ngdoc service
	 * @name $resource
	 * @requires $http
	 *
	 * @description
	 * A factory which creates a resource object that lets you interact with
	 * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
	 *
	 * The returned resource object has action methods which provide high-level behaviors without
	 * the need to interact with the low level {@link ng.$http $http} service.
	 *
	 * Requires the {@link ngResource `ngResource`} module to be installed.
	 *
	 * By default, trailing slashes will be stripped from the calculated URLs,
	 * which can pose problems with server backends that do not expect that
	 * behavior.  This can be disabled by configuring the `$resourceProvider` like
	 * this:
	 *
	 * ```js
	     app.config(['$resourceProvider', function($resourceProvider) {
	       // Don't strip trailing slashes from calculated URLs
	       $resourceProvider.defaults.stripTrailingSlashes = false;
	     }]);
	 * ```
	 *
	 * @param {string} url A parameterized URL template with parameters prefixed by `:` as in
	 *   `/user/:username`. If you are using a URL with a port number (e.g.
	 *   `http://example.com:8080/api`), it will be respected.
	 *
	 *   If you are using a url with a suffix, just add the suffix, like this:
	 *   `$resource('http://example.com/resource.json')` or `$resource('http://example.com/:id.json')`
	 *   or even `$resource('http://example.com/resource/:resource_id.:format')`
	 *   If the parameter before the suffix is empty, :resource_id in this case, then the `/.` will be
	 *   collapsed down to a single `.`.  If you need this sequence to appear and not collapse then you
	 *   can escape it with `/\.`.
	 *
	 * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
	 *   `actions` methods. If any of the parameter value is a function, it will be executed every time
	 *   when a param value needs to be obtained for a request (unless the param was overridden).
	 *
	 *   Each key value in the parameter object is first bound to url template if present and then any
	 *   excess keys are appended to the url search query after the `?`.
	 *
	 *   Given a template `/path/:verb` and parameter `{verb:'greet', salutation:'Hello'}` results in
	 *   URL `/path/greet?salutation=Hello`.
	 *
	 *   If the parameter value is prefixed with `@` then the value for that parameter will be extracted
	 *   from the corresponding property on the `data` object (provided when calling an action method).  For
	 *   example, if the `defaultParam` object is `{someParam: '@someProp'}` then the value of `someParam`
	 *   will be `data.someProp`.
	 *
	 * @param {Object.<Object>=} actions Hash with declaration of custom actions that should extend
	 *   the default set of resource actions. The declaration should be created in the format of {@link
	 *   ng.$http#usage $http.config}:
	 *
	 *       {action1: {method:?, params:?, isArray:?, headers:?, ...},
	 *        action2: {method:?, params:?, isArray:?, headers:?, ...},
	 *        ...}
	 *
	 *   Where:
	 *
	 *   - **`action`** – {string} – The name of action. This name becomes the name of the method on
	 *     your resource object.
	 *   - **`method`** – {string} – Case insensitive HTTP method (e.g. `GET`, `POST`, `PUT`,
	 *     `DELETE`, `JSONP`, etc).
	 *   - **`params`** – {Object=} – Optional set of pre-bound parameters for this action. If any of
	 *     the parameter value is a function, it will be executed every time when a param value needs to
	 *     be obtained for a request (unless the param was overridden).
	 *   - **`url`** – {string} – action specific `url` override. The url templating is supported just
	 *     like for the resource-level urls.
	 *   - **`isArray`** – {boolean=} – If true then the returned object for this action is an array,
	 *     see `returns` section.
	 *   - **`transformRequest`** –
	 *     `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
	 *     transform function or an array of such functions. The transform function takes the http
	 *     request body and headers and returns its transformed (typically serialized) version.
	 *     By default, transformRequest will contain one function that checks if the request data is
	 *     an object and serializes to using `angular.toJson`. To prevent this behavior, set
	 *     `transformRequest` to an empty array: `transformRequest: []`
	 *   - **`transformResponse`** –
	 *     `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
	 *     transform function or an array of such functions. The transform function takes the http
	 *     response body and headers and returns its transformed (typically deserialized) version.
	 *     By default, transformResponse will contain one function that checks if the response looks like
	 *     a JSON string and deserializes it using `angular.fromJson`. To prevent this behavior, set
	 *     `transformResponse` to an empty array: `transformResponse: []`
	 *   - **`cache`** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
	 *     GET request, otherwise if a cache instance built with
	 *     {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
	 *     caching.
	 *   - **`timeout`** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise} that
	 *     should abort the request when resolved.
	 *   - **`withCredentials`** - `{boolean}` - whether to set the `withCredentials` flag on the
	 *     XHR object. See
	 *     [requests with credentials](https://developer.mozilla.org/en/http_access_control#section_5)
	 *     for more information.
	 *   - **`responseType`** - `{string}` - see
	 *     [requestType](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType).
	 *   - **`interceptor`** - `{Object=}` - The interceptor object has two optional methods -
	 *     `response` and `responseError`. Both `response` and `responseError` interceptors get called
	 *     with `http response` object. See {@link ng.$http $http interceptors}.
	 *
	 * @param {Object} options Hash with custom settings that should extend the
	 *   default `$resourceProvider` behavior.  The only supported option is
	 *
	 *   Where:
	 *
	 *   - **`stripTrailingSlashes`** – {boolean} – If true then the trailing
	 *   slashes from any calculated URL will be stripped. (Defaults to true.)
	 *
	 * @returns {Object} A resource "class" object with methods for the default set of resource actions
	 *   optionally extended with custom `actions`. The default set contains these actions:
	 *   ```js
	 *   { 'get':    {method:'GET'},
	 *     'save':   {method:'POST'},
	 *     'query':  {method:'GET', isArray:true},
	 *     'remove': {method:'DELETE'},
	 *     'delete': {method:'DELETE'} };
	 *   ```
	 *
	 *   Calling these methods invoke an {@link ng.$http} with the specified http method,
	 *   destination and parameters. When the data is returned from the server then the object is an
	 *   instance of the resource class. The actions `save`, `remove` and `delete` are available on it
	 *   as  methods with the `$` prefix. This allows you to easily perform CRUD operations (create,
	 *   read, update, delete) on server-side data like this:
	 *   ```js
	 *   var User = $resource('/user/:userId', {userId:'@id'});
	 *   var user = User.get({userId:123}, function() {
	 *     user.abc = true;
	 *     user.$save();
	 *   });
	 *   ```
	 *
	 *   It is important to realize that invoking a $resource object method immediately returns an
	 *   empty reference (object or array depending on `isArray`). Once the data is returned from the
	 *   server the existing reference is populated with the actual data. This is a useful trick since
	 *   usually the resource is assigned to a model which is then rendered by the view. Having an empty
	 *   object results in no rendering, once the data arrives from the server then the object is
	 *   populated with the data and the view automatically re-renders itself showing the new data. This
	 *   means that in most cases one never has to write a callback function for the action methods.
	 *
	 *   The action methods on the class object or instance object can be invoked with the following
	 *   parameters:
	 *
	 *   - HTTP GET "class" actions: `Resource.action([parameters], [success], [error])`
	 *   - non-GET "class" actions: `Resource.action([parameters], postData, [success], [error])`
	 *   - non-GET instance actions:  `instance.$action([parameters], [success], [error])`
	 *
	 *
	 *   Success callback is called with (value, responseHeaders) arguments, where the value is
	 *   the populated resource instance or collection object. The error callback is called
	 *   with (httpResponse) argument.
	 *
	 *   Class actions return empty instance (with additional properties below).
	 *   Instance actions return promise of the action.
	 *
	 *   The Resource instances and collection have these additional properties:
	 *
	 *   - `$promise`: the {@link ng.$q promise} of the original server interaction that created this
	 *     instance or collection.
	 *
	 *     On success, the promise is resolved with the same resource instance or collection object,
	 *     updated with data from server. This makes it easy to use in
	 *     {@link ngRoute.$routeProvider resolve section of $routeProvider.when()} to defer view
	 *     rendering until the resource(s) are loaded.
	 *
	 *     On failure, the promise is resolved with the {@link ng.$http http response} object, without
	 *     the `resource` property.
	 *
	 *     If an interceptor object was provided, the promise will instead be resolved with the value
	 *     returned by the interceptor.
	 *
	 *   - `$resolved`: `true` after first server interaction is completed (either with success or
	 *      rejection), `false` before that. Knowing if the Resource has been resolved is useful in
	 *      data-binding.
	 *
	 * @example
	 *
	 * # Credit card resource
	 *
	 * ```js
	     // Define CreditCard class
	     var CreditCard = $resource('/user/:userId/card/:cardId',
	      {userId:123, cardId:'@id'}, {
	       charge: {method:'POST', params:{charge:true}}
	      });
	
	     // We can retrieve a collection from the server
	     var cards = CreditCard.query(function() {
	       // GET: /user/123/card
	       // server returns: [ {id:456, number:'1234', name:'Smith'} ];
	
	       var card = cards[0];
	       // each item is an instance of CreditCard
	       expect(card instanceof CreditCard).toEqual(true);
	       card.name = "J. Smith";
	       // non GET methods are mapped onto the instances
	       card.$save();
	       // POST: /user/123/card/456 {id:456, number:'1234', name:'J. Smith'}
	       // server returns: {id:456, number:'1234', name: 'J. Smith'};
	
	       // our custom method is mapped as well.
	       card.$charge({amount:9.99});
	       // POST: /user/123/card/456?amount=9.99&charge=true {id:456, number:'1234', name:'J. Smith'}
	     });
	
	     // we can create an instance as well
	     var newCard = new CreditCard({number:'0123'});
	     newCard.name = "Mike Smith";
	     newCard.$save();
	     // POST: /user/123/card {number:'0123', name:'Mike Smith'}
	     // server returns: {id:789, number:'0123', name: 'Mike Smith'};
	     expect(newCard.id).toEqual(789);
	 * ```
	 *
	 * The object returned from this function execution is a resource "class" which has "static" method
	 * for each action in the definition.
	 *
	 * Calling these methods invoke `$http` on the `url` template with the given `method`, `params` and
	 * `headers`.
	 * When the data is returned from the server then the object is an instance of the resource type and
	 * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
	 * operations (create, read, update, delete) on server-side data.
	
	   ```js
	     var User = $resource('/user/:userId', {userId:'@id'});
	     User.get({userId:123}, function(user) {
	       user.abc = true;
	       user.$save();
	     });
	   ```
	 *
	 * It's worth noting that the success callback for `get`, `query` and other methods gets passed
	 * in the response that came from the server as well as $http header getter function, so one
	 * could rewrite the above example and get access to http headers as:
	 *
	   ```js
	     var User = $resource('/user/:userId', {userId:'@id'});
	     User.get({userId:123}, function(u, getResponseHeaders){
	       u.abc = true;
	       u.$save(function(u, putResponseHeaders) {
	         //u => saved user object
	         //putResponseHeaders => $http header getter
	       });
	     });
	   ```
	 *
	 * You can also access the raw `$http` promise via the `$promise` property on the object returned
	 *
	   ```
	     var User = $resource('/user/:userId', {userId:'@id'});
	     User.get({userId:123})
	         .$promise.then(function(user) {
	           $scope.user = user;
	         });
	   ```
	
	 * # Creating a custom 'PUT' request
	 * In this example we create a custom method on our resource to make a PUT request
	 * ```js
	 *    var app = angular.module('app', ['ngResource', 'ngRoute']);
	 *
	 *    // Some APIs expect a PUT request in the format URL/object/ID
	 *    // Here we are creating an 'update' method
	 *    app.factory('Notes', ['$resource', function($resource) {
	 *    return $resource('/notes/:id', null,
	 *        {
	 *            'update': { method:'PUT' }
	 *        });
	 *    }]);
	 *
	 *    // In our controller we get the ID from the URL using ngRoute and $routeParams
	 *    // We pass in $routeParams and our Notes factory along with $scope
	 *    app.controller('NotesCtrl', ['$scope', '$routeParams', 'Notes',
	                                      function($scope, $routeParams, Notes) {
	 *    // First get a note object from the factory
	 *    var note = Notes.get({ id:$routeParams.id });
	 *    $id = note.id;
	 *
	 *    // Now call update passing in the ID first then the object you are updating
	 *    Notes.update({ id:$id }, note);
	 *
	 *    // This will PUT /notes/ID with the note object in the request payload
	 *    }]);
	 * ```
	 */
	angular.module('ngResource', ['ng']).
	  provider('$resource', function() {
	    var PROTOCOL_AND_DOMAIN_REGEX = /^https?:\/\/[^\/]*/;
	    var provider = this;
	
	    this.defaults = {
	      // Strip slashes by default
	      stripTrailingSlashes: true,
	
	      // Default actions configuration
	      actions: {
	        'get': {method: 'GET'},
	        'save': {method: 'POST'},
	        'query': {method: 'GET', isArray: true},
	        'remove': {method: 'DELETE'},
	        'delete': {method: 'DELETE'}
	      }
	    };
	
	    this.$get = ['$http', '$q', function($http, $q) {
	
	      var noop = angular.noop,
	        forEach = angular.forEach,
	        extend = angular.extend,
	        copy = angular.copy,
	        isFunction = angular.isFunction;
	
	      /**
	       * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
	       * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set
	       * (pchar) allowed in path segments:
	       *    segment       = *pchar
	       *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
	       *    pct-encoded   = "%" HEXDIG HEXDIG
	       *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
	       *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
	       *                     / "*" / "+" / "," / ";" / "="
	       */
	      function encodeUriSegment(val) {
	        return encodeUriQuery(val, true).
	          replace(/%26/gi, '&').
	          replace(/%3D/gi, '=').
	          replace(/%2B/gi, '+');
	      }
	
	
	      /**
	       * This method is intended for encoding *key* or *value* parts of query component. We need a
	       * custom method because encodeURIComponent is too aggressive and encodes stuff that doesn't
	       * have to be encoded per http://tools.ietf.org/html/rfc3986:
	       *    query       = *( pchar / "/" / "?" )
	       *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
	       *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
	       *    pct-encoded   = "%" HEXDIG HEXDIG
	       *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
	       *                     / "*" / "+" / "," / ";" / "="
	       */
	      function encodeUriQuery(val, pctEncodeSpaces) {
	        return encodeURIComponent(val).
	          replace(/%40/gi, '@').
	          replace(/%3A/gi, ':').
	          replace(/%24/g, '$').
	          replace(/%2C/gi, ',').
	          replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
	      }
	
	      function Route(template, defaults) {
	        this.template = template;
	        this.defaults = extend({}, provider.defaults, defaults);
	        this.urlParams = {};
	      }
	
	      Route.prototype = {
	        setUrlParams: function(config, params, actionUrl) {
	          var self = this,
	            url = actionUrl || self.template,
	            val,
	            encodedVal,
	            protocolAndDomain = '';
	
	          var urlParams = self.urlParams = {};
	          forEach(url.split(/\W/), function(param) {
	            if (param === 'hasOwnProperty') {
	              throw $resourceMinErr('badname', "hasOwnProperty is not a valid parameter name.");
	            }
	            if (!(new RegExp("^\\d+$").test(param)) && param &&
	              (new RegExp("(^|[^\\\\]):" + param + "(\\W|$)").test(url))) {
	              urlParams[param] = true;
	            }
	          });
	          url = url.replace(/\\:/g, ':');
	          url = url.replace(PROTOCOL_AND_DOMAIN_REGEX, function(match) {
	            protocolAndDomain = match;
	            return '';
	          });
	
	          params = params || {};
	          forEach(self.urlParams, function(_, urlParam) {
	            val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam];
	            if (angular.isDefined(val) && val !== null) {
	              encodedVal = encodeUriSegment(val);
	              url = url.replace(new RegExp(":" + urlParam + "(\\W|$)", "g"), function(match, p1) {
	                return encodedVal + p1;
	              });
	            } else {
	              url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W|$)", "g"), function(match,
	                  leadingSlashes, tail) {
	                if (tail.charAt(0) == '/') {
	                  return tail;
	                } else {
	                  return leadingSlashes + tail;
	                }
	              });
	            }
	          });
	
	          // strip trailing slashes and set the url (unless this behavior is specifically disabled)
	          if (self.defaults.stripTrailingSlashes) {
	            url = url.replace(/\/+$/, '') || '/';
	          }
	
	          // then replace collapse `/.` if found in the last URL path segment before the query
	          // E.g. `http://url.com/id./format?q=x` becomes `http://url.com/id.format?q=x`
	          url = url.replace(/\/\.(?=\w+($|\?))/, '.');
	          // replace escaped `/\.` with `/.`
	          config.url = protocolAndDomain + url.replace(/\/\\\./, '/.');
	
	
	          // set params - delegate param encoding to $http
	          forEach(params, function(value, key) {
	            if (!self.urlParams[key]) {
	              config.params = config.params || {};
	              config.params[key] = value;
	            }
	          });
	        }
	      };
	
	
	      function resourceFactory(url, paramDefaults, actions, options) {
	        var route = new Route(url, options);
	
	        actions = extend({}, provider.defaults.actions, actions);
	
	        function extractParams(data, actionParams) {
	          var ids = {};
	          actionParams = extend({}, paramDefaults, actionParams);
	          forEach(actionParams, function(value, key) {
	            if (isFunction(value)) { value = value(); }
	            ids[key] = value && value.charAt && value.charAt(0) == '@' ?
	              lookupDottedPath(data, value.substr(1)) : value;
	          });
	          return ids;
	        }
	
	        function defaultResponseInterceptor(response) {
	          return response.resource;
	        }
	
	        function Resource(value) {
	          shallowClearAndCopy(value || {}, this);
	        }
	
	        Resource.prototype.toJSON = function() {
	          var data = extend({}, this);
	          delete data.$promise;
	          delete data.$resolved;
	          return data;
	        };
	
	        forEach(actions, function(action, name) {
	          var hasBody = /^(POST|PUT|PATCH)$/i.test(action.method);
	
	          Resource[name] = function(a1, a2, a3, a4) {
	            var params = {}, data, success, error;
	
	            /* jshint -W086 */ /* (purposefully fall through case statements) */
	            switch (arguments.length) {
	              case 4:
	                error = a4;
	                success = a3;
	              //fallthrough
	              case 3:
	              case 2:
	                if (isFunction(a2)) {
	                  if (isFunction(a1)) {
	                    success = a1;
	                    error = a2;
	                    break;
	                  }
	
	                  success = a2;
	                  error = a3;
	                  //fallthrough
	                } else {
	                  params = a1;
	                  data = a2;
	                  success = a3;
	                  break;
	                }
	              case 1:
	                if (isFunction(a1)) success = a1;
	                else if (hasBody) data = a1;
	                else params = a1;
	                break;
	              case 0: break;
	              default:
	                throw $resourceMinErr('badargs',
	                  "Expected up to 4 arguments [params, data, success, error], got {0} arguments",
	                  arguments.length);
	            }
	            /* jshint +W086 */ /* (purposefully fall through case statements) */
	
	            var isInstanceCall = this instanceof Resource;
	            var value = isInstanceCall ? data : (action.isArray ? [] : new Resource(data));
	            var httpConfig = {};
	            var responseInterceptor = action.interceptor && action.interceptor.response ||
	              defaultResponseInterceptor;
	            var responseErrorInterceptor = action.interceptor && action.interceptor.responseError ||
	              undefined;
	
	            forEach(action, function(value, key) {
	              if (key != 'params' && key != 'isArray' && key != 'interceptor') {
	                httpConfig[key] = copy(value);
	              }
	            });
	
	            if (hasBody) httpConfig.data = data;
	            route.setUrlParams(httpConfig,
	              extend({}, extractParams(data, action.params || {}), params),
	              action.url);
	
	            var promise = $http(httpConfig).then(function(response) {
	              var data = response.data,
	                promise = value.$promise;
	
	              if (data) {
	                // Need to convert action.isArray to boolean in case it is undefined
	                // jshint -W018
	                if (angular.isArray(data) !== (!!action.isArray)) {
	                  throw $resourceMinErr('badcfg',
	                      'Error in resource configuration for action `{0}`. Expected response to ' +
	                      'contain an {1} but got an {2} (Request: {3} {4})', name, action.isArray ? 'array' : 'object',
	                    angular.isArray(data) ? 'array' : 'object', httpConfig.method, httpConfig.url);
	                }
	                // jshint +W018
	                if (action.isArray) {
	                  value.length = 0;
	                  forEach(data, function(item) {
	                    if (typeof item === "object") {
	                      value.push(new Resource(item));
	                    } else {
	                      // Valid JSON values may be string literals, and these should not be converted
	                      // into objects. These items will not have access to the Resource prototype
	                      // methods, but unfortunately there
	                      value.push(item);
	                    }
	                  });
	                } else {
	                  shallowClearAndCopy(data, value);
	                  value.$promise = promise;
	                }
	              }
	
	              value.$resolved = true;
	
	              response.resource = value;
	
	              return response;
	            }, function(response) {
	              value.$resolved = true;
	
	              (error || noop)(response);
	
	              return $q.reject(response);
	            });
	
	            promise = promise.then(
	              function(response) {
	                var value = responseInterceptor(response);
	                (success || noop)(value, response.headers);
	                return value;
	              },
	              responseErrorInterceptor);
	
	            if (!isInstanceCall) {
	              // we are creating instance / collection
	              // - set the initial promise
	              // - return the instance / collection
	              value.$promise = promise;
	              value.$resolved = false;
	
	              return value;
	            }
	
	            // instance call
	            return promise;
	          };
	
	
	          Resource.prototype['$' + name] = function(params, success, error) {
	            if (isFunction(params)) {
	              error = success; success = params; params = {};
	            }
	            var result = Resource[name].call(this, params, this, success, error);
	            return result.$promise || result;
	          };
	        });
	
	        Resource.bind = function(additionalParamDefaults) {
	          return resourceFactory(url, extend({}, paramDefaults, additionalParamDefaults), actions);
	        };
	
	        return Resource;
	      }
	
	      return resourceFactory;
	    }];
	  });
	
	
	})(window, window.angular);


/***/ },
/* 256 */
/***/ function(module, exports) {

	/**
	 * A resource factory inspired by $resource from AngularJS
	 * @version v2.0.0 - 2015-02-11
	 * @link https://github.com/FineLinePrototyping/angularjs-rails-resource.git
	 * @author 
	 */
	
	(function (undefined) {
	    angular.module('rails', ['ng']);
	}());
	
	
	
	(function (undefined) {
	    angular.module('rails').factory('RailsInflector', function() {
	        function camelize(key) {
	            if (!angular.isString(key)) {
	                return key;
	            }
	
	            // should this match more than word and digit characters?
	            return key.replace(/_[\w\d]/g, function (match, index, string) {
	                return index === 0 ? match : string.charAt(index + 1).toUpperCase();
	            });
	        }
	
	        function underscore(key) {
	            if (!angular.isString(key)) {
	                return key;
	            }
	
	            // TODO match the latest logic from Active Support
	            return key.replace(/[A-Z]/g, function (match, index) {
	                return index === 0 ? match : '_' + match.toLowerCase();
	            });
	        }
	
	        function pluralize(value) {
	            // TODO match Active Support
	            return value + 's';
	        }
	
	        return {
	            camelize: camelize,
	            underscore: underscore,
	            pluralize: pluralize
	        };
	    });
	}());
	(function (undefined) {
	    angular.module('rails').factory('RailsResourceInjector', ['$injector', function($injector) {
	        /**
	         * Allow dependencies to be referenced by name or instance.  If referenced by name AngularJS $injector
	         * is used to retrieve the dependency.
	         *
	         * @param dependency (string | function) The dependency to retrieve
	         * @returns {*} The dependency
	         */
	        function getDependency(dependency) {
	            if (dependency) {
	                return angular.isString(dependency) ? $injector.get(dependency) : dependency;
	            }
	
	            return undefined;
	        }
	
	        /**
	         * Looks up and instantiates an instance of the requested service.  If the service is not a string then it is
	         * assumed to be a constructor function.
	         *
	         * @param {String|function|Object} service  The service to instantiate
	         * @returns {*} A new instance of the requested service
	         */
	        function createService(service) {
	            if (service) {
	                return $injector.instantiate(getDependency(service));
	            }
	
	            return undefined;
	        }
	
	        /**
	         * Looks up and instantiates an instance of the requested service if .
	         * @param {String|function|Object} service The service to instantiate
	         * @returns {*}
	         */
	        function getService(service) {
	            // strings and functions are not considered objects by angular.isObject()
	            if (angular.isObject(service)) {
	                return service;
	            } else if (service) {
	                return createService(service);
	            }
	
	            return undefined;
	        }
	
	        return {
	            createService: createService,
	            getService: getService,
	            getDependency: getDependency
	        };
	    }]);
	}());
	/**
	 * @ngdoc function
	 * @name rails.railsUrlBuilder
	 * @function
	 * @requires $interpolate
	 *
	 * @description
	 *
	 * Compiles a URL template string into an interpolation function using $interpolate.  If no interpolation bindings
	 * found then {{id}} is appended to the url string.
	 *
	   <pre>
	       expect(railsUrlBuilder('/books')()).toEqual('/books')
	       expect(railsUrlBuilder('/books')({id: 1})).toEqual('/books/1')
	       expect(railsUrlBuilder('/authors/{{authorId}}/books/{{id}}')({id: 1, authorId: 2})).toEqual('/authors/2/books/1')
	   </pre>
	 *
	 * If the $interpolate startSymbol and endSymbol have been customized those values should be used instead of {{ and }}
	 *
	 * @param {string|function} url If the url is a function then that function is returned.  Otherwise the url string
	 *    is passed to $interpolate as an expression.
	 *
	 * @returns {function(context)} As stated by $interpolate documentation:
	 *    An interpolation function which is used to compute the interpolated
	 *    string. The function has these parameters:
	 *
	 *    * `context`: an object against which any expressions embedded in the strings are evaluated
	 *      against.
	 *
	 */
	(function (undefined) {
	    angular.module('rails').factory('railsUrlBuilder', ['$interpolate', function($interpolate) {
	        return function (config) {
	            var url = config.url,
	              idAttribute = config.idAttribute,
	              expression;
	
	            if (angular.isFunction(url) || angular.isUndefined(url)) {
	                return url;
	            }
	
	            if (url.indexOf($interpolate.startSymbol()) === -1) {
	                url = url + '/' + $interpolate.startSymbol() + idAttribute + $interpolate.endSymbol();
	            }
	
	            expression = $interpolate(url);
	
	            return function (params) {
	                url = expression(params);
	
	                if (url.charAt(url.length - 1) === '/') {
	                    url = url.substr(0, url.length - 1);
	                }
	
	                return url;
	            };
	        };
	    }]);
	}());
	
	(function (undefined) {
	    angular.module('rails').provider('railsSerializer', function() {
	        var defaultOptions = {
	            underscore: undefined,
	            camelize: undefined,
	            pluralize: undefined,
	            exclusionMatchers: []
	        };
	
	        /**
	         * Configures the underscore method used by the serializer.  If not defined then <code>RailsInflector.underscore</code>
	         * will be used.
	         *
	         * @param {function(string):string} fn The function to use for underscore conversion
	         * @returns {railsSerializerProvider} The provider for chaining
	         */
	        this.underscore = function(fn) {
	            defaultOptions.underscore = fn;
	            return this;
	        };
	
	        /**
	         * Configures the camelize method used by the serializer.  If not defined then <code>RailsInflector.camelize</code>
	         * will be used.
	         *
	         * @param {function(string):string} fn The function to use for camelize conversion
	         * @returns {railsSerializerProvider} The provider for chaining
	         */
	        this.camelize = function(fn) {
	            defaultOptions.camelize = fn;
	            return this;
	        };
	
	        /**
	         * Configures the pluralize method used by the serializer.  If not defined then <code>RailsInflector.pluralize</code>
	         * will be used.
	         *
	         * @param {function(string):string} fn The function to use for pluralizing strings.
	         * @returns {railsSerializerProvider} The provider for chaining
	         */
	        this.pluralize = function(fn) {
	            defaultOptions.pluralize = fn;
	            return this;
	        };
	
	        /**
	         * Configures the array exclusion matchers by the serializer.  Exclusion matchers can be one of the following:
	         * * string - Defines a prefix that is used to test for exclusion
	         * * RegExp - A custom regular expression that is tested against the attribute name
	         * * function - A custom function that accepts a string argument and returns a boolean with true indicating exclusion.
	         *
	         * @param {Array.<string|function(string):boolean|RegExp} exclusions An array of exclusion matchers
	         * @returns {railsSerializerProvider} The provider for chaining
	         */
	        this.exclusionMatchers = function(exclusions) {
	            defaultOptions.exclusionMatchers = exclusions;
	            return this;
	        };
	
	        this.$get = ['$injector', 'RailsInflector', 'RailsResourceInjector', function ($injector, RailsInflector, RailsResourceInjector) {
	            defaultOptions.underscore = defaultOptions.underscore || RailsInflector.underscore;
	            defaultOptions.camelize = defaultOptions.camelize || RailsInflector.camelize;
	            defaultOptions.pluralize = defaultOptions.pluralize || RailsInflector.pluralize;
	
	            function railsSerializer(options, customizer) {
	
	                function Serializer() {
	                    if (angular.isFunction(options)) {
	                        customizer = options;
	                        options = {};
	                    }
	
	                    this.exclusions = {};
	                    this.inclusions = {};
	                    this.serializeMappings = {};
	                    this.deserializeMappings = {};
	                    this.customSerializedAttributes = {};
	                    this.preservedAttributes = {};
	                    this.customSerializers = {};
	                    this.nestedResources = {};
	                    this.options = angular.extend({excludeByDefault: false}, defaultOptions, options || {});
	
	                    if (customizer) {
	                        customizer.call(this, this);
	                    }
	                }
	
	                /**
	                 * Accepts a variable list of attribute names to exclude from JSON serialization.
	                 *
	                 * @param attributeNames... {string} Variable number of attribute name parameters
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.exclude = function () {
	                    var exclusions = this.exclusions;
	
	                    angular.forEach(arguments, function (attributeName) {
	                        exclusions[attributeName] = false;
	                    });
	
	                    return this;
	                };
	
	                /**
	                 * Accepts a variable list of attribute names that should be included in JSON serialization.
	                 * Using this method will by default exclude all other attributes and only the ones explicitly included using <code>only</code> will be serialized.
	                 * @param attributeNames... {string} Variable number of attribute name parameters
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.only = function () {
	                    var inclusions = this.inclusions;
	                    this.options.excludeByDefault = true;
	
	                    angular.forEach(arguments, function (attributeName) {
	                        inclusions[attributeName] = true;
	                    });
	
	                    return this;
	                };
	
	                /**
	                 * This is a shortcut for rename that allows you to specify a variable number of attributes that should all be renamed to
	                 * <code>{attributeName}_attributes</code> to work with the Rails nested_attributes feature.
	                 * @param attributeNames... {string} Variable number of attribute name parameters
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.nestedAttribute = function () {
	                    var self = this;
	
	                    angular.forEach(arguments, function (attributeName) {
	                        self.rename(attributeName, attributeName + '_attributes');
	                    });
	
	                    return this;
	                };
	
	                /**
	                 * Specifies an attribute that is a nested resource within the parent object.
	                 * Nested resources do not imply nested attributes, if you want both you still have to specify call <code>nestedAttribute</code> as well.
	                 *
	                 * A nested resource serves two purposes.  First, it defines the resource that should be used when constructing resources from the server.
	                 * Second, it specifies how the nested object should be serialized.
	                 *
	                 * An optional third parameter <code>serializer</code> is available to override the serialization logic
	                 * of the resource in case you need to serialize it differently in multiple contexts.
	                 *
	                 * @param attributeName {string} The name of the attribute that is a nested resource
	                 * @param resource {string | Resource} A reference to the resource that the attribute is a type of.
	                 * @param serializer {string | Serializer} (optional) An optional serializer reference to override the nested resource's default serializer
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.resource = function (attributeName, resource, serializer) {
	                    this.nestedResources[attributeName] = resource;
	
	                    if (serializer) {
	                        this.serializeWith(attributeName, serializer);
	                    }
	
	                    return this;
	                };
	
	                /**
	                 * Specifies a custom name mapping for an attribute.
	                 * On serializing to JSON the jsonName will be used.
	                 * On deserialization, if jsonName is seen then it will be renamed as javascriptName in the resulting resource.
	                 *
	                 * @param javascriptName {string} The attribute name as it appears in the JavaScript object
	                 * @param jsonName {string} The attribute name as it should appear in JSON
	                 * @param bidirectional {boolean} (optional) Allows turning off the bidirectional renaming, defaults to true.
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.rename = function (javascriptName, jsonName, bidirectional) {
	                    this.serializeMappings[javascriptName] = jsonName;
	
	                    if (bidirectional || bidirectional === undefined) {
	                        this.deserializeMappings[jsonName] = javascriptName;
	                    }
	                    return this;
	                };
	
	                /**
	                 * Allows custom attribute creation as part of the serialization to JSON.
	                 *
	                 * @param attributeName {string} The name of the attribute to add
	                 * @param value {*} The value to add, if specified as a function then the function will be called during serialization
	                 *     and should return the value to add.
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.add = function (attributeName, value) {
	                    this.customSerializedAttributes[attributeName] = value;
	                    return this;
	                };
	
	
	                /**
	                 * Allows the attribute to be preserved unmodified in the resulting object.
	                 *
	                 * @param attributeName {string} The name of the attribute to add
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.preserve = function(attributeName) {
	                    this.preservedAttributes[attributeName] =  true;
	                    return this;
	                };
	
	                /**
	                 * Specify a custom serializer to use for an attribute.
	                 *
	                 * @param attributeName {string} The name of the attribute
	                 * @param serializer {string | function} A reference to the custom serializer to use for the attribute.
	                 * @returns {Serializer} this for chaining support
	                 */
	                Serializer.prototype.serializeWith = function (attributeName, serializer) {
	                    this.customSerializers[attributeName] = serializer;
	                    return this;
	                };
	
	                /**
	                 * Determines whether or not an attribute should be excluded.
	                 *
	                 * If the option excludeByDefault has been set then attributes will default to excluded and will only
	                 * be included if they have been included using the "only" customization function.
	                 *
	                 * If the option excludeByDefault has not been set then attributes must be explicitly excluded using the "exclude"
	                 * customization function or must be matched by one of the exclusionMatchers.
	                 *
	                 * @param attributeName The name of the attribute to check for exclusion
	                 * @returns {boolean} true if excluded, false otherwise
	                 */
	                Serializer.prototype.isExcludedFromSerialization = function (attributeName) {
	                    if ((this.options.excludeByDefault && !this.inclusions.hasOwnProperty(attributeName)) || this.exclusions.hasOwnProperty(attributeName)) {
	                        return true;
	                    }
	
	                    if (this.options.exclusionMatchers) {
	                        var excluded = false;
	
	                        angular.forEach(this.options.exclusionMatchers, function (matcher) {
	                            if (angular.isString(matcher)) {
	                                excluded = excluded || attributeName.indexOf(matcher) === 0;
	                            } else if (angular.isFunction(matcher)) {
	                                excluded = excluded || matcher.call(undefined, attributeName);
	                            } else if (matcher instanceof RegExp) {
	                                excluded = excluded || matcher.test(attributeName);
	                            }
	                        });
	
	                        return excluded;
	                    }
	
	                    return false;
	                };
	
	                /**
	                 * Remaps the attribute name to the serialized form which includes:
	                 *   - checking for exclusion
	                 *   - remapping to a custom value specified by the rename customization function
	                 *   - underscoring the name
	                 *
	                 * @param attributeName The current attribute name
	                 * @returns {*} undefined if the attribute should be excluded or the mapped attribute name
	                 */
	                Serializer.prototype.getSerializedAttributeName = function (attributeName) {
	                    var mappedName = this.serializeMappings[attributeName] || attributeName;
	
	                    var mappedNameExcluded = this.isExcludedFromSerialization(mappedName),
	                        attributeNameExcluded = this.isExcludedFromSerialization(attributeName);
	
	                    if(this.options.excludeByDefault) {
	                        if(mappedNameExcluded && attributeNameExcluded) {
	                            return undefined;
	                        }
	                    } else {
	                        if (mappedNameExcluded || attributeNameExcluded) {
	                            return undefined;
	                        }
	                    }
	
	                    return this.underscore(mappedName);
	                };
	
	                /**
	                 * Determines whether or not an attribute should be excluded from deserialization.
	                 *
	                 * By default, we do not exclude any attributes from deserialization.
	                 *
	                 * @param attributeName The name of the attribute to check for exclusion
	                 * @returns {boolean} true if excluded, false otherwise
	                 */
	                Serializer.prototype.isExcludedFromDeserialization = function (attributeName) {
	                    return false;
	                };
	
	                /**
	                 * Remaps the attribute name to the deserialized form which includes:
	                 *   - camelizing the name
	                 *   - checking for exclusion
	                 *   - remapping to a custom value specified by the rename customization function
	                 *
	                 * @param attributeName The current attribute name
	                 * @returns {*} undefined if the attribute should be excluded or the mapped attribute name
	                 */
	                Serializer.prototype.getDeserializedAttributeName = function (attributeName) {
	                    var camelizedName = this.camelize(attributeName);
	
	                    camelizedName = this.deserializeMappings[attributeName] ||
	                        this.deserializeMappings[camelizedName] ||
	                        camelizedName;
	
	                    if (this.isExcludedFromDeserialization(attributeName) || this.isExcludedFromDeserialization(camelizedName)) {
	                        return undefined;
	                    }
	
	                    return camelizedName;
	                };
	
	                /**
	                 * Returns a reference to the nested resource that has been specified for the attribute.
	                 * @param attributeName The attribute name
	                 * @returns {*} undefined if no nested resource has been specified or a reference to the nested resource class
	                 */
	                Serializer.prototype.getNestedResource = function (attributeName) {
	                    return RailsResourceInjector.getDependency(this.nestedResources[attributeName]);
	                };
	
	                /**
	                 * Returns a custom serializer for the attribute if one has been specified.  Custom serializers can be specified
	                 * in one of two ways.  The serializeWith customization method allows specifying a custom serializer for any attribute.
	                 * Or an attribute could have been specified as a nested resource in which case the nested resource's serializer
	                 * is used.  Custom serializers specified using serializeWith take precedence over the nested resource serializer.
	                 *
	                 * @param attributeName The attribute name
	                 * @returns {*} undefined if no custom serializer has been specified or an instance of the Serializer
	                 */
	                Serializer.prototype.getAttributeSerializer = function (attributeName) {
	                    var resource = this.getNestedResource(attributeName),
	                        serializer = this.customSerializers[attributeName];
	
	                    // custom serializer takes precedence over resource serializer
	                    if (serializer) {
	                        return RailsResourceInjector.createService(serializer);
	                    } else if (resource) {
	                        return resource.config.serializer;
	                    }
	
	                    return undefined;
	                };
	
	
	                /**
	                 * Prepares the data for serialization to JSON.
	                 *
	                 * @param data The data to prepare
	                 * @returns {*} A new object or array that is ready for JSON serialization
	                 */
	                Serializer.prototype.serializeData = function (data) {
	                    var result = data,
	                        self = this;
	
	                    if (angular.isArray(data)) {
	                        result = [];
	
	                        angular.forEach(data, function (value) {
	                            result.push(self.serializeData(value));
	                        });
	                    } else if (angular.isObject(data)) {
	                        if (angular.isDate(data)) {
	                            return data;
	                        }
	                        result = {};
	
	                        this.serializeObject(result, data);
	
	                    }
	
	                    return result;
	                };
	
	                Serializer.prototype.serializeObject = function(result, data){
	
	
	                    var tthis = this;
	                    angular.forEach(data, function (value, key) {
	                        // if the value is a function then it can't be serialized to JSON so we'll just skip it
	                        if (!angular.isFunction(value)) {
	                            tthis.serializeAttribute(result, key, value);
	                        }
	                    });
	                    return data;
	                };
	
	                /**
	                 * Transforms an attribute and its value and stores it on the parent data object.  The attribute will be
	                 * renamed as needed and the value itself will be serialized as well.
	                 *
	                 * @param data The object that the attribute will be added to
	                 * @param attribute The attribute to transform
	                 * @param value The current value of the attribute
	                 */
	                Serializer.prototype.serializeAttribute = function (data, attribute, value) {
	                    var serializer = this.getAttributeSerializer(attribute),
	                        serializedAttributeName = this.getSerializedAttributeName(attribute);
	
	                    // undefined means the attribute should be excluded from serialization
	                    if (serializedAttributeName === undefined) {
	                        return;
	                    }
	
	                    data[serializedAttributeName] = serializer ? serializer.serialize(value) : this.serializeData(value);
	                };
	
	                /**
	                 * Serializes the data by applying various transformations such as:
	                 *   - Underscoring attribute names
	                 *   - attribute renaming
	                 *   - attribute exclusion
	                 *   - custom attribute addition
	                 *
	                 * @param data The data to prepare
	                 * @returns {*} A new object or array that is ready for JSON serialization
	                 */
	                Serializer.prototype.serialize = function (data) {
	                    var result = angular.copy(data),
	                        self = this;
	
	                    if (angular.isObject(result)) {
	                        angular.forEach(this.customSerializedAttributes, function (value, key) {
	                            if (angular.isArray(result)) {
	                                angular.forEach(result, function (item, index) {
	                                    var itemValue = value;
	                                    if (angular.isFunction(value)) {
	                                        itemValue = itemValue.call(item, item);
	                                    }
	
	                                    self.serializeAttribute(item, key, itemValue);
	                                });
	                            } else {
	                                if (angular.isFunction(value)) {
	                                    value = value.call(data, data);
	                                }
	
	                                self.serializeAttribute(result, key, value);
	                            }
	                        });
	                    }
	
	                    result = this.serializeData(result);
	
	                    return result;
	                };
	
	                /**
	                 * Iterates over the data deserializing each entry on arrays and each key/value on objects.
	                 *
	                 * @param data The object to deserialize
	                 * @param Resource (optional) The resource type to deserialize the result into
	                 * @returns {*} A new object or an instance of Resource populated with deserialized data.
	                 */
	                Serializer.prototype.deserializeData = function (data, Resource) {
	                    var result = data,
	                        self = this;
	
	                    if (angular.isArray(data)) {
	                        result = [];
	
	                        angular.forEach(data, function (value) {
	                            result.push(self.deserializeData(value, Resource));
	                        });
	                    } else if (angular.isObject(data)) {
	                        if (angular.isDate(data)) {
	                            return data;
	                        }
	                        result = {};
	
	                        if (Resource) {
	                            result = new Resource.config.resourceConstructor();
	                        }
	
	                        this.deserializeObject(result, data);
	
	                    }
	
	                    return result;
	                };
	
	                Serializer.prototype.deserializeObject = function (result, data) {
	
	                    var tthis = this;
	                    angular.forEach(data, function (value, key) {
	                        tthis.deserializeAttribute(result, key, value);
	                    });
	                    return data;
	                };
	
	
	                /**
	                 * Transforms an attribute and its value and stores it on the parent data object.  The attribute will be
	                 * renamed as needed and the value itself will be deserialized as well.
	                 *
	                 * @param data The object that the attribute will be added to
	                 * @param attribute The attribute to transform
	                 * @param value The current value of the attribute
	                 */
	                Serializer.prototype.deserializeAttribute = function (data, attribute, value) {
	                    var serializer,
	                        NestedResource,
	                        attributeName = this.getDeserializedAttributeName(attribute);
	
	                    // undefined means the attribute should be excluded from serialization
	                    if (attributeName === undefined) {
	                        return;
	                    }
	
	                    serializer = this.getAttributeSerializer(attributeName);
	                    NestedResource = this.getNestedResource(attributeName);
	
	                    // preserved attributes are assigned unmodified
	                    if (this.preservedAttributes[attributeName]) {
	                        data[attributeName] = value;
	                    } else {
	                        data[attributeName] = serializer ? serializer.deserialize(value, NestedResource) : this.deserializeData(value, NestedResource);
	                    }
	                };
	
	                /**
	                 * Deserializes the data by applying various transformations such as:
	                 *   - Camelizing attribute names
	                 *   - attribute renaming
	                 *   - attribute exclusion
	                 *   - nested resource creation
	                 *
	                 * @param data The object to deserialize
	                 * @param Resource (optional) The resource type to deserialize the result into
	                 * @returns {*} A new object or an instance of Resource populated with deserialized data
	                 */
	                Serializer.prototype.deserialize = function (data, Resource) {
	                    // just calls deserializeValue for now so we can more easily add on custom attribute logic for deserialize too
	                    return this.deserializeData(data, Resource);
	                };
	
	                Serializer.prototype.pluralize = function (value) {
	                    if (this.options.pluralize) {
	                        return this.options.pluralize(value);
	                    }
	                    return value;
	                };
	
	                Serializer.prototype.underscore = function (value) {
	                    if (this.options.underscore) {
	                        return this.options.underscore(value);
	                    }
	                    return value;
	                };
	
	                Serializer.prototype.camelize = function (value) {
	                    if (this.options.camelize) {
	                        return this.options.camelize(value);
	                    }
	                    return value;
	                };
	
	                return Serializer;
	            }
	
	            railsSerializer.defaultOptions = defaultOptions;
	            return railsSerializer;
	        }];
	    });
	}());
	(function (undefined) {
	    angular.module('rails').factory('railsRootWrapper', function () {
	        return {
	            wrap: function (data, resource) {
	                var result = {};
	                result[angular.isArray(data) ? resource.config.pluralName : resource.config.name] = data;
	                return result;
	            },
	            unwrap: function (response, resource, isObject) {
	                if (response.data && response.data.hasOwnProperty(resource.config.name)) {
	                    response.data = response.data[resource.config.name];
	                } else if (response.data && response.data.hasOwnProperty(resource.config.pluralName) && !isObject) {
	                    response.data = response.data[resource.config.pluralName];
	                }
	
	                return response;
	            }
	        };
	    });
	
	    angular.module('rails').provider('RailsResource', function () {
	        var defaultOptions = {
	            rootWrapping: true,
	            updateMethod: 'put',
	            httpConfig: {},
	            defaultParams: undefined,
	            underscoreParams: true,
	            fullResponse: false,
	            extensions: []
	        };
	
	        /**
	         * Enables or disables root wrapping by default for RailsResources
	         * Defaults to true.
	         * @param {boolean} value true to enable root wrapping, false to disable
	         * @returns {RailsResourceProvider} The provider instance
	         */
	        this.rootWrapping = function (value) {
	            defaultOptions.rootWrapping = value;
	            return this;
	        };
	
	        /**
	         * Configures what HTTP operation should be used for update by default for RailsResources.
	         * Defaults to 'put'
	         * @param value
	         * @returns {RailsResourceProvider} The provider instance
	         */
	        this.updateMethod = function (value) {
	            defaultOptions.updateMethod = value;
	            return this;
	        };
	
	        /**
	         * Configures default HTTP configuration operations for all RailsResources.
	         *
	         * @param {Object} value See $http for available configuration options.
	         * @returns {RailsResourceProvider} The provider instance
	         */
	        this.httpConfig = function (value) {
	            defaultOptions.httpConfig = value;
	            return this;
	        };
	
	        /**
	         * Configures default HTTP query parameters for all RailsResources.
	         *
	         * @param {Object} value Object of key/value pairs representing the HTTP query parameters for all HTTP operations.
	         * @returns {RailsResourceProvider} The provider instance
	         */
	        this.defaultParams = function (value) {
	            defaultOptions.defaultParams = value;
	            return this;
	        };
	
	        /**
	         * Configures whether or not underscore query parameters
	         * @param {boolean} value true to underscore.  Defaults to true.
	         * @returns {RailsResourceProvider} The provider instance
	         */
	        this.underscoreParams = function (value) {
	            defaultOptions.underscoreParams = value;
	            return this;
	        };
	
	        /**
	         * Configures whether the full response from $http is returned or just the result data.
	         * @param {boolean} value true to return full $http response.  Defaults to false.
	         * @returns {RailsResourceProvider} The provider instance
	         */
	        this.fullResponse = function (value) {
	            defaultOptions.fullResponse = value;
	            return this;
	        };
	
	        /**
	         * List of RailsResource extensions to include by default.
	         *
	         * @param {...string} extensions One or more extension names to include
	         * @returns {*}
	         */
	        this.extensions = function () {
	            defaultOptions.extensions = [];
	            angular.forEach(arguments, function (value) {
	                defaultOptions.extensions = defaultOptions.extensions.concat(value);
	            });
	            return this;
	        };
	
	        this.$get = ['$http', '$q', 'railsUrlBuilder', 'railsSerializer', 'railsRootWrapper', 'RailsResourceInjector',
	            function ($http, $q, railsUrlBuilder, railsSerializer, railsRootWrapper, RailsResourceInjector) {
	
	                function RailsResource(value) {
	                    if (value) {
	                        var response = this.constructor.deserialize({data: value});
	                        if (this.constructor.config.rootWrapping) {
	                            response = railsRootWrapper.unwrap(response, this.constructor, true);
	                        }
	                        angular.extend(this, response.data);
	                    }
	                }
	
	                /**
	                 * Extends the RailsResource to the child constructor function making the child constructor a subclass of
	                 * RailsResource.  This is modeled off of CoffeeScript's class extend function.  All RailsResource
	                 * class properties defined are copied to the child class and the child's prototype chain is configured
	                 * to allow instances of the child class to have all of the instance methods of RailsResource.
	                 *
	                 * Like CoffeeScript, a __super__ property is set on the child class to the parent resource's prototype chain.
	                 * This is done to allow subclasses to extend the functionality of instance methods and still
	                 * call back to the original method using:
	                 *
	                 *     Class.__super__.method.apply(this, arguments);
	                 *
	                 * @param {function} child Child constructor function
	                 * @returns {function} Child constructor function
	                 */
	                RailsResource.extendTo = function (child) {
	                    angular.forEach(this, function (value, key) {
	                        child[key] = value;
	                    });
	
	                    if (angular.isArray(this.$modules)) {
	                        child.$modules = this.$modules.slice(0);
	                    }
	
	                    function ctor() {
	                        this.constructor = child;
	                    }
	
	                    ctor.prototype = this.prototype;
	                    child.prototype = new ctor();
	                    child.__super__ = this.prototype;
	                    return child;
	                };
	
	                /**
	                 * Copies a mixin's properties to the resource.
	                 *
	                 * If module is a String then we it will be loaded using Angular's dependency injection.  If the name is
	                 * not valid then Angular will throw an error.
	                 *
	                 * @param {...String|function|Object} mixins The mixin or name of the mixin to add.
	                 * @returns {RailsResource} this
	                 */
	                RailsResource.extend = function () {
	                    angular.forEach(arguments, function (mixin) {
	                        addMixin(this, this, mixin, function (Resource, mixin) {
	                            if (angular.isFunction(mixin.extended)) {
	                                mixin.extended(Resource);
	                            }
	                        });
	                    }, this);
	
	                    return this;
	                };
	
	                /**
	                 * Copies a mixin's properties to the resource's prototype chain.
	                 *
	                 * If module is a String then we it will be loaded using Angular's dependency injection.  If the name is
	                 * not valid then Angular will throw an error.
	                 *
	                 * @param {...String|function|Object} mixins The mixin or name of the mixin to add
	                 * @returns {RailsResource} this
	                 */
	                RailsResource.include = function () {
	                    angular.forEach(arguments, function (mixin) {
	                        addMixin(this, this.prototype, mixin, function (Resource, mixin) {
	                            if (angular.isFunction(mixin.included)) {
	                                mixin.included(Resource);
	                            }
	                        });
	                    }, this);
	
	                    return this;
	                };
	
	                /**
	                 * Sets configuration options.  This method may be called multiple times to set additional options or to
	                 * override previous values (such as the case with inherited resources).
	                 * @param cfg
	                 */
	                RailsResource.configure = function (cfg) {
	                    cfg = cfg || {};
	
	                    if (this.config) {
	                        cfg = angular.extend({}, this.config, cfg);
	                    }
	
	                    this.config = {};
	                    this.config.idAttribute = cfg.idAttribute || 'id';
	                    this.config.url = cfg.url;
	                    this.config.rootWrapping = booleanParam(cfg.rootWrapping, defaultOptions.rootWrapping); // using undefined check because config.rootWrapping || true would be true when config.rootWrapping === false
	                    this.config.httpConfig = cfg.httpConfig || defaultOptions.httpConfig;
	                    this.config.httpConfig.headers = angular.extend({'Accept': 'application/json', 'Content-Type': 'application/json'}, this.config.httpConfig.headers || {});
	                    this.config.defaultParams = cfg.defaultParams || defaultOptions.defaultParams;
	                    this.config.underscoreParams = booleanParam(cfg.underscoreParams, defaultOptions.underscoreParams);
	                    this.config.updateMethod = (cfg.updateMethod || defaultOptions.updateMethod).toLowerCase();
	                    this.config.fullResponse = booleanParam(cfg.fullResponse, defaultOptions.fullResponse);
	
	                    this.config.requestTransformers = cfg.requestTransformers ? cfg.requestTransformers.slice(0) : [];
	                    this.config.responseInterceptors = cfg.responseInterceptors ? cfg.responseInterceptors.slice(0) : [];
	                    this.config.afterResponseInterceptors = cfg.afterResponseInterceptors ? cfg.afterResponseInterceptors.slice(0) : [];
	                    this.config.interceptors = cfg.interceptors ? cfg.interceptors.slice(0) : [];
	
	                    this.config.serializer = RailsResourceInjector.getService(cfg.serializer || railsSerializer());
	
	                    this.config.name = this.config.serializer.underscore(cfg.name);
	
	                    // we don't want to turn undefined name into "undefineds" then the plural name won't update when the name is set
	                    if (this.config.name) {
	                        this.config.pluralName = this.config.serializer.underscore(cfg.pluralName || this.config.serializer.pluralize(this.config.name));
	                    }
	
	                    this.config.urlBuilder = railsUrlBuilder(this.config);
	                    this.config.resourceConstructor = this;
	
	                    this.extend.apply(this, loadExtensions((cfg.extensions || []).concat(defaultOptions.extensions)));
	
	                    angular.forEach(this.$mixins, function (mixin) {
	                        if (angular.isFunction(mixin.configure)) {
	                            mixin.configure(this.config, cfg);
	                        }
	                    }, this);
	                };
	
	                /**
	                 * Configures the URL for the resource.
	                 * @param {String|function} url The url string or function.
	                 */
	                RailsResource.setUrl = function (url) {
	                    this.configure({url: url});
	                };
	
	                RailsResource.buildUrl = function (context) {
	                    return this.config.urlBuilder(context);
	                };
	
	                /**
	                 * Interceptors utilize $q promises to allow for both synchronous and asynchronous processing during
	                 * a request / response cycle.
	                 *
	                 * Interceptors can be added as a service factory name or as an object with properties matching one
	                 * or more of the phases.  Each property should have a value of a function to be called during that phase.
	                 *
	                 * There are multiple phases for both request and response.  In addition, each phase has a corresponding
	                 * error phase to handle promise rejections.
	                 *
	                 * Each request phase interceptor is called with the $http config object, the resource constructor, and if
	                 * applicable the resource instance.  The interceptor is free to modify the config or create a new one.
	                 * The interceptor function must return a valid $http config or a promise that will eventually resolve
	                 * to a config object.
	                 *
	                 * The valid request phases are:
	                 *
	                 * * beforeRequest: Interceptors are called prior to any data serialization or root wrapping.
	                 * * beforeRequestError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 * * beforeRequestWrapping: Interceptors are called after data serialization but before root wrapping.
	                 * * beforeRequestWrappingError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 * * request:  Interceptors are called after any data serialization and root wrapping have been performed.
	                 * * requestError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 *
	                 * The beforeResponse and response interceptors are called with the $http response object,
	                 * the resource constructor, and if applicable the resource instance.  The afterResponse interceptors
	                 * are typically called with the response data instead of the full response object unless the config option
	                 * fullResponse has been set to true.  Like the request interceptor callbacks the response callbacks can
	                 * manipulate the data or return new data.  The interceptor function must return
	                 *
	                 * The valid response phases are:
	                 *
	                 * * beforeResponse: Interceptors are called prior to any data processing.
	                 * * beforeResponseError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 * * beforeResponseDeserialize: Interceptors are called after root unwrapping but prior to data deserializing.
	                 * * beforeResponseDeserializeError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 * * response:  Interceptors are called after the data has been deserialized and root unwrapped but
	                 *      prior to the data being copied to the resource instance if applicable.
	                 * * responseError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 * * afterResponse:  Interceptors are called at the very end of the response chain after all processing
	                 *      has been completed.  The value of the first parameter is one of the following:
	                 *       - resource instance: When fullResponse is false and the operation was called on a resource instance.
	                 *       - response data: When fullResponse is false and the operation was called on the resource class.
	                 *       - $http response: When fullResponse is true
	                 * * afterResponseError: Interceptors get called when a previous interceptor threw an error or
	                 *      resolved with a rejection.
	                 *
	                 * @param {String | Object} interceptor
	                 */
	                RailsResource.addInterceptor = function (interceptor) {
	                    this.config.interceptors.push(interceptor);
	                };
	
	                /**
	                 * Adds an interceptor callback function for the specified phase.
	                 * @param {String} phase The interceptor phase, one of:
	                 *      beforeRequest, request, beforeResponse, response, afterResponse
	                 * @param fn The function to call.
	                 */
	                RailsResource.intercept = function (phase, fn) {
	                    var interceptor = {};
	                    fn = RailsResourceInjector.getDependency(fn);
	
	                    interceptor[phase] = function (value, resourceConstructor, context) {
	                        return fn(value, resourceConstructor, context) || value;
	                    };
	
	                    this.addInterceptor(interceptor);
	                };
	
	                /**
	                 * Adds interceptor on 'beforeRequest' phase.
	                 * @param fn(httpConfig, constructor, context) - httpConfig is the config object to pass to $http,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptBeforeRequest = function (fn) {
	                    this.intercept('beforeRequest', fn);
	                };
	
	                /**
	                 * Adds interceptor on 'beforeRequestWrapping' phase.
	                 * @param fn(httpConfig, constructor, context) - httpConfig is the config object to pass to $http,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptBeforeRequestWrapping = function (fn) {
	                    this.intercept('beforeRequestWrapping', fn);
	                };
	
	                /**
	                 * Adds interceptor on 'request' phase.
	                 * @param fn(httpConfig, constructor, context) - httpConfig is the config object to pass to $http,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptRequest = function (fn) {
	                    this.intercept('request', fn);
	                };
	
	                /**
	                 * Adds interceptor on 'beforeResponse' phase.
	                 * @param fn(response data, constructor, context) - response data is either the resource instance returned or an array of resource instances,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptBeforeResponse = function (fn) {
	                    this.intercept('beforeResponse', fn);
	                };
	
	                /**
	                 * Adds interceptor on 'beforeResponseDeserialize' phase.
	                 * @param fn(response data, constructor, context) - response data is either the resource instance returned or an array of resource instances,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptBeforeResponseDeserialize = function (fn) {
	                    this.intercept('beforeResponseDeserialize', fn);
	                };
	
	                /**
	                 * Adds interceptor on 'response' phase.
	                 * @param fn(response data, constructor, context) - response data is either the resource instance returned or an array of resource instances,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptResponse = function (fn) {
	                    this.intercept('response', fn);
	                };
	
	                /**
	                 * Adds interceptor on 'afterResponse' phase.
	                 * @param fn(response data, constructor, context) - response data is either the resource instance returned or an array of resource instances,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.interceptAfterResponse = function (fn) {
	                    this.intercept('afterResponse', fn);
	                };
	
	                /**
	                 * Deprecated, see interceptors
	                 * Add a callback to run on response.
	                 * @deprecated since version 1.0.0, use interceptResponse instead
	                 * @param fn(response data, constructor, context) - response data is either the resource instance returned or an array of resource instances,
	                 *      constructor is the resource class calling the function,
	                 *      context is the resource instance of the calling method (create, update, delete) or undefined if the method was a class method (get, query)
	                 */
	                RailsResource.beforeResponse = function (fn) {
	                    fn = RailsResourceInjector.getDependency(fn);
	                    this.interceptResponse(function (response, resource, context) {
	                        fn(response.data, resource.config.resourceConstructor, context);
	                        return response;
	                    });
	                };
	
	                /**
	                 * Deprecated, see interceptors
	                 * Add a callback to run after response has been processed.  These callbacks are not called on object construction.
	                 * @deprecated since version 1.0.0, use interceptAfterResponse instead
	                 * @param fn(response data, constructor) - response data is either the resource instance returned or an array of resource instances and constructor is the resource class calling the function
	                 */
	                RailsResource.afterResponse = function (fn) {
	                    fn = RailsResourceInjector.getDependency(fn);
	                    this.interceptAfterResponse(function (response, resource, context) {
	                        fn(response, resource.config.resourceConstructor, context);
	                        return response;
	                    });
	                };
	
	                /**
	                 * Deprecated, see interceptors
	                 * Adds a function to run after serializing the data to send to the server, but before root-wrapping it.
	                 * @deprecated since version 1.0.0, use interceptBeforeRequestWrapping instead
	                 * @param fn (data, constructor) - data object is the serialized resource instance, and constructor the resource class calling the function
	                 */
	                RailsResource.beforeRequest = function (fn) {
	                    fn = RailsResourceInjector.getDependency(fn);
	                    this.interceptBeforeRequestWrapping(function (httpConfig, resource) {
	                        httpConfig.data = fn(httpConfig.data, resource.config.resourceConstructor) || httpConfig.data;
	                        return httpConfig;
	                    });
	                };
	
	                RailsResource.serialize = function (httpConfig) {
	                    if (httpConfig.data) {
	                        httpConfig.data = this.config.serializer.serialize(httpConfig.data);
	                    }
	
	                    return httpConfig;
	                };
	
	                /**
	                 * Deserializes the response data on the $http response.  Stores the original version of the data
	                 * on the response as "originalData" and sets the deserialized data in the "data" property.
	                 * @param response The $http response object
	                 * @returns {*} The $http response
	                 */
	                RailsResource.deserialize = function (response) {
	                    response.data = this.config.serializer.deserialize(response.data, this.config.resourceConstructor);
	                    return response;
	                };
	
	                /**
	                 * Deprecated, see interceptors
	                 * Transform data after response has been converted to a resource instance
	                 * @deprecated
	                 * @param promise
	                 * @param context
	                 */
	                RailsResource.callResponseInterceptors = function (promise, context) {
	                    var config = this.config;
	                    forEachDependency(config.responseInterceptors, function (interceptor) {
	                        promise.resource = config.resourceConstructor;
	                        promise.context = context;
	                        promise = interceptor(promise);
	                    });
	                    return promise;
	                };
	
	                /**
	                 * Deprecated, see interceptors
	                 * Transform data after response has been converted to a resource instance
	                 * @deprecated
	                 * @param promise
	                 * @param context
	                 */
	                RailsResource.callAfterResponseInterceptors = function (promise) {
	                    var config = this.config;
	                    // data is now deserialized. call response interceptors including afterResponse
	                    forEachDependency(config.afterResponseInterceptors, function (interceptor) {
	                        promise.resource = config.resourceConstructor;
	                        promise = interceptor(promise);
	                    });
	
	                    return promise;
	                };
	
	                RailsResource.runInterceptorPhase = function (phase, context, promise) {
	                    var config = this.config, chain = [];
	
	                    forEachDependency(config.interceptors, function (interceptor) {
	                        if (interceptor[phase] || interceptor[phase + 'Error']) {
	                            chain.push(interceptor[phase], interceptor[phase + 'Error']);
	                        }
	                    });
	
	                    while (chain.length) {
	                        var thenFn = chain.shift();
	                        var rejectFn = chain.shift();
	
	                        promise = promise.then(createInterceptorSuccessCallback(thenFn, config.resourceConstructor, context),
	                            createInterceptorRejectionCallback(rejectFn, config.resourceConstructor, context));
	                    }
	
	                    return promise;
	                };
	
	                /**
	                 * Executes an HTTP request using $http.
	                 *
	                 * This method is used by all RailsResource operations that execute HTTP requests.  Handles serializing
	                 * the request data using the resource serializer, root wrapping (if enabled), deserializing the response
	                 * data using the resource serializer, root unwrapping (if enabled), and copying the result back into the
	                 * resource context if applicable.  Executes interceptors at each phase of the request / response to allow
	                 * users to build synchronous & asynchronous customizations to manipulate the data as necessary.
	                 *
	                 * @param httpConfig The config to pass to $http, see $http docs for details
	                 * @param context An optional reference to the resource instance that is the context for the operation.
	                 *      If specified, the result data will be copied into the context during the response handling.
	                 * @param resourceConfigOverrides An optional set of RailsResource configuration options overrides.
	                 *      These overrides allow users to build custom operations more easily with different resource settings.
	                 * @returns {Promise} The promise that will eventually be resolved after all request / response handling
	                 *      has completed.
	                 */
	                RailsResource.$http = function (httpConfig, context, resourceConfigOverrides) {
	                    var config = angular.extend(angular.copy(this.config), resourceConfigOverrides || {}),
	                        resourceConstructor = config.resourceConstructor,
	                        promise = $q.when(httpConfig);
	
	                    if (!config.skipRequestProcessing) {
	
	                        promise = this.runInterceptorPhase('beforeRequest', context, promise).then(function (httpConfig) {
	                            httpConfig = resourceConstructor.serialize(httpConfig);
	
	                            forEachDependency(config.requestTransformers, function (transformer) {
	                                httpConfig.data = transformer(httpConfig.data, config.resourceConstructor);
	                            });
	
	                            return httpConfig;
	                        });
	
	                        promise = this.runInterceptorPhase('beforeRequestWrapping', context, promise);
	
	                        if (config.rootWrapping) {
	                            promise = promise.then(function (httpConfig) {
	                                httpConfig.data = railsRootWrapper.wrap(httpConfig.data, config.resourceConstructor);
	                                return httpConfig;
	                            });
	                        }
	
	                        promise = this.runInterceptorPhase('request', context, promise).then(function (httpConfig) {
	                            return $http(httpConfig);
	                        });
	
	                    } else {
	
	                        promise = $http(httpConfig);
	
	                    }
	
	                    promise = this.runInterceptorPhase('beforeResponse', context, promise).then(function (response) {
	                      // store off the data so we don't lose access to it after deserializing and unwrapping
	                      response.originalData = response.data;
	                      return response;
	                    });
	
	                    if (config.rootWrapping) {
	                        promise = promise.then(function (response) {
	                            return railsRootWrapper.unwrap(response, config.resourceConstructor, false);
	                        });
	                    }
	
	                    promise = this.runInterceptorPhase('beforeResponseDeserialize', context, promise).then(function (response) {
	                        return resourceConstructor.deserialize(response);
	                    });
	
	                    promise = this.callResponseInterceptors(promise, context);
	                    promise = this.runInterceptorPhase('response', context, promise).then(function (response) {
	                        if (context) {
	                            // we may not have response data
	                            if (response.hasOwnProperty('data') && angular.isObject(response.data)) {
	                                angular.extend(context, response.data);
	                            }
	                        }
	
	                        return config.fullResponse ? response : (context || response.data);
	                    });
	
	                    promise = this.callAfterResponseInterceptors(promise, context);
	                    promise = this.runInterceptorPhase('afterResponse', context, promise);
	                    promise.resource = config.resourceConstructor;
	                    promise.context = context;
	                    return promise;
	                };
	
	                /**
	                 * Processes query parameters before request.  You can override to modify
	                 * the query params or return a new object.
	                 *
	                 * @param {Object} queryParams - The query parameters for the request
	                 * @returns {Object} The query parameters for the request
	                 */
	                RailsResource.processParameters = function (queryParams) {
	                    var newParams = {};
	
	                    if (angular.isObject(queryParams) && this.config.underscoreParams) {
	                        angular.forEach(queryParams, function (v, k) {
	                            newParams[this.config.serializer.underscore(k)] = v;
	                        }, this);
	
	                        return newParams;
	                    }
	
	                    return queryParams;
	                };
	
	                RailsResource.getParameters = function (queryParams) {
	                    var params;
	
	                    if (this.config.defaultParams) {
	                        // we need to clone it so we don't modify it when we add the additional
	                        // query params below
	                        params = angular.copy(this.config.defaultParams);
	                    }
	
	                    if (angular.isObject(queryParams)) {
	                        params = angular.extend(params || {}, queryParams);
	                    }
	
	                    return this.processParameters(params);
	                };
	
	                RailsResource.getHttpConfig = function (queryParams) {
	                    var params = this.getParameters(queryParams);
	
	                    if (params) {
	                        return angular.extend({params: params}, this.config.httpConfig);
	                    }
	
	                    return angular.copy(this.config.httpConfig);
	                };
	
	                /**
	                 * Returns a URL from the given parameters.  You can override this method on your resource definitions to provide
	                 * custom logic for building your URLs or you can utilize the parameterized url strings to substitute values in the
	                 * URL string.
	                 *
	                 * The parameters in the URL string follow the normal Angular binding expression using {{ and }} for the start/end symbols.
	                 *
	                 * If the context is a number and the URL string does not contain an id parameter then the number is appended
	                 * to the URL string.
	                 *
	                 * If the context is a number and the URL string does
	                 * @param context
	                 * @param path {string} (optional) An additional path to append to the URL
	                 * @return {string}
	                 */
	                RailsResource.$url = RailsResource.resourceUrl = function (context, path) {
	                    if (!angular.isObject(context)) {
	                        context = {id: context};
	                    }
	
	                    return appendPath(this.buildUrl(context || {}), path);
	                };
	
	                RailsResource.$get = function (url, queryParams) {
	                    return this.$http(angular.extend({method: 'get', url: url}, this.getHttpConfig(queryParams)));
	                };
	
	                RailsResource.query = function (queryParams, context) {
	                    return this.$get(this.resourceUrl(context), queryParams);
	                };
	
	                RailsResource.get = function (context, queryParams) {
	                    return this.$get(this.resourceUrl(context), queryParams);
	                };
	
	                /**
	                 * Returns the URL for this resource.
	                 *
	                 * @param path {string} (optional) An additional path to append to the URL
	                 * @returns {string} The URL for the resource
	                 */
	                RailsResource.prototype.$url = function (path) {
	                    return appendPath(this.constructor.resourceUrl(this), path);
	                };
	
	                /**
	                 * Executes $http with the resource instance as the context.
	                 *
	                 * @param httpConfig The config to pass to $http, see $http docs for details
	                 * @param context An optional reference to the resource instance that is the context for the operation.
	                 *      If specified, the result data will be copied into the context during the response handling.
	                 * @param resourceConfigOverrides An optional set of RailsResource configuration options overrides.
	                 *      These overrides allow users to build custom operations more easily with different resource settings.
	                 * @returns {Promise} The promise that will eventually be resolved after all request / response handling
	                 *      has completed.
	                 */
	                RailsResource.prototype.$http = function (httpConfig, resourceConfigOverrides) {
	                    return this.constructor.$http(httpConfig, this, resourceConfigOverrides);
	                };
	
	                angular.forEach(['post', 'put', 'patch'], function (method) {
	                    RailsResource['$' + method] = function (url, data, resourceConfigOverrides) {
	                        // clone so we can manipulate w/o modifying the actual instance
	                        data = angular.copy(data);
	                        return this.$http(angular.extend({method: method, url: url, data: data}, this.getHttpConfig()), null, resourceConfigOverrides);
	                    };
	
	                    RailsResource.prototype['$' + method] = function (url) {
	                        // clone so we can manipulate w/o modifying the actual instance
	                        var data = angular.copy(this, {});
	                        return this.constructor.$http(angular.extend({method: method, url: url, data: data}, this.constructor.getHttpConfig()), this);
	
	                    };
	                });
	
	                RailsResource.prototype.create = function () {
	                    return this.$post(this.$url(), this);
	                };
	
	                RailsResource.prototype.update = function () {
	                    return this['$' + this.constructor.config.updateMethod](this.$url(), this);
	                };
	
	                RailsResource.prototype.get = function () {
	                    return this.constructor.$http(angular.extend({method: 'GET', url: this.$url()}, this.constructor.getHttpConfig()), this);
	                };
	
	                RailsResource.prototype.isNew = function () {
	                    var idAttribute = this.constructor.config.idAttribute;
	                    return angular.isUndefined(this[idAttribute]) ||
	                        this[idAttribute] === null;
	                };
	
	                RailsResource.prototype.save = function () {
	                    if (this.isNew()) {
	                        return this.create();
	                    } else {
	                        return this.update();
	                    }
	                };
	
	                RailsResource.$delete = function (url, queryParams) {
	                    return this.$http(angular.extend({method: 'delete', url: url}, this.getHttpConfig(queryParams)));
	                };
	
	                RailsResource.prototype.$delete = function (url, queryParams) {
	                    return this.constructor.$http(angular.extend({method: 'delete', url: url}, this.constructor.getHttpConfig(queryParams)), this);
	                };
	
	                //using ['delete'] instead of .delete for IE7/8 compatibility
	                RailsResource.prototype.remove = RailsResource.prototype['delete'] = function () {
	                    return this.$delete(this.$url());
	                };
	
	                return RailsResource;
	
	                function appendPath(url, path) {
	                    if (path) {
	                        if (path[0] !== '/') {
	                            url += '/';
	                        }
	
	                        url += path;
	                    }
	
	                    return url;
	                }
	
	                function forEachDependency(list, callback) {
	                    var dependency;
	
	                    for (var i = 0, len = list.length; i < len; i++) {
	                        dependency = list[i];
	
	                        if (angular.isString(dependency)) {
	                            dependency = list[i] = RailsResourceInjector.getDependency(dependency);
	                        }
	
	                        callback(dependency);
	                    }
	                }
	
	                function addMixin(Resource, destination, mixin, callback) {
	                    var excludedKeys = ['included', 'extended,', 'configure'];
	
	                    if (!Resource.$mixins) {
	                        Resource.$mixins = [];
	                    }
	
	                    if (angular.isString(mixin)) {
	                        mixin = RailsResourceInjector.getDependency(mixin);
	                    }
	
	                    if (mixin && Resource.$mixins.indexOf(mixin) === -1) {
	                        angular.forEach(mixin, function (value, key) {
	                            if (excludedKeys.indexOf(key) === -1) {
	                                destination[key] = value;
	                            }
	                        });
	
	                        Resource.$mixins.push(mixin);
	
	                        if (angular.isFunction(callback)) {
	                            callback(Resource, mixin);
	                        }
	                    }
	                }
	
	                function loadExtensions(extensions) {
	                    var modules = [];
	
	                    angular.forEach(extensions, function (extensionName) {
	                        extensionName = 'RailsResource' + extensionName.charAt(0).toUpperCase() + extensionName.slice(1) + 'Mixin';
	
	                        modules.push(RailsResourceInjector.getDependency(extensionName));
	                    });
	
	                    return modules;
	                }
	
	                function booleanParam(value, defaultValue) {
	                    return angular.isUndefined(value) ? defaultValue : value;
	                }
	
	                function createInterceptorSuccessCallback(thenFn, resourceConstructor, context) {
	                    return function (data) {
	                        return (thenFn || angular.identity)(data, resourceConstructor, context);
	                    };
	                }
	
	                function createInterceptorRejectionCallback(rejectFn, resourceConstructor, context) {
	                    return function (rejection) {
	                        // can't use identity because we need to return a rejected promise to keep the error chain going
	                        return rejectFn ? rejectFn(rejection, resourceConstructor, context) : $q.reject(rejection);
	                    };
	                }
	            }];
	    });
	
	    angular.module('rails').factory('railsResourceFactory', ['RailsResource', function (RailsResource) {
	        return function (config) {
	            function Resource() {
	                Resource.__super__.constructor.apply(this, arguments);
	            }
	
	            RailsResource.extendTo(Resource);
	            Resource.configure(config);
	
	            return Resource;
	        };
	    }]);
	
	}());


/***/ },
/* 257 */
/***/ function(module, exports) {

	!function(window,angular,undefined){"use strict";angular.module("angulartics.google.analytics",["angulartics"]).config(["$analyticsProvider",function($analyticsProvider){$analyticsProvider.settings.pageTracking.trackRelativePath=!0,$analyticsProvider.settings.ga={additionalAccountNames:undefined,userId:null},$analyticsProvider.registerPageTrack(function(path){window._gaq&&(_gaq.push(["_trackPageview",path]),angular.forEach($analyticsProvider.settings.ga.additionalAccountNames,function(accountName){_gaq.push([accountName+"._trackPageview",path])})),window.ga&&($analyticsProvider.settings.ga.userId&&ga("set","&uid",$analyticsProvider.settings.ga.userId),ga("send","pageview",path),angular.forEach($analyticsProvider.settings.ga.additionalAccountNames,function(accountName){ga(accountName+".send","pageview",path)}))}),$analyticsProvider.registerEventTrack(function(action,properties){if(properties&&properties.category||(properties=properties||{},properties.category="Event"),properties.value){var parsed=parseInt(properties.value,10);properties.value=isNaN(parsed)?0:parsed}if(window.ga){for(var eventOptions={eventCategory:properties.category,eventAction:action,eventLabel:properties.label,eventValue:properties.value,nonInteraction:properties.noninteraction,page:properties.page||window.location.hash.substring(1)||window.location.pathname,userId:$analyticsProvider.settings.ga.userId},idx=1;20>=idx;idx++)properties["dimension"+idx.toString()]&&(eventOptions["dimension"+idx.toString()]=properties["dimension"+idx.toString()]),properties["metric"+idx.toString()]&&(eventOptions["metric"+idx.toString()]=properties["metric"+idx.toString()]);ga("send","event",eventOptions),angular.forEach($analyticsProvider.settings.ga.additionalAccountNames,function(accountName){ga(accountName+".send","event",eventOptions)})}else window._gaq&&_gaq.push(["_trackEvent",properties.category,action,properties.label,properties.value,properties.noninteraction])}),$analyticsProvider.registerSetUsername(function(userId){$analyticsProvider.settings.ga.userId=userId})}])}(window,window.angular);
	//# sourceMappingURL=../dist/angulartics-google-analytics.min.js.map

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

	/* WEBPACK VAR INJECTION */(function(global) {"use strict";
	
	__webpack_require__(259);
	
	__webpack_require__(446);
	
	if (global._babelPolyfill) {
	  throw new Error("only one instance of babel-polyfill is allowed");
	}
	global._babelPolyfill = true;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

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

	__webpack_require__(260);
	__webpack_require__(293);
	__webpack_require__(299);
	__webpack_require__(301);
	__webpack_require__(303);
	__webpack_require__(305);
	__webpack_require__(307);
	__webpack_require__(309);
	__webpack_require__(310);
	__webpack_require__(311);
	__webpack_require__(312);
	__webpack_require__(313);
	__webpack_require__(314);
	__webpack_require__(315);
	__webpack_require__(316);
	__webpack_require__(317);
	__webpack_require__(318);
	__webpack_require__(319);
	__webpack_require__(320);
	__webpack_require__(323);
	__webpack_require__(324);
	__webpack_require__(325);
	__webpack_require__(327);
	__webpack_require__(328);
	__webpack_require__(329);
	__webpack_require__(330);
	__webpack_require__(331);
	__webpack_require__(332);
	__webpack_require__(333);
	__webpack_require__(335);
	__webpack_require__(336);
	__webpack_require__(337);
	__webpack_require__(339);
	__webpack_require__(340);
	__webpack_require__(341);
	__webpack_require__(343);
	__webpack_require__(344);
	__webpack_require__(345);
	__webpack_require__(346);
	__webpack_require__(347);
	__webpack_require__(348);
	__webpack_require__(349);
	__webpack_require__(350);
	__webpack_require__(351);
	__webpack_require__(352);
	__webpack_require__(353);
	__webpack_require__(354);
	__webpack_require__(355);
	__webpack_require__(356);
	__webpack_require__(361);
	__webpack_require__(362);
	__webpack_require__(366);
	__webpack_require__(367);
	__webpack_require__(369);
	__webpack_require__(370);
	__webpack_require__(375);
	__webpack_require__(376);
	__webpack_require__(379);
	__webpack_require__(381);
	__webpack_require__(383);
	__webpack_require__(385);
	__webpack_require__(386);
	__webpack_require__(387);
	__webpack_require__(389);
	__webpack_require__(390);
	__webpack_require__(392);
	__webpack_require__(393);
	__webpack_require__(394);
	__webpack_require__(395);
	__webpack_require__(402);
	__webpack_require__(405);
	__webpack_require__(406);
	__webpack_require__(408);
	__webpack_require__(409);
	__webpack_require__(410);
	__webpack_require__(411);
	__webpack_require__(412);
	__webpack_require__(413);
	__webpack_require__(414);
	__webpack_require__(415);
	__webpack_require__(416);
	__webpack_require__(417);
	__webpack_require__(418);
	__webpack_require__(419);
	__webpack_require__(421);
	__webpack_require__(422);
	__webpack_require__(423);
	__webpack_require__(424);
	__webpack_require__(425);
	__webpack_require__(426);
	__webpack_require__(428);
	__webpack_require__(429);
	__webpack_require__(430);
	__webpack_require__(431);
	__webpack_require__(433);
	__webpack_require__(434);
	__webpack_require__(436);
	__webpack_require__(437);
	__webpack_require__(439);
	__webpack_require__(440);
	__webpack_require__(441);
	__webpack_require__(444);
	__webpack_require__(445);
	module.exports = __webpack_require__(264);

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

	'use strict';
	var $                 = __webpack_require__(261)
	  , $export           = __webpack_require__(262)
	  , DESCRIPTORS       = __webpack_require__(267)
	  , createDesc        = __webpack_require__(266)
	  , html              = __webpack_require__(273)
	  , cel               = __webpack_require__(274)
	  , has               = __webpack_require__(276)
	  , cof               = __webpack_require__(277)
	  , invoke            = __webpack_require__(278)
	  , fails             = __webpack_require__(268)
	  , anObject          = __webpack_require__(279)
	  , aFunction         = __webpack_require__(272)
	  , isObject          = __webpack_require__(275)
	  , toObject          = __webpack_require__(280)
	  , toIObject         = __webpack_require__(282)
	  , toInteger         = __webpack_require__(284)
	  , toIndex           = __webpack_require__(285)
	  , toLength          = __webpack_require__(286)
	  , IObject           = __webpack_require__(283)
	  , IE_PROTO          = __webpack_require__(270)('__proto__')
	  , createArrayMethod = __webpack_require__(287)
	  , arrayIndexOf      = __webpack_require__(292)(false)
	  , ObjectProto       = Object.prototype
	  , ArrayProto        = Array.prototype
	  , arraySlice        = ArrayProto.slice
	  , arrayJoin         = ArrayProto.join
	  , defineProperty    = $.setDesc
	  , getOwnDescriptor  = $.getDesc
	  , defineProperties  = $.setDescs
	  , factories         = {}
	  , IE8_DOM_DEFINE;
	
	if(!DESCRIPTORS){
	  IE8_DOM_DEFINE = !fails(function(){
	    return defineProperty(cel('div'), 'a', {get: function(){ return 7; }}).a != 7;
	  });
	  $.setDesc = function(O, P, Attributes){
	    if(IE8_DOM_DEFINE)try {
	      return defineProperty(O, P, Attributes);
	    } catch(e){ /* empty */ }
	    if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
	    if('value' in Attributes)anObject(O)[P] = Attributes.value;
	    return O;
	  };
	  $.getDesc = function(O, P){
	    if(IE8_DOM_DEFINE)try {
	      return getOwnDescriptor(O, P);
	    } catch(e){ /* empty */ }
	    if(has(O, P))return createDesc(!ObjectProto.propertyIsEnumerable.call(O, P), O[P]);
	  };
	  $.setDescs = defineProperties = function(O, Properties){
	    anObject(O);
	    var keys   = $.getKeys(Properties)
	      , length = keys.length
	      , i = 0
	      , P;
	    while(length > i)$.setDesc(O, P = keys[i++], Properties[P]);
	    return O;
	  };
	}
	$export($export.S + $export.F * !DESCRIPTORS, 'Object', {
	  // 19.1.2.6 / 15.2.3.3 Object.getOwnPropertyDescriptor(O, P)
	  getOwnPropertyDescriptor: $.getDesc,
	  // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
	  defineProperty: $.setDesc,
	  // 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties)
	  defineProperties: defineProperties
	});
	
	  // IE 8- don't enum bug keys
	var keys1 = ('constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,' +
	            'toLocaleString,toString,valueOf').split(',')
	  // Additional keys for getOwnPropertyNames
	  , keys2 = keys1.concat('length', 'prototype')
	  , keysLen1 = keys1.length;
	
	// Create object with `null` prototype: use iframe Object with cleared prototype
	var createDict = function(){
	  // Thrash, waste and sodomy: IE GC bug
	  var iframe = cel('iframe')
	    , i      = keysLen1
	    , gt     = '>'
	    , iframeDocument;
	  iframe.style.display = 'none';
	  html.appendChild(iframe);
	  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
	  // createDict = iframe.contentWindow.Object;
	  // html.removeChild(iframe);
	  iframeDocument = iframe.contentWindow.document;
	  iframeDocument.open();
	  iframeDocument.write('<script>document.F=Object</script' + gt);
	  iframeDocument.close();
	  createDict = iframeDocument.F;
	  while(i--)delete createDict.prototype[keys1[i]];
	  return createDict();
	};
	var createGetKeys = function(names, length){
	  return function(object){
	    var O      = toIObject(object)
	      , i      = 0
	      , result = []
	      , key;
	    for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
	    // Don't enum bug & hidden keys
	    while(length > i)if(has(O, key = names[i++])){
	      ~arrayIndexOf(result, key) || result.push(key);
	    }
	    return result;
	  };
	};
	var Empty = function(){};
	$export($export.S, 'Object', {
	  // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
	  getPrototypeOf: $.getProto = $.getProto || function(O){
	    O = toObject(O);
	    if(has(O, IE_PROTO))return O[IE_PROTO];
	    if(typeof O.constructor == 'function' && O instanceof O.constructor){
	      return O.constructor.prototype;
	    } return O instanceof Object ? ObjectProto : null;
	  },
	  // 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
	  getOwnPropertyNames: $.getNames = $.getNames || createGetKeys(keys2, keys2.length, true),
	  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
	  create: $.create = $.create || function(O, /*?*/Properties){
	    var result;
	    if(O !== null){
	      Empty.prototype = anObject(O);
	      result = new Empty();
	      Empty.prototype = null;
	      // add "__proto__" for Object.getPrototypeOf shim
	      result[IE_PROTO] = O;
	    } else result = createDict();
	    return Properties === undefined ? result : defineProperties(result, Properties);
	  },
	  // 19.1.2.14 / 15.2.3.14 Object.keys(O)
	  keys: $.getKeys = $.getKeys || createGetKeys(keys1, keysLen1, false)
	});
	
	var construct = function(F, len, args){
	  if(!(len in factories)){
	    for(var n = [], i = 0; i < len; i++)n[i] = 'a[' + i + ']';
	    factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
	  }
	  return factories[len](F, args);
	};
	
	// 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...)
	$export($export.P, 'Function', {
	  bind: function bind(that /*, args... */){
	    var fn       = aFunction(this)
	      , partArgs = arraySlice.call(arguments, 1);
	    var bound = function(/* args... */){
	      var args = partArgs.concat(arraySlice.call(arguments));
	      return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);
	    };
	    if(isObject(fn.prototype))bound.prototype = fn.prototype;
	    return bound;
	  }
	});
	
	// fallback for not array-like ES3 strings and DOM objects
	$export($export.P + $export.F * fails(function(){
	  if(html)arraySlice.call(html);
	}), 'Array', {
	  slice: function(begin, end){
	    var len   = toLength(this.length)
	      , klass = cof(this);
	    end = end === undefined ? len : end;
	    if(klass == 'Array')return arraySlice.call(this, begin, end);
	    var start  = toIndex(begin, len)
	      , upTo   = toIndex(end, len)
	      , size   = toLength(upTo - start)
	      , cloned = Array(size)
	      , i      = 0;
	    for(; i < size; i++)cloned[i] = klass == 'String'
	      ? this.charAt(start + i)
	      : this[start + i];
	    return cloned;
	  }
	});
	$export($export.P + $export.F * (IObject != Object), 'Array', {
	  join: function join(separator){
	    return arrayJoin.call(IObject(this), separator === undefined ? ',' : separator);
	  }
	});
	
	// 22.1.2.2 / 15.4.3.2 Array.isArray(arg)
	$export($export.S, 'Array', {isArray: __webpack_require__(289)});
	
	var createArrayReduce = function(isRight){
	  return function(callbackfn, memo){
	    aFunction(callbackfn);
	    var O      = IObject(this)
	      , length = toLength(O.length)
	      , index  = isRight ? length - 1 : 0
	      , i      = isRight ? -1 : 1;
	    if(arguments.length < 2)for(;;){
	      if(index in O){
	        memo = O[index];
	        index += i;
	        break;
	      }
	      index += i;
	      if(isRight ? index < 0 : length <= index){
	        throw TypeError('Reduce of empty array with no initial value');
	      }
	    }
	    for(;isRight ? index >= 0 : length > index; index += i)if(index in O){
	      memo = callbackfn(memo, O[index], index, this);
	    }
	    return memo;
	  };
	};
	
	var methodize = function($fn){
	  return function(arg1/*, arg2 = undefined */){
	    return $fn(this, arg1, arguments[1]);
	  };
	};
	
	$export($export.P, 'Array', {
	  // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])
	  forEach: $.each = $.each || methodize(createArrayMethod(0)),
	  // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])
	  map: methodize(createArrayMethod(1)),
	  // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])
	  filter: methodize(createArrayMethod(2)),
	  // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])
	  some: methodize(createArrayMethod(3)),
	  // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])
	  every: methodize(createArrayMethod(4)),
	  // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])
	  reduce: createArrayReduce(false),
	  // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])
	  reduceRight: createArrayReduce(true),
	  // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])
	  indexOf: methodize(arrayIndexOf),
	  // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])
	  lastIndexOf: function(el, fromIndex /* = @[*-1] */){
	    var O      = toIObject(this)
	      , length = toLength(O.length)
	      , index  = length - 1;
	    if(arguments.length > 1)index = Math.min(index, toInteger(fromIndex));
	    if(index < 0)index = toLength(length + index);
	    for(;index >= 0; index--)if(index in O)if(O[index] === el)return index;
	    return -1;
	  }
	});
	
	// 20.3.3.1 / 15.9.4.4 Date.now()
	$export($export.S, 'Date', {now: function(){ return +new Date; }});
	
	var lz = function(num){
	  return num > 9 ? num : '0' + num;
	};
	
	// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
	// PhantomJS / old WebKit has a broken implementations
	$export($export.P + $export.F * (fails(function(){
	  return new Date(-5e13 - 1).toISOString() != '0385-07-25T07:06:39.999Z';
	}) || !fails(function(){
	  new Date(NaN).toISOString();
	})), 'Date', {
	  toISOString: function toISOString(){
	    if(!isFinite(this))throw RangeError('Invalid time value');
	    var d = this
	      , y = d.getUTCFullYear()
	      , m = d.getUTCMilliseconds()
	      , s = y < 0 ? '-' : y > 9999 ? '+' : '';
	    return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +
	      '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +
	      'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +
	      ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
	  }
	});

/***/ },
/* 261 */
/***/ function(module, exports) {

	var $Object = Object;
	module.exports = {
	  create:     $Object.create,
	  getProto:   $Object.getPrototypeOf,
	  isEnum:     {}.propertyIsEnumerable,
	  getDesc:    $Object.getOwnPropertyDescriptor,
	  setDesc:    $Object.defineProperty,
	  setDescs:   $Object.defineProperties,
	  getKeys:    $Object.keys,
	  getNames:   $Object.getOwnPropertyNames,
	  getSymbols: $Object.getOwnPropertySymbols,
	  each:       [].forEach
	};

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

	var global    = __webpack_require__(263)
	  , core      = __webpack_require__(264)
	  , hide      = __webpack_require__(265)
	  , redefine  = __webpack_require__(269)
	  , ctx       = __webpack_require__(271)
	  , PROTOTYPE = 'prototype';
	
	var $export = function(type, name, source){
	  var IS_FORCED = type & $export.F
	    , IS_GLOBAL = type & $export.G
	    , IS_STATIC = type & $export.S
	    , IS_PROTO  = type & $export.P
	    , IS_BIND   = type & $export.B
	    , target    = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
	    , exports   = IS_GLOBAL ? core : core[name] || (core[name] = {})
	    , expProto  = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
	    , key, own, out, exp;
	  if(IS_GLOBAL)source = name;
	  for(key in source){
	    // contains in native
	    own = !IS_FORCED && target && key in target;
	    // export native or passed
	    out = (own ? target : source)[key];
	    // bind timers to global for call from export context
	    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
	    // extend global
	    if(target && !own)redefine(target, key, out);
	    // export
	    if(exports[key] != out)hide(exports, key, exp);
	    if(IS_PROTO && expProto[key] != out)expProto[key] = out;
	  }
	};
	global.core = core;
	// type bitmap
	$export.F = 1;  // forced
	$export.G = 2;  // global
	$export.S = 4;  // static
	$export.P = 8;  // proto
	$export.B = 16; // bind
	$export.W = 32; // wrap
	module.exports = $export;

/***/ },
/* 263 */
/***/ function(module, exports) {

	// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
	var global = module.exports = typeof window != 'undefined' && window.Math == Math
	  ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef

/***/ },
/* 264 */
/***/ function(module, exports) {

	var core = module.exports = {version: '1.2.6'};
	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef

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

	var $          = __webpack_require__(261)
	  , createDesc = __webpack_require__(266);
	module.exports = __webpack_require__(267) ? function(object, key, value){
	  return $.setDesc(object, key, createDesc(1, value));
	} : function(object, key, value){
	  object[key] = value;
	  return object;
	};

/***/ },
/* 266 */
/***/ function(module, exports) {

	module.exports = function(bitmap, value){
	  return {
	    enumerable  : !(bitmap & 1),
	    configurable: !(bitmap & 2),
	    writable    : !(bitmap & 4),
	    value       : value
	  };
	};

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

	// Thank's IE8 for his funny defineProperty
	module.exports = !__webpack_require__(268)(function(){
	  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
	});

/***/ },
/* 268 */
/***/ function(module, exports) {

	module.exports = function(exec){
	  try {
	    return !!exec();
	  } catch(e){
	    return true;
	  }
	};

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

	// add fake Function#toString
	// for correct work wrapped methods / constructors with methods like LoDash isNative
	var global    = __webpack_require__(263)
	  , hide      = __webpack_require__(265)
	  , SRC       = __webpack_require__(270)('src')
	  , TO_STRING = 'toString'
	  , $toString = Function[TO_STRING]
	  , TPL       = ('' + $toString).split(TO_STRING);
	
	__webpack_require__(264).inspectSource = function(it){
	  return $toString.call(it);
	};
	
	(module.exports = function(O, key, val, safe){
	  if(typeof val == 'function'){
	    val.hasOwnProperty(SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
	    val.hasOwnProperty('name') || hide(val, 'name', key);
	  }
	  if(O === global){
	    O[key] = val;
	  } else {
	    if(!safe)delete O[key];
	    hide(O, key, val);
	  }
	})(Function.prototype, TO_STRING, function toString(){
	  return typeof this == 'function' && this[SRC] || $toString.call(this);
	});

/***/ },
/* 270 */
/***/ function(module, exports) {

	var id = 0
	  , px = Math.random();
	module.exports = function(key){
	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
	};

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

	// optional / simple context binding
	var aFunction = __webpack_require__(272);
	module.exports = function(fn, that, length){
	  aFunction(fn);
	  if(that === undefined)return fn;
	  switch(length){
	    case 1: return function(a){
	      return fn.call(that, a);
	    };
	    case 2: return function(a, b){
	      return fn.call(that, a, b);
	    };
	    case 3: return function(a, b, c){
	      return fn.call(that, a, b, c);
	    };
	  }
	  return function(/* ...args */){
	    return fn.apply(that, arguments);
	  };
	};

/***/ },
/* 272 */
/***/ function(module, exports) {

	module.exports = function(it){
	  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
	  return it;
	};

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

	module.exports = __webpack_require__(263).document && document.documentElement;

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

	var isObject = __webpack_require__(275)
	  , document = __webpack_require__(263).document
	  // in old IE typeof document.createElement is 'object'
	  , is = isObject(document) && isObject(document.createElement);
	module.exports = function(it){
	  return is ? document.createElement(it) : {};
	};

/***/ },
/* 275 */
/***/ function(module, exports) {

	module.exports = function(it){
	  return typeof it === 'object' ? it !== null : typeof it === 'function';
	};

/***/ },
/* 276 */
/***/ function(module, exports) {

	var hasOwnProperty = {}.hasOwnProperty;
	module.exports = function(it, key){
	  return hasOwnProperty.call(it, key);
	};

/***/ },
/* 277 */
/***/ function(module, exports) {

	var toString = {}.toString;
	
	module.exports = function(it){
	  return toString.call(it).slice(8, -1);
	};

/***/ },
/* 278 */
/***/ function(module, exports) {

	// fast apply, http://jsperf.lnkit.com/fast-apply/5
	module.exports = function(fn, args, that){
	  var un = that === undefined;
	  switch(args.length){
	    case 0: return un ? fn()
	                      : fn.call(that);
	    case 1: return un ? fn(args[0])
	                      : fn.call(that, args[0]);
	    case 2: return un ? fn(args[0], args[1])
	                      : fn.call(that, args[0], args[1]);
	    case 3: return un ? fn(args[0], args[1], args[2])
	                      : fn.call(that, args[0], args[1], args[2]);
	    case 4: return un ? fn(args[0], args[1], args[2], args[3])
	                      : fn.call(that, args[0], args[1], args[2], args[3]);
	  } return              fn.apply(that, args);
	};

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

	var isObject = __webpack_require__(275);
	module.exports = function(it){
	  if(!isObject(it))throw TypeError(it + ' is not an object!');
	  return it;
	};

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

	// 7.1.13 ToObject(argument)
	var defined = __webpack_require__(281);
	module.exports = function(it){
	  return Object(defined(it));
	};

/***/ },
/* 281 */
/***/ function(module, exports) {

	// 7.2.1 RequireObjectCoercible(argument)
	module.exports = function(it){
	  if(it == undefined)throw TypeError("Can't call method on  " + it);
	  return it;
	};

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

	// to indexed object, toObject with fallback for non-array-like ES3 strings
	var IObject = __webpack_require__(283)
	  , defined = __webpack_require__(281);
	module.exports = function(it){
	  return IObject(defined(it));
	};

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

	// fallback for non-array-like ES3 and non-enumerable old V8 strings
	var cof = __webpack_require__(277);
	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
	  return cof(it) == 'String' ? it.split('') : Object(it);
	};

/***/ },
/* 284 */
/***/ function(module, exports) {

	// 7.1.4 ToInteger
	var ceil  = Math.ceil
	  , floor = Math.floor;
	module.exports = function(it){
	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
	};

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

	var toInteger = __webpack_require__(284)
	  , max       = Math.max
	  , min       = Math.min;
	module.exports = function(index, length){
	  index = toInteger(index);
	  return index < 0 ? max(index + length, 0) : min(index, length);
	};

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

	// 7.1.15 ToLength
	var toInteger = __webpack_require__(284)
	  , min       = Math.min;
	module.exports = function(it){
	  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
	};

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

	// 0 -> Array#forEach
	// 1 -> Array#map
	// 2 -> Array#filter
	// 3 -> Array#some
	// 4 -> Array#every
	// 5 -> Array#find
	// 6 -> Array#findIndex
	var ctx      = __webpack_require__(271)
	  , IObject  = __webpack_require__(283)
	  , toObject = __webpack_require__(280)
	  , toLength = __webpack_require__(286)
	  , asc      = __webpack_require__(288);
	module.exports = function(TYPE){
	  var IS_MAP        = TYPE == 1
	    , IS_FILTER     = TYPE == 2
	    , IS_SOME       = TYPE == 3
	    , IS_EVERY      = TYPE == 4
	    , IS_FIND_INDEX = TYPE == 6
	    , NO_HOLES      = TYPE == 5 || IS_FIND_INDEX;
	  return function($this, callbackfn, that){
	    var O      = toObject($this)
	      , self   = IObject(O)
	      , f      = ctx(callbackfn, that, 3)
	      , length = toLength(self.length)
	      , index  = 0
	      , result = IS_MAP ? asc($this, length) : IS_FILTER ? asc($this, 0) : undefined
	      , val, res;
	    for(;length > index; index++)if(NO_HOLES || index in self){
	      val = self[index];
	      res = f(val, index, O);
	      if(TYPE){
	        if(IS_MAP)result[index] = res;            // map
	        else if(res)switch(TYPE){
	          case 3: return true;                    // some
	          case 5: return val;                     // find
	          case 6: return index;                   // findIndex
	          case 2: result.push(val);               // filter
	        } else if(IS_EVERY)return false;          // every
	      }
	    }
	    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
	  };
	};

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

	// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
	var isObject = __webpack_require__(275)
	  , isArray  = __webpack_require__(289)
	  , SPECIES  = __webpack_require__(290)('species');
	module.exports = function(original, length){
	  var C;
	  if(isArray(original)){
	    C = original.constructor;
	    // cross-realm fallback
	    if(typeof C == 'function' && (C === Array || isArray(C.prototype)))C = undefined;
	    if(isObject(C)){
	      C = C[SPECIES];
	      if(C === null)C = undefined;
	    }
	  } return new (C === undefined ? Array : C)(length);
	};

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

	// 7.2.2 IsArray(argument)
	var cof = __webpack_require__(277);
	module.exports = Array.isArray || function(arg){
	  return cof(arg) == 'Array';
	};

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

	var store  = __webpack_require__(291)('wks')
	  , uid    = __webpack_require__(270)
	  , Symbol = __webpack_require__(263).Symbol;
	module.exports = function(name){
	  return store[name] || (store[name] =
	    Symbol && Symbol[name] || (Symbol || uid)('Symbol.' + name));
	};

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

	var global = __webpack_require__(263)
	  , SHARED = '__core-js_shared__'
	  , store  = global[SHARED] || (global[SHARED] = {});
	module.exports = function(key){
	  return store[key] || (store[key] = {});
	};

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

	// false -> Array#indexOf
	// true  -> Array#includes
	var toIObject = __webpack_require__(282)
	  , toLength  = __webpack_require__(286)
	  , toIndex   = __webpack_require__(285);
	module.exports = function(IS_INCLUDES){
	  return function($this, el, fromIndex){
	    var O      = toIObject($this)
	      , length = toLength(O.length)
	      , index  = toIndex(fromIndex, length)
	      , value;
	    // Array#includes uses SameValueZero equality algorithm
	    if(IS_INCLUDES && el != el)while(length > index){
	      value = O[index++];
	      if(value != value)return true;
	    // Array#toIndex ignores holes, Array#includes - not
	    } else for(;length > index; index++)if(IS_INCLUDES || index in O){
	      if(O[index] === el)return IS_INCLUDES || index;
	    } return !IS_INCLUDES && -1;
	  };
	};

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

	'use strict';
	// ECMAScript 6 symbols shim
	var $              = __webpack_require__(261)
	  , global         = __webpack_require__(263)
	  , has            = __webpack_require__(276)
	  , DESCRIPTORS    = __webpack_require__(267)
	  , $export        = __webpack_require__(262)
	  , redefine       = __webpack_require__(269)
	  , $fails         = __webpack_require__(268)
	  , shared         = __webpack_require__(291)
	  , setToStringTag = __webpack_require__(294)
	  , uid            = __webpack_require__(270)
	  , wks            = __webpack_require__(290)
	  , keyOf          = __webpack_require__(295)
	  , $names         = __webpack_require__(296)
	  , enumKeys       = __webpack_require__(297)
	  , isArray        = __webpack_require__(289)
	  , anObject       = __webpack_require__(279)
	  , toIObject      = __webpack_require__(282)
	  , createDesc     = __webpack_require__(266)
	  , getDesc        = $.getDesc
	  , setDesc        = $.setDesc
	  , _create        = $.create
	  , getNames       = $names.get
	  , $Symbol        = global.Symbol
	  , $JSON          = global.JSON
	  , _stringify     = $JSON && $JSON.stringify
	  , setter         = false
	  , HIDDEN         = wks('_hidden')
	  , isEnum         = $.isEnum
	  , SymbolRegistry = shared('symbol-registry')
	  , AllSymbols     = shared('symbols')
	  , useNative      = typeof $Symbol == 'function'
	  , ObjectProto    = Object.prototype;
	
	// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
	var setSymbolDesc = DESCRIPTORS && $fails(function(){
	  return _create(setDesc({}, 'a', {
	    get: function(){ return setDesc(this, 'a', {value: 7}).a; }
	  })).a != 7;
	}) ? function(it, key, D){
	  var protoDesc = getDesc(ObjectProto, key);
	  if(protoDesc)delete ObjectProto[key];
	  setDesc(it, key, D);
	  if(protoDesc && it !== ObjectProto)setDesc(ObjectProto, key, protoDesc);
	} : setDesc;
	
	var wrap = function(tag){
	  var sym = AllSymbols[tag] = _create($Symbol.prototype);
	  sym._k = tag;
	  DESCRIPTORS && setter && setSymbolDesc(ObjectProto, tag, {
	    configurable: true,
	    set: function(value){
	      if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
	      setSymbolDesc(this, tag, createDesc(1, value));
	    }
	  });
	  return sym;
	};
	
	var isSymbol = function(it){
	  return typeof it == 'symbol';
	};
	
	var $defineProperty = function defineProperty(it, key, D){
	  if(D && has(AllSymbols, key)){
	    if(!D.enumerable){
	      if(!has(it, HIDDEN))setDesc(it, HIDDEN, createDesc(1, {}));
	      it[HIDDEN][key] = true;
	    } else {
	      if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
	      D = _create(D, {enumerable: createDesc(0, false)});
	    } return setSymbolDesc(it, key, D);
	  } return setDesc(it, key, D);
	};
	var $defineProperties = function defineProperties(it, P){
	  anObject(it);
	  var keys = enumKeys(P = toIObject(P))
	    , i    = 0
	    , l = keys.length
	    , key;
	  while(l > i)$defineProperty(it, key = keys[i++], P[key]);
	  return it;
	};
	var $create = function create(it, P){
	  return P === undefined ? _create(it) : $defineProperties(_create(it), P);
	};
	var $propertyIsEnumerable = function propertyIsEnumerable(key){
	  var E = isEnum.call(this, key);
	  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key]
	    ? E : true;
	};
	var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
	  var D = getDesc(it = toIObject(it), key);
	  if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
	  return D;
	};
	var $getOwnPropertyNames = function getOwnPropertyNames(it){
	  var names  = getNames(toIObject(it))
	    , result = []
	    , i      = 0
	    , key;
	  while(names.length > i)if(!has(AllSymbols, key = names[i++]) && key != HIDDEN)result.push(key);
	  return result;
	};
	var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
	  var names  = getNames(toIObject(it))
	    , result = []
	    , i      = 0
	    , key;
	  while(names.length > i)if(has(AllSymbols, key = names[i++]))result.push(AllSymbols[key]);
	  return result;
	};
	var $stringify = function stringify(it){
	  if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
	  var args = [it]
	    , i    = 1
	    , $$   = arguments
	    , replacer, $replacer;
	  while($$.length > i)args.push($$[i++]);
	  replacer = args[1];
	  if(typeof replacer == 'function')$replacer = replacer;
	  if($replacer || !isArray(replacer))replacer = function(key, value){
	    if($replacer)value = $replacer.call(this, key, value);
	    if(!isSymbol(value))return value;
	  };
	  args[1] = replacer;
	  return _stringify.apply($JSON, args);
	};
	var buggyJSON = $fails(function(){
	  var S = $Symbol();
	  // MS Edge converts symbol values to JSON as {}
	  // WebKit converts symbol values to JSON as null
	  // V8 throws on boxed symbols
	  return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
	});
	
	// 19.4.1.1 Symbol([description])
	if(!useNative){
	  $Symbol = function Symbol(){
	    if(isSymbol(this))throw TypeError('Symbol is not a constructor');
	    return wrap(uid(arguments.length > 0 ? arguments[0] : undefined));
	  };
	  redefine($Symbol.prototype, 'toString', function toString(){
	    return this._k;
	  });
	
	  isSymbol = function(it){
	    return it instanceof $Symbol;
	  };
	
	  $.create     = $create;
	  $.isEnum     = $propertyIsEnumerable;
	  $.getDesc    = $getOwnPropertyDescriptor;
	  $.setDesc    = $defineProperty;
	  $.setDescs   = $defineProperties;
	  $.getNames   = $names.get = $getOwnPropertyNames;
	  $.getSymbols = $getOwnPropertySymbols;
	
	  if(DESCRIPTORS && !__webpack_require__(298)){
	    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
	  }
	}
	
	var symbolStatics = {
	  // 19.4.2.1 Symbol.for(key)
	  'for': function(key){
	    return has(SymbolRegistry, key += '')
	      ? SymbolRegistry[key]
	      : SymbolRegistry[key] = $Symbol(key);
	  },
	  // 19.4.2.5 Symbol.keyFor(sym)
	  keyFor: function keyFor(key){
	    return keyOf(SymbolRegistry, key);
	  },
	  useSetter: function(){ setter = true; },
	  useSimple: function(){ setter = false; }
	};
	// 19.4.2.2 Symbol.hasInstance
	// 19.4.2.3 Symbol.isConcatSpreadable
	// 19.4.2.4 Symbol.iterator
	// 19.4.2.6 Symbol.match
	// 19.4.2.8 Symbol.replace
	// 19.4.2.9 Symbol.search
	// 19.4.2.10 Symbol.species
	// 19.4.2.11 Symbol.split
	// 19.4.2.12 Symbol.toPrimitive
	// 19.4.2.13 Symbol.toStringTag
	// 19.4.2.14 Symbol.unscopables
	$.each.call((
	  'hasInstance,isConcatSpreadable,iterator,match,replace,search,' +
	  'species,split,toPrimitive,toStringTag,unscopables'
	).split(','), function(it){
	  var sym = wks(it);
	  symbolStatics[it] = useNative ? sym : wrap(sym);
	});
	
	setter = true;
	
	$export($export.G + $export.W, {Symbol: $Symbol});
	
	$export($export.S, 'Symbol', symbolStatics);
	
	$export($export.S + $export.F * !useNative, 'Object', {
	  // 19.1.2.2 Object.create(O [, Properties])
	  create: $create,
	  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
	  defineProperty: $defineProperty,
	  // 19.1.2.3 Object.defineProperties(O, Properties)
	  defineProperties: $defineProperties,
	  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
	  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
	  // 19.1.2.7 Object.getOwnPropertyNames(O)
	  getOwnPropertyNames: $getOwnPropertyNames,
	  // 19.1.2.8 Object.getOwnPropertySymbols(O)
	  getOwnPropertySymbols: $getOwnPropertySymbols
	});
	
	// 24.3.2 JSON.stringify(value [, replacer [, space]])
	$JSON && $export($export.S + $export.F * (!useNative || buggyJSON), 'JSON', {stringify: $stringify});
	
	// 19.4.3.5 Symbol.prototype[@@toStringTag]
	setToStringTag($Symbol, 'Symbol');
	// 20.2.1.9 Math[@@toStringTag]
	setToStringTag(Math, 'Math', true);
	// 24.3.3 JSON[@@toStringTag]
	setToStringTag(global.JSON, 'JSON', true);

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

	var def = __webpack_require__(261).setDesc
	  , has = __webpack_require__(276)
	  , TAG = __webpack_require__(290)('toStringTag');
	
	module.exports = function(it, tag, stat){
	  if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
	};

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

	var $         = __webpack_require__(261)
	  , toIObject = __webpack_require__(282);
	module.exports = function(object, el){
	  var O      = toIObject(object)
	    , keys   = $.getKeys(O)
	    , length = keys.length
	    , index  = 0
	    , key;
	  while(length > index)if(O[key = keys[index++]] === el)return key;
	};

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

	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
	var toIObject = __webpack_require__(282)
	  , getNames  = __webpack_require__(261).getNames
	  , toString  = {}.toString;
	
	var windowNames = typeof window == 'object' && Object.getOwnPropertyNames
	  ? Object.getOwnPropertyNames(window) : [];
	
	var getWindowNames = function(it){
	  try {
	    return getNames(it);
	  } catch(e){
	    return windowNames.slice();
	  }
	};
	
	module.exports.get = function getOwnPropertyNames(it){
	  if(windowNames && toString.call(it) == '[object Window]')return getWindowNames(it);
	  return getNames(toIObject(it));
	};

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

	// all enumerable object keys, includes symbols
	var $ = __webpack_require__(261);
	module.exports = function(it){
	  var keys       = $.getKeys(it)
	    , getSymbols = $.getSymbols;
	  if(getSymbols){
	    var symbols = getSymbols(it)
	      , isEnum  = $.isEnum
	      , i       = 0
	      , key;
	    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
	  }
	  return keys;
	};

/***/ },
/* 298 */
/***/ function(module, exports) {

	module.exports = false;

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

	// 19.1.3.1 Object.assign(target, source)
	var $export = __webpack_require__(262);
	
	$export($export.S + $export.F, 'Object', {assign: __webpack_require__(300)});

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

	// 19.1.2.1 Object.assign(target, source, ...)
	var $        = __webpack_require__(261)
	  , toObject = __webpack_require__(280)
	  , IObject  = __webpack_require__(283);
	
	// should work with symbols and should have deterministic property order (V8 bug)
	module.exports = __webpack_require__(268)(function(){
	  var a = Object.assign
	    , A = {}
	    , B = {}
	    , S = Symbol()
	    , K = 'abcdefghijklmnopqrst';
	  A[S] = 7;
	  K.split('').forEach(function(k){ B[k] = k; });
	  return a({}, A)[S] != 7 || Object.keys(a({}, B)).join('') != K;
	}) ? function assign(target, source){ // eslint-disable-line no-unused-vars
	  var T     = toObject(target)
	    , $$    = arguments
	    , $$len = $$.length
	    , index = 1
	    , getKeys    = $.getKeys
	    , getSymbols = $.getSymbols
	    , isEnum     = $.isEnum;
	  while($$len > index){
	    var S      = IObject($$[index++])
	      , keys   = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
	      , length = keys.length
	      , j      = 0
	      , key;
	    while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
	  }
	  return T;
	} : Object.assign;

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

	// 19.1.3.10 Object.is(value1, value2)
	var $export = __webpack_require__(262);
	$export($export.S, 'Object', {is: __webpack_require__(302)});

/***/ },
/* 302 */
/***/ function(module, exports) {

	// 7.2.9 SameValue(x, y)
	module.exports = Object.is || function is(x, y){
	  return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
	};

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

	// 19.1.3.19 Object.setPrototypeOf(O, proto)
	var $export = __webpack_require__(262);
	$export($export.S, 'Object', {setPrototypeOf: __webpack_require__(304).set});

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

	// Works with __proto__ only. Old v8 can't work with null proto objects.
	/* eslint-disable no-proto */
	var getDesc  = __webpack_require__(261).getDesc
	  , isObject = __webpack_require__(275)
	  , anObject = __webpack_require__(279);
	var check = function(O, proto){
	  anObject(O);
	  if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
	};
	module.exports = {
	  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
	    function(test, buggy, set){
	      try {
	        set = __webpack_require__(271)(Function.call, getDesc(Object.prototype, '__proto__').set, 2);
	        set(test, []);
	        buggy = !(test instanceof Array);
	      } catch(e){ buggy = true; }
	      return function setPrototypeOf(O, proto){
	        check(O, proto);
	        if(buggy)O.__proto__ = proto;
	        else set(O, proto);
	        return O;
	      };
	    }({}, false) : undefined),
	  check: check
	};

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

	'use strict';
	// 19.1.3.6 Object.prototype.toString()
	var classof = __webpack_require__(306)
	  , test    = {};
	test[__webpack_require__(290)('toStringTag')] = 'z';
	if(test + '' != '[object z]'){
	  __webpack_require__(269)(Object.prototype, 'toString', function toString(){
	    return '[object ' + classof(this) + ']';
	  }, true);
	}

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

	// getting tag from 19.1.3.6 Object.prototype.toString()
	var cof = __webpack_require__(277)
	  , TAG = __webpack_require__(290)('toStringTag')
	  // ES3 wrong here
	  , ARG = cof(function(){ return arguments; }()) == 'Arguments';
	
	module.exports = function(it){
	  var O, T, B;
	  return it === undefined ? 'Undefined' : it === null ? 'Null'
	    // @@toStringTag case
	    : typeof (T = (O = Object(it))[TAG]) == 'string' ? T
	    // builtinTag case
	    : ARG ? cof(O)
	    // ES3 arguments fallback
	    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
	};

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

	// 19.1.2.5 Object.freeze(O)
	var isObject = __webpack_require__(275);
	
	__webpack_require__(308)('freeze', function($freeze){
	  return function freeze(it){
	    return $freeze && isObject(it) ? $freeze(it) : it;
	  };
	});

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

	// most Object methods by ES6 should accept primitives
	var $export = __webpack_require__(262)
	  , core    = __webpack_require__(264)
	  , fails   = __webpack_require__(268);
	module.exports = function(KEY, exec){
	  var fn  = (core.Object || {})[KEY] || Object[KEY]
	    , exp = {};
	  exp[KEY] = exec(fn);
	  $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
	};

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

	// 19.1.2.17 Object.seal(O)
	var isObject = __webpack_require__(275);
	
	__webpack_require__(308)('seal', function($seal){
	  return function seal(it){
	    return $seal && isObject(it) ? $seal(it) : it;
	  };
	});

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

	// 19.1.2.15 Object.preventExtensions(O)
	var isObject = __webpack_require__(275);
	
	__webpack_require__(308)('preventExtensions', function($preventExtensions){
	  return function preventExtensions(it){
	    return $preventExtensions && isObject(it) ? $preventExtensions(it) : it;
	  };
	});

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

	// 19.1.2.12 Object.isFrozen(O)
	var isObject = __webpack_require__(275);
	
	__webpack_require__(308)('isFrozen', function($isFrozen){
	  return function isFrozen(it){
	    return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true;
	  };
	});

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

	// 19.1.2.13 Object.isSealed(O)
	var isObject = __webpack_require__(275);
	
	__webpack_require__(308)('isSealed', function($isSealed){
	  return function isSealed(it){
	    return isObject(it) ? $isSealed ? $isSealed(it) : false : true;
	  };
	});

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

	// 19.1.2.11 Object.isExtensible(O)
	var isObject = __webpack_require__(275);
	
	__webpack_require__(308)('isExtensible', function($isExtensible){
	  return function isExtensible(it){
	    return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false;
	  };
	});

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

	// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
	var toIObject = __webpack_require__(282);
	
	__webpack_require__(308)('getOwnPropertyDescriptor', function($getOwnPropertyDescriptor){
	  return function getOwnPropertyDescriptor(it, key){
	    return $getOwnPropertyDescriptor(toIObject(it), key);
	  };
	});

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

	// 19.1.2.9 Object.getPrototypeOf(O)
	var toObject = __webpack_require__(280);
	
	__webpack_require__(308)('getPrototypeOf', function($getPrototypeOf){
	  return function getPrototypeOf(it){
	    return $getPrototypeOf(toObject(it));
	  };
	});

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

	// 19.1.2.14 Object.keys(O)
	var toObject = __webpack_require__(280);
	
	__webpack_require__(308)('keys', function($keys){
	  return function keys(it){
	    return $keys(toObject(it));
	  };
	});

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

	// 19.1.2.7 Object.getOwnPropertyNames(O)
	__webpack_require__(308)('getOwnPropertyNames', function(){
	  return __webpack_require__(296).get;
	});

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

	var setDesc    = __webpack_require__(261).setDesc
	  , createDesc = __webpack_require__(266)
	  , has        = __webpack_require__(276)
	  , FProto     = Function.prototype
	  , nameRE     = /^\s*function ([^ (]*)/
	  , NAME       = 'name';
	// 19.2.4.2 name
	NAME in FProto || __webpack_require__(267) && setDesc(FProto, NAME, {
	  configurable: true,
	  get: function(){
	    var match = ('' + this).match(nameRE)
	      , name  = match ? match[1] : '';
	    has(this, NAME) || setDesc(this, NAME, createDesc(5, name));
	    return name;
	  }
	});

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

	'use strict';
	var $             = __webpack_require__(261)
	  , isObject      = __webpack_require__(275)
	  , HAS_INSTANCE  = __webpack_require__(290)('hasInstance')
	  , FunctionProto = Function.prototype;
	// 19.2.3.6 Function.prototype[@@hasInstance](V)
	if(!(HAS_INSTANCE in FunctionProto))$.setDesc(FunctionProto, HAS_INSTANCE, {value: function(O){
	  if(typeof this != 'function' || !isObject(O))return false;
	  if(!isObject(this.prototype))return O instanceof this;
	  // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:
	  while(O = $.getProto(O))if(this.prototype === O)return true;
	  return false;
	}});

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

	'use strict';
	var $           = __webpack_require__(261)
	  , global      = __webpack_require__(263)
	  , has         = __webpack_require__(276)
	  , cof         = __webpack_require__(277)
	  , toPrimitive = __webpack_require__(321)
	  , fails       = __webpack_require__(268)
	  , $trim       = __webpack_require__(322).trim
	  , NUMBER      = 'Number'
	  , $Number     = global[NUMBER]
	  , Base        = $Number
	  , proto       = $Number.prototype
	  // Opera ~12 has broken Object#toString
	  , BROKEN_COF  = cof($.create(proto)) == NUMBER
	  , TRIM        = 'trim' in String.prototype;
	
	// 7.1.3 ToNumber(argument)
	var toNumber = function(argument){
	  var it = toPrimitive(argument, false);
	  if(typeof it == 'string' && it.length > 2){
	    it = TRIM ? it.trim() : $trim(it, 3);
	    var first = it.charCodeAt(0)
	      , third, radix, maxCode;
	    if(first === 43 || first === 45){
	      third = it.charCodeAt(2);
	      if(third === 88 || third === 120)return NaN; // Number('+0x1') should be NaN, old V8 fix
	    } else if(first === 48){
	      switch(it.charCodeAt(1)){
	        case 66 : case 98  : radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i
	        case 79 : case 111 : radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i
	        default : return +it;
	      }
	      for(var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++){
	        code = digits.charCodeAt(i);
	        // parseInt parses a string to a first unavailable symbol
	        // but ToNumber should return NaN if a string contains unavailable symbols
	        if(code < 48 || code > maxCode)return NaN;
	      } return parseInt(digits, radix);
	    }
	  } return +it;
	};
	
	if(!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')){
	  $Number = function Number(value){
	    var it = arguments.length < 1 ? 0 : value
	      , that = this;
	    return that instanceof $Number
	      // check on 1..constructor(foo) case
	      && (BROKEN_COF ? fails(function(){ proto.valueOf.call(that); }) : cof(that) != NUMBER)
	        ? new Base(toNumber(it)) : toNumber(it);
	  };
	  $.each.call(__webpack_require__(267) ? $.getNames(Base) : (
	    // ES3:
	    'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
	    // ES6 (in case, if modules with ES6 Number statics required before):
	    'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
	    'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
	  ).split(','), function(key){
	    if(has(Base, key) && !has($Number, key)){
	      $.setDesc($Number, key, $.getDesc(Base, key));
	    }
	  });
	  $Number.prototype = proto;
	  proto.constructor = $Number;
	  __webpack_require__(269)(global, NUMBER, $Number);
	}

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

	// 7.1.1 ToPrimitive(input [, PreferredType])
	var isObject = __webpack_require__(275);
	// instead of the ES6 spec version, we didn't implement @@toPrimitive case
	// and the second argument - flag - preferred type is a string
	module.exports = function(it, S){
	  if(!isObject(it))return it;
	  var fn, val;
	  if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
	  if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
	  if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
	  throw TypeError("Can't convert object to primitive value");
	};

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

	var $export = __webpack_require__(262)
	  , defined = __webpack_require__(281)
	  , fails   = __webpack_require__(268)
	  , spaces  = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
	      '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'
	  , space   = '[' + spaces + ']'
	  , non     = '\u200b\u0085'
	  , ltrim   = RegExp('^' + space + space + '*')
	  , rtrim   = RegExp(space + space + '*$');
	
	var exporter = function(KEY, exec){
	  var exp  = {};
	  exp[KEY] = exec(trim);
	  $export($export.P + $export.F * fails(function(){
	    return !!spaces[KEY]() || non[KEY]() != non;
	  }), 'String', exp);
	};
	
	// 1 -> String#trimLeft
	// 2 -> String#trimRight
	// 3 -> String#trim
	var trim = exporter.trim = function(string, TYPE){
	  string = String(defined(string));
	  if(TYPE & 1)string = string.replace(ltrim, '');
	  if(TYPE & 2)string = string.replace(rtrim, '');
	  return string;
	};
	
	module.exports = exporter;

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

	// 20.1.2.1 Number.EPSILON
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {EPSILON: Math.pow(2, -52)});

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

	// 20.1.2.2 Number.isFinite(number)
	var $export   = __webpack_require__(262)
	  , _isFinite = __webpack_require__(263).isFinite;
	
	$export($export.S, 'Number', {
	  isFinite: function isFinite(it){
	    return typeof it == 'number' && _isFinite(it);
	  }
	});

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

	// 20.1.2.3 Number.isInteger(number)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {isInteger: __webpack_require__(326)});

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

	// 20.1.2.3 Number.isInteger(number)
	var isObject = __webpack_require__(275)
	  , floor    = Math.floor;
	module.exports = function isInteger(it){
	  return !isObject(it) && isFinite(it) && floor(it) === it;
	};

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

	// 20.1.2.4 Number.isNaN(number)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {
	  isNaN: function isNaN(number){
	    return number != number;
	  }
	});

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

	// 20.1.2.5 Number.isSafeInteger(number)
	var $export   = __webpack_require__(262)
	  , isInteger = __webpack_require__(326)
	  , abs       = Math.abs;
	
	$export($export.S, 'Number', {
	  isSafeInteger: function isSafeInteger(number){
	    return isInteger(number) && abs(number) <= 0x1fffffffffffff;
	  }
	});

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

	// 20.1.2.6 Number.MAX_SAFE_INTEGER
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {MAX_SAFE_INTEGER: 0x1fffffffffffff});

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

	// 20.1.2.10 Number.MIN_SAFE_INTEGER
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {MIN_SAFE_INTEGER: -0x1fffffffffffff});

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

	// 20.1.2.12 Number.parseFloat(string)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {parseFloat: parseFloat});

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

	// 20.1.2.13 Number.parseInt(string, radix)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Number', {parseInt: parseInt});

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

	// 20.2.2.3 Math.acosh(x)
	var $export = __webpack_require__(262)
	  , log1p   = __webpack_require__(334)
	  , sqrt    = Math.sqrt
	  , $acosh  = Math.acosh;
	
	// V8 bug https://code.google.com/p/v8/issues/detail?id=3509
	$export($export.S + $export.F * !($acosh && Math.floor($acosh(Number.MAX_VALUE)) == 710), 'Math', {
	  acosh: function acosh(x){
	    return (x = +x) < 1 ? NaN : x > 94906265.62425156
	      ? Math.log(x) + Math.LN2
	      : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
	  }
	});

/***/ },
/* 334 */
/***/ function(module, exports) {

	// 20.2.2.20 Math.log1p(x)
	module.exports = Math.log1p || function log1p(x){
	  return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x);
	};

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

	// 20.2.2.5 Math.asinh(x)
	var $export = __webpack_require__(262);
	
	function asinh(x){
	  return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1));
	}
	
	$export($export.S, 'Math', {asinh: asinh});

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

	// 20.2.2.7 Math.atanh(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {
	  atanh: function atanh(x){
	    return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;
	  }
	});

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

	// 20.2.2.9 Math.cbrt(x)
	var $export = __webpack_require__(262)
	  , sign    = __webpack_require__(338);
	
	$export($export.S, 'Math', {
	  cbrt: function cbrt(x){
	    return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3);
	  }
	});

/***/ },
/* 338 */
/***/ function(module, exports) {

	// 20.2.2.28 Math.sign(x)
	module.exports = Math.sign || function sign(x){
	  return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
	};

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

	// 20.2.2.11 Math.clz32(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {
	  clz32: function clz32(x){
	    return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32;
	  }
	});

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

	// 20.2.2.12 Math.cosh(x)
	var $export = __webpack_require__(262)
	  , exp     = Math.exp;
	
	$export($export.S, 'Math', {
	  cosh: function cosh(x){
	    return (exp(x = +x) + exp(-x)) / 2;
	  }
	});

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

	// 20.2.2.14 Math.expm1(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {expm1: __webpack_require__(342)});

/***/ },
/* 342 */
/***/ function(module, exports) {

	// 20.2.2.14 Math.expm1(x)
	module.exports = Math.expm1 || function expm1(x){
	  return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;
	};

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

	// 20.2.2.16 Math.fround(x)
	var $export   = __webpack_require__(262)
	  , sign      = __webpack_require__(338)
	  , pow       = Math.pow
	  , EPSILON   = pow(2, -52)
	  , EPSILON32 = pow(2, -23)
	  , MAX32     = pow(2, 127) * (2 - EPSILON32)
	  , MIN32     = pow(2, -126);
	
	var roundTiesToEven = function(n){
	  return n + 1 / EPSILON - 1 / EPSILON;
	};
	
	
	$export($export.S, 'Math', {
	  fround: function fround(x){
	    var $abs  = Math.abs(x)
	      , $sign = sign(x)
	      , a, result;
	    if($abs < MIN32)return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
	    a = (1 + EPSILON32 / EPSILON) * $abs;
	    result = a - (a - $abs);
	    if(result > MAX32 || result != result)return $sign * Infinity;
	    return $sign * result;
	  }
	});

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

	// 20.2.2.17 Math.hypot([value1[, value2[, … ]]])
	var $export = __webpack_require__(262)
	  , abs     = Math.abs;
	
	$export($export.S, 'Math', {
	  hypot: function hypot(value1, value2){ // eslint-disable-line no-unused-vars
	    var sum   = 0
	      , i     = 0
	      , $$    = arguments
	      , $$len = $$.length
	      , larg  = 0
	      , arg, div;
	    while(i < $$len){
	      arg = abs($$[i++]);
	      if(larg < arg){
	        div  = larg / arg;
	        sum  = sum * div * div + 1;
	        larg = arg;
	      } else if(arg > 0){
	        div  = arg / larg;
	        sum += div * div;
	      } else sum += arg;
	    }
	    return larg === Infinity ? Infinity : larg * Math.sqrt(sum);
	  }
	});

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

	// 20.2.2.18 Math.imul(x, y)
	var $export = __webpack_require__(262)
	  , $imul   = Math.imul;
	
	// some WebKit versions fails with big numbers, some has wrong arity
	$export($export.S + $export.F * __webpack_require__(268)(function(){
	  return $imul(0xffffffff, 5) != -5 || $imul.length != 2;
	}), 'Math', {
	  imul: function imul(x, y){
	    var UINT16 = 0xffff
	      , xn = +x
	      , yn = +y
	      , xl = UINT16 & xn
	      , yl = UINT16 & yn;
	    return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);
	  }
	});

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

	// 20.2.2.21 Math.log10(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {
	  log10: function log10(x){
	    return Math.log(x) / Math.LN10;
	  }
	});

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

	// 20.2.2.20 Math.log1p(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {log1p: __webpack_require__(334)});

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

	// 20.2.2.22 Math.log2(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {
	  log2: function log2(x){
	    return Math.log(x) / Math.LN2;
	  }
	});

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

	// 20.2.2.28 Math.sign(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {sign: __webpack_require__(338)});

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

	// 20.2.2.30 Math.sinh(x)
	var $export = __webpack_require__(262)
	  , expm1   = __webpack_require__(342)
	  , exp     = Math.exp;
	
	// V8 near Chromium 38 has a problem with very small numbers
	$export($export.S + $export.F * __webpack_require__(268)(function(){
	  return !Math.sinh(-2e-17) != -2e-17;
	}), 'Math', {
	  sinh: function sinh(x){
	    return Math.abs(x = +x) < 1
	      ? (expm1(x) - expm1(-x)) / 2
	      : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2);
	  }
	});

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

	// 20.2.2.33 Math.tanh(x)
	var $export = __webpack_require__(262)
	  , expm1   = __webpack_require__(342)
	  , exp     = Math.exp;
	
	$export($export.S, 'Math', {
	  tanh: function tanh(x){
	    var a = expm1(x = +x)
	      , b = expm1(-x);
	    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
	  }
	});

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

	// 20.2.2.34 Math.trunc(x)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Math', {
	  trunc: function trunc(it){
	    return (it > 0 ? Math.floor : Math.ceil)(it);
	  }
	});

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

	var $export        = __webpack_require__(262)
	  , toIndex        = __webpack_require__(285)
	  , fromCharCode   = String.fromCharCode
	  , $fromCodePoint = String.fromCodePoint;
	
	// length should be 1, old FF problem
	$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
	  // 21.1.2.2 String.fromCodePoint(...codePoints)
	  fromCodePoint: function fromCodePoint(x){ // eslint-disable-line no-unused-vars
	    var res   = []
	      , $$    = arguments
	      , $$len = $$.length
	      , i     = 0
	      , code;
	    while($$len > i){
	      code = +$$[i++];
	      if(toIndex(code, 0x10ffff) !== code)throw RangeError(code + ' is not a valid code point');
	      res.push(code < 0x10000
	        ? fromCharCode(code)
	        : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
	      );
	    } return res.join('');
	  }
	});

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

	var $export   = __webpack_require__(262)
	  , toIObject = __webpack_require__(282)
	  , toLength  = __webpack_require__(286);
	
	$export($export.S, 'String', {
	  // 21.1.2.4 String.raw(callSite, ...substitutions)
	  raw: function raw(callSite){
	    var tpl   = toIObject(callSite.raw)
	      , len   = toLength(tpl.length)
	      , $$    = arguments
	      , $$len = $$.length
	      , res   = []
	      , i     = 0;
	    while(len > i){
	      res.push(String(tpl[i++]));
	      if(i < $$len)res.push(String($$[i]));
	    } return res.join('');
	  }
	});

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

	'use strict';
	// 21.1.3.25 String.prototype.trim()
	__webpack_require__(322)('trim', function($trim){
	  return function trim(){
	    return $trim(this, 3);
	  };
	});

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

	'use strict';
	var $at  = __webpack_require__(357)(true);
	
	// 21.1.3.27 String.prototype[@@iterator]()
	__webpack_require__(358)(String, 'String', function(iterated){
	  this._t = String(iterated); // target
	  this._i = 0;                // next index
	// 21.1.5.2.1 %StringIteratorPrototype%.next()
	}, function(){
	  var O     = this._t
	    , index = this._i
	    , point;
	  if(index >= O.length)return {value: undefined, done: true};
	  point = $at(O, index);
	  this._i += point.length;
	  return {value: point, done: false};
	});

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

	var toInteger = __webpack_require__(284)
	  , defined   = __webpack_require__(281);
	// true  -> String#at
	// false -> String#codePointAt
	module.exports = function(TO_STRING){
	  return function(that, pos){
	    var s = String(defined(that))
	      , i = toInteger(pos)
	      , l = s.length
	      , a, b;
	    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
	    a = s.charCodeAt(i);
	    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
	      ? TO_STRING ? s.charAt(i) : a
	      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
	  };
	};

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

	'use strict';
	var LIBRARY        = __webpack_require__(298)
	  , $export        = __webpack_require__(262)
	  , redefine       = __webpack_require__(269)
	  , hide           = __webpack_require__(265)
	  , has            = __webpack_require__(276)
	  , Iterators      = __webpack_require__(359)
	  , $iterCreate    = __webpack_require__(360)
	  , setToStringTag = __webpack_require__(294)
	  , getProto       = __webpack_require__(261).getProto
	  , ITERATOR       = __webpack_require__(290)('iterator')
	  , BUGGY          = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
	  , FF_ITERATOR    = '@@iterator'
	  , KEYS           = 'keys'
	  , VALUES         = 'values';
	
	var returnThis = function(){ return this; };
	
	module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
	  $iterCreate(Constructor, NAME, next);
	  var getMethod = function(kind){
	    if(!BUGGY && kind in proto)return proto[kind];
	    switch(kind){
	      case KEYS: return function keys(){ return new Constructor(this, kind); };
	      case VALUES: return function values(){ return new Constructor(this, kind); };
	    } return function entries(){ return new Constructor(this, kind); };
	  };
	  var TAG        = NAME + ' Iterator'
	    , DEF_VALUES = DEFAULT == VALUES
	    , VALUES_BUG = false
	    , proto      = Base.prototype
	    , $native    = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
	    , $default   = $native || getMethod(DEFAULT)
	    , methods, key;
	  // Fix native
	  if($native){
	    var IteratorPrototype = getProto($default.call(new Base));
	    // Set @@toStringTag to native iterators
	    setToStringTag(IteratorPrototype, TAG, true);
	    // FF fix
	    if(!LIBRARY && has(proto, FF_ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
	    // fix Array#{values, @@iterator}.name in V8 / FF
	    if(DEF_VALUES && $native.name !== VALUES){
	      VALUES_BUG = true;
	      $default = function values(){ return $native.call(this); };
	    }
	  }
	  // Define iterator
	  if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
	    hide(proto, ITERATOR, $default);
	  }
	  // Plug for library
	  Iterators[NAME] = $default;
	  Iterators[TAG]  = returnThis;
	  if(DEFAULT){
	    methods = {
	      values:  DEF_VALUES  ? $default : getMethod(VALUES),
	      keys:    IS_SET      ? $default : getMethod(KEYS),
	      entries: !DEF_VALUES ? $default : getMethod('entries')
	    };
	    if(FORCED)for(key in methods){
	      if(!(key in proto))redefine(proto, key, methods[key]);
	    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
	  }
	  return methods;
	};

/***/ },
/* 359 */
/***/ function(module, exports) {

	module.exports = {};

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

	'use strict';
	var $              = __webpack_require__(261)
	  , descriptor     = __webpack_require__(266)
	  , setToStringTag = __webpack_require__(294)
	  , IteratorPrototype = {};
	
	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
	__webpack_require__(265)(IteratorPrototype, __webpack_require__(290)('iterator'), function(){ return this; });
	
	module.exports = function(Constructor, NAME, next){
	  Constructor.prototype = $.create(IteratorPrototype, {next: descriptor(1, next)});
	  setToStringTag(Constructor, NAME + ' Iterator');
	};

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

	'use strict';
	var $export = __webpack_require__(262)
	  , $at     = __webpack_require__(357)(false);
	$export($export.P, 'String', {
	  // 21.1.3.3 String.prototype.codePointAt(pos)
	  codePointAt: function codePointAt(pos){
	    return $at(this, pos);
	  }
	});

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

	// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])
	'use strict';
	var $export   = __webpack_require__(262)
	  , toLength  = __webpack_require__(286)
	  , context   = __webpack_require__(363)
	  , ENDS_WITH = 'endsWith'
	  , $endsWith = ''[ENDS_WITH];
	
	$export($export.P + $export.F * __webpack_require__(365)(ENDS_WITH), 'String', {
	  endsWith: function endsWith(searchString /*, endPosition = @length */){
	    var that = context(this, searchString, ENDS_WITH)
	      , $$   = arguments
	      , endPosition = $$.length > 1 ? $$[1] : undefined
	      , len    = toLength(that.length)
	      , end    = endPosition === undefined ? len : Math.min(toLength(endPosition), len)
	      , search = String(searchString);
	    return $endsWith
	      ? $endsWith.call(that, search, end)
	      : that.slice(end - search.length, end) === search;
	  }
	});

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

	// helper for String#{startsWith, endsWith, includes}
	var isRegExp = __webpack_require__(364)
	  , defined  = __webpack_require__(281);
	
	module.exports = function(that, searchString, NAME){
	  if(isRegExp(searchString))throw TypeError('String#' + NAME + " doesn't accept regex!");
	  return String(defined(that));
	};

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

	// 7.2.8 IsRegExp(argument)
	var isObject = __webpack_require__(275)
	  , cof      = __webpack_require__(277)
	  , MATCH    = __webpack_require__(290)('match');
	module.exports = function(it){
	  var isRegExp;
	  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
	};

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

	var MATCH = __webpack_require__(290)('match');
	module.exports = function(KEY){
	  var re = /./;
	  try {
	    '/./'[KEY](re);
	  } catch(e){
	    try {
	      re[MATCH] = false;
	      return !'/./'[KEY](re);
	    } catch(f){ /* empty */ }
	  } return true;
	};

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

	// 21.1.3.7 String.prototype.includes(searchString, position = 0)
	'use strict';
	var $export  = __webpack_require__(262)
	  , context  = __webpack_require__(363)
	  , INCLUDES = 'includes';
	
	$export($export.P + $export.F * __webpack_require__(365)(INCLUDES), 'String', {
	  includes: function includes(searchString /*, position = 0 */){
	    return !!~context(this, searchString, INCLUDES)
	      .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
	  }
	});

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

	var $export = __webpack_require__(262);
	
	$export($export.P, 'String', {
	  // 21.1.3.13 String.prototype.repeat(count)
	  repeat: __webpack_require__(368)
	});

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

	'use strict';
	var toInteger = __webpack_require__(284)
	  , defined   = __webpack_require__(281);
	
	module.exports = function repeat(count){
	  var str = String(defined(this))
	    , res = ''
	    , n   = toInteger(count);
	  if(n < 0 || n == Infinity)throw RangeError("Count can't be negative");
	  for(;n > 0; (n >>>= 1) && (str += str))if(n & 1)res += str;
	  return res;
	};

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

	// 21.1.3.18 String.prototype.startsWith(searchString [, position ])
	'use strict';
	var $export     = __webpack_require__(262)
	  , toLength    = __webpack_require__(286)
	  , context     = __webpack_require__(363)
	  , STARTS_WITH = 'startsWith'
	  , $startsWith = ''[STARTS_WITH];
	
	$export($export.P + $export.F * __webpack_require__(365)(STARTS_WITH), 'String', {
	  startsWith: function startsWith(searchString /*, position = 0 */){
	    var that   = context(this, searchString, STARTS_WITH)
	      , $$     = arguments
	      , index  = toLength(Math.min($$.length > 1 ? $$[1] : undefined, that.length))
	      , search = String(searchString);
	    return $startsWith
	      ? $startsWith.call(that, search, index)
	      : that.slice(index, index + search.length) === search;
	  }
	});

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

	'use strict';
	var ctx         = __webpack_require__(271)
	  , $export     = __webpack_require__(262)
	  , toObject    = __webpack_require__(280)
	  , call        = __webpack_require__(371)
	  , isArrayIter = __webpack_require__(372)
	  , toLength    = __webpack_require__(286)
	  , getIterFn   = __webpack_require__(373);
	$export($export.S + $export.F * !__webpack_require__(374)(function(iter){ Array.from(iter); }), 'Array', {
	  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
	  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
	    var O       = toObject(arrayLike)
	      , C       = typeof this == 'function' ? this : Array
	      , $$      = arguments
	      , $$len   = $$.length
	      , mapfn   = $$len > 1 ? $$[1] : undefined
	      , mapping = mapfn !== undefined
	      , index   = 0
	      , iterFn  = getIterFn(O)
	      , length, result, step, iterator;
	    if(mapping)mapfn = ctx(mapfn, $$len > 2 ? $$[2] : undefined, 2);
	    // if object isn't iterable or it's array with default iterator - use simple case
	    if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){
	      for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){
	        result[index] = mapping ? call(iterator, mapfn, [step.value, index], true) : step.value;
	      }
	    } else {
	      length = toLength(O.length);
	      for(result = new C(length); length > index; index++){
	        result[index] = mapping ? mapfn(O[index], index) : O[index];
	      }
	    }
	    result.length = index;
	    return result;
	  }
	});


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

	// call something on iterator step with safe closing on error
	var anObject = __webpack_require__(279);
	module.exports = function(iterator, fn, value, entries){
	  try {
	    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
	  // 7.4.6 IteratorClose(iterator, completion)
	  } catch(e){
	    var ret = iterator['return'];
	    if(ret !== undefined)anObject(ret.call(iterator));
	    throw e;
	  }
	};

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

	// check on default Array iterator
	var Iterators  = __webpack_require__(359)
	  , ITERATOR   = __webpack_require__(290)('iterator')
	  , ArrayProto = Array.prototype;
	
	module.exports = function(it){
	  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
	};

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

	var classof   = __webpack_require__(306)
	  , ITERATOR  = __webpack_require__(290)('iterator')
	  , Iterators = __webpack_require__(359);
	module.exports = __webpack_require__(264).getIteratorMethod = function(it){
	  if(it != undefined)return it[ITERATOR]
	    || it['@@iterator']
	    || Iterators[classof(it)];
	};

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

	var ITERATOR     = __webpack_require__(290)('iterator')
	  , SAFE_CLOSING = false;
	
	try {
	  var riter = [7][ITERATOR]();
	  riter['return'] = function(){ SAFE_CLOSING = true; };
	  Array.from(riter, function(){ throw 2; });
	} catch(e){ /* empty */ }
	
	module.exports = function(exec, skipClosing){
	  if(!skipClosing && !SAFE_CLOSING)return false;
	  var safe = false;
	  try {
	    var arr  = [7]
	      , iter = arr[ITERATOR]();
	    iter.next = function(){ safe = true; };
	    arr[ITERATOR] = function(){ return iter; };
	    exec(arr);
	  } catch(e){ /* empty */ }
	  return safe;
	};

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

	'use strict';
	var $export = __webpack_require__(262);
	
	// WebKit Array.of isn't generic
	$export($export.S + $export.F * __webpack_require__(268)(function(){
	  function F(){}
	  return !(Array.of.call(F) instanceof F);
	}), 'Array', {
	  // 22.1.2.3 Array.of( ...items)
	  of: function of(/* ...args */){
	    var index  = 0
	      , $$     = arguments
	      , $$len  = $$.length
	      , result = new (typeof this == 'function' ? this : Array)($$len);
	    while($$len > index)result[index] = $$[index++];
	    result.length = $$len;
	    return result;
	  }
	});

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

	'use strict';
	var addToUnscopables = __webpack_require__(377)
	  , step             = __webpack_require__(378)
	  , Iterators        = __webpack_require__(359)
	  , toIObject        = __webpack_require__(282);
	
	// 22.1.3.4 Array.prototype.entries()
	// 22.1.3.13 Array.prototype.keys()
	// 22.1.3.29 Array.prototype.values()
	// 22.1.3.30 Array.prototype[@@iterator]()
	module.exports = __webpack_require__(358)(Array, 'Array', function(iterated, kind){
	  this._t = toIObject(iterated); // target
	  this._i = 0;                   // next index
	  this._k = kind;                // kind
	// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
	}, function(){
	  var O     = this._t
	    , kind  = this._k
	    , index = this._i++;
	  if(!O || index >= O.length){
	    this._t = undefined;
	    return step(1);
	  }
	  if(kind == 'keys'  )return step(0, index);
	  if(kind == 'values')return step(0, O[index]);
	  return step(0, [index, O[index]]);
	}, 'values');
	
	// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
	Iterators.Arguments = Iterators.Array;
	
	addToUnscopables('keys');
	addToUnscopables('values');
	addToUnscopables('entries');

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

	// 22.1.3.31 Array.prototype[@@unscopables]
	var UNSCOPABLES = __webpack_require__(290)('unscopables')
	  , ArrayProto  = Array.prototype;
	if(ArrayProto[UNSCOPABLES] == undefined)__webpack_require__(265)(ArrayProto, UNSCOPABLES, {});
	module.exports = function(key){
	  ArrayProto[UNSCOPABLES][key] = true;
	};

/***/ },
/* 378 */
/***/ function(module, exports) {

	module.exports = function(done, value){
	  return {value: value, done: !!done};
	};

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

	__webpack_require__(380)('Array');

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

	'use strict';
	var global      = __webpack_require__(263)
	  , $           = __webpack_require__(261)
	  , DESCRIPTORS = __webpack_require__(267)
	  , SPECIES     = __webpack_require__(290)('species');
	
	module.exports = function(KEY){
	  var C = global[KEY];
	  if(DESCRIPTORS && C && !C[SPECIES])$.setDesc(C, SPECIES, {
	    configurable: true,
	    get: function(){ return this; }
	  });
	};

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

	// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
	var $export = __webpack_require__(262);
	
	$export($export.P, 'Array', {copyWithin: __webpack_require__(382)});
	
	__webpack_require__(377)('copyWithin');

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

	// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
	'use strict';
	var toObject = __webpack_require__(280)
	  , toIndex  = __webpack_require__(285)
	  , toLength = __webpack_require__(286);
	
	module.exports = [].copyWithin || function copyWithin(target/*= 0*/, start/*= 0, end = @length*/){
	  var O     = toObject(this)
	    , len   = toLength(O.length)
	    , to    = toIndex(target, len)
	    , from  = toIndex(start, len)
	    , $$    = arguments
	    , end   = $$.length > 2 ? $$[2] : undefined
	    , count = Math.min((end === undefined ? len : toIndex(end, len)) - from, len - to)
	    , inc   = 1;
	  if(from < to && to < from + count){
	    inc  = -1;
	    from += count - 1;
	    to   += count - 1;
	  }
	  while(count-- > 0){
	    if(from in O)O[to] = O[from];
	    else delete O[to];
	    to   += inc;
	    from += inc;
	  } return O;
	};

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

	// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
	var $export = __webpack_require__(262);
	
	$export($export.P, 'Array', {fill: __webpack_require__(384)});
	
	__webpack_require__(377)('fill');

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

	// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
	'use strict';
	var toObject = __webpack_require__(280)
	  , toIndex  = __webpack_require__(285)
	  , toLength = __webpack_require__(286);
	module.exports = [].fill || function fill(value /*, start = 0, end = @length */){
	  var O      = toObject(this)
	    , length = toLength(O.length)
	    , $$     = arguments
	    , $$len  = $$.length
	    , index  = toIndex($$len > 1 ? $$[1] : undefined, length)
	    , end    = $$len > 2 ? $$[2] : undefined
	    , endPos = end === undefined ? length : toIndex(end, length);
	  while(endPos > index)O[index++] = value;
	  return O;
	};

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

	'use strict';
	// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
	var $export = __webpack_require__(262)
	  , $find   = __webpack_require__(287)(5)
	  , KEY     = 'find'
	  , forced  = true;
	// Shouldn't skip holes
	if(KEY in [])Array(1)[KEY](function(){ forced = false; });
	$export($export.P + $export.F * forced, 'Array', {
	  find: function find(callbackfn/*, that = undefined */){
	    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
	  }
	});
	__webpack_require__(377)(KEY);

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

	'use strict';
	// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
	var $export = __webpack_require__(262)
	  , $find   = __webpack_require__(287)(6)
	  , KEY     = 'findIndex'
	  , forced  = true;
	// Shouldn't skip holes
	if(KEY in [])Array(1)[KEY](function(){ forced = false; });
	$export($export.P + $export.F * forced, 'Array', {
	  findIndex: function findIndex(callbackfn/*, that = undefined */){
	    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
	  }
	});
	__webpack_require__(377)(KEY);

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

	var $        = __webpack_require__(261)
	  , global   = __webpack_require__(263)
	  , isRegExp = __webpack_require__(364)
	  , $flags   = __webpack_require__(388)
	  , $RegExp  = global.RegExp
	  , Base     = $RegExp
	  , proto    = $RegExp.prototype
	  , re1      = /a/g
	  , re2      = /a/g
	  // "new" creates a new object, old webkit buggy here
	  , CORRECT_NEW = new $RegExp(re1) !== re1;
	
	if(__webpack_require__(267) && (!CORRECT_NEW || __webpack_require__(268)(function(){
	  re2[__webpack_require__(290)('match')] = false;
	  // RegExp constructor can alter flags and IsRegExp works correct with @@match
	  return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i';
	}))){
	  $RegExp = function RegExp(p, f){
	    var piRE = isRegExp(p)
	      , fiU  = f === undefined;
	    return !(this instanceof $RegExp) && piRE && p.constructor === $RegExp && fiU ? p
	      : CORRECT_NEW
	        ? new Base(piRE && !fiU ? p.source : p, f)
	        : Base((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? $flags.call(p) : f);
	  };
	  $.each.call($.getNames(Base), function(key){
	    key in $RegExp || $.setDesc($RegExp, key, {
	      configurable: true,
	      get: function(){ return Base[key]; },
	      set: function(it){ Base[key] = it; }
	    });
	  });
	  proto.constructor = $RegExp;
	  $RegExp.prototype = proto;
	  __webpack_require__(269)(global, 'RegExp', $RegExp);
	}
	
	__webpack_require__(380)('RegExp');

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

	'use strict';
	// 21.2.5.3 get RegExp.prototype.flags
	var anObject = __webpack_require__(279);
	module.exports = function(){
	  var that   = anObject(this)
	    , result = '';
	  if(that.global)     result += 'g';
	  if(that.ignoreCase) result += 'i';
	  if(that.multiline)  result += 'm';
	  if(that.unicode)    result += 'u';
	  if(that.sticky)     result += 'y';
	  return result;
	};

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

	// 21.2.5.3 get RegExp.prototype.flags()
	var $ = __webpack_require__(261);
	if(__webpack_require__(267) && /./g.flags != 'g')$.setDesc(RegExp.prototype, 'flags', {
	  configurable: true,
	  get: __webpack_require__(388)
	});

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

	// @@match logic
	__webpack_require__(391)('match', 1, function(defined, MATCH){
	  // 21.1.3.11 String.prototype.match(regexp)
	  return function match(regexp){
	    'use strict';
	    var O  = defined(this)
	      , fn = regexp == undefined ? undefined : regexp[MATCH];
	    return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
	  };
	});

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

	'use strict';
	var hide     = __webpack_require__(265)
	  , redefine = __webpack_require__(269)
	  , fails    = __webpack_require__(268)
	  , defined  = __webpack_require__(281)
	  , wks      = __webpack_require__(290);
	
	module.exports = function(KEY, length, exec){
	  var SYMBOL   = wks(KEY)
	    , original = ''[KEY];
	  if(fails(function(){
	    var O = {};
	    O[SYMBOL] = function(){ return 7; };
	    return ''[KEY](O) != 7;
	  })){
	    redefine(String.prototype, KEY, exec(defined, SYMBOL, original));
	    hide(RegExp.prototype, SYMBOL, length == 2
	      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
	      // 21.2.5.11 RegExp.prototype[@@split](string, limit)
	      ? function(string, arg){ return original.call(string, this, arg); }
	      // 21.2.5.6 RegExp.prototype[@@match](string)
	      // 21.2.5.9 RegExp.prototype[@@search](string)
	      : function(string){ return original.call(string, this); }
	    );
	  }
	};

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

	// @@replace logic
	__webpack_require__(391)('replace', 2, function(defined, REPLACE, $replace){
	  // 21.1.3.14 String.prototype.replace(searchValue, replaceValue)
	  return function replace(searchValue, replaceValue){
	    'use strict';
	    var O  = defined(this)
	      , fn = searchValue == undefined ? undefined : searchValue[REPLACE];
	    return fn !== undefined
	      ? fn.call(searchValue, O, replaceValue)
	      : $replace.call(String(O), searchValue, replaceValue);
	  };
	});

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

	// @@search logic
	__webpack_require__(391)('search', 1, function(defined, SEARCH){
	  // 21.1.3.15 String.prototype.search(regexp)
	  return function search(regexp){
	    'use strict';
	    var O  = defined(this)
	      , fn = regexp == undefined ? undefined : regexp[SEARCH];
	    return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
	  };
	});

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

	// @@split logic
	__webpack_require__(391)('split', 2, function(defined, SPLIT, $split){
	  // 21.1.3.17 String.prototype.split(separator, limit)
	  return function split(separator, limit){
	    'use strict';
	    var O  = defined(this)
	      , fn = separator == undefined ? undefined : separator[SPLIT];
	    return fn !== undefined
	      ? fn.call(separator, O, limit)
	      : $split.call(String(O), separator, limit);
	  };
	});

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

	'use strict';
	var $          = __webpack_require__(261)
	  , LIBRARY    = __webpack_require__(298)
	  , global     = __webpack_require__(263)
	  , ctx        = __webpack_require__(271)
	  , classof    = __webpack_require__(306)
	  , $export    = __webpack_require__(262)
	  , isObject   = __webpack_require__(275)
	  , anObject   = __webpack_require__(279)
	  , aFunction  = __webpack_require__(272)
	  , strictNew  = __webpack_require__(396)
	  , forOf      = __webpack_require__(397)
	  , setProto   = __webpack_require__(304).set
	  , same       = __webpack_require__(302)
	  , SPECIES    = __webpack_require__(290)('species')
	  , speciesConstructor = __webpack_require__(398)
	  , asap       = __webpack_require__(399)
	  , PROMISE    = 'Promise'
	  , process    = global.process
	  , isNode     = classof(process) == 'process'
	  , P          = global[PROMISE]
	  , Wrapper;
	
	var testResolve = function(sub){
	  var test = new P(function(){});
	  if(sub)test.constructor = Object;
	  return P.resolve(test) === test;
	};
	
	var USE_NATIVE = function(){
	  var works = false;
	  function P2(x){
	    var self = new P(x);
	    setProto(self, P2.prototype);
	    return self;
	  }
	  try {
	    works = P && P.resolve && testResolve();
	    setProto(P2, P);
	    P2.prototype = $.create(P.prototype, {constructor: {value: P2}});
	    // actual Firefox has broken subclass support, test that
	    if(!(P2.resolve(5).then(function(){}) instanceof P2)){
	      works = false;
	    }
	    // actual V8 bug, https://code.google.com/p/v8/issues/detail?id=4162
	    if(works && __webpack_require__(267)){
	      var thenableThenGotten = false;
	      P.resolve($.setDesc({}, 'then', {
	        get: function(){ thenableThenGotten = true; }
	      }));
	      works = thenableThenGotten;
	    }
	  } catch(e){ works = false; }
	  return works;
	}();
	
	// helpers
	var sameConstructor = function(a, b){
	  // library wrapper special case
	  if(LIBRARY && a === P && b === Wrapper)return true;
	  return same(a, b);
	};
	var getConstructor = function(C){
	  var S = anObject(C)[SPECIES];
	  return S != undefined ? S : C;
	};
	var isThenable = function(it){
	  var then;
	  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
	};
	var PromiseCapability = function(C){
	  var resolve, reject;
	  this.promise = new C(function($$resolve, $$reject){
	    if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');
	    resolve = $$resolve;
	    reject  = $$reject;
	  });
	  this.resolve = aFunction(resolve),
	  this.reject  = aFunction(reject)
	};
	var perform = function(exec){
	  try {
	    exec();
	  } catch(e){
	    return {error: e};
	  }
	};
	var notify = function(record, isReject){
	  if(record.n)return;
	  record.n = true;
	  var chain = record.c;
	  asap(function(){
	    var value = record.v
	      , ok    = record.s == 1
	      , i     = 0;
	    var run = function(reaction){
	      var handler = ok ? reaction.ok : reaction.fail
	        , resolve = reaction.resolve
	        , reject  = reaction.reject
	        , result, then;
	      try {
	        if(handler){
	          if(!ok)record.h = true;
	          result = handler === true ? value : handler(value);
	          if(result === reaction.promise){
	            reject(TypeError('Promise-chain cycle'));
	          } else if(then = isThenable(result)){
	            then.call(result, resolve, reject);
	          } else resolve(result);
	        } else reject(value);
	      } catch(e){
	        reject(e);
	      }
	    };
	    while(chain.length > i)run(chain[i++]); // variable length - can't use forEach
	    chain.length = 0;
	    record.n = false;
	    if(isReject)setTimeout(function(){
	      var promise = record.p
	        , handler, console;
	      if(isUnhandled(promise)){
	        if(isNode){
	          process.emit('unhandledRejection', value, promise);
	        } else if(handler = global.onunhandledrejection){
	          handler({promise: promise, reason: value});
	        } else if((console = global.console) && console.error){
	          console.error('Unhandled promise rejection', value);
	        }
	      } record.a = undefined;
	    }, 1);
	  });
	};
	var isUnhandled = function(promise){
	  var record = promise._d
	    , chain  = record.a || record.c
	    , i      = 0
	    , reaction;
	  if(record.h)return false;
	  while(chain.length > i){
	    reaction = chain[i++];
	    if(reaction.fail || !isUnhandled(reaction.promise))return false;
	  } return true;
	};
	var $reject = function(value){
	  var record = this;
	  if(record.d)return;
	  record.d = true;
	  record = record.r || record; // unwrap
	  record.v = value;
	  record.s = 2;
	  record.a = record.c.slice();
	  notify(record, true);
	};
	var $resolve = function(value){
	  var record = this
	    , then;
	  if(record.d)return;
	  record.d = true;
	  record = record.r || record; // unwrap
	  try {
	    if(record.p === value)throw TypeError("Promise can't be resolved itself");
	    if(then = isThenable(value)){
	      asap(function(){
	        var wrapper = {r: record, d: false}; // wrap
	        try {
	          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
	        } catch(e){
	          $reject.call(wrapper, e);
	        }
	      });
	    } else {
	      record.v = value;
	      record.s = 1;
	      notify(record, false);
	    }
	  } catch(e){
	    $reject.call({r: record, d: false}, e); // wrap
	  }
	};
	
	// constructor polyfill
	if(!USE_NATIVE){
	  // 25.4.3.1 Promise(executor)
	  P = function Promise(executor){
	    aFunction(executor);
	    var record = this._d = {
	      p: strictNew(this, P, PROMISE),         // <- promise
	      c: [],                                  // <- awaiting reactions
	      a: undefined,                           // <- checked in isUnhandled reactions
	      s: 0,                                   // <- state
	      d: false,                               // <- done
	      v: undefined,                           // <- value
	      h: false,                               // <- handled rejection
	      n: false                                // <- notify
	    };
	    try {
	      executor(ctx($resolve, record, 1), ctx($reject, record, 1));
	    } catch(err){
	      $reject.call(record, err);
	    }
	  };
	  __webpack_require__(401)(P.prototype, {
	    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
	    then: function then(onFulfilled, onRejected){
	      var reaction = new PromiseCapability(speciesConstructor(this, P))
	        , promise  = reaction.promise
	        , record   = this._d;
	      reaction.ok   = typeof onFulfilled == 'function' ? onFulfilled : true;
	      reaction.fail = typeof onRejected == 'function' && onRejected;
	      record.c.push(reaction);
	      if(record.a)record.a.push(reaction);
	      if(record.s)notify(record, false);
	      return promise;
	    },
	    // 25.4.5.1 Promise.prototype.catch(onRejected)
	    'catch': function(onRejected){
	      return this.then(undefined, onRejected);
	    }
	  });
	}
	
	$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: P});
	__webpack_require__(294)(P, PROMISE);
	__webpack_require__(380)(PROMISE);
	Wrapper = __webpack_require__(264)[PROMISE];
	
	// statics
	$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
	  // 25.4.4.5 Promise.reject(r)
	  reject: function reject(r){
	    var capability = new PromiseCapability(this)
	      , $$reject   = capability.reject;
	    $$reject(r);
	    return capability.promise;
	  }
	});
	$export($export.S + $export.F * (!USE_NATIVE || testResolve(true)), PROMISE, {
	  // 25.4.4.6 Promise.resolve(x)
	  resolve: function resolve(x){
	    // instanceof instead of internal slot check because we should fix it without replacement native Promise core
	    if(x instanceof P && sameConstructor(x.constructor, this))return x;
	    var capability = new PromiseCapability(this)
	      , $$resolve  = capability.resolve;
	    $$resolve(x);
	    return capability.promise;
	  }
	});
	$export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(374)(function(iter){
	  P.all(iter)['catch'](function(){});
	})), PROMISE, {
	  // 25.4.4.1 Promise.all(iterable)
	  all: function all(iterable){
	    var C          = getConstructor(this)
	      , capability = new PromiseCapability(C)
	      , resolve    = capability.resolve
	      , reject     = capability.reject
	      , values     = [];
	    var abrupt = perform(function(){
	      forOf(iterable, false, values.push, values);
	      var remaining = values.length
	        , results   = Array(remaining);
	      if(remaining)$.each.call(values, function(promise, index){
	        var alreadyCalled = false;
	        C.resolve(promise).then(function(value){
	          if(alreadyCalled)return;
	          alreadyCalled = true;
	          results[index] = value;
	          --remaining || resolve(results);
	        }, reject);
	      });
	      else resolve(results);
	    });
	    if(abrupt)reject(abrupt.error);
	    return capability.promise;
	  },
	  // 25.4.4.4 Promise.race(iterable)
	  race: function race(iterable){
	    var C          = getConstructor(this)
	      , capability = new PromiseCapability(C)
	      , reject     = capability.reject;
	    var abrupt = perform(function(){
	      forOf(iterable, false, function(promise){
	        C.resolve(promise).then(capability.resolve, reject);
	      });
	    });
	    if(abrupt)reject(abrupt.error);
	    return capability.promise;
	  }
	});

/***/ },
/* 396 */
/***/ function(module, exports) {

	module.exports = function(it, Constructor, name){
	  if(!(it instanceof Constructor))throw TypeError(name + ": use the 'new' operator!");
	  return it;
	};

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

	var ctx         = __webpack_require__(271)
	  , call        = __webpack_require__(371)
	  , isArrayIter = __webpack_require__(372)
	  , anObject    = __webpack_require__(279)
	  , toLength    = __webpack_require__(286)
	  , getIterFn   = __webpack_require__(373);
	module.exports = function(iterable, entries, fn, that){
	  var iterFn = getIterFn(iterable)
	    , f      = ctx(fn, that, entries ? 2 : 1)
	    , index  = 0
	    , length, step, iterator;
	  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
	  // fast case for arrays with default iterator
	  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){
	    entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
	  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
	    call(iterator, f, step.value, entries);
	  }
	};

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

	// 7.3.20 SpeciesConstructor(O, defaultConstructor)
	var anObject  = __webpack_require__(279)
	  , aFunction = __webpack_require__(272)
	  , SPECIES   = __webpack_require__(290)('species');
	module.exports = function(O, D){
	  var C = anObject(O).constructor, S;
	  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
	};

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

	var global    = __webpack_require__(263)
	  , macrotask = __webpack_require__(400).set
	  , Observer  = global.MutationObserver || global.WebKitMutationObserver
	  , process   = global.process
	  , Promise   = global.Promise
	  , isNode    = __webpack_require__(277)(process) == 'process'
	  , head, last, notify;
	
	var flush = function(){
	  var parent, domain, fn;
	  if(isNode && (parent = process.domain)){
	    process.domain = null;
	    parent.exit();
	  }
	  while(head){
	    domain = head.domain;
	    fn     = head.fn;
	    if(domain)domain.enter();
	    fn(); // <- currently we use it only for Promise - try / catch not required
	    if(domain)domain.exit();
	    head = head.next;
	  } last = undefined;
	  if(parent)parent.enter();
	};
	
	// Node.js
	if(isNode){
	  notify = function(){
	    process.nextTick(flush);
	  };
	// browsers with MutationObserver
	} else if(Observer){
	  var toggle = 1
	    , node   = document.createTextNode('');
	  new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new
	  notify = function(){
	    node.data = toggle = -toggle;
	  };
	// environments with maybe non-completely correct, but existent Promise
	} else if(Promise && Promise.resolve){
	  notify = function(){
	    Promise.resolve().then(flush);
	  };
	// for other environments - macrotask based on:
	// - setImmediate
	// - MessageChannel
	// - window.postMessag
	// - onreadystatechange
	// - setTimeout
	} else {
	  notify = function(){
	    // strange IE + webpack dev server bug - use .call(global)
	    macrotask.call(global, flush);
	  };
	}
	
	module.exports = function asap(fn){
	  var task = {fn: fn, next: undefined, domain: isNode && process.domain};
	  if(last)last.next = task;
	  if(!head){
	    head = task;
	    notify();
	  } last = task;
	};

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

	var ctx                = __webpack_require__(271)
	  , invoke             = __webpack_require__(278)
	  , html               = __webpack_require__(273)
	  , cel                = __webpack_require__(274)
	  , global             = __webpack_require__(263)
	  , process            = global.process
	  , setTask            = global.setImmediate
	  , clearTask          = global.clearImmediate
	  , MessageChannel     = global.MessageChannel
	  , counter            = 0
	  , queue              = {}
	  , ONREADYSTATECHANGE = 'onreadystatechange'
	  , defer, channel, port;
	var run = function(){
	  var id = +this;
	  if(queue.hasOwnProperty(id)){
	    var fn = queue[id];
	    delete queue[id];
	    fn();
	  }
	};
	var listner = function(event){
	  run.call(event.data);
	};
	// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
	if(!setTask || !clearTask){
	  setTask = function setImmediate(fn){
	    var args = [], i = 1;
	    while(arguments.length > i)args.push(arguments[i++]);
	    queue[++counter] = function(){
	      invoke(typeof fn == 'function' ? fn : Function(fn), args);
	    };
	    defer(counter);
	    return counter;
	  };
	  clearTask = function clearImmediate(id){
	    delete queue[id];
	  };
	  // Node.js 0.8-
	  if(__webpack_require__(277)(process) == 'process'){
	    defer = function(id){
	      process.nextTick(ctx(run, id, 1));
	    };
	  // Browsers with MessageChannel, includes WebWorkers
	  } else if(MessageChannel){
	    channel = new MessageChannel;
	    port    = channel.port2;
	    channel.port1.onmessage = listner;
	    defer = ctx(port.postMessage, port, 1);
	  // Browsers with postMessage, skip WebWorkers
	  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
	  } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){
	    defer = function(id){
	      global.postMessage(id + '', '*');
	    };
	    global.addEventListener('message', listner, false);
	  // IE8-
	  } else if(ONREADYSTATECHANGE in cel('script')){
	    defer = function(id){
	      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
	        html.removeChild(this);
	        run.call(id);
	      };
	    };
	  // Rest old browsers
	  } else {
	    defer = function(id){
	      setTimeout(ctx(run, id, 1), 0);
	    };
	  }
	}
	module.exports = {
	  set:   setTask,
	  clear: clearTask
	};

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

	var redefine = __webpack_require__(269);
	module.exports = function(target, src){
	  for(var key in src)redefine(target, key, src[key]);
	  return target;
	};

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

	'use strict';
	var strong = __webpack_require__(403);
	
	// 23.1 Map Objects
	__webpack_require__(404)('Map', function(get){
	  return function Map(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
	}, {
	  // 23.1.3.6 Map.prototype.get(key)
	  get: function get(key){
	    var entry = strong.getEntry(this, key);
	    return entry && entry.v;
	  },
	  // 23.1.3.9 Map.prototype.set(key, value)
	  set: function set(key, value){
	    return strong.def(this, key === 0 ? 0 : key, value);
	  }
	}, strong, true);

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

	'use strict';
	var $            = __webpack_require__(261)
	  , hide         = __webpack_require__(265)
	  , redefineAll  = __webpack_require__(401)
	  , ctx          = __webpack_require__(271)
	  , strictNew    = __webpack_require__(396)
	  , defined      = __webpack_require__(281)
	  , forOf        = __webpack_require__(397)
	  , $iterDefine  = __webpack_require__(358)
	  , step         = __webpack_require__(378)
	  , ID           = __webpack_require__(270)('id')
	  , $has         = __webpack_require__(276)
	  , isObject     = __webpack_require__(275)
	  , setSpecies   = __webpack_require__(380)
	  , DESCRIPTORS  = __webpack_require__(267)
	  , isExtensible = Object.isExtensible || isObject
	  , SIZE         = DESCRIPTORS ? '_s' : 'size'
	  , id           = 0;
	
	var fastKey = function(it, create){
	  // return primitive with prefix
	  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
	  if(!$has(it, ID)){
	    // can't set id to frozen object
	    if(!isExtensible(it))return 'F';
	    // not necessary to add id
	    if(!create)return 'E';
	    // add missing object id
	    hide(it, ID, ++id);
	  // return object id with prefix
	  } return 'O' + it[ID];
	};
	
	var getEntry = function(that, key){
	  // fast case
	  var index = fastKey(key), entry;
	  if(index !== 'F')return that._i[index];
	  // frozen object case
	  for(entry = that._f; entry; entry = entry.n){
	    if(entry.k == key)return entry;
	  }
	};
	
	module.exports = {
	  getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
	    var C = wrapper(function(that, iterable){
	      strictNew(that, C, NAME);
	      that._i = $.create(null); // index
	      that._f = undefined;      // first entry
	      that._l = undefined;      // last entry
	      that[SIZE] = 0;           // size
	      if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
	    });
	    redefineAll(C.prototype, {
	      // 23.1.3.1 Map.prototype.clear()
	      // 23.2.3.2 Set.prototype.clear()
	      clear: function clear(){
	        for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){
	          entry.r = true;
	          if(entry.p)entry.p = entry.p.n = undefined;
	          delete data[entry.i];
	        }
	        that._f = that._l = undefined;
	        that[SIZE] = 0;
	      },
	      // 23.1.3.3 Map.prototype.delete(key)
	      // 23.2.3.4 Set.prototype.delete(value)
	      'delete': function(key){
	        var that  = this
	          , entry = getEntry(that, key);
	        if(entry){
	          var next = entry.n
	            , prev = entry.p;
	          delete that._i[entry.i];
	          entry.r = true;
	          if(prev)prev.n = next;
	          if(next)next.p = prev;
	          if(that._f == entry)that._f = next;
	          if(that._l == entry)that._l = prev;
	          that[SIZE]--;
	        } return !!entry;
	      },
	      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
	      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
	      forEach: function forEach(callbackfn /*, that = undefined */){
	        var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3)
	          , entry;
	        while(entry = entry ? entry.n : this._f){
	          f(entry.v, entry.k, this);
	          // revert to the last existing entry
	          while(entry && entry.r)entry = entry.p;
	        }
	      },
	      // 23.1.3.7 Map.prototype.has(key)
	      // 23.2.3.7 Set.prototype.has(value)
	      has: function has(key){
	        return !!getEntry(this, key);
	      }
	    });
	    if(DESCRIPTORS)$.setDesc(C.prototype, 'size', {
	      get: function(){
	        return defined(this[SIZE]);
	      }
	    });
	    return C;
	  },
	  def: function(that, key, value){
	    var entry = getEntry(that, key)
	      , prev, index;
	    // change existing entry
	    if(entry){
	      entry.v = value;
	    // create new entry
	    } else {
	      that._l = entry = {
	        i: index = fastKey(key, true), // <- index
	        k: key,                        // <- key
	        v: value,                      // <- value
	        p: prev = that._l,             // <- previous entry
	        n: undefined,                  // <- next entry
	        r: false                       // <- removed
	      };
	      if(!that._f)that._f = entry;
	      if(prev)prev.n = entry;
	      that[SIZE]++;
	      // add to index
	      if(index !== 'F')that._i[index] = entry;
	    } return that;
	  },
	  getEntry: getEntry,
	  setStrong: function(C, NAME, IS_MAP){
	    // add .keys, .values, .entries, [@@iterator]
	    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
	    $iterDefine(C, NAME, function(iterated, kind){
	      this._t = iterated;  // target
	      this._k = kind;      // kind
	      this._l = undefined; // previous
	    }, function(){
	      var that  = this
	        , kind  = that._k
	        , entry = that._l;
	      // revert to the last existing entry
	      while(entry && entry.r)entry = entry.p;
	      // get next entry
	      if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){
	        // or finish the iteration
	        that._t = undefined;
	        return step(1);
	      }
	      // return step by kind
	      if(kind == 'keys'  )return step(0, entry.k);
	      if(kind == 'values')return step(0, entry.v);
	      return step(0, [entry.k, entry.v]);
	    }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);
	
	    // add [@@species], 23.1.2.2, 23.2.2.2
	    setSpecies(NAME);
	  }
	};

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

	'use strict';
	var global         = __webpack_require__(263)
	  , $export        = __webpack_require__(262)
	  , redefine       = __webpack_require__(269)
	  , redefineAll    = __webpack_require__(401)
	  , forOf          = __webpack_require__(397)
	  , strictNew      = __webpack_require__(396)
	  , isObject       = __webpack_require__(275)
	  , fails          = __webpack_require__(268)
	  , $iterDetect    = __webpack_require__(374)
	  , setToStringTag = __webpack_require__(294);
	
	module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
	  var Base  = global[NAME]
	    , C     = Base
	    , ADDER = IS_MAP ? 'set' : 'add'
	    , proto = C && C.prototype
	    , O     = {};
	  var fixMethod = function(KEY){
	    var fn = proto[KEY];
	    redefine(proto, KEY,
	      KEY == 'delete' ? function(a){
	        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
	      } : KEY == 'has' ? function has(a){
	        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
	      } : KEY == 'get' ? function get(a){
	        return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
	      } : KEY == 'add' ? function add(a){ fn.call(this, a === 0 ? 0 : a); return this; }
	        : function set(a, b){ fn.call(this, a === 0 ? 0 : a, b); return this; }
	    );
	  };
	  if(typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){
	    new C().entries().next();
	  }))){
	    // create collection constructor
	    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
	    redefineAll(C.prototype, methods);
	  } else {
	    var instance             = new C
	      // early implementations not supports chaining
	      , HASNT_CHAINING       = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance
	      // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
	      , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); })
	      // most early implementations doesn't supports iterables, most modern - not close it correctly
	      , ACCEPT_ITERABLES     = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new
	      // for early implementations -0 and +0 not the same
	      , BUGGY_ZERO;
	    if(!ACCEPT_ITERABLES){ 
	      C = wrapper(function(target, iterable){
	        strictNew(target, C, NAME);
	        var that = new Base;
	        if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
	        return that;
	      });
	      C.prototype = proto;
	      proto.constructor = C;
	    }
	    IS_WEAK || instance.forEach(function(val, key){
	      BUGGY_ZERO = 1 / key === -Infinity;
	    });
	    if(THROWS_ON_PRIMITIVES || BUGGY_ZERO){
	      fixMethod('delete');
	      fixMethod('has');
	      IS_MAP && fixMethod('get');
	    }
	    if(BUGGY_ZERO || HASNT_CHAINING)fixMethod(ADDER);
	    // weak collections should not contains .clear method
	    if(IS_WEAK && proto.clear)delete proto.clear;
	  }
	
	  setToStringTag(C, NAME);
	
	  O[NAME] = C;
	  $export($export.G + $export.W + $export.F * (C != Base), O);
	
	  if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP);
	
	  return C;
	};

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

	'use strict';
	var strong = __webpack_require__(403);
	
	// 23.2 Set Objects
	__webpack_require__(404)('Set', function(get){
	  return function Set(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
	}, {
	  // 23.2.3.1 Set.prototype.add(value)
	  add: function add(value){
	    return strong.def(this, value = value === 0 ? 0 : value, value);
	  }
	}, strong);

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

	'use strict';
	var $            = __webpack_require__(261)
	  , redefine     = __webpack_require__(269)
	  , weak         = __webpack_require__(407)
	  , isObject     = __webpack_require__(275)
	  , has          = __webpack_require__(276)
	  , frozenStore  = weak.frozenStore
	  , WEAK         = weak.WEAK
	  , isExtensible = Object.isExtensible || isObject
	  , tmp          = {};
	
	// 23.3 WeakMap Objects
	var $WeakMap = __webpack_require__(404)('WeakMap', function(get){
	  return function WeakMap(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
	}, {
	  // 23.3.3.3 WeakMap.prototype.get(key)
	  get: function get(key){
	    if(isObject(key)){
	      if(!isExtensible(key))return frozenStore(this).get(key);
	      if(has(key, WEAK))return key[WEAK][this._i];
	    }
	  },
	  // 23.3.3.5 WeakMap.prototype.set(key, value)
	  set: function set(key, value){
	    return weak.def(this, key, value);
	  }
	}, weak, true, true);
	
	// IE11 WeakMap frozen keys fix
	if(new $WeakMap().set((Object.freeze || Object)(tmp), 7).get(tmp) != 7){
	  $.each.call(['delete', 'has', 'get', 'set'], function(key){
	    var proto  = $WeakMap.prototype
	      , method = proto[key];
	    redefine(proto, key, function(a, b){
	      // store frozen objects on leaky map
	      if(isObject(a) && !isExtensible(a)){
	        var result = frozenStore(this)[key](a, b);
	        return key == 'set' ? this : result;
	      // store all the rest on native weakmap
	      } return method.call(this, a, b);
	    });
	  });
	}

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

	'use strict';
	var hide              = __webpack_require__(265)
	  , redefineAll       = __webpack_require__(401)
	  , anObject          = __webpack_require__(279)
	  , isObject          = __webpack_require__(275)
	  , strictNew         = __webpack_require__(396)
	  , forOf             = __webpack_require__(397)
	  , createArrayMethod = __webpack_require__(287)
	  , $has              = __webpack_require__(276)
	  , WEAK              = __webpack_require__(270)('weak')
	  , isExtensible      = Object.isExtensible || isObject
	  , arrayFind         = createArrayMethod(5)
	  , arrayFindIndex    = createArrayMethod(6)
	  , id                = 0;
	
	// fallback for frozen keys
	var frozenStore = function(that){
	  return that._l || (that._l = new FrozenStore);
	};
	var FrozenStore = function(){
	  this.a = [];
	};
	var findFrozen = function(store, key){
	  return arrayFind(store.a, function(it){
	    return it[0] === key;
	  });
	};
	FrozenStore.prototype = {
	  get: function(key){
	    var entry = findFrozen(this, key);
	    if(entry)return entry[1];
	  },
	  has: function(key){
	    return !!findFrozen(this, key);
	  },
	  set: function(key, value){
	    var entry = findFrozen(this, key);
	    if(entry)entry[1] = value;
	    else this.a.push([key, value]);
	  },
	  'delete': function(key){
	    var index = arrayFindIndex(this.a, function(it){
	      return it[0] === key;
	    });
	    if(~index)this.a.splice(index, 1);
	    return !!~index;
	  }
	};
	
	module.exports = {
	  getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
	    var C = wrapper(function(that, iterable){
	      strictNew(that, C, NAME);
	      that._i = id++;      // collection id
	      that._l = undefined; // leak store for frozen objects
	      if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
	    });
	    redefineAll(C.prototype, {
	      // 23.3.3.2 WeakMap.prototype.delete(key)
	      // 23.4.3.3 WeakSet.prototype.delete(value)
	      'delete': function(key){
	        if(!isObject(key))return false;
	        if(!isExtensible(key))return frozenStore(this)['delete'](key);
	        return $has(key, WEAK) && $has(key[WEAK], this._i) && delete key[WEAK][this._i];
	      },
	      // 23.3.3.4 WeakMap.prototype.has(key)
	      // 23.4.3.4 WeakSet.prototype.has(value)
	      has: function has(key){
	        if(!isObject(key))return false;
	        if(!isExtensible(key))return frozenStore(this).has(key);
	        return $has(key, WEAK) && $has(key[WEAK], this._i);
	      }
	    });
	    return C;
	  },
	  def: function(that, key, value){
	    if(!isExtensible(anObject(key))){
	      frozenStore(that).set(key, value);
	    } else {
	      $has(key, WEAK) || hide(key, WEAK, {});
	      key[WEAK][that._i] = value;
	    } return that;
	  },
	  frozenStore: frozenStore,
	  WEAK: WEAK
	};

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

	'use strict';
	var weak = __webpack_require__(407);
	
	// 23.4 WeakSet Objects
	__webpack_require__(404)('WeakSet', function(get){
	  return function WeakSet(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
	}, {
	  // 23.4.3.1 WeakSet.prototype.add(value)
	  add: function add(value){
	    return weak.def(this, value, true);
	  }
	}, weak, false, true);

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

	// 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
	var $export = __webpack_require__(262)
	  , _apply  = Function.apply;
	
	$export($export.S, 'Reflect', {
	  apply: function apply(target, thisArgument, argumentsList){
	    return _apply.call(target, thisArgument, argumentsList);
	  }
	});

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

	// 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
	var $         = __webpack_require__(261)
	  , $export   = __webpack_require__(262)
	  , aFunction = __webpack_require__(272)
	  , anObject  = __webpack_require__(279)
	  , isObject  = __webpack_require__(275)
	  , bind      = Function.bind || __webpack_require__(264).Function.prototype.bind;
	
	// MS Edge supports only 2 arguments
	// FF Nightly sets third argument as `new.target`, but does not create `this` from it
	$export($export.S + $export.F * __webpack_require__(268)(function(){
	  function F(){}
	  return !(Reflect.construct(function(){}, [], F) instanceof F);
	}), 'Reflect', {
	  construct: function construct(Target, args /*, newTarget*/){
	    aFunction(Target);
	    var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
	    if(Target == newTarget){
	      // w/o altered newTarget, optimization for 0-4 arguments
	      if(args != undefined)switch(anObject(args).length){
	        case 0: return new Target;
	        case 1: return new Target(args[0]);
	        case 2: return new Target(args[0], args[1]);
	        case 3: return new Target(args[0], args[1], args[2]);
	        case 4: return new Target(args[0], args[1], args[2], args[3]);
	      }
	      // w/o altered newTarget, lot of arguments case
	      var $args = [null];
	      $args.push.apply($args, args);
	      return new (bind.apply(Target, $args));
	    }
	    // with altered newTarget, not support built-in constructors
	    var proto    = newTarget.prototype
	      , instance = $.create(isObject(proto) ? proto : Object.prototype)
	      , result   = Function.apply.call(Target, instance, args);
	    return isObject(result) ? result : instance;
	  }
	});

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

	// 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
	var $        = __webpack_require__(261)
	  , $export  = __webpack_require__(262)
	  , anObject = __webpack_require__(279);
	
	// MS Edge has broken Reflect.defineProperty - throwing instead of returning false
	$export($export.S + $export.F * __webpack_require__(268)(function(){
	  Reflect.defineProperty($.setDesc({}, 1, {value: 1}), 1, {value: 2});
	}), 'Reflect', {
	  defineProperty: function defineProperty(target, propertyKey, attributes){
	    anObject(target);
	    try {
	      $.setDesc(target, propertyKey, attributes);
	      return true;
	    } catch(e){
	      return false;
	    }
	  }
	});

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

	// 26.1.4 Reflect.deleteProperty(target, propertyKey)
	var $export  = __webpack_require__(262)
	  , getDesc  = __webpack_require__(261).getDesc
	  , anObject = __webpack_require__(279);
	
	$export($export.S, 'Reflect', {
	  deleteProperty: function deleteProperty(target, propertyKey){
	    var desc = getDesc(anObject(target), propertyKey);
	    return desc && !desc.configurable ? false : delete target[propertyKey];
	  }
	});

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

	'use strict';
	// 26.1.5 Reflect.enumerate(target)
	var $export  = __webpack_require__(262)
	  , anObject = __webpack_require__(279);
	var Enumerate = function(iterated){
	  this._t = anObject(iterated); // target
	  this._i = 0;                  // next index
	  var keys = this._k = []       // keys
	    , key;
	  for(key in iterated)keys.push(key);
	};
	__webpack_require__(360)(Enumerate, 'Object', function(){
	  var that = this
	    , keys = that._k
	    , key;
	  do {
	    if(that._i >= keys.length)return {value: undefined, done: true};
	  } while(!((key = keys[that._i++]) in that._t));
	  return {value: key, done: false};
	});
	
	$export($export.S, 'Reflect', {
	  enumerate: function enumerate(target){
	    return new Enumerate(target);
	  }
	});

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

	// 26.1.6 Reflect.get(target, propertyKey [, receiver])
	var $        = __webpack_require__(261)
	  , has      = __webpack_require__(276)
	  , $export  = __webpack_require__(262)
	  , isObject = __webpack_require__(275)
	  , anObject = __webpack_require__(279);
	
	function get(target, propertyKey/*, receiver*/){
	  var receiver = arguments.length < 3 ? target : arguments[2]
	    , desc, proto;
	  if(anObject(target) === receiver)return target[propertyKey];
	  if(desc = $.getDesc(target, propertyKey))return has(desc, 'value')
	    ? desc.value
	    : desc.get !== undefined
	      ? desc.get.call(receiver)
	      : undefined;
	  if(isObject(proto = $.getProto(target)))return get(proto, propertyKey, receiver);
	}
	
	$export($export.S, 'Reflect', {get: get});

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

	// 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
	var $        = __webpack_require__(261)
	  , $export  = __webpack_require__(262)
	  , anObject = __webpack_require__(279);
	
	$export($export.S, 'Reflect', {
	  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey){
	    return $.getDesc(anObject(target), propertyKey);
	  }
	});

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

	// 26.1.8 Reflect.getPrototypeOf(target)
	var $export  = __webpack_require__(262)
	  , getProto = __webpack_require__(261).getProto
	  , anObject = __webpack_require__(279);
	
	$export($export.S, 'Reflect', {
	  getPrototypeOf: function getPrototypeOf(target){
	    return getProto(anObject(target));
	  }
	});

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

	// 26.1.9 Reflect.has(target, propertyKey)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Reflect', {
	  has: function has(target, propertyKey){
	    return propertyKey in target;
	  }
	});

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

	// 26.1.10 Reflect.isExtensible(target)
	var $export       = __webpack_require__(262)
	  , anObject      = __webpack_require__(279)
	  , $isExtensible = Object.isExtensible;
	
	$export($export.S, 'Reflect', {
	  isExtensible: function isExtensible(target){
	    anObject(target);
	    return $isExtensible ? $isExtensible(target) : true;
	  }
	});

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

	// 26.1.11 Reflect.ownKeys(target)
	var $export = __webpack_require__(262);
	
	$export($export.S, 'Reflect', {ownKeys: __webpack_require__(420)});

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

	// all object keys, includes non-enumerable and symbols
	var $        = __webpack_require__(261)
	  , anObject = __webpack_require__(279)
	  , Reflect  = __webpack_require__(263).Reflect;
	module.exports = Reflect && Reflect.ownKeys || function ownKeys(it){
	  var keys       = $.getNames(anObject(it))
	    , getSymbols = $.getSymbols;
	  return getSymbols ? keys.concat(getSymbols(it)) : keys;
	};

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

	// 26.1.12 Reflect.preventExtensions(target)
	var $export            = __webpack_require__(262)
	  , anObject           = __webpack_require__(279)
	  , $preventExtensions = Object.preventExtensions;
	
	$export($export.S, 'Reflect', {
	  preventExtensions: function preventExtensions(target){
	    anObject(target);
	    try {
	      if($preventExtensions)$preventExtensions(target);
	      return true;
	    } catch(e){
	      return false;
	    }
	  }
	});

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

	// 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
	var $          = __webpack_require__(261)
	  , has        = __webpack_require__(276)
	  , $export    = __webpack_require__(262)
	  , createDesc = __webpack_require__(266)
	  , anObject   = __webpack_require__(279)
	  , isObject   = __webpack_require__(275);
	
	function set(target, propertyKey, V/*, receiver*/){
	  var receiver = arguments.length < 4 ? target : arguments[3]
	    , ownDesc  = $.getDesc(anObject(target), propertyKey)
	    , existingDescriptor, proto;
	  if(!ownDesc){
	    if(isObject(proto = $.getProto(target))){
	      return set(proto, propertyKey, V, receiver);
	    }
	    ownDesc = createDesc(0);
	  }
	  if(has(ownDesc, 'value')){
	    if(ownDesc.writable === false || !isObject(receiver))return false;
	    existingDescriptor = $.getDesc(receiver, propertyKey) || createDesc(0);
	    existingDescriptor.value = V;
	    $.setDesc(receiver, propertyKey, existingDescriptor);
	    return true;
	  }
	  return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
	}
	
	$export($export.S, 'Reflect', {set: set});

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

	// 26.1.14 Reflect.setPrototypeOf(target, proto)
	var $export  = __webpack_require__(262)
	  , setProto = __webpack_require__(304);
	
	if(setProto)$export($export.S, 'Reflect', {
	  setPrototypeOf: function setPrototypeOf(target, proto){
	    setProto.check(target, proto);
	    try {
	      setProto.set(target, proto);
	      return true;
	    } catch(e){
	      return false;
	    }
	  }
	});

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

	'use strict';
	var $export   = __webpack_require__(262)
	  , $includes = __webpack_require__(292)(true);
	
	$export($export.P, 'Array', {
	  // https://github.com/domenic/Array.prototype.includes
	  includes: function includes(el /*, fromIndex = 0 */){
	    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
	  }
	});
	
	__webpack_require__(377)('includes');

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

	'use strict';
	// https://github.com/mathiasbynens/String.prototype.at
	var $export = __webpack_require__(262)
	  , $at     = __webpack_require__(357)(true);
	
	$export($export.P, 'String', {
	  at: function at(pos){
	    return $at(this, pos);
	  }
	});

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

	'use strict';
	var $export = __webpack_require__(262)
	  , $pad    = __webpack_require__(427);
	
	$export($export.P, 'String', {
	  padLeft: function padLeft(maxLength /*, fillString = ' ' */){
	    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
	  }
	});

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

	// https://github.com/ljharb/proposal-string-pad-left-right
	var toLength = __webpack_require__(286)
	  , repeat   = __webpack_require__(368)
	  , defined  = __webpack_require__(281);
	
	module.exports = function(that, maxLength, fillString, left){
	  var S            = String(defined(that))
	    , stringLength = S.length
	    , fillStr      = fillString === undefined ? ' ' : String(fillString)
	    , intMaxLength = toLength(maxLength);
	  if(intMaxLength <= stringLength)return S;
	  if(fillStr == '')fillStr = ' ';
	  var fillLen = intMaxLength - stringLength
	    , stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
	  if(stringFiller.length > fillLen)stringFiller = stringFiller.slice(0, fillLen);
	  return left ? stringFiller + S : S + stringFiller;
	};

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

	'use strict';
	var $export = __webpack_require__(262)
	  , $pad    = __webpack_require__(427);
	
	$export($export.P, 'String', {
	  padRight: function padRight(maxLength /*, fillString = ' ' */){
	    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
	  }
	});

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

	'use strict';
	// https://github.com/sebmarkbage/ecmascript-string-left-right-trim
	__webpack_require__(322)('trimLeft', function($trim){
	  return function trimLeft(){
	    return $trim(this, 1);
	  };
	});

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

	'use strict';
	// https://github.com/sebmarkbage/ecmascript-string-left-right-trim
	__webpack_require__(322)('trimRight', function($trim){
	  return function trimRight(){
	    return $trim(this, 2);
	  };
	});

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

	// https://github.com/benjamingr/RexExp.escape
	var $export = __webpack_require__(262)
	  , $re     = __webpack_require__(432)(/[\\^$*+?.()|[\]{}]/g, '\\$&');
	
	$export($export.S, 'RegExp', {escape: function escape(it){ return $re(it); }});


/***/ },
/* 432 */
/***/ function(module, exports) {

	module.exports = function(regExp, replace){
	  var replacer = replace === Object(replace) ? function(part){
	    return replace[part];
	  } : replace;
	  return function(it){
	    return String(it).replace(regExp, replacer);
	  };
	};

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

	// https://gist.github.com/WebReflection/9353781
	var $          = __webpack_require__(261)
	  , $export    = __webpack_require__(262)
	  , ownKeys    = __webpack_require__(420)
	  , toIObject  = __webpack_require__(282)
	  , createDesc = __webpack_require__(266);
	
	$export($export.S, 'Object', {
	  getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object){
	    var O       = toIObject(object)
	      , setDesc = $.setDesc
	      , getDesc = $.getDesc
	      , keys    = ownKeys(O)
	      , result  = {}
	      , i       = 0
	      , key, D;
	    while(keys.length > i){
	      D = getDesc(O, key = keys[i++]);
	      if(key in result)setDesc(result, key, createDesc(0, D));
	      else result[key] = D;
	    } return result;
	  }
	});

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

	// http://goo.gl/XkBrjD
	var $export = __webpack_require__(262)
	  , $values = __webpack_require__(435)(false);
	
	$export($export.S, 'Object', {
	  values: function values(it){
	    return $values(it);
	  }
	});

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

	var $         = __webpack_require__(261)
	  , toIObject = __webpack_require__(282)
	  , isEnum    = $.isEnum;
	module.exports = function(isEntries){
	  return function(it){
	    var O      = toIObject(it)
	      , keys   = $.getKeys(O)
	      , length = keys.length
	      , i      = 0
	      , result = []
	      , key;
	    while(length > i)if(isEnum.call(O, key = keys[i++])){
	      result.push(isEntries ? [key, O[key]] : O[key]);
	    } return result;
	  };
	};

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

	// http://goo.gl/XkBrjD
	var $export  = __webpack_require__(262)
	  , $entries = __webpack_require__(435)(true);
	
	$export($export.S, 'Object', {
	  entries: function entries(it){
	    return $entries(it);
	  }
	});

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

	// https://github.com/DavidBruant/Map-Set.prototype.toJSON
	var $export  = __webpack_require__(262);
	
	$export($export.P, 'Map', {toJSON: __webpack_require__(438)('Map')});

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

	// https://github.com/DavidBruant/Map-Set.prototype.toJSON
	var forOf   = __webpack_require__(397)
	  , classof = __webpack_require__(306);
	module.exports = function(NAME){
	  return function toJSON(){
	    if(classof(this) != NAME)throw TypeError(NAME + "#toJSON isn't generic");
	    var arr = [];
	    forOf(this, false, arr.push, arr);
	    return arr;
	  };
	};

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

	// https://github.com/DavidBruant/Map-Set.prototype.toJSON
	var $export  = __webpack_require__(262);
	
	$export($export.P, 'Set', {toJSON: __webpack_require__(438)('Set')});

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

	// JavaScript 1.6 / Strawman array statics shim
	var $       = __webpack_require__(261)
	  , $export = __webpack_require__(262)
	  , $ctx    = __webpack_require__(271)
	  , $Array  = __webpack_require__(264).Array || Array
	  , statics = {};
	var setStatics = function(keys, length){
	  $.each.call(keys.split(','), function(key){
	    if(length == undefined && key in $Array)statics[key] = $Array[key];
	    else if(key in [])statics[key] = $ctx(Function.call, [][key], length);
	  });
	};
	setStatics('pop,reverse,shift,keys,values,entries', 1);
	setStatics('indexOf,every,some,forEach,map,filter,find,findIndex,includes', 3);
	setStatics('join,slice,concat,push,splice,unshift,sort,lastIndexOf,' +
	           'reduce,reduceRight,copyWithin,fill');
	$export($export.S, 'Array', statics);

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

	// ie9- setTimeout & setInterval additional parameters fix
	var global     = __webpack_require__(263)
	  , $export    = __webpack_require__(262)
	  , invoke     = __webpack_require__(278)
	  , partial    = __webpack_require__(442)
	  , navigator  = global.navigator
	  , MSIE       = !!navigator && /MSIE .\./.test(navigator.userAgent); // <- dirty ie9- check
	var wrap = function(set){
	  return MSIE ? function(fn, time /*, ...args */){
	    return set(invoke(
	      partial,
	      [].slice.call(arguments, 2),
	      typeof fn == 'function' ? fn : Function(fn)
	    ), time);
	  } : set;
	};
	$export($export.G + $export.B + $export.F * MSIE, {
	  setTimeout:  wrap(global.setTimeout),
	  setInterval: wrap(global.setInterval)
	});

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

	'use strict';
	var path      = __webpack_require__(443)
	  , invoke    = __webpack_require__(278)
	  , aFunction = __webpack_require__(272);
	module.exports = function(/* ...pargs */){
	  var fn     = aFunction(this)
	    , length = arguments.length
	    , pargs  = Array(length)
	    , i      = 0
	    , _      = path._
	    , holder = false;
	  while(length > i)if((pargs[i] = arguments[i++]) === _)holder = true;
	  return function(/* ...args */){
	    var that  = this
	      , $$    = arguments
	      , $$len = $$.length
	      , j = 0, k = 0, args;
	    if(!holder && !$$len)return invoke(fn, pargs, that);
	    args = pargs.slice();
	    if(holder)for(;length > j; j++)if(args[j] === _)args[j] = $$[k++];
	    while($$len > k)args.push($$[k++]);
	    return invoke(fn, args, that);
	  };
	};

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

	module.exports = __webpack_require__(263);

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

	var $export = __webpack_require__(262)
	  , $task   = __webpack_require__(400);
	$export($export.G + $export.B, {
	  setImmediate:   $task.set,
	  clearImmediate: $task.clear
	});

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

	__webpack_require__(376);
	var global      = __webpack_require__(263)
	  , hide        = __webpack_require__(265)
	  , Iterators   = __webpack_require__(359)
	  , ITERATOR    = __webpack_require__(290)('iterator')
	  , NL          = global.NodeList
	  , HTC         = global.HTMLCollection
	  , NLProto     = NL && NL.prototype
	  , HTCProto    = HTC && HTC.prototype
	  , ArrayValues = Iterators.NodeList = Iterators.HTMLCollection = Iterators.Array;
	if(NLProto && !NLProto[ITERATOR])hide(NLProto, ITERATOR, ArrayValues);
	if(HTCProto && !HTCProto[ITERATOR])hide(HTCProto, ITERATOR, ArrayValues);

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

	/* WEBPACK VAR INJECTION */(function(global, process) {/**
	 * Copyright (c) 2014, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
	 * additional grant of patent rights can be found in the PATENTS file in
	 * the same directory.
	 */
	
	!(function(global) {
	  "use strict";
	
	  var hasOwn = Object.prototype.hasOwnProperty;
	  var undefined; // More compressible than void 0.
	  var iteratorSymbol =
	    typeof Symbol === "function" && Symbol.iterator || "@@iterator";
	
	  var inModule = typeof module === "object";
	  var runtime = global.regeneratorRuntime;
	  if (runtime) {
	    if (inModule) {
	      // If regeneratorRuntime is defined globally and we're in a module,
	      // make the exports object identical to regeneratorRuntime.
	      module.exports = runtime;
	    }
	    // Don't bother evaluating the rest of this file if the runtime was
	    // already defined globally.
	    return;
	  }
	
	  // Define the runtime globally (as expected by generated code) as either
	  // module.exports (if we're in a module) or a new, empty object.
	  runtime = global.regeneratorRuntime = inModule ? module.exports : {};
	
	  function wrap(innerFn, outerFn, self, tryLocsList) {
	    // If outerFn provided, then outerFn.prototype instanceof Generator.
	    var generator = Object.create((outerFn || Generator).prototype);
	    var context = new Context(tryLocsList || []);
	
	    // The ._invoke method unifies the implementations of the .next,
	    // .throw, and .return methods.
	    generator._invoke = makeInvokeMethod(innerFn, self, context);
	
	    return generator;
	  }
	  runtime.wrap = wrap;
	
	  // Try/catch helper to minimize deoptimizations. Returns a completion
	  // record like context.tryEntries[i].completion. This interface could
	  // have been (and was previously) designed to take a closure to be
	  // invoked without arguments, but in all the cases we care about we
	  // already have an existing method we want to call, so there's no need
	  // to create a new function object. We can even get away with assuming
	  // the method takes exactly one argument, since that happens to be true
	  // in every case, so we don't have to touch the arguments object. The
	  // only additional allocation required is the completion record, which
	  // has a stable shape and so hopefully should be cheap to allocate.
	  function tryCatch(fn, obj, arg) {
	    try {
	      return { type: "normal", arg: fn.call(obj, arg) };
	    } catch (err) {
	      return { type: "throw", arg: err };
	    }
	  }
	
	  var GenStateSuspendedStart = "suspendedStart";
	  var GenStateSuspendedYield = "suspendedYield";
	  var GenStateExecuting = "executing";
	  var GenStateCompleted = "completed";
	
	  // Returning this object from the innerFn has the same effect as
	  // breaking out of the dispatch switch statement.
	  var ContinueSentinel = {};
	
	  // Dummy constructor functions that we use as the .constructor and
	  // .constructor.prototype properties for functions that return Generator
	  // objects. For full spec compliance, you may wish to configure your
	  // minifier not to mangle the names of these two functions.
	  function Generator() {}
	  function GeneratorFunction() {}
	  function GeneratorFunctionPrototype() {}
	
	  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype;
	  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
	  GeneratorFunctionPrototype.constructor = GeneratorFunction;
	  GeneratorFunction.displayName = "GeneratorFunction";
	
	  // Helper for defining the .next, .throw, and .return methods of the
	  // Iterator interface in terms of a single ._invoke method.
	  function defineIteratorMethods(prototype) {
	    ["next", "throw", "return"].forEach(function(method) {
	      prototype[method] = function(arg) {
	        return this._invoke(method, arg);
	      };
	    });
	  }
	
	  runtime.isGeneratorFunction = function(genFun) {
	    var ctor = typeof genFun === "function" && genFun.constructor;
	    return ctor
	      ? ctor === GeneratorFunction ||
	        // For the native GeneratorFunction constructor, the best we can
	        // do is to check its .name property.
	        (ctor.displayName || ctor.name) === "GeneratorFunction"
	      : false;
	  };
	
	  runtime.mark = function(genFun) {
	    if (Object.setPrototypeOf) {
	      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
	    } else {
	      genFun.__proto__ = GeneratorFunctionPrototype;
	    }
	    genFun.prototype = Object.create(Gp);
	    return genFun;
	  };
	
	  // Within the body of any async function, `await x` is transformed to
	  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
	  // `value instanceof AwaitArgument` to determine if the yielded value is
	  // meant to be awaited. Some may consider the name of this method too
	  // cutesy, but they are curmudgeons.
	  runtime.awrap = function(arg) {
	    return new AwaitArgument(arg);
	  };
	
	  function AwaitArgument(arg) {
	    this.arg = arg;
	  }
	
	  function AsyncIterator(generator) {
	    // This invoke function is written in a style that assumes some
	    // calling function (or Promise) will handle exceptions.
	    function invoke(method, arg) {
	      var result = generator[method](arg);
	      var value = result.value;
	      return value instanceof AwaitArgument
	        ? Promise.resolve(value.arg).then(invokeNext, invokeThrow)
	        : Promise.resolve(value).then(function(unwrapped) {
	            // When a yielded Promise is resolved, its final value becomes
	            // the .value of the Promise<{value,done}> result for the
	            // current iteration. If the Promise is rejected, however, the
	            // result for this iteration will be rejected with the same
	            // reason. Note that rejections of yielded Promises are not
	            // thrown back into the generator function, as is the case
	            // when an awaited Promise is rejected. This difference in
	            // behavior between yield and await is important, because it
	            // allows the consumer to decide what to do with the yielded
	            // rejection (swallow it and continue, manually .throw it back
	            // into the generator, abandon iteration, whatever). With
	            // await, by contrast, there is no opportunity to examine the
	            // rejection reason outside the generator function, so the
	            // only option is to throw it from the await expression, and
	            // let the generator function handle the exception.
	            result.value = unwrapped;
	            return result;
	          });
	    }
	
	    if (typeof process === "object" && process.domain) {
	      invoke = process.domain.bind(invoke);
	    }
	
	    var invokeNext = invoke.bind(generator, "next");
	    var invokeThrow = invoke.bind(generator, "throw");
	    var invokeReturn = invoke.bind(generator, "return");
	    var previousPromise;
	
	    function enqueue(method, arg) {
	      function callInvokeWithMethodAndArg() {
	        return invoke(method, arg);
	      }
	
	      return previousPromise =
	        // If enqueue has been called before, then we want to wait until
	        // all previous Promises have been resolved before calling invoke,
	        // so that results are always delivered in the correct order. If
	        // enqueue has not been called before, then it is important to
	        // call invoke immediately, without waiting on a callback to fire,
	        // so that the async generator function has the opportunity to do
	        // any necessary setup in a predictable way. This predictability
	        // is why the Promise constructor synchronously invokes its
	        // executor callback, and why async functions synchronously
	        // execute code before the first await. Since we implement simple
	        // async functions in terms of async generators, it is especially
	        // important to get this right, even though it requires care.
	        previousPromise ? previousPromise.then(
	          callInvokeWithMethodAndArg,
	          // Avoid propagating failures to Promises returned by later
	          // invocations of the iterator.
	          callInvokeWithMethodAndArg
	        ) : new Promise(function (resolve) {
	          resolve(callInvokeWithMethodAndArg());
	        });
	    }
	
	    // Define the unified helper method that is used to implement .next,
	    // .throw, and .return (see defineIteratorMethods).
	    this._invoke = enqueue;
	  }
	
	  defineIteratorMethods(AsyncIterator.prototype);
	
	  // Note that simple async functions are implemented on top of
	  // AsyncIterator objects; they just return a Promise for the value of
	  // the final result produced by the iterator.
	  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
	    var iter = new AsyncIterator(
	      wrap(innerFn, outerFn, self, tryLocsList)
	    );
	
	    return runtime.isGeneratorFunction(outerFn)
	      ? iter // If outerFn is a generator, return the full iterator.
	      : iter.next().then(function(result) {
	          return result.done ? result.value : iter.next();
	        });
	  };
	
	  function makeInvokeMethod(innerFn, self, context) {
	    var state = GenStateSuspendedStart;
	
	    return function invoke(method, arg) {
	      if (state === GenStateExecuting) {
	        throw new Error("Generator is already running");
	      }
	
	      if (state === GenStateCompleted) {
	        if (method === "throw") {
	          throw arg;
	        }
	
	        // Be forgiving, per 25.3.3.3.3 of the spec:
	        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
	        return doneResult();
	      }
	
	      while (true) {
	        var delegate = context.delegate;
	        if (delegate) {
	          if (method === "return" ||
	              (method === "throw" && delegate.iterator[method] === undefined)) {
	            // A return or throw (when the delegate iterator has no throw
	            // method) always terminates the yield* loop.
	            context.delegate = null;
	
	            // If the delegate iterator has a return method, give it a
	            // chance to clean up.
	            var returnMethod = delegate.iterator["return"];
	            if (returnMethod) {
	              var record = tryCatch(returnMethod, delegate.iterator, arg);
	              if (record.type === "throw") {
	                // If the return method threw an exception, let that
	                // exception prevail over the original return or throw.
	                method = "throw";
	                arg = record.arg;
	                continue;
	              }
	            }
	
	            if (method === "return") {
	              // Continue with the outer return, now that the delegate
	              // iterator has been terminated.
	              continue;
	            }
	          }
	
	          var record = tryCatch(
	            delegate.iterator[method],
	            delegate.iterator,
	            arg
	          );
	
	          if (record.type === "throw") {
	            context.delegate = null;
	
	            // Like returning generator.throw(uncaught), but without the
	            // overhead of an extra function call.
	            method = "throw";
	            arg = record.arg;
	            continue;
	          }
	
	          // Delegate generator ran and handled its own exceptions so
	          // regardless of what the method was, we continue as if it is
	          // "next" with an undefined arg.
	          method = "next";
	          arg = undefined;
	
	          var info = record.arg;
	          if (info.done) {
	            context[delegate.resultName] = info.value;
	            context.next = delegate.nextLoc;
	          } else {
	            state = GenStateSuspendedYield;
	            return info;
	          }
	
	          context.delegate = null;
	        }
	
	        if (method === "next") {
	          context._sent = arg;
	
	          if (state === GenStateSuspendedYield) {
	            context.sent = arg;
	          } else {
	            context.sent = undefined;
	          }
	        } else if (method === "throw") {
	          if (state === GenStateSuspendedStart) {
	            state = GenStateCompleted;
	            throw arg;
	          }
	
	          if (context.dispatchException(arg)) {
	            // If the dispatched exception was caught by a catch block,
	            // then let that catch block handle the exception normally.
	            method = "next";
	            arg = undefined;
	          }
	
	        } else if (method === "return") {
	          context.abrupt("return", arg);
	        }
	
	        state = GenStateExecuting;
	
	        var record = tryCatch(innerFn, self, context);
	        if (record.type === "normal") {
	          // If an exception is thrown from innerFn, we leave state ===
	          // GenStateExecuting and loop back for another invocation.
	          state = context.done
	            ? GenStateCompleted
	            : GenStateSuspendedYield;
	
	          var info = {
	            value: record.arg,
	            done: context.done
	          };
	
	          if (record.arg === ContinueSentinel) {
	            if (context.delegate && method === "next") {
	              // Deliberately forget the last sent value so that we don't
	              // accidentally pass it on to the delegate.
	              arg = undefined;
	            }
	          } else {
	            return info;
	          }
	
	        } else if (record.type === "throw") {
	          state = GenStateCompleted;
	          // Dispatch the exception by looping back around to the
	          // context.dispatchException(arg) call above.
	          method = "throw";
	          arg = record.arg;
	        }
	      }
	    };
	  }
	
	  // Define Generator.prototype.{next,throw,return} in terms of the
	  // unified ._invoke helper method.
	  defineIteratorMethods(Gp);
	
	  Gp[iteratorSymbol] = function() {
	    return this;
	  };
	
	  Gp.toString = function() {
	    return "[object Generator]";
	  };
	
	  function pushTryEntry(locs) {
	    var entry = { tryLoc: locs[0] };
	
	    if (1 in locs) {
	      entry.catchLoc = locs[1];
	    }
	
	    if (2 in locs) {
	      entry.finallyLoc = locs[2];
	      entry.afterLoc = locs[3];
	    }
	
	    this.tryEntries.push(entry);
	  }
	
	  function resetTryEntry(entry) {
	    var record = entry.completion || {};
	    record.type = "normal";
	    delete record.arg;
	    entry.completion = record;
	  }
	
	  function Context(tryLocsList) {
	    // The root entry object (effectively a try statement without a catch
	    // or a finally block) gives us a place to store values thrown from
	    // locations where there is no enclosing try statement.
	    this.tryEntries = [{ tryLoc: "root" }];
	    tryLocsList.forEach(pushTryEntry, this);
	    this.reset(true);
	  }
	
	  runtime.keys = function(object) {
	    var keys = [];
	    for (var key in object) {
	      keys.push(key);
	    }
	    keys.reverse();
	
	    // Rather than returning an object with a next method, we keep
	    // things simple and return the next function itself.
	    return function next() {
	      while (keys.length) {
	        var key = keys.pop();
	        if (key in object) {
	          next.value = key;
	          next.done = false;
	          return next;
	        }
	      }
	
	      // To avoid creating an additional object, we just hang the .value
	      // and .done properties off the next function object itself. This
	      // also ensures that the minifier will not anonymize the function.
	      next.done = true;
	      return next;
	    };
	  };
	
	  function values(iterable) {
	    if (iterable) {
	      var iteratorMethod = iterable[iteratorSymbol];
	      if (iteratorMethod) {
	        return iteratorMethod.call(iterable);
	      }
	
	      if (typeof iterable.next === "function") {
	        return iterable;
	      }
	
	      if (!isNaN(iterable.length)) {
	        var i = -1, next = function next() {
	          while (++i < iterable.length) {
	            if (hasOwn.call(iterable, i)) {
	              next.value = iterable[i];
	              next.done = false;
	              return next;
	            }
	          }
	
	          next.value = undefined;
	          next.done = true;
	
	          return next;
	        };
	
	        return next.next = next;
	      }
	    }
	
	    // Return an iterator with no values.
	    return { next: doneResult };
	  }
	  runtime.values = values;
	
	  function doneResult() {
	    return { value: undefined, done: true };
	  }
	
	  Context.prototype = {
	    constructor: Context,
	
	    reset: function(skipTempReset) {
	      this.prev = 0;
	      this.next = 0;
	      this.sent = undefined;
	      this.done = false;
	      this.delegate = null;
	
	      this.tryEntries.forEach(resetTryEntry);
	
	      if (!skipTempReset) {
	        for (var name in this) {
	          // Not sure about the optimal order of these conditions:
	          if (name.charAt(0) === "t" &&
	              hasOwn.call(this, name) &&
	              !isNaN(+name.slice(1))) {
	            this[name] = undefined;
	          }
	        }
	      }
	    },
	
	    stop: function() {
	      this.done = true;
	
	      var rootEntry = this.tryEntries[0];
	      var rootRecord = rootEntry.completion;
	      if (rootRecord.type === "throw") {
	        throw rootRecord.arg;
	      }
	
	      return this.rval;
	    },
	
	    dispatchException: function(exception) {
	      if (this.done) {
	        throw exception;
	      }
	
	      var context = this;
	      function handle(loc, caught) {
	        record.type = "throw";
	        record.arg = exception;
	        context.next = loc;
	        return !!caught;
	      }
	
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        var record = entry.completion;
	
	        if (entry.tryLoc === "root") {
	          // Exception thrown outside of any try block that could handle
	          // it, so set the completion value of the entire function to
	          // throw the exception.
	          return handle("end");
	        }
	
	        if (entry.tryLoc <= this.prev) {
	          var hasCatch = hasOwn.call(entry, "catchLoc");
	          var hasFinally = hasOwn.call(entry, "finallyLoc");
	
	          if (hasCatch && hasFinally) {
	            if (this.prev < entry.catchLoc) {
	              return handle(entry.catchLoc, true);
	            } else if (this.prev < entry.finallyLoc) {
	              return handle(entry.finallyLoc);
	            }
	
	          } else if (hasCatch) {
	            if (this.prev < entry.catchLoc) {
	              return handle(entry.catchLoc, true);
	            }
	
	          } else if (hasFinally) {
	            if (this.prev < entry.finallyLoc) {
	              return handle(entry.finallyLoc);
	            }
	
	          } else {
	            throw new Error("try statement without catch or finally");
	          }
	        }
	      }
	    },
	
	    abrupt: function(type, arg) {
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        if (entry.tryLoc <= this.prev &&
	            hasOwn.call(entry, "finallyLoc") &&
	            this.prev < entry.finallyLoc) {
	          var finallyEntry = entry;
	          break;
	        }
	      }
	
	      if (finallyEntry &&
	          (type === "break" ||
	           type === "continue") &&
	          finallyEntry.tryLoc <= arg &&
	          arg <= finallyEntry.finallyLoc) {
	        // Ignore the finally entry if control is not jumping to a
	        // location outside the try/catch block.
	        finallyEntry = null;
	      }
	
	      var record = finallyEntry ? finallyEntry.completion : {};
	      record.type = type;
	      record.arg = arg;
	
	      if (finallyEntry) {
	        this.next = finallyEntry.finallyLoc;
	      } else {
	        this.complete(record);
	      }
	
	      return ContinueSentinel;
	    },
	
	    complete: function(record, afterLoc) {
	      if (record.type === "throw") {
	        throw record.arg;
	      }
	
	      if (record.type === "break" ||
	          record.type === "continue") {
	        this.next = record.arg;
	      } else if (record.type === "return") {
	        this.rval = record.arg;
	        this.next = "end";
	      } else if (record.type === "normal" && afterLoc) {
	        this.next = afterLoc;
	      }
	    },
	
	    finish: function(finallyLoc) {
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        if (entry.finallyLoc === finallyLoc) {
	          this.complete(entry.completion, entry.afterLoc);
	          resetTryEntry(entry);
	          return ContinueSentinel;
	        }
	      }
	    },
	
	    "catch": function(tryLoc) {
	      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
	        var entry = this.tryEntries[i];
	        if (entry.tryLoc === tryLoc) {
	          var record = entry.completion;
	          if (record.type === "throw") {
	            var thrown = record.arg;
	            resetTryEntry(entry);
	          }
	          return thrown;
	        }
	      }
	
	      // The context.catch method must only be called with a location
	      // argument that corresponds to a known catch block.
	      throw new Error("illegal catch attempt");
	    },
	
	    delegateYield: function(iterable, resultName, nextLoc) {
	      this.delegate = {
	        iterator: values(iterable),
	        resultName: resultName,
	        nextLoc: nextLoc
	      };
	
	      return ContinueSentinel;
	    }
	  };
	})(
	  // Among the various tricks for obtaining a reference to the global
	  // object, this seems to be the most reliable technique that does not
	  // use indirect eval (which violates Content Security Policy).
	  typeof global === "object" ? global :
	  typeof window === "object" ? window :
	  typeof self === "object" ? self : this
	);
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(447)))

/***/ },
/* 447 */
/***/ function(module, exports) {

	// shim for using process in browser
	
	var process = module.exports = {};
	var queue = [];
	var draining = false;
	var currentQueue;
	var queueIndex = -1;
	
	function cleanUpNextTick() {
	    draining = false;
	    if (currentQueue.length) {
	        queue = currentQueue.concat(queue);
	    } else {
	        queueIndex = -1;
	    }
	    if (queue.length) {
	        drainQueue();
	    }
	}
	
	function drainQueue() {
	    if (draining) {
	        return;
	    }
	    var timeout = setTimeout(cleanUpNextTick);
	    draining = true;
	
	    var len = queue.length;
	    while(len) {
	        currentQueue = queue;
	        queue = [];
	        while (++queueIndex < len) {
	            if (currentQueue) {
	                currentQueue[queueIndex].run();
	            }
	        }
	        queueIndex = -1;
	        len = queue.length;
	    }
	    currentQueue = null;
	    draining = false;
	    clearTimeout(timeout);
	}
	
	process.nextTick = function (fun) {
	    var args = new Array(arguments.length - 1);
	    if (arguments.length > 1) {
	        for (var i = 1; i < arguments.length; i++) {
	            args[i - 1] = arguments[i];
	        }
	    }
	    queue.push(new Item(fun, args));
	    if (queue.length === 1 && !draining) {
	        setTimeout(drainQueue, 0);
	    }
	};
	
	// v8 likes predictible objects
	function Item(fun, array) {
	    this.fun = fun;
	    this.array = array;
	}
	Item.prototype.run = function () {
	    this.fun.apply(null, this.array);
	};
	process.title = 'browser';
	process.browser = true;
	process.env = {};
	process.argv = [];
	process.version = ''; // empty string to avoid regexp issues
	process.versions = {};
	
	function noop() {}
	
	process.on = noop;
	process.addListener = noop;
	process.once = noop;
	process.off = noop;
	process.removeListener = noop;
	process.removeAllListeners = noop;
	process.emit = noop;
	
	process.binding = function (name) {
	    throw new Error('process.binding is not supported');
	};
	
	process.cwd = function () { return '/' };
	process.chdir = function (dir) {
	    throw new Error('process.chdir is not supported');
	};
	process.umask = function() { return 0; };


/***/ }
/******/ ]);
//# sourceMappingURL=ancillary.js.map