\\n\"\n\n/***/ }),\n\n/***/ \"../node_modules/squid/dist/core/api.js\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\n\nexports.__esModule = true;\nexports.$Api = undefined;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nexports.$getLatestCorrelationID = $getLatestCorrelationID;\n\nvar _jquery = __webpack_require__(\"../node_modules/jquery/dist/jquery.min.js\");\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _logger = __webpack_require__(\"../node_modules/xo-beaver/dist/logger.js\");\n\nvar _event = __webpack_require__(\"../node_modules/squid/dist/core/event.js\");\n\nvar _class = __webpack_require__(\"../node_modules/squid/dist/core/class.js\");\n\nvar _util = __webpack_require__(\"../node_modules/squid/dist/core/util.js\");\n\nvar _promise = __webpack_require__(\"../node_modules/squid/dist/core/promise.js\");\n\nvar _config = __webpack_require__(\"../node_modules/squid/dist/core/config.js\");\n\nvar _error = __webpack_require__(\"../node_modules/squid/dist/core/error.js\");\n\nvar _loader = __webpack_require__(\"../node_modules/squid/dist/core/loader.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\n/*\n API\n ---\n\n This layer is responsible for handling api requests. It has a number of responsibilities:\n\n - Caching responses\n - Transparently returning data that has been preloaded into the initial page response\n - Instrumentation\n - Batching multiple api calls into a single http request\n - Handling multiple types of responses and dispatching to the correct handlers\n - Emitting loading events for all http calls\n */\n\n_config.$meta.headers = _config.$meta.headers || {};\n_config.$meta.headers['x-cookies'] = _typeof(_config.$meta.headers['x-cookies']) !== 'object' ? JSON.parse(_config.$meta.headers['x-cookies'] || '{}') : _config.$meta.headers['x-cookies'];\n\n// Are we in 'cookies disabled' mode? (Do we need to keep a local store of cookies)\nfunction cookiesEnabled() {\n return _util.$util.cookiesEnabled() && window.location.hostname.indexOf('.paypal.com') > -1;\n}\n\n// Cache for api responses, when cache: true\nvar cache = {};\nvar standardHeaders = {};\n\nvar latestCorrelationID = _config.$meta.correlationId;\n\n// Window load promise\nvar windowLoad = _util.$util.memoize(function () {\n return _promise.$promise.resolver(function (resolve) {\n if (document.readyState === 'complete') {\n resolve();\n } else {\n window.addEventListener('load', resolve);\n }\n });\n});\n\n// Buffer for batch requests made within the same frame\nvar batchQueue = {};\n\n// Backwards compat\nwindow.pre = {};\n\n// Transient cache resolvers\nvar transientCache = {};\n\n// Transient cache resolvers\nvar transientCacheResolvers = {};\n\n// Metabuilder\nvar metaBuilder = void 0;\n\n// Add to transientCache\nwindow.preload = function (method, url, data, name) {\n\n if (name) {\n window.pre[name] = {\n method: method,\n uri: url,\n res: data\n };\n }\n\n var key = method + ':' + url;\n var resolvers = transientCacheResolvers[key] || [];\n\n transientCache[key] = data;\n\n while (resolvers.length) {\n resolvers.pop().call();\n }\n};\n\n// Preload complete\nvar preloadComplete = false;\n\nwindow.preloadComplete = function () {\n preloadComplete = true;\n Object.keys(transientCacheResolvers).forEach(function (key) {\n var resolvers = transientCacheResolvers[key] || [];\n\n while (resolvers.length) {\n resolvers.pop().call();\n }\n });\n};\n\n_logger.$logger.info(cookiesEnabled() ? 'cookies_enabled' : 'cookies_disabled');\n\nvar $Api = exports.$Api = _class.$Class.extend('$Api', {\n\n // Cache any GET responses indefinitely\n cache: false,\n\n // Http timeout for all requests\n timeout: 45000,\n\n // Default number of attempts on aborted requests and 500 server errors\n getAttempts: 3,\n postAttempts: 1,\n\n // POST on a resource with an action name myapi.action('foo') -> POST /my/api/foo\n action: function action(_action, options) {\n options.action = _action;\n return this.post(options);\n },\n\n // GET on a resource myapi.retrieve() -> GET /my/api\n retrieve: function retrieve(options) {\n options.method = 'get';\n return this.call(options);\n },\n\n // POST on a resource myapi.retrieve() -> POST /my/api\n post: function post(options) {\n options.method = 'post';\n return this.call(options);\n },\n\n // Generic handler for calling an api and dispatching requests to the right place\n call: function call(options) {\n var self = this;\n\n // Set up request options and params. `options` is an object which should contain everything\n // the request needs to run and handle the response\n\n options.api = this;\n options.uri = this.getURI(options.model, options.action);\n options.params = options.params || {};\n options.cache = options.cache || self.cache && options.method === 'get';\n options.name = this.buildAPIName(options);\n options.meta = this.buildMeta();\n options.transientError = options.transientError || false;\n options.cacheKey = _util.$util.buildURL(options.uri, options.params);\n\n _logger.$logger.info(options.name + '_call', {\n name: options.name,\n method: options.method,\n uri: options.uri\n });\n\n if (!options.silent) {\n _event.$event.emit('loading');\n }\n\n // Decide where to get the response\n return _promise.$promise.first([\n\n // If caching is enabled and we have the data in local cache, use the cache\n function () {\n if (options.cache && cache[options.cacheKey]) {\n return cache[options.cacheKey];\n }\n },\n\n // Otherwise if we have transient cache data for this api, we can use that\n function () {\n return _promise.$promise.providing(self.hasTransientCacheData(options), function () {\n\n // The reason we use self.attemptRequest here is so any errors in the cached response\n // can trigger the retry code path, as if it were a regular request\n return self.attemptRequest(options);\n });\n },\n\n // If we're in batch mode, queue up a batch request\n function () {\n if (options.batch) {\n return self.batchRequest(options);\n }\n },\n\n // Otherwise attempt a regular http request (at this point an http call is guaranteed)\n function () {\n return self.attemptRequest(options);\n }])['finally'](function () {\n\n if (!options.silent) {\n _event.$event.emit('loaded');\n }\n }).then(function (res) {\n\n // Cache the response if we need to\n if (options.cache) {\n cache[options.cacheKey] = res;\n }\n\n // Handle the response\n return self.handleResponse(res.data, options);\n }, function (err) {\n\n // $BatchShortCircuit will be thrown if:\n //\n // 1. batch api call B depends on api call A, but-\n // 2. api call A fails\n //\n // In which case we end up in a situation where had it been a regular chain of events,\n // api B would never have been called in the first place.\n //\n // One possibility here is to return $unresolved, which prevents the promise from ever\n // resolving, but this has the potential to cause a lot of difficulty debugging and strange\n // corner cases.\n //\n // Instead we opt to simply reject the promise, and not call any of the response handlers\n\n if (err instanceof _error.$BatchShortCircuit) {\n return _promise.$promise.reject(err);\n }\n\n // Otherwise, handle the error normally\n return self.handleErrorResponse(err, options);\n });\n },\n\n // Set up a batch request for processing in the next frame\n batchRequest: function batchRequest(options) {\n\n // Batch Requests are an optimization layer on top of regular api calls. The purpose of this\n // layer is to combine multiple atomic api calls into a single http request, without forcing\n // developers to create large orchestration layers on the client/server with cross-cutting concerns.\n //\n // This layer will queue up multiple requests made in the same frame whenever batch-mode is enabled,\n // attach them all to an http call to /api/batch/:name, then on the response it will dispatch each\n // individual api call to the correct handler.\n //\n // The way this is implemented is to place each response in the transient api cache, then to yield\n // control to the regular api request handler, which will handle instrumentation and retries\n\n // For quick dev-time feedback...\n _util.$util.assert(options.batch.name, 'Must define a \"name\" for batch request: ' + options.batch);\n _util.$util.assert(options.batch.id, 'Must define a \"id\" for batch request: ' + options.batch);\n\n var name = options.batch.name;\n var id = options.batch.id;\n\n // Add the batch request options to the batchQueue for processing on the next frame\n var batch = batchQueue[name] = batchQueue[name] || {};\n\n batch[id] = options;\n\n // Fire off a batch request. This will be debounced: calls in the same frame will be combined to one\n return this.buildBatchRequest(name).then(function (results) {\n\n // We get back a mapping of id->response, so we now extract the response for our api\n // call. If we have no response, we can assume the call was never made, and short circuit.\n return results[id].then(function (result) {\n return result || _promise.$promise.reject(new _error.$BatchShortCircuit());\n });\n });\n },\n\n // Process all of the accumulated batch api requests\n buildBatchRequest: _promise.$promise.debounce(function (name) {\n\n var self = this;\n var batch = batchQueue[name];\n var batchIds = _class.$Class.keys(batch);\n var batchData = {};\n var headers = {};\n\n delete batchQueue[name];\n\n // If we have just a single request, we can short-circuit and just hit that api\n\n if (batchIds.length === 1) {\n\n var batchId = batchIds[0];\n var opts = batch[batchId];\n\n var results = {};\n\n results[batchId] = opts.api.attemptRequest(opts);\n return results;\n }\n\n // Build the request to send to the server side. This is an mapping of id->request, each containing\n // the method, uri, data, and dependencies for each api.\n //\n // Specifying a dependency for an api essentially means the back-end will only\n // call api-B if api-A returns ack=success. Otherwise there will be no response for api B.\n\n _util.$util.forEach(batch, function (options, id) {\n\n batchData[id] = {\n method: options.method,\n uri: options.api.getURI(options.model, options.action, true),\n data: options.data,\n params: options.params,\n dependencies: options.batch.dependencies\n };\n\n _util.$util.extend(headers, options.headers);\n });\n\n // Unfortunate circular dependency... $Api depends on another api.\n //\n // $batchApi is subject to all of the same rules regarding retries, so if for some reason the server\n // does not respond the first time, our batch request can still get through.\n\n return $batchApi.action(name, { // eslint-disable-line no-use-before-define\n data: batchData,\n headers: headers\n }).then(function (res) {\n\n // The final response will be a mapping of id->response-promise.\n //\n // However, we do not treat this data as our final response. Instead, we simply use it to\n // prime our transient cache, then proceed to jump to our regular request handler. This will\n // take care of retries and instrumentation as if this were a regular request.\n //\n // Note that a retry for $batchApi is different to a retry for an individual api. If\n // an *individual* api call fails, we do not want to re-do the entire batch call; instead we\n // can just retry the individual api call.\n\n return self.handleBatchResponse(batch, res.data);\n });\n }),\n\n // Process the responses for all of the batch requests we sent to the server\n handleBatchResponse: function handleBatchResponse(batch, data) {\n\n var self = this;\n\n var promises = {};\n\n // Loop over each individual api response contained in the batch response, and process the result\n\n _util.$util.forEach(batch, function (options, id) {\n\n // Store each response promise so we can check and wait for api dependencies\n\n promises[id] = _promise.$promise.run(function () {\n\n // Check if all of the dependencies are present for our individual api call. To do this\n // we must wait until the dependent api call is entirely complete, including any retries.\n\n var depsPresent = _promise.$promise.every(options.batch.dependencies || [], function (depName) {\n\n if (!batch[depName]) {\n _logger.$logger.info('missing_batch_dependency', {\n dependency: depName,\n available: Object.keys(batch).join('|')\n });\n }\n\n return !batch[depName] || promises[depName].then(function (dependency) {\n return dependency && dependency.data && dependency.data.ack === 'success';\n });\n });\n\n // If our dependencies are present, we can continue, otherwise we are not interested in\n // the result of the individual api call - if its dependency is not present, it will not be.\n\n return _promise.$promise.providing(depsPresent, function () {\n\n // If there is data returned for the individual call, add it to the transient cache\n\n return _promise.$promise.providing(data[id], function (result) {\n var uri = options.api.getURI(options.model, options.action);\n\n uri = _util.$util.buildURL(uri, options.params);\n\n self.addTransientCacheData(options.method, uri, result);\n }).then(function () {\n\n // Regardless of whether or not there is data, we can now attempt the request.\n // This will either get the data from the transient cache, or make an http call,\n // and handle any retries that need to be made.\n\n return options.api.attemptRequest(options);\n });\n });\n });\n });\n\n return promises;\n },\n\n // Handle the request and any retries, using either the transient cache or http calls\n attemptRequest: function attemptRequest(options) {\n var self = this;\n\n var attempts = options.method === 'get' ? this.getAttempts : this.postAttempts;\n\n // We allow a certain number of attempts/retries for each api call\n return _promise.$promise.attempt(attempts, function (remaining) {\n\n // Query the transient cache\n return self.getTransientCacheResponse(options).then(function (res) {\n\n // If we can get a response from the transient cache, then use it\n if (res) {\n return res;\n }\n\n // Otherwise resort to making an http call\n return self.getHttpResponse(options);\n })['catch'](function (res) {\n\n // If our request was aborted without even a status code, force a single retry\n if ((!res || !res.status) && attempts === 1) {\n\n _logger.$logger.warn('api_retry_aborted', {\n method: options.method,\n uri: options.uri\n });\n\n return self.getHttpResponse(options);\n }\n\n return _promise.$promise.reject(res);\n })['catch'](function (res) {\n\n // If our request was 401 denied (probably due to a CSRF error), force a single retry\n if (res.status === 401) {\n\n _logger.$logger.warn('api_retry_401', {\n method: options.method,\n uri: options.uri\n });\n\n return self.getHttpResponse(options);\n }\n\n return _promise.$promise.reject(res);\n })['catch'](function (res) {\n\n // Set the correct response and ack for 401\n if (res.status === 401) {\n return {\n data: {\n ack: 'permission_denied'\n }\n };\n }\n\n // Setup to throw a TOO_MANY_REQUESTS contingency for 429 response from ratelimiter (velocityserv)\n if (res.status === 429) {\n return {\n data: {\n ack: 'contingency',\n contingency: 'TOO_MANY_REQUESTS'\n }\n };\n }\n\n // If we have any remaining retries, log and reject\n if (remaining) {\n\n _logger.$logger.warn('api_retry', {\n method: options.method,\n uri: options.uri\n });\n\n return _promise.$promise.reject(res);\n }\n\n // Otherwise reject the request with the appropriate error\n\n // We got ack=error in the response\n if (res && res.data && res.data.ack === 'error') {\n return _promise.$promise.reject(new _error.$ApiError('api_error', { // eslint-disable-line no-reserved-keys\n name: options.name,\n method: options.method,\n uri: options.uri,\n stack: res.data.stack,\n transient: options.transientError\n }));\n }\n\n // We got a response error status\n else if (res && res.status) {\n return _promise.$promise.reject(new _error.$ApiError('response_status_' + res.status, { // eslint-disable-line no-reserved-keys\n uri: options.uri,\n transient: options.transientError\n }));\n } else if (res && res.error) {\n return _promise.$promise.reject(new _error.$ApiError('request_' + res.error, { // eslint-disable-line no-reserved-keys\n uri: options.uri,\n transient: options.transientError\n }));\n }\n\n // The request was aborted\n else {\n return _promise.$promise.reject(new _error.$ApiError('request_aborted', { // eslint-disable-line no-reserved-keys\n uri: options.uri,\n transient: options.transientError\n }));\n }\n });\n });\n },\n\n // Get an api response via http\n getHttpResponse: function getHttpResponse(options) {\n var self = this;\n\n var startTime = _util.$util.now();\n\n var request = this.http(options);\n\n return request['finally'](function () {\n\n // Calculate the end-to-end duration of the request from the client's perspective\n options.duration = _util.$util.now() - startTime;\n })['catch'](function (res) {\n\n // Turn responses with an ack into a 'success' so it makes it to the standard handlers\n if (res && res.status && res.data && res.data.ack && res.data.ack !== 'error') {\n return res;\n }\n\n return _promise.$promise.reject(res);\n }).then(function (res) {\n self.saveResponseState(res);\n\n var loggerPayload = {\n name: options.name,\n method: options.method,\n uri: options.uri,\n server: res.data.server,\n time: options.duration,\n duration: options.duration,\n corrid: res && res.headers('Paypal-Debug-Id')\n };\n\n // In certain browsers we can match up this api call to the performance data from the browser\n if (window.performance && window.performance.getEntries) {\n _util.$util.forEach(window.performance.getEntries(), function (resource) {\n if (resource.name && resource.name.indexOf(options.uri) > -1) {\n _util.$util.extend(loggerPayload, resource);\n }\n });\n }\n\n _logger.$logger.info('api_response', loggerPayload);\n\n if (res && res.status) {\n _logger.$logger.info('http_response_' + res.status);\n }\n\n return res;\n }, function (res) {\n self.saveResponseState(res);\n\n if (res && res.status) {\n _logger.$logger.info('http_response_' + res.status, {\n corrid: res.headers('Paypal-Debug-Id'),\n referenceId: res.headers('X-Reference-Header') || undefined // To not serialize this data if not present\n });\n }\n\n return _promise.$promise.reject(res);\n });\n },\n\n setTransientCache: function setTransientCache(data) {\n throw new Error('NotImplemented');\n },\n\n // Get an individual api response from the transient cache, as an object\n getTransientCacheData: function getTransientCacheData(options, pop) {\n\n if (!_config.$config.enablePreload) {\n return _promise.$promise.resolve();\n }\n\n var preMethod = options.method.toLowerCase();\n var preUri = _util.$util.buildURL(options.uri, options.params);\n\n var key = preMethod + ':' + preUri;\n\n return _promise.$promise.resolver(function (resolve) {\n\n function res() {\n var data = transientCache[key];\n\n if (pop) {\n delete transientCache[key];\n }\n resolve(data);\n }\n\n if (transientCache[key] || document.readyState === 'complete' || preloadComplete) {\n return res();\n }\n\n transientCacheResolvers[key] = transientCacheResolvers[key] || [];\n transientCacheResolvers[key].push(res);\n\n windowLoad().then(res);\n });\n },\n\n // Check if the transient cache has the data for a particular api\n hasTransientCacheData: function hasTransientCacheData(options) {\n return this.getTransientCacheData(options, false).then(function (data) {\n return Boolean(data);\n });\n },\n\n // Add data to the transient cache\n addTransientCacheData: function addTransientCacheData(method, uri, data) {\n var key = method + ':' + uri;\n\n transientCache[key] = data;\n },\n\n // Get an individual api response from transient cache, as a res promise with the correct status code\n getTransientCacheResponse: function getTransientCacheResponse(options) {\n\n return this.getTransientCacheData(options, true).then(function (data) {\n\n // Preload data does not come with a response code, so massage it into a response promise\n if (data) {\n if (data.ack === 'error') {\n return _promise.$promise.reject({\n status: 500,\n data: data\n });\n } else if (data.ack === 'permission_denied') {\n return _promise.$promise.reject({\n status: 401,\n data: data\n });\n } else if (data.ack === 'contingency' || data.ack === 'validation_error') {\n return {\n status: 400,\n data: data\n };\n } else {\n return {\n status: 200,\n data: data\n };\n }\n }\n\n // Log a cache miss if we are currently in the first-page load\n else if (options.method === 'get' && !_loader.$loader.firstLoad() && !options.silent) {\n _logger.$logger.info('preload_cache_miss', {\n uri: options.uri\n });\n }\n });\n },\n\n getHeaders: function getHeaders(options) {\n\n if (!_config.$meta.headers['x-csrf-jwt'] && !_config.$meta.csrfJwt) {\n _logger.$logger.warn('missing_csrf_jwt');\n }\n\n var headers = {\n 'X-Requested-With': 'XMLHttpRequest',\n 'x-csrf-jwt': _config.$meta.headers['x-csrf-jwt'] || _config.$meta.csrfJwt\n };\n\n _util.$util.extend(headers, standardHeaders);\n\n if (!cookiesEnabled()) {\n headers['x-cookies'] = JSON.stringify(_config.$meta.headers['x-cookies']);\n }\n\n if (options.headers) {\n _util.$util.extend(headers, options.headers);\n }\n\n return headers;\n },\n http: function http(options) {\n return this.httpJQuery(options);\n },\n\n\n /*\n // Raw http call\n httpAngular: function(options) {\n let request = {\n method: options.method,\n url: options.uri,\n data: {\n data: options.data,\n meta: options.meta\n },\n headers: this.getHeaders(options),\n params: options.params,\n requestType: 'json',\n responseType: 'json',\n timeout: this.timeout\n };\n if (options.method === 'get' && options.meta && Object.keys(options.meta).length) {\n request.params.meta = JSON.stringify(options.meta);\n }\n return $http(request);\n },\n */\n\n httpJQuery: function httpJQuery(options) {\n\n var request = {\n method: options.method,\n data: options.method === 'get' ? options.params : JSON.stringify({\n data: options.data,\n meta: options.meta || {}\n }),\n headers: this.getHeaders(options),\n timeout: this.timeout\n };\n\n if (options.method === 'post') {\n request.headers['Content-Type'] = 'application/json;charset=UTF-8';\n } else if (options.method === 'get') {\n request.data.meta = JSON.stringify(options.meta);\n }\n\n return _promise.$promise.resolver(function (resolve, reject) {\n\n function getRes(res, data) {\n return {\n status: res.status,\n data: data,\n headers: function headers(name) {\n return res.getResponseHeader(name);\n }\n };\n }\n\n request.success = function (data, status, res) {\n return resolve(getRes(res, data));\n };\n\n request.error = function (res) {\n if (res && res.status) {\n if (res.status >= 400) {\n return reject(getRes(res, res.responseJSON));\n } else {\n return resolve(getRes(res, res.responseJSON));\n }\n }\n\n return reject({\n status: 0,\n headers: _util.$util.noop,\n error: res && res.statusText\n });\n };\n\n _jquery2['default'].ajax(options.uri, request);\n });\n },\n\n // Save cookies and jwt-csrf token from the response\n saveResponseState: function saveResponseState(res) {\n\n if (res.headers('x-csrf-jwt')) {\n _config.$meta.headers['x-csrf-jwt'] = res.headers('x-csrf-jwt');\n _config.$meta.csrfJwt = res.headers('x-csrf-jwt');\n _config.$meta.headers['x-csrf-jwt-hash'] = res.headers('x-csrf-jwt-hash');\n }\n\n if (res.headers('X-cookies')) {\n\n _config.$meta.headers['x-cookies-hash'] = res.headers('x-cookies-hash');\n\n // Extend local cookie jar of encrypted-cookie-name->encrypted-cookie-value with any new cookies\n _util.$util.extend(_config.$meta.headers['x-cookies'], JSON.parse(res.headers('X-cookies') || '{}'));\n }\n\n latestCorrelationID = res.headers('Paypal-Debug-Id') || latestCorrelationID;\n },\n\n // Dispatch the response to the correct handlers\n handleResponse: function handleResponse(res, options) {\n var loggerName = 'ui_' + options.name;\n\n var loggerPayload = {\n name: options.name,\n method: options.method,\n uri: options.uri,\n time: options.duration,\n duration: options.duration\n };\n\n // Here we dispatch the response to the correct handler based on the ack.\n //\n // ack=success -> options.success()\n // ack=error -> options.error()\n // ack=validation -> options.validation()\n // ack=contingency -> options.contingencies[contingency]()\n //\n // Why do this rather than just rejecting the promise with a custom error?\n //\n // a) Angular promises have no `.catchType()`, so this saves us a lot of `instanceof` checks\n // b) Angular promises have no `.done()`, so callers can not assert that they have handled\n // every error they want to. This is exacerbated by the fact that there is no single thread\n // of execution on the front-end a la node, so we can't just call `.done()` at the very end :(\n //\n // This way, if somebody passes a handler, it will be called. Otherwise, an error will be thrown\n // and the global error handler will be invoked. The api responses are also given as promises.\n\n var resultModel = options.resultModel || options.model;\n\n /* jshint maxcomplexity: 17 */\n return _promise.$promise.call(function () {\n\n // If we are given a `resultModel`, we always extend it with `res.data`, no matter the ack\n\n if (res.data && resultModel) {\n\n if (resultModel.populate) {\n resultModel.populate(res.data);\n } else {\n _util.$util.extend(resultModel, res.data);\n }\n }\n\n if (res && res.ack === 'success' && resultModel && resultModel.fetchChildren) {\n return _promise.$promise.resolve(resultModel.fetchChildren()).then(function (children) {\n return _util.$util.extend(resultModel, children);\n });\n }\n }).then(function () {\n // eslint-disable-line max-statements\n\n // Handle each ack type, throw errors accordingly\n\n if (res.ack === 'success') {\n _logger.$logger.info(loggerName + '_success', loggerPayload);\n\n if (options.success) {\n if (options.success instanceof Function) {\n return options.success(res.data);\n }\n return options.success;\n }\n\n return res;\n }\n\n if (options.failSilently) {\n return;\n }\n\n if (res.ack === 'contingency') {\n _logger.$logger.info(loggerName + '_contingency', _util.$util.extend(loggerPayload, {\n contingency: res.contingency\n }));\n\n if (!res.contingency) {\n throw new _error.$ApiError('expected_contingency_name', {\n api: options.name\n });\n }\n\n var contingency = new _error.$Contingency(res.contingency, { // eslint-disable-line no-reserved-keys\n transient: options.transientError\n });\n\n if (resultModel) {\n resultModel.errorData = res.errorData || {};\n }\n\n var handler = options.contingencies && (options.contingencies[contingency.message] || options.contingencies['DEFAULT']);\n\n _util.$util.extend(contingency, res.errorData);\n\n if (handler) {\n if (handler instanceof Function) {\n return handler(contingency.message, contingency);\n }\n return handler;\n }\n\n throw contingency;\n } else if (res.ack === 'validation') {\n _logger.$logger.info(loggerName + '_validation', _util.$util.extend(loggerPayload, {\n validation: res.validation\n }));\n\n if (options.validation) {\n return options.validation(res.validation);\n }\n\n throw new _error.$ApiError('validation', { // eslint-disable-line no-reserved-keys\n transient: options.transientError\n });\n } else if (res.ack === 'permission_denied') {\n _logger.$logger.info(loggerName + '_denied', loggerPayload);\n\n var properties = {\n transient: options.transientError\n };\n\n if (res.reason) {\n properties.reason = res.reason;\n }\n\n throw new _error.$Forbidden(options.uri + ': forbidden', properties);\n } else {\n _logger.$logger.info(loggerName + '_noack', loggerPayload);\n\n throw new _error.$ApiError('noack', { // eslint-disable-line no-reserved-keys\n transient: options.transientError\n });\n }\n });\n },\n\n // Handle http error responses (ack=error or unhandled errors)\n handleErrorResponse: function handleErrorResponse(err, options) {\n\n return _promise.$promise.run(function () {\n\n // If the caller provides an error handler, let them handle it\n if (options.error) {\n return options.error(err);\n }\n\n // Otherwise we throw the error. Please not that this is NOT just rejecting the promise,\n // this will always end up in the global error handler due to how angular promises work.\n throw err;\n });\n },\n\n // Build the uri for the api call\n getURI: function getURI(model, action, relative) {\n var self = this;\n\n // build the uri as a seriest of segments\n var uri = [];\n\n uri.push(this.uri.replace(/\\/:[\\w\\.]+\\?/g, function (key) {\n\n // Add any *optional* dynamic keys from the model (/foo/:bar? -> /foo/{{model.bar}})\n\n key = key.slice(2);\n key = key.substring(0, key.length - 1);\n\n var component = model.get ? model.get(key) : model[key];\n\n if (!component) {\n return '';\n }\n\n return '/' + component;\n }).replace(/:[\\w\\.]+/g, function (key) {\n\n // Add any dynamic keys from the model (/foo/:bar -> /foo/{{model.bar}})\n\n key = key.slice(1);\n\n var component = model.get ? model.get(key) : model[key];\n\n if (!component) {\n throw new Error('Property \"' + key + '\" not found in model for: ' + self.uri);\n }\n\n return component;\n }));\n\n // Add the action, if provided (`foo.action('bar', {...})` -> /api/foo/bar\n if (action) {\n uri.push(action);\n }\n\n // Add the extension (e.g. for doing a GET on a .json resource)\n if (this.ext) {\n uri[uri.length - 1] += '.' + this.ext;\n }\n\n // Join the uri segments and strip any extra slashes\n uri = '/' + uri.join('/').replace(/\\/{2,}/g, '/').replace(/^\\//, '');\n\n // Add on the base uri, e.g. /webapps/hermes\n if (!relative) {\n uri = (this.baseURI || _config.$config.urls.baseUrl) + uri;\n }\n\n return uri;\n },\n\n // Attach meta data provided by the parent app\n buildMeta: function buildMeta() {\n if (metaBuilder) {\n return metaBuilder();\n }\n },\n\n // Build the name of the api for logging. /api/foo/bar -> api_foo_bar\n buildAPIName: function buildAPIName(options) {\n var self = this;\n var apiName = self.uri.replace(/^\\/+/, ''). // Remove leading '/'\n replace(/\\//g, '_'). // Replace remaining '/' with '_'\n replace(/\\?(.*)/, ''). // Remove everything after '?'\n replace(/[^a-zA-Z0-9_]/g, '');\n\n apiName = options.action ? apiName + '_' + options.action : apiName;\n apiName = apiName.charAt(0) === '_' ? apiName.slice(1) : apiName;\n return apiName;\n }\n});\n\n$Api.reopenClass({\n clearCache: function clearCache() {\n cache = {};\n }\n});\n\n$Api.registerMetaBuilder = function (builder) {\n metaBuilder = builder;\n};\n\n$Api.addHeader = function (name, value) {\n standardHeaders[name] = value;\n};\n\nvar $batchApi = new $Api({\n uri: '/api/batch',\n postAttempts: 3\n});\n\nfunction $getLatestCorrelationID() {\n return latestCorrelationID;\n}\n\nangular.value(\"$Api\", $Api);\nangular.value(\"$getLatestCorrelationID\", $getLatestCorrelationID);\n_logger.$logger;\n\n_event.$event;\n\n_class.$Class;\n\n_util.$util;\n\n_promise.$promise;\n\n_config.$config;\n\n_config.$meta;\n\n_error.$Contingency;\n\n_error.$Forbidden;\n\n_error.$ApiError;\n\n_error.$BatchShortCircuit;\n\n_loader.$loader;\n\n/***/ }),\n\n/***/ \"../node_modules/squid/dist/core/class.js\":\n/***/ (function(module, exports) {\n\n\n\nexports.__esModule = true;\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/*\n Class\n -----\n\n A class pattern, adding sugar on top of javascript prototypes\n\n ### Basic Usage\n\n let MyClass = Class.extend({\n foo: 'bar';\n });\n\n myInstance = new MyClass({\n hello: 'world'\n });\n\n console.log(myInstance.foo, myInstance.hello)\n\n In this example, `foo` becomes a property on `MyClass`'s prototype,\n and `hello` becomes a property on `myInstance`.\n\n ### Default Object Methods\n\n - `init()`: Called after the object is first instantiated, with all properties available\n\n - `get(, )`: Get an object an arbitrary number of levels deep, or return a default\n\n e.g. `myInstance.get('foo.bar.baz', 'some_default');`\n\n Default return value is undefined\n\n - `set(, )`: Set an object an arbitrary number of levels deep\n\n e.g. `myInstance.set('foo.bar.baz', 'some_value');`\n\n Error is thrown if no object is found to set the value on\n\n - `setProperties(