{"version":3,"sources":["webpack:///firebase-storage.js","webpack:///./src/storage/implementation/type.ts","webpack:///./src/storage/implementation/error.ts","webpack:///./src/storage/implementation/promise_external.ts","webpack:///./src/storage/implementation/object.ts","webpack:///./src/storage/implementation/constants.ts","webpack:///./src/storage/implementation/location.ts","webpack:///./src/storage/implementation/string.ts","webpack:///./src/storage/implementation/args.ts","webpack:///./src/storage/implementation/array.ts","webpack:///./src/storage/implementation/metadata.ts","webpack:///./src/storage/implementation/url.ts","webpack:///./src/storage/implementation/taskenums.ts","webpack:///./src/storage/reference.ts","webpack:///./src/storage/implementation/blob.ts","webpack:///./src/storage/implementation/path.ts","webpack:///./src/storage/implementation/requests.ts","webpack:///./src/storage/implementation/xhrio.ts","webpack:///./src/storage/implementation/xhriopool.ts","webpack:///./src/storage/service.ts","webpack:///./src/storage.ts","webpack:///./src/storage/implementation/async.ts","webpack:///./src/storage/implementation/authwrapper.ts","webpack:///./src/storage/implementation/backoff.ts","webpack:///./src/storage/implementation/failrequest.ts","webpack:///./src/storage/implementation/fs.ts","webpack:///./src/storage/implementation/json.ts","webpack:///./src/storage/implementation/observer.ts","webpack:///./src/storage/implementation/request.ts","webpack:///./src/storage/implementation/requestinfo.ts","webpack:///./src/storage/implementation/requestmap.ts","webpack:///./src/storage/implementation/xhrio_network.ts","webpack:///./src/storage/task.ts","webpack:///./src/storage/tasksnapshot.ts"],"names":["webpackJsonpFirebase","module","exports","__webpack_require__","isDef","p","isJustDef","isFunction","isObject","_typeof","isNonNullObject","isNonArrayObject","Array","isArray","isString","String","isNumber","Number","isNativeBlob","isNativeBlobDefined","Blob","Object","defineProperty","value","Symbol","iterator","obj","constructor","prototype","_classCallCheck","instance","Constructor","TypeError","prependCode","code","unknown","FirebaseStorageError","Code","UNKNOWN","objectNotFound","path","OBJECT_NOT_FOUND","bucketNotFound","bucket","BUCKET_NOT_FOUND","projectNotFound","project","PROJECT_NOT_FOUND","quotaExceeded","QUOTA_EXCEEDED","unauthenticated","UNAUTHENTICATED","unauthorized","UNAUTHORIZED","retryLimitExceeded","RETRY_LIMIT_EXCEEDED","invalidChecksum","checksum","calculated","INVALID_CHECKSUM","canceled","CANCELED","invalidEventName","name","INVALID_EVENT_NAME","invalidUrl","url","INVALID_URL","invalidDefaultBucket","INVALID_DEFAULT_BUCKET","noDefaultBucket","NO_DEFAULT_BUCKET","_constants","configOption","cannotSliceBlob","CANNOT_SLICE_BLOB","serverFileWrongSize","SERVER_FILE_WRONG_SIZE","noDownloadURL","NO_DOWNLOAD_URL","invalidArgument","index","fnName","message","INVALID_ARGUMENT","invalidArgumentCount","argMin","argMax","real","countPart","plural","INVALID_ARGUMENT_COUNT","appDeleted","APP_DELETED","invalidRootOperation","INVALID_ROOT_OPERATION","invalidFormat","format","INVALID_FORMAT","internalError","INTERNAL_ERROR","errors","undefined","_createClass","defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","key","protoProps","staticProps","this","code_","message_","serverResponse_","name_","codeProp","serverResponse","get","make","resolver","_shared_promise","local","Promise","resolve","reject","error","contains","prop","hasOwnProperty","call","forEach","f","clone","c","val","setDomainBase","domainBase","downloadBase","apiBaseUrl","apiUploadBaseUrl","shortMaxOperationRetryTime","defaultMaxOperationRetryTime","defaultMaxUploadRetryTime","minSafeInteger","Location","_error","errorsExports","__esModule","newObj","default","path_","encode","encodeURIComponent","bucketString","bucketLocation","makeFromUrl","e","location","gsRegex","RegExp","httpRegex","groups","regex","indices","postModify","loc","charAt","slice","decodeURIComponent","group","captures","exec","bucketValue","pathValue","formatValidator","stringFormat","StringFormat","RAW","BASE64","BASE64URL","DATA_URL","dataFromString","string","StringData","utf8Bytes_","base64Bytes_","dataURLBytes_","dataURLContentType_","b","charCodeAt","push","valid","hi","lo","Uint8Array","percentEncodedBytes_","decoded","hasMinus","indexOf","hasUnder","invalidChar","hasPlus","hasSlash","_invalidChar","replace","bytes","atob","array","parts","DataURLParts","base64","rest","contentType","endsWith","s","end","substring","data","opt_contentType","dataURL","matches","match","middle","_interopRequireWildcard","validate","specs","passed","minArgs","maxArgs","optional","_i","validator","Error","and_","v1","v2","stringSpec","opt_validator","opt_optional","stringValidator","type","ArgSpec","uploadDataSpec","ArrayBuffer","metadataSpec","MetadataUtils","metadataValidator","nonNegativeNumberSpec","looseObjectSpec","nullFunctionSpec","_metadata","_type","self","elem","arraylike","remove","splice","noXform_","metadata","xformPath","fullPath","lastComponent","getMappings","mappings_","mappings","Mapping","nameMapping","xform","sizeMapping","size","tokens","split","map","token","urlPart","UrlUtils","makeDownloadUrl","makeQueryString","alt","addRef","authWrapper","_location","makeStorageReference","fromResource","resource","len","mapping","server","fromResourceString","resourceString","json","jsonObjectOrNull","toResourceString","JSON","stringify","_json","_path","_url","opt_local","opt_writable","opt_xform","makeNormalUrl","constants","makeUploadUrl","params","queryPart","object","nextPart","_object","taskStateFromInternalTaskState","state","InternalTaskState","RUNNING","PAUSING","CANCELING","TaskState","PAUSED","SUCCESS","ERROR","TaskEvent","STATE_CHANGED","Reference","_args","args","_blob","_requests","requests","_string","fbsString","_task","arguments","childPath","newPath","child","newRef","throwIfRoot_","UploadTask","FbsBlob","opt_metadata","getAuthToken","then","authToken","requestInfo","deleteObject","makeRequest","getPromise","getMetadata","updateMetadata","parent","service","_fs","fs","opt_elideCopy","blobType","data_","byteLength","set","size_","type_","startByte","endByte","realBlob","sliced","sliceBlob","buffer","_len","var_args","_key","blobby","getBlob","apply","uint8Arrays","finalLength","merged","lastIndexOf","canonicalChildPath","filter","component","join","handlerCheck","cndn","metadataHandler","xhr","text","sharedErrorHandler","err","newErr","getStatus","setServerResponseProp","serverResponseProp","objectErrorHandler","shared","fullServerUrl","timeout","maxOperationRetryTime","_requestinfo","RequestInfo","errorHandler","body","headers","Content-Type","successCodes","determineContentType_","blob","metadataForUpload_","multipartUpload","bucketOnlyServerUrl","X-Goog-Upload-Protocol","boundary","str","Math","random","toString","metadataString","preBlobPart","urlParams","maxUploadRetryTime","uploadData","checkResumeHeader_","opt_allowed","status","getResponseHeader","createResumableUpload","X-Goog-Upload-Command","X-Goog-Upload-Header-Content-Length","X-Goog-Upload-Header-Content-Type","getResumableUploadStatus","sizeString","parseInt","isNaN","ResumableUploadStatus","continueResumableUpload","chunkSize","opt_status","opt_progressCallback","current","total","bytesLeft","bytesToUpload","min","uploadCommand","X-Goog-Upload-Offset","uploadStatus","newCurrent","progressCallback","resumableUploadChunkSize","_array","finalized","ErrorCode","XhrIoPool","_xhrio_network","NetworkXhrIo","ServiceInternals","Service","_authwrapper","_promise_external","fbsPromiseImpl","_request","RequestExports","_reference","app","pool","bucket_","authWrapper_","AuthWrapper","app_","makeFromBucketSpec","authWrapperBucket","internals_","test","ref","time","setMaxUploadRetryTime","setMaxOperationRetryTime","service_","deleteApp","factory","unused","opt_url","_service","_xhriopool","registerStorage","INTERNAL","registerService","STORAGE_TYPE","_taskenums","Storage","_app","async","argsToForward","promiseimpl","_error2","_failrequest","_requestmap","maker","requestMaker","deleted_","options","extractBucket_","storageRefMaker_","requestMaker_","pool_","maxOperationRetryTime_","maxUploadRetryTime_","requestMap_","RequestMap","getToken","response","accessToken","FailRequest","request","addRequest","clear","config","start","callback","cancelState","triggerCallback","triggeredCallback","callWithDelay","millis","timeoutId","setTimeout","handler","success","hitTimeout","waitSeconds","waitMillis","stop","wasTimeout","stopped","clearTimeout","id","promise_","getBlobBuilder","BlobBuilder","WebKitBlobBuilder","bb","append","webkitSlice","mozSlice","parse","Observer","nextOrObserver","opt_error","opt_complete","next","complete","observer","addAuthHeader_","addVersionHeader_","number","firebase","SDK_VERSION","NetworkRequest","method","additionalRetryCodes","RequestEndStatus","_backoff","backoff","_xhrio","XhrIoExports","errorCallback","pendingXhr_","backoffId_","resolve_","reject_","canceled_","appDelete_","url_","method_","headers_","body_","successCodes_","additionalRetryCodes_","callback_","errorCallback_","progressCallback_","timeout_","start_","doTheRequest","backoffCallback","progressListener","progressEvent","loaded","lengthComputable","createXhrIo","addUploadProgressListener","send","removeUploadProgressListener","hitServer","getErrorCode","NO_ERROR","isRetryStatusCode_","wasCanceled","ABORT","successCode","backoffDone","requestWentThrough","wasSuccessCode","result","getResponseText","_err","_err2","appDelete","abort","isExtraRetryCode","isRequestSpecificRetryCode","opt_canceled","map_","id_","r","unmap","cancel","_this","sent_","xhr_","XMLHttpRequest","errorCode_","sendPromise_","addEventListener","NETWORK_ERROR","opt_body","opt_headers","_this2","open","setRequestHeader","responseText","header","listener","upload","removeEventListener","fbsTaskEnums","_observer","_tasksnapshot","fbsArgs","fbsArray","_async","fbsPromiseimpl","fbsRequests","typeUtils","transferred_","needToFetchStatus_","needToFetchMetadata_","observers_","error_","uploadUrl_","request_","chunkMultiplier_","ref_","location_","blob_","metadata_","resumable_","shouldDoResumable_","state_","errorHandler_","codeEquals","completeTransitions_","transition_","metadataErrorHandler_","sizeBefore","updateProgress_","createResumable_","fetchStatus_","fetchMetadata_","continueUpload_","oneShotUpload_","_this3","_this4","resolveToken_","createRequest","_this5","statusRequest","_this6","makeProgressCallback_","uploadRequest","newStatus","increaseMultiplier_","_this7","metadataRequest","_this8","multipartRequest","transferred","old","notifyObservers_","wasPaused","nextOrObserverValidator","nextValidator","observerValidator","nextOrObserverMessage","makeBinder","completed","addObserver_","removeObserver_","binderSpecs","onFulfilled","onRejected","notifyObserver_","_this9","finishPromise_","triggered","bind","snapshot","toCall","externalState","UploadTaskSnapshot","bytesTransferred","totalBytes","task","urls"],"mappings":"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","file":"firebase-storage.js","sourcesContent":["try {\n          webpackJsonpFirebase([0],[\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\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.isDef = isDef;\nexports.isJustDef = isJustDef;\nexports.isFunction = isFunction;\nexports.isObject = isObject;\nexports.isNonNullObject = isNonNullObject;\nexports.isNonArrayObject = isNonArrayObject;\nexports.isString = isString;\nexports.isNumber = isNumber;\nexports.isNativeBlob = isNativeBlob;\nexports.isNativeBlobDefined = isNativeBlobDefined;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @return False if the object is undefined or null, true otherwise.\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/function isDef(p) {\n    return p != null;\n}\nfunction isJustDef(p) {\n    return p !== void 0;\n}\nfunction isFunction(p) {\n    return typeof p === 'function';\n}\nfunction isObject(p) {\n    return (typeof p === 'undefined' ? 'undefined' : _typeof(p)) === 'object';\n}\nfunction isNonNullObject(p) {\n    return isObject(p) && p !== null;\n}\nfunction isNonArrayObject(p) {\n    return isObject(p) && !Array.isArray(p);\n}\nfunction isString(p) {\n    return typeof p === 'string' || p instanceof String;\n}\nfunction isNumber(p) {\n    return typeof p === 'number' || p instanceof Number;\n}\nfunction isNativeBlob(p) {\n    return isNativeBlobDefined() && p instanceof Blob;\n}\nfunction isNativeBlobDefined() {\n    return typeof Blob !== 'undefined';\n}\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Code = exports.errors = exports.FirebaseStorageError = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n\n\nexports.prependCode = prependCode;\nexports.unknown = unknown;\nexports.objectNotFound = objectNotFound;\nexports.bucketNotFound = bucketNotFound;\nexports.projectNotFound = projectNotFound;\nexports.quotaExceeded = quotaExceeded;\nexports.unauthenticated = unauthenticated;\nexports.unauthorized = unauthorized;\nexports.retryLimitExceeded = retryLimitExceeded;\nexports.invalidChecksum = invalidChecksum;\nexports.canceled = canceled;\nexports.invalidEventName = invalidEventName;\nexports.invalidUrl = invalidUrl;\nexports.invalidDefaultBucket = invalidDefaultBucket;\nexports.noDefaultBucket = noDefaultBucket;\nexports.cannotSliceBlob = cannotSliceBlob;\nexports.serverFileWrongSize = serverFileWrongSize;\nexports.noDownloadURL = noDownloadURL;\nexports.invalidArgument = invalidArgument;\nexports.invalidArgumentCount = invalidArgumentCount;\nexports.appDeleted = appDeleted;\nexports.invalidRootOperation = invalidRootOperation;\nexports.invalidFormat = invalidFormat;\nexports.internalError = internalError;\n\nvar _constants = __webpack_require__(6);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar FirebaseStorageError = exports.FirebaseStorageError = function () {\n    function FirebaseStorageError(code, message) {\n        _classCallCheck(this, FirebaseStorageError);\n\n        this.code_ = prependCode(code);\n        this.message_ = 'Firebase Storage: ' + message;\n        this.serverResponse_ = null;\n        this.name_ = 'FirebaseError';\n    }\n\n    _createClass(FirebaseStorageError, [{\n        key: 'codeProp',\n        value: function codeProp() {\n            return this.code;\n        }\n    }, {\n        key: 'codeEquals',\n        value: function codeEquals(code) {\n            return prependCode(code) === this.codeProp();\n        }\n    }, {\n        key: 'serverResponseProp',\n        value: function serverResponseProp() {\n            return this.serverResponse_;\n        }\n    }, {\n        key: 'setServerResponseProp',\n        value: function setServerResponseProp(serverResponse) {\n            this.serverResponse_ = serverResponse;\n        }\n    }, {\n        key: 'name',\n        get: function get() {\n            return this.name_;\n        }\n    }, {\n        key: 'code',\n        get: function get() {\n            return this.code_;\n        }\n    }, {\n        key: 'message',\n        get: function get() {\n            return this.message_;\n        }\n    }, {\n        key: 'serverResponse',\n        get: function get() {\n            return this.serverResponse_;\n        }\n    }]);\n\n    return FirebaseStorageError;\n}();\n\nvar errors = exports.errors = {};\nvar Code = exports.Code = {\n    // Shared between all platforms\n    UNKNOWN: 'unknown',\n    OBJECT_NOT_FOUND: 'object-not-found',\n    BUCKET_NOT_FOUND: 'bucket-not-found',\n    PROJECT_NOT_FOUND: 'project-not-found',\n    QUOTA_EXCEEDED: 'quota-exceeded',\n    UNAUTHENTICATED: 'unauthenticated',\n    UNAUTHORIZED: 'unauthorized',\n    RETRY_LIMIT_EXCEEDED: 'retry-limit-exceeded',\n    INVALID_CHECKSUM: 'invalid-checksum',\n    CANCELED: 'canceled',\n    // JS specific\n    INVALID_EVENT_NAME: 'invalid-event-name',\n    INVALID_URL: 'invalid-url',\n    INVALID_DEFAULT_BUCKET: 'invalid-default-bucket',\n    NO_DEFAULT_BUCKET: 'no-default-bucket',\n    CANNOT_SLICE_BLOB: 'cannot-slice-blob',\n    SERVER_FILE_WRONG_SIZE: 'server-file-wrong-size',\n    NO_DOWNLOAD_URL: 'no-download-url',\n    INVALID_ARGUMENT: 'invalid-argument',\n    INVALID_ARGUMENT_COUNT: 'invalid-argument-count',\n    APP_DELETED: 'app-deleted',\n    INVALID_ROOT_OPERATION: 'invalid-root-operation',\n    INVALID_FORMAT: 'invalid-format',\n    INTERNAL_ERROR: 'internal-error'\n};\nfunction prependCode(code) {\n    return 'storage/' + code;\n}\nfunction unknown() {\n    return new FirebaseStorageError(Code.UNKNOWN, 'An unknown error occurred, please check the error payload for ' + 'server response.');\n}\nfunction objectNotFound(path) {\n    return new FirebaseStorageError(Code.OBJECT_NOT_FOUND, 'Object \\'' + path + '\\' does not exist.');\n}\nfunction bucketNotFound(bucket) {\n    return new FirebaseStorageError(Code.BUCKET_NOT_FOUND, 'Bucket \\'' + bucket + '\\' does not exist.');\n}\nfunction projectNotFound(project) {\n    return new FirebaseStorageError(Code.PROJECT_NOT_FOUND, 'Project \\'' + project + '\\' does not exist.');\n}\nfunction quotaExceeded(bucket) {\n    return new FirebaseStorageError(Code.QUOTA_EXCEEDED, 'Quota for bucket \\'' + bucket + '\\' exceeded, please view quota on ' + 'https://firebase.google.com/pricing/.');\n}\nfunction unauthenticated() {\n    return new FirebaseStorageError(Code.UNAUTHENTICATED, 'User is not authenticated, please authenticate using Firebase ' + 'Authentication and try again.');\n}\nfunction unauthorized(path) {\n    return new FirebaseStorageError(Code.UNAUTHORIZED, 'User does not have permission to access \\'' + path + '\\'.');\n}\nfunction retryLimitExceeded() {\n    return new FirebaseStorageError(Code.RETRY_LIMIT_EXCEEDED, 'Max retry time for operation exceeded, please try again.');\n}\nfunction invalidChecksum(path, checksum, calculated) {\n    return new FirebaseStorageError(Code.INVALID_CHECKSUM, 'Uploaded/downloaded object \\'' + path + '\\' has checksum \\'' + checksum + '\\' which does not match \\'' + calculated + '\\'. Please retry the upload/download.');\n}\nfunction canceled() {\n    return new FirebaseStorageError(Code.CANCELED, 'User canceled the upload/download.');\n}\nfunction invalidEventName(name) {\n    return new FirebaseStorageError(Code.INVALID_EVENT_NAME, 'Invalid event name \\'' + name + '\\'.');\n}\nfunction invalidUrl(url) {\n    return new FirebaseStorageError(Code.INVALID_URL, 'Invalid URL \\'' + url + '\\'.');\n}\nfunction invalidDefaultBucket(bucket) {\n    return new FirebaseStorageError(Code.INVALID_DEFAULT_BUCKET, 'Invalid default bucket \\'' + bucket + '\\'.');\n}\nfunction noDefaultBucket() {\n    return new FirebaseStorageError(Code.NO_DEFAULT_BUCKET, 'No default bucket ' + 'found. Did you set the \\'' + _constants.configOption + '\\' property when initializing the app?');\n}\nfunction cannotSliceBlob() {\n    return new FirebaseStorageError(Code.CANNOT_SLICE_BLOB, 'Cannot slice blob for upload. Please retry the upload.');\n}\nfunction serverFileWrongSize() {\n    return new FirebaseStorageError(Code.SERVER_FILE_WRONG_SIZE, 'Server recorded incorrect upload file size, please retry the upload.');\n}\nfunction noDownloadURL() {\n    return new FirebaseStorageError(Code.NO_DOWNLOAD_URL, 'The given file does not have any download URLs.');\n}\nfunction invalidArgument(index, fnName, message) {\n    return new FirebaseStorageError(Code.INVALID_ARGUMENT, 'Invalid argument in `' + fnName + '` at index ' + index + ': ' + message);\n}\nfunction invalidArgumentCount(argMin, argMax, fnName, real) {\n    var countPart = void 0;\n    var plural = void 0;\n    if (argMin === argMax) {\n        countPart = argMin;\n        plural = argMin === 1 ? 'argument' : 'arguments';\n    } else {\n        countPart = 'between ' + argMin + ' and ' + argMax;\n        plural = 'arguments';\n    }\n    return new FirebaseStorageError(Code.INVALID_ARGUMENT_COUNT, 'Invalid argument count in `' + fnName + '`: Expected ' + countPart + ' ' + plural + ', received ' + real + '.');\n}\nfunction appDeleted() {\n    return new FirebaseStorageError(Code.APP_DELETED, 'The Firebase app was deleted.');\n}\n/**\n * @param name The name of the operation that was invalid.\n */\nfunction invalidRootOperation(name) {\n    return new FirebaseStorageError(Code.INVALID_ROOT_OPERATION, 'The operation \\'' + name + '\\' cannot be performed on a root reference, create a non-root ' + 'reference using child, such as .child(\\'file.png\\').');\n}\n/**\n * @param format The format that was not valid.\n * @param message A message describing the format violation.\n */\nfunction invalidFormat(format, message) {\n    return new FirebaseStorageError(Code.INVALID_FORMAT, 'String does not match format \\'' + format + '\\': ' + message);\n}\n/**\n * @param message A message describing the internal error.\n */\nfunction internalError(message) {\n    throw new FirebaseStorageError(Code.INTERNAL_ERROR, 'Internal error: ' + message);\n}\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.make = make;\nexports.resolve = resolve;\nexports.reject = reject;\n\nvar _shared_promise = __webpack_require__(10);\n\nfunction make(resolver) {\n  return new _shared_promise.local.Promise(resolver);\n}\n/**\n * @template T\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Implements the promise abstraction interface for external\n * (public SDK) packaging, which just passes through to the firebase-app impl.\n */\n/**\n * @template T\n * @param {function((function(T): void),\n *                  (function(!Error): void))} resolver\n */\nfunction resolve(value) {\n  return _shared_promise.local.Promise.resolve(value);\n}\nfunction reject(error) {\n  return _shared_promise.local.Promise.reject(error);\n}\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.contains = contains;\nexports.forEach = forEach;\nexports.clone = clone;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Contains methods for working with objects.\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/function contains(obj, prop) {\n    return Object.prototype.hasOwnProperty.call(obj, prop);\n}\nfunction forEach(obj, f) {\n    for (var key in obj) {\n        if (contains(obj, key)) {\n            f(key, obj[key]);\n        }\n    }\n}\nfunction clone(obj) {\n    if (obj == null) {\n        return {};\n    }\n    var c = {};\n    forEach(obj, function (key, val) {\n        c[key] = val;\n    });\n    return c;\n}\n\n/***/ }),\n/* 4 */,\n/* 5 */,\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.setDomainBase = setDomainBase;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Constants used in the Firebase Storage library.\n */\n/**\n * Domain and scheme for API calls.\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/var domainBase = exports.domainBase = 'https://firebasestorage.googleapis.com';\n/**\n * Domain and scheme for object downloads.\n */\nvar downloadBase = exports.downloadBase = 'https://firebasestorage.googleapis.com';\n/**\n * Base URL for non-upload calls to the API.\n */\nvar apiBaseUrl = exports.apiBaseUrl = '/v0';\n/**\n * Base URL for upload calls to the API.\n */\nvar apiUploadBaseUrl = exports.apiUploadBaseUrl = '/v0';\nfunction setDomainBase(domainBase) {\n  domainBase = domainBase;\n}\nvar configOption = exports.configOption = 'storageBucket';\n/**\n * 1 minute\n */\nvar shortMaxOperationRetryTime = exports.shortMaxOperationRetryTime = 1 * 60 * 1000;\n/**\n * 2 minutes\n */\nvar defaultMaxOperationRetryTime = exports.defaultMaxOperationRetryTime = 2 * 60 * 1000;\n/**\n * 10 minutes\n */\nvar defaultMaxUploadRetryTime = exports.defaultMaxUploadRetryTime = 10 * 60 * 100;\n/**\n * This is the value of Number.MIN_SAFE_INTEGER, which is not well supported\n * enough for us to use it directly.\n */\nvar minSafeInteger = exports.minSafeInteger = -9007199254740991;\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Location = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n/**\n * @fileoverview Functionality related to the parsing/composition of bucket/\n * object location.\n */\n\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * @struct\n */\nvar Location = exports.Location = function () {\n    function Location(bucket, path) {\n        _classCallCheck(this, Location);\n\n        this.bucket = bucket;\n        this.path_ = path;\n    }\n\n    _createClass(Location, [{\n        key: 'fullServerUrl',\n        value: function fullServerUrl() {\n            var encode = encodeURIComponent;\n            return '/b/' + encode(this.bucket) + '/o/' + encode(this.path);\n        }\n    }, {\n        key: 'bucketOnlyServerUrl',\n        value: function bucketOnlyServerUrl() {\n            var encode = encodeURIComponent;\n            return '/b/' + encode(this.bucket) + '/o';\n        }\n    }, {\n        key: 'path',\n        get: function get() {\n            return this.path_;\n        }\n    }], [{\n        key: 'makeFromBucketSpec',\n        value: function makeFromBucketSpec(bucketString) {\n            var bucketLocation = void 0;\n            try {\n                bucketLocation = Location.makeFromUrl(bucketString);\n            } catch (e) {\n                // Not valid URL, use as-is. This lets you put bare bucket names in\n                // config.\n                return new Location(bucketString, '');\n            }\n            if (bucketLocation.path === '') {\n                return bucketLocation;\n            } else {\n                throw errorsExports.invalidDefaultBucket(bucketString);\n            }\n        }\n    }, {\n        key: 'makeFromUrl',\n        value: function makeFromUrl(url) {\n            var location = null;\n            var bucketDomain = '([A-Za-z0-9.\\\\-]+)';\n\n            var gsRegex = new RegExp('^gs://' + bucketDomain + '(/(.*))?$', 'i');\n\n            var httpRegex = new RegExp('^https?://firebasestorage\\\\.googleapis\\\\.com/' + 'v[A-Za-z0-9_]+' + '/b/' + bucketDomain + '/o' + '(/([^?#]*).*)?$', 'i');\n\n            var groups = [{ regex: gsRegex, indices: { bucket: 1, path: 3 }, postModify: function (loc) {\n                    if (loc.path.charAt(loc.path.length - 1) === '/') {\n                        loc.path_ = loc.path_.slice(0, -1);\n                    }\n                } }, { regex: httpRegex, indices: { bucket: 1, path: 3 }, postModify: function (loc) {\n                    loc.path_ = decodeURIComponent(loc.path);\n                } }];\n            for (var i = 0; i < groups.length; i++) {\n                var group = groups[i];\n                var captures = group.regex.exec(url);\n                if (captures) {\n                    var bucketValue = captures[group.indices.bucket];\n                    var pathValue = captures[group.indices.path];\n                    if (!pathValue) {\n                        pathValue = '';\n                    }\n                    location = new Location(bucketValue, pathValue);\n                    group.postModify(location);\n                    break;\n                }\n            }\n            if (location == null) {\n                throw errorsExports.invalidUrl(url);\n            }\n            return location;\n        }\n    }]);\n\n    return Location;\n}();\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.StringData = exports.StringFormat = undefined;\nexports.formatValidator = formatValidator;\nexports.dataFromString = dataFromString;\nexports.utf8Bytes_ = utf8Bytes_;\nexports.percentEncodedBytes_ = percentEncodedBytes_;\nexports.base64Bytes_ = base64Bytes_;\nexports.dataURLBytes_ = dataURLBytes_;\nexports.dataURLContentType_ = dataURLContentType_;\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /**\n                                                                                                                                                          * Copyright 2017 Google Inc.\n                                                                                                                                                          *\n                                                                                                                                                          * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                          * you may not use this file except in compliance with the License.\n                                                                                                                                                          * You may obtain a copy of the License at\n                                                                                                                                                          *\n                                                                                                                                                          *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                          *\n                                                                                                                                                          * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                          * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                          * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                          * See the License for the specific language governing permissions and\n                                                                                                                                                          * limitations under the License.\n                                                                                                                                                          */\n\n\nvar StringFormat = exports.StringFormat = {\n    RAW: 'raw',\n    BASE64: 'base64',\n    BASE64URL: 'base64url',\n    DATA_URL: 'data_url'\n};\nfunction formatValidator(stringFormat) {\n    switch (stringFormat) {\n        case StringFormat.RAW:\n        case StringFormat.BASE64:\n        case StringFormat.BASE64URL:\n        case StringFormat.DATA_URL:\n            return;\n        default:\n            throw 'Expected one of the event types: [' + StringFormat.RAW + ', ' + StringFormat.BASE64 + ', ' + StringFormat.BASE64URL + ', ' + StringFormat.DATA_URL + '].';\n    }\n}\n/**\n * @struct\n */\n\nvar StringData = exports.StringData = function StringData(data, opt_contentType) {\n    _classCallCheck(this, StringData);\n\n    this.data = data;\n    this.contentType = opt_contentType || null;\n};\n\nfunction dataFromString(format, string) {\n    switch (format) {\n        case StringFormat.RAW:\n            return new StringData(utf8Bytes_(string));\n        case StringFormat.BASE64:\n        case StringFormat.BASE64URL:\n            return new StringData(base64Bytes_(format, string));\n        case StringFormat.DATA_URL:\n            return new StringData(dataURLBytes_(string), dataURLContentType_(string));\n    }\n    // assert(false);\n    throw errorsExports.unknown();\n}\nfunction utf8Bytes_(string) {\n    var b = [];\n    for (var i = 0; i < string.length; i++) {\n        var c = string.charCodeAt(i);\n        if (c <= 127) {\n            b.push(c);\n        } else {\n            if (c <= 2047) {\n                b.push(192 | c >> 6, 128 | c & 63);\n            } else {\n                if ((c & 64512) == 55296) {\n                    // The start of a surrogate pair.\n                    var valid = i < string.length - 1 && (string.charCodeAt(i + 1) & 64512) == 56320;\n                    if (!valid) {\n                        // The second surrogate wasn't there.\n                        b.push(239, 191, 189);\n                    } else {\n                        var hi = c;\n                        var lo = string.charCodeAt(++i);\n                        c = 65536 | (hi & 1023) << 10 | lo & 1023;\n                        b.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);\n                    }\n                } else {\n                    if ((c & 64512) == 56320) {\n                        // Invalid low surrogate.\n                        b.push(239, 191, 189);\n                    } else {\n                        b.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);\n                    }\n                }\n            }\n        }\n    }\n    return new Uint8Array(b);\n}\nfunction percentEncodedBytes_(string) {\n    var decoded = void 0;\n    try {\n        decoded = decodeURIComponent(string);\n    } catch (e) {\n        throw errorsExports.invalidFormat(StringFormat.DATA_URL, 'Malformed data URL.');\n    }\n    return utf8Bytes_(decoded);\n}\nfunction base64Bytes_(format, string) {\n    switch (format) {\n        case StringFormat.BASE64:\n            {\n                var hasMinus = string.indexOf('-') !== -1;\n                var hasUnder = string.indexOf('_') !== -1;\n                if (hasMinus || hasUnder) {\n                    var invalidChar = hasMinus ? '-' : '_';\n                    throw errorsExports.invalidFormat(format, 'Invalid character \\'' + invalidChar + '\\' found: is it base64url encoded?');\n                }\n                break;\n            }\n        case StringFormat.BASE64URL:\n            {\n                var hasPlus = string.indexOf('+') !== -1;\n                var hasSlash = string.indexOf('/') !== -1;\n                if (hasPlus || hasSlash) {\n                    var _invalidChar = hasPlus ? '+' : '/';\n                    throw errorsExports.invalidFormat(format, 'Invalid character \\'' + _invalidChar + '\\' found: is it base64 encoded?');\n                }\n                string = string.replace(/-/g, '+').replace(/_/g, '/');\n                break;\n            }\n    }\n    var bytes = void 0;\n    try {\n        bytes = atob(string);\n    } catch (e) {\n        throw errorsExports.invalidFormat(format, 'Invalid character found');\n    }\n    var array = new Uint8Array(bytes.length);\n    for (var i = 0; i < bytes.length; i++) {\n        array[i] = bytes.charCodeAt(i);\n    }\n    return array;\n}\n/**\n * @struct\n */\n\nvar DataURLParts = function DataURLParts(dataURL) {\n    _classCallCheck(this, DataURLParts);\n\n    this.base64 = false;\n    this.contentType = null;\n    var matches = dataURL.match(/^data:([^,]+)?,/);\n    if (matches === null) {\n        throw errorsExports.invalidFormat(StringFormat.DATA_URL, 'Must be formatted \\'data:[<mediatype>][;base64],<data>');\n    }\n    var middle = matches[1] || null;\n    if (middle != null) {\n        this.base64 = endsWith(middle, ';base64');\n        this.contentType = this.base64 ? middle.substring(0, middle.length - ';base64'.length) : middle;\n    }\n    this.rest = dataURL.substring(dataURL.indexOf(',') + 1);\n};\n\nfunction dataURLBytes_(string) {\n    var parts = new DataURLParts(string);\n    if (parts.base64) {\n        return base64Bytes_(StringFormat.BASE64, parts.rest);\n    } else {\n        return percentEncodedBytes_(parts.rest);\n    }\n}\nfunction dataURLContentType_(string) {\n    var parts = new DataURLParts(string);\n    return parts.contentType;\n}\nfunction endsWith(s, end) {\n    var longEnough = s.length >= end.length;\n    if (!longEnough) {\n        return false;\n    }\n    return s.substring(s.length - end.length) === end;\n}\n\n/***/ }),\n/* 9 */,\n/* 10 */,\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.ArgSpec = undefined;\nexports.validate = validate;\nexports.and_ = and_;\nexports.stringSpec = stringSpec;\nexports.uploadDataSpec = uploadDataSpec;\nexports.metadataSpec = metadataSpec;\nexports.nonNegativeNumberSpec = nonNegativeNumberSpec;\nexports.looseObjectSpec = looseObjectSpec;\nexports.nullFunctionSpec = nullFunctionSpec;\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nvar _metadata = __webpack_require__(13);\n\nvar MetadataUtils = _interopRequireWildcard(_metadata);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /**\n                                                                                                                                                          * Copyright 2017 Google Inc.\n                                                                                                                                                          *\n                                                                                                                                                          * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                          * you may not use this file except in compliance with the License.\n                                                                                                                                                          * You may obtain a copy of the License at\n                                                                                                                                                          *\n                                                                                                                                                          *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                          *\n                                                                                                                                                          * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                          * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                          * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                          * See the License for the specific language governing permissions and\n                                                                                                                                                          * limitations under the License.\n                                                                                                                                                          */\n\n\n/**\n * @param name Name of the function.\n * @param specs Argument specs.\n * @param passed The actual arguments passed to the function.\n * @throws {fbs.Error} If the arguments are invalid.\n */\nfunction validate(name, specs, passed) {\n    var minArgs = specs.length;\n    var maxArgs = specs.length;\n    for (var i = 0; i < specs.length; i++) {\n        if (specs[i].optional) {\n            minArgs = i;\n            break;\n        }\n    }\n    var validLength = minArgs <= passed.length && passed.length <= maxArgs;\n    if (!validLength) {\n        throw errorsExports.invalidArgumentCount(minArgs, maxArgs, name, passed.length);\n    }\n    for (var _i = 0; _i < passed.length; _i++) {\n        try {\n            specs[_i].validator(passed[_i]);\n        } catch (e) {\n            if (e instanceof Error) {\n                throw errorsExports.invalidArgument(_i, name, e.message);\n            } else {\n                throw errorsExports.invalidArgument(_i, name, e);\n            }\n        }\n    }\n}\n/**\n * @struct\n */\n\nvar ArgSpec = exports.ArgSpec = function ArgSpec(validator, opt_optional) {\n    _classCallCheck(this, ArgSpec);\n\n    var self = this;\n    this.validator = function (p) {\n        if (self.optional && !type.isJustDef(p)) {\n            return;\n        }\n        validator(p);\n    };\n    this.optional = !!opt_optional;\n};\n\nfunction and_(v1, v2) {\n    return function (p) {\n        v1(p);\n        v2(p);\n    };\n}\nfunction stringSpec(opt_validator, opt_optional) {\n    function stringValidator(p) {\n        if (!type.isString(p)) {\n            throw 'Expected string.';\n        }\n    }\n    var validator = void 0;\n    if (opt_validator) {\n        validator = and_(stringValidator, opt_validator);\n    } else {\n        validator = stringValidator;\n    }\n    return new ArgSpec(validator, opt_optional);\n}\nfunction uploadDataSpec() {\n    return new ArgSpec(function (p) {\n        var valid = p instanceof Uint8Array || p instanceof ArrayBuffer || type.isNativeBlobDefined() && p instanceof Blob;\n        if (!valid) {\n            throw 'Expected Blob or File.';\n        }\n    });\n}\nfunction metadataSpec(opt_optional) {\n    return new ArgSpec(MetadataUtils.metadataValidator, opt_optional);\n}\nfunction nonNegativeNumberSpec() {\n    return new ArgSpec(function (p) {\n        var valid = type.isNumber(p) && p >= 0;\n        if (!valid) {\n            throw 'Expected a number 0 or greater.';\n        }\n    });\n}\nfunction looseObjectSpec(opt_validator, opt_optional) {\n    return new ArgSpec(function (p) {\n        var isLooseObject = p === null || type.isDef(p) && p instanceof Object;\n        if (!isLooseObject) {\n            throw 'Expected an Object.';\n        }\n        if (opt_validator !== undefined && opt_validator !== null) {\n            opt_validator(p);\n        }\n    }, opt_optional);\n}\nfunction nullFunctionSpec(opt_optional) {\n    return new ArgSpec(function (p) {\n        var valid = p === null || type.isFunction(p);\n        if (!valid) {\n            throw 'Expected a Function.';\n        }\n    }, opt_optional);\n}\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.contains = contains;\nexports.clone = clone;\nexports.remove = remove;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * Returns true if the object is contained in the array (compared with ===).\n * @template T\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/function contains(array, elem) {\n    return array.indexOf(elem) !== -1;\n}\n/**\n * Returns a shallow copy of the array or array-like object (e.g. arguments).\n * @template T\n */\nfunction clone(arraylike) {\n    return Array.prototype.slice.call(arraylike);\n}\n/**\n * Removes the given element from the given array, if it is contained.\n * Directly modifies the passed-in array.\n * @template T\n */\nfunction remove(array, elem) {\n    var i = array.indexOf(elem);\n    if (i !== -1) {\n        array.splice(i, 1);\n    }\n}\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Mapping = undefined;\nexports.noXform_ = noXform_;\nexports.xformPath = xformPath;\nexports.getMappings = getMappings;\nexports.addRef = addRef;\nexports.fromResource = fromResource;\nexports.fromResourceString = fromResourceString;\nexports.toResourceString = toResourceString;\nexports.metadataValidator = metadataValidator;\n\nvar _json = __webpack_require__(43);\n\nvar json = _interopRequireWildcard(_json);\n\nvar _location = __webpack_require__(7);\n\nvar _path = __webpack_require__(23);\n\nvar path = _interopRequireWildcard(_path);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nvar _url = __webpack_require__(14);\n\nvar UrlUtils = _interopRequireWildcard(_url);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /**\n                                                                                                                                                          * Copyright 2017 Google Inc.\n                                                                                                                                                          *\n                                                                                                                                                          * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                          * you may not use this file except in compliance with the License.\n                                                                                                                                                          * You may obtain a copy of the License at\n                                                                                                                                                          *\n                                                                                                                                                          *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                          *\n                                                                                                                                                          * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                          * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                          * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                          * See the License for the specific language governing permissions and\n                                                                                                                                                          * limitations under the License.\n                                                                                                                                                          */\n\n\nfunction noXform_(metadata, value) {\n    return value;\n}\n/**\n * @struct\n */\n\nvar Mapping = exports.Mapping = function Mapping(server, opt_local, opt_writable, opt_xform) {\n    _classCallCheck(this, Mapping);\n\n    this.server = server;\n    this.local = opt_local || server;\n    this.writable = !!opt_writable;\n    this.xform = opt_xform || noXform_;\n};\n\nvar mappings_ = null;\nfunction xformPath(fullPath) {\n    var valid = type.isString(fullPath);\n    if (!valid || fullPath.length < 2) {\n        return fullPath;\n    } else {\n        fullPath = fullPath;\n        return path.lastComponent(fullPath);\n    }\n}\nfunction getMappings() {\n    if (mappings_) {\n        return mappings_;\n    }\n    var mappings = [];\n    mappings.push(new Mapping('bucket'));\n    mappings.push(new Mapping('generation'));\n    mappings.push(new Mapping('metageneration'));\n    mappings.push(new Mapping('name', 'fullPath', true));\n\n    var nameMapping = new Mapping('name');\n    nameMapping.xform = function (metadata, fullPath) {\n        return xformPath(fullPath);\n    };\n    mappings.push(nameMapping);\n    /**\n     * Coerces the second param to a number, if it is defined.\n     */\n\n    var sizeMapping = new Mapping('size');\n    sizeMapping.xform = function (metadata, size) {\n        if (type.isDef(size)) {\n            return +size;\n        } else {\n            return size;\n        }\n    };\n    mappings.push(sizeMapping);\n    mappings.push(new Mapping('timeCreated'));\n    mappings.push(new Mapping('updated'));\n    mappings.push(new Mapping('md5Hash', null, true));\n    mappings.push(new Mapping('cacheControl', null, true));\n    mappings.push(new Mapping('contentDisposition', null, true));\n    mappings.push(new Mapping('contentEncoding', null, true));\n    mappings.push(new Mapping('contentLanguage', null, true));\n    mappings.push(new Mapping('contentType', null, true));\n    mappings.push(new Mapping('metadata', 'customMetadata', true));\n    /**\n     * Transforms a comma-separated string of tokens into a list of download\n     * URLs.\n     */\n\n    mappings.push(new Mapping('downloadTokens', 'downloadURLs', false, function (metadata, tokens) {\n        var valid = type.isString(tokens) && tokens.length > 0;\n        if (!valid) {\n            // This can happen if objects are uploaded through GCS and retrieved\n            // through list, so we don't want to throw an Error.\n            return [];\n        }\n        var encode = encodeURIComponent;\n        var tokensList = tokens.split(',');\n        var urls = tokensList.map(function (token) {\n            var bucket = metadata['bucket'];\n            var path = metadata['fullPath'];\n            var urlPart = '/b/' + encode(bucket) + '/o/' + encode(path);\n            var base = UrlUtils.makeDownloadUrl(urlPart);\n            var queryString = UrlUtils.makeQueryString({ 'alt': 'media', 'token': token });\n            return base + queryString;\n        });\n        return urls;\n    }));\n    mappings_ = mappings;\n    return mappings_;\n}\nfunction addRef(metadata, authWrapper) {\n    Object.defineProperty(metadata, 'ref', { get: function () {\n            var bucket = metadata['bucket'];\n            var path = metadata['fullPath'];\n            var loc = new _location.Location(bucket, path);\n            return authWrapper.makeStorageReference(loc);\n        } });\n}\nfunction fromResource(authWrapper, resource, mappings) {\n    var metadata = {};\n    metadata['type'] = 'file';\n    var len = mappings.length;\n    for (var i = 0; i < len; i++) {\n        var mapping = mappings[i];\n        metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);\n    }\n    addRef(metadata, authWrapper);\n    return metadata;\n}\nfunction fromResourceString(authWrapper, resourceString, mappings) {\n    var obj = json.jsonObjectOrNull(resourceString);\n    if (obj === null) {\n        return null;\n    }\n\n    return fromResource(authWrapper, obj, mappings);\n}\nfunction toResourceString(metadata, mappings) {\n    var resource = {};\n    var len = mappings.length;\n    for (var i = 0; i < len; i++) {\n        var mapping = mappings[i];\n        if (mapping.writable) {\n            resource[mapping.server] = metadata[mapping.local];\n        }\n    }\n    return JSON.stringify(resource);\n}\nfunction metadataValidator(p) {\n    var validType = p && type.isObject(p);\n    if (!validType) {\n        throw 'Expected Metadata object.';\n    }\n    for (var key in p) {\n        var val = p[key];\n        if (key === 'customMetadata') {\n            if (!type.isObject(val)) {\n                throw 'Expected object for \\'customMetadata\\' mapping.';\n            }\n        } else {\n            if (type.isNonNullObject(val)) {\n                throw 'Mapping for \\'' + key + '\\' cannot be an object.';\n            }\n        }\n    }\n}\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.makeNormalUrl = makeNormalUrl;\nexports.makeDownloadUrl = makeDownloadUrl;\nexports.makeUploadUrl = makeUploadUrl;\nexports.makeQueryString = makeQueryString;\n\nvar _constants = __webpack_require__(6);\n\nvar constants = _interopRequireWildcard(_constants);\n\nvar _object = __webpack_require__(3);\n\nvar object = _interopRequireWildcard(_object);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Functions to create and manipulate URLs for the server API.\n */\nfunction makeNormalUrl(urlPart) {\n    return constants.domainBase + constants.apiBaseUrl + urlPart;\n}\nfunction makeDownloadUrl(urlPart) {\n    return constants.downloadBase + constants.apiBaseUrl + urlPart;\n}\nfunction makeUploadUrl(urlPart) {\n    return constants.domainBase + constants.apiUploadBaseUrl + urlPart;\n}\nfunction makeQueryString(params) {\n    var encode = encodeURIComponent;\n    var queryPart = '?';\n    object.forEach(params, function (key, val) {\n        var nextPart = encode(key) + '=' + encode(val);\n        queryPart = queryPart + nextPart + '&';\n    });\n    // Chop off the extra '&' or '?' on the end\n    queryPart = queryPart.slice(0, -1);\n    return queryPart;\n}\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.taskStateFromInternalTaskState = taskStateFromInternalTaskState;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nvar TaskEvent = exports.TaskEvent = {\n    /** Triggered whenever the task changes or progress is updated. */\n    STATE_CHANGED: 'state_changed'\n};\nvar InternalTaskState = exports.InternalTaskState = {\n    RUNNING: 'running',\n    PAUSING: 'pausing',\n    PAUSED: 'paused',\n    SUCCESS: 'success',\n    CANCELING: 'canceling',\n    CANCELED: 'canceled',\n    ERROR: 'error'\n};\nvar TaskState = exports.TaskState = {\n    /** The task is currently transferring data. */\n    RUNNING: 'running',\n    /** The task was paused by the user. */\n    PAUSED: 'paused',\n    /** The task completed successfully. */\n    SUCCESS: 'success',\n    /** The task was canceled. */\n    CANCELED: 'canceled',\n    /** The task failed with an error. */\n    ERROR: 'error'\n};\nfunction taskStateFromInternalTaskState(state) {\n    switch (state) {\n        case InternalTaskState.RUNNING:\n        case InternalTaskState.PAUSING:\n        case InternalTaskState.CANCELING:\n            return TaskState.RUNNING;\n        case InternalTaskState.PAUSED:\n            return TaskState.PAUSED;\n        case InternalTaskState.SUCCESS:\n            return TaskState.SUCCESS;\n        case InternalTaskState.CANCELED:\n            return TaskState.CANCELED;\n        case InternalTaskState.ERROR:\n            return TaskState.ERROR;\n        default:\n            // TODO(andysoto): assert(false);\n            return TaskState.ERROR;\n    }\n}\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Reference = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n/**\n * @fileoverview Defines the Firebase Storage Reference class.\n */\n\n\nvar _args = __webpack_require__(11);\n\nvar args = _interopRequireWildcard(_args);\n\nvar _blob = __webpack_require__(22);\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nvar _location = __webpack_require__(7);\n\nvar _metadata = __webpack_require__(13);\n\nvar metadata = _interopRequireWildcard(_metadata);\n\nvar _object = __webpack_require__(3);\n\nvar object = _interopRequireWildcard(_object);\n\nvar _path = __webpack_require__(23);\n\nvar path = _interopRequireWildcard(_path);\n\nvar _requests = __webpack_require__(24);\n\nvar requests = _interopRequireWildcard(_requests);\n\nvar _string = __webpack_require__(8);\n\nvar fbsString = _interopRequireWildcard(_string);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nvar _task = __webpack_require__(49);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Provides methods to interact with a bucket in the Firebase Storage service.\n * @param location An fbs.location, or the URL at\n *     which to base this object, in one of the following forms:\n *         gs://<bucket>/<object-path>\n *         http[s]://firebasestorage.googleapis.com/\n *                     <api-version>/b/<bucket>/o/<object-path>\n *     Any query or fragment strings will be ignored in the http[s]\n *     format. If no value is passed, the storage object will use a URL based on\n *     the project ID of the base firebase.App instance.\n */\nvar Reference = exports.Reference = function () {\n    function Reference(authWrapper, location) {\n        _classCallCheck(this, Reference);\n\n        this.authWrapper = authWrapper;\n        if (location instanceof _location.Location) {\n            this.location = location;\n        } else {\n            this.location = _location.Location.makeFromUrl(location);\n        }\n    }\n    /**\n     * @return The URL for the bucket and path this object references,\n     *     in the form gs://<bucket>/<object-path>\n     * @override\n     */\n\n\n    _createClass(Reference, [{\n        key: 'toString',\n        value: function toString() {\n            args.validate('toString', [], arguments);\n            return 'gs://' + this.location.bucket + '/' + this.location.path;\n        }\n    }, {\n        key: 'newRef',\n        value: function newRef(authWrapper, location) {\n            return new Reference(authWrapper, location);\n        }\n    }, {\n        key: 'mappings',\n        value: function mappings() {\n            return metadata.getMappings();\n        }\n        /**\n         * @return A reference to the object obtained by\n         *     appending childPath, removing any duplicate, beginning, or trailing\n         *     slashes.\n         */\n\n    }, {\n        key: 'child',\n        value: function child(childPath) {\n            args.validate('child', [args.stringSpec()], arguments);\n            var newPath = path.child(this.location.path, childPath);\n            var location = new _location.Location(this.location.bucket, newPath);\n            return this.newRef(this.authWrapper, location);\n        }\n        /**\n         * @return A reference to the parent of the\n         *     current object, or null if the current object is the root.\n         */\n\n    }, {\n        key: 'put',\n\n        /**\n         * Uploads a blob to this object's location.\n         * @param data The blob to upload.\n         * @return An UploadTask that lets you control and\n         *     observe the upload.\n         */\n        value: function put(data) {\n            var metadata = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n\n            args.validate('put', [args.uploadDataSpec(), args.metadataSpec(true)], arguments);\n            this.throwIfRoot_('put');\n            return new _task.UploadTask(this, this.authWrapper, this.location, this.mappings(), new _blob.FbsBlob(data), metadata);\n        }\n        /**\n         * Uploads a string to this object's location.\n         * @param string The string to upload.\n         * @param opt_format The format of the string to upload.\n         * @return An UploadTask that lets you control and\n         *     observe the upload.\n         */\n\n    }, {\n        key: 'putString',\n        value: function putString(string) {\n            var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _string.StringFormat.RAW;\n            var opt_metadata = arguments[2];\n\n            args.validate('putString', [args.stringSpec(), args.stringSpec(fbsString.formatValidator, true), args.metadataSpec(true)], arguments);\n            this.throwIfRoot_('putString');\n            var data = fbsString.dataFromString(format, string);\n            var metadata = object.clone(opt_metadata);\n            if (!type.isDef(metadata['contentType']) && type.isDef(data.contentType)) {\n                metadata['contentType'] = data.contentType;\n            }\n            return new _task.UploadTask(this, this.authWrapper, this.location, this.mappings(), new _blob.FbsBlob(data.data, true), metadata);\n        }\n        /**\n         * Deletes the object at this location.\n         * @return A promise that resolves if the deletion succeeds.\n         */\n\n    }, {\n        key: 'delete',\n        value: function _delete() {\n            args.validate('delete', [], arguments);\n            this.throwIfRoot_('delete');\n            var self = this;\n            return this.authWrapper.getAuthToken().then(function (authToken) {\n                var requestInfo = requests.deleteObject(self.authWrapper, self.location);\n                return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();\n            });\n        }\n        /**\n         *     A promise that resolves with the metadata for this object. If this\n         *     object doesn't exist or metadata cannot be retreived, the promise is\n         *     rejected.\n         */\n\n    }, {\n        key: 'getMetadata',\n        value: function getMetadata() {\n            args.validate('getMetadata', [], arguments);\n            this.throwIfRoot_('getMetadata');\n            var self = this;\n            return this.authWrapper.getAuthToken().then(function (authToken) {\n                var requestInfo = requests.getMetadata(self.authWrapper, self.location, self.mappings());\n                return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();\n            });\n        }\n        /**\n         * Updates the metadata for this object.\n         * @param metadata The new metadata for the object.\n         *     Only values that have been explicitly set will be changed. Explicitly\n         *     setting a value to null will remove the metadata.\n         * @return A promise that resolves\n         *     with the new metadata for this object.\n         *     @see firebaseStorage.Reference.prototype.getMetadata\n         */\n\n    }, {\n        key: 'updateMetadata',\n        value: function updateMetadata(metadata) {\n            args.validate('updateMetadata', [args.metadataSpec()], arguments);\n            this.throwIfRoot_('updateMetadata');\n            var self = this;\n            return this.authWrapper.getAuthToken().then(function (authToken) {\n                var requestInfo = requests.updateMetadata(self.authWrapper, self.location, metadata, self.mappings());\n                return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();\n            });\n        }\n        /**\n         * @return A promise that resolves with the download\n         *     URL for this object.\n         */\n\n    }, {\n        key: 'getDownloadURL',\n        value: function getDownloadURL() {\n            args.validate('getDownloadURL', [], arguments);\n            this.throwIfRoot_('getDownloadURL');\n            return this.getMetadata().then(function (metadata) {\n                var url = metadata['downloadURLs'][0];\n                if (type.isDef(url)) {\n                    return url;\n                } else {\n                    throw errorsExports.noDownloadURL();\n                }\n            });\n        }\n    }, {\n        key: 'throwIfRoot_',\n        value: function throwIfRoot_(name) {\n            if (this.location.path === '') {\n                throw errorsExports.invalidRootOperation(name);\n            }\n        }\n    }, {\n        key: 'parent',\n        get: function get() {\n            var newPath = path.parent(this.location.path);\n            if (newPath === null) {\n                return null;\n            }\n            var location = new _location.Location(this.location.bucket, newPath);\n            return this.newRef(this.authWrapper, location);\n        }\n        /**\n         * @return An reference to the root of this\n         *     object's bucket.\n         */\n\n    }, {\n        key: 'root',\n        get: function get() {\n            var location = new _location.Location(this.location.bucket, '');\n            return this.newRef(this.authWrapper, location);\n        }\n    }, {\n        key: 'bucket',\n        get: function get() {\n            return this.location.bucket;\n        }\n    }, {\n        key: 'fullPath',\n        get: function get() {\n            return this.location.path;\n        }\n    }, {\n        key: 'name',\n        get: function get() {\n            return path.lastComponent(this.location.path);\n        }\n    }, {\n        key: 'storage',\n        get: function get() {\n            return this.authWrapper.service();\n        }\n    }]);\n\n    return Reference;\n}();\n\n/***/ }),\n/* 17 */,\n/* 18 */,\n/* 19 */,\n/* 20 */,\n/* 21 */,\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.FbsBlob = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n/**\n * @file Provides a Blob-like wrapper for various binary types (including the\n * native Blob type). This makes it possible to upload types like ArrayBuffers,\n * making uploads possible in environments without the native Blob type.\n */\n\n\nvar _fs = __webpack_require__(42);\n\nvar fs = _interopRequireWildcard(_fs);\n\nvar _string = __webpack_require__(8);\n\nvar string = _interopRequireWildcard(_string);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * @param opt_elideCopy If true, doesn't copy mutable input data\n *     (e.g. Uint8Arrays). Pass true only if you know the objects will not be\n *     modified after this blob's construction.\n */\nvar FbsBlob = exports.FbsBlob = function () {\n    function FbsBlob(data, opt_elideCopy) {\n        _classCallCheck(this, FbsBlob);\n\n        var size = 0;\n        var blobType = '';\n        if (type.isNativeBlob(data)) {\n            this.data_ = data;\n            size = data.size;\n            blobType = data.type;\n        } else if (data instanceof ArrayBuffer) {\n            if (opt_elideCopy) {\n                this.data_ = new Uint8Array(data);\n            } else {\n                this.data_ = new Uint8Array(data.byteLength);\n                this.data_.set(new Uint8Array(data));\n            }\n            size = this.data_.length;\n        } else if (data instanceof Uint8Array) {\n            if (opt_elideCopy) {\n                this.data_ = data;\n            } else {\n                this.data_ = new Uint8Array(data.length);\n                this.data_.set(data);\n            }\n            size = data.length;\n        }\n        this.size_ = size;\n        this.type_ = blobType;\n    }\n\n    _createClass(FbsBlob, [{\n        key: 'size',\n        value: function size() {\n            return this.size_;\n        }\n    }, {\n        key: 'type',\n        value: function () {\n            return this.type_;\n        }\n    }, {\n        key: 'slice',\n        value: function slice(startByte, endByte) {\n            if (type.isNativeBlob(this.data_)) {\n                var realBlob = this.data_;\n                var sliced = fs.sliceBlob(realBlob, startByte, endByte);\n                if (sliced === null) {\n                    return null;\n                }\n                return new FbsBlob(sliced);\n            } else {\n                var slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);\n                return new FbsBlob(slice, true);\n            }\n        }\n    }, {\n        key: 'uploadData',\n        value: function uploadData() {\n            return this.data_;\n        }\n    }], [{\n        key: 'getBlob',\n        value: function getBlob() {\n            for (var _len = arguments.length, var_args = Array(_len), _key = 0; _key < _len; _key++) {\n                var_args[_key] = arguments[_key];\n            }\n\n            if (type.isNativeBlobDefined()) {\n                var blobby = var_args.map(function (val) {\n                    if (val instanceof FbsBlob) {\n                        return val.data_;\n                    } else {\n                        return val;\n                    }\n                });\n                return new FbsBlob(fs.getBlob.apply(null, blobby));\n            } else {\n                var uint8Arrays = var_args.map(function (val) {\n                    if (type.isString(val)) {\n                        return string.dataFromString(_string.StringFormat.RAW, val).data;\n                    } else {\n                        // Blobs don't exist, so this has to be a Uint8Array.\n                        return val.data_;\n                    }\n                });\n                var finalLength = 0;\n                uint8Arrays.forEach(function (array) {\n                    finalLength += array.byteLength;\n                });\n                var merged = new Uint8Array(finalLength);\n                var index = 0;\n                uint8Arrays.forEach(function (array) {\n                    for (var i = 0; i < array.length; i++) {\n                        merged[index++] = array[i];\n                    }\n                });\n                return new FbsBlob(merged, true);\n            }\n        }\n    }]);\n\n    return FbsBlob;\n}();\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.parent = parent;\nexports.child = child;\nexports.lastComponent = lastComponent;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Contains helper methods for manipulating paths.\n */\n/**\n * @return Null if the path is already at the root.\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/function parent(path) {\n    if (path.length == 0) {\n        return null;\n    }\n    var index = path.lastIndexOf('/');\n    if (index === -1) {\n        return '';\n    }\n    var newPath = path.slice(0, index);\n    return newPath;\n}\nfunction child(path, childPath) {\n    var canonicalChildPath = childPath.split('/').filter(function (component) {\n        return component.length > 0;\n    }).join('/');\n    if (path.length === 0) {\n        return canonicalChildPath;\n    } else {\n        return path + '/' + canonicalChildPath;\n    }\n}\n/**\n * Returns the last component of a path.\n * '/foo/bar' -> 'bar'\n * '/foo/bar/baz/' -> 'baz/'\n * '/a' -> 'a'\n */\nfunction lastComponent(path) {\n    var index = path.lastIndexOf('/', path.length - 2);\n    if (index === -1) {\n        return path;\n    } else {\n        return path.slice(index + 1);\n    }\n}\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.resumableUploadChunkSize = exports.ResumableUploadStatus = undefined;\nexports.handlerCheck = handlerCheck;\nexports.metadataHandler = metadataHandler;\nexports.sharedErrorHandler = sharedErrorHandler;\nexports.objectErrorHandler = objectErrorHandler;\nexports.getMetadata = getMetadata;\nexports.updateMetadata = updateMetadata;\nexports.deleteObject = deleteObject;\nexports.determineContentType_ = determineContentType_;\nexports.metadataForUpload_ = metadataForUpload_;\nexports.multipartUpload = multipartUpload;\nexports.checkResumeHeader_ = checkResumeHeader_;\nexports.createResumableUpload = createResumableUpload;\nexports.getResumableUploadStatus = getResumableUploadStatus;\nexports.continueResumableUpload = continueResumableUpload;\n\nvar _array = __webpack_require__(12);\n\nvar array = _interopRequireWildcard(_array);\n\nvar _blob = __webpack_require__(22);\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nvar _metadata = __webpack_require__(13);\n\nvar MetadataUtils = _interopRequireWildcard(_metadata);\n\nvar _object = __webpack_require__(3);\n\nvar object = _interopRequireWildcard(_object);\n\nvar _requestinfo = __webpack_require__(46);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nvar _url = __webpack_require__(14);\n\nvar UrlUtils = _interopRequireWildcard(_url);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /**\n                                                                                                                                                          * Copyright 2017 Google Inc.\n                                                                                                                                                          *\n                                                                                                                                                          * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                          * you may not use this file except in compliance with the License.\n                                                                                                                                                          * You may obtain a copy of the License at\n                                                                                                                                                          *\n                                                                                                                                                          *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                          *\n                                                                                                                                                          * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                          * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                          * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                          * See the License for the specific language governing permissions and\n                                                                                                                                                          * limitations under the License.\n                                                                                                                                                          */\n\n\n/**\n * Throws the UNKNOWN FirebaseStorageError if cndn is false.\n */\nfunction handlerCheck(cndn) {\n    if (!cndn) {\n        throw errorsExports.unknown();\n    }\n}\nfunction metadataHandler(authWrapper, mappings) {\n    return function (xhr, text) {\n        var metadata = MetadataUtils.fromResourceString(authWrapper, text, mappings);\n        handlerCheck(metadata !== null);\n        return metadata;\n    };\n}\nfunction sharedErrorHandler(location) {\n    return function (xhr, err) {\n        var newErr = void 0;\n        if (xhr.getStatus() === 401) {\n            newErr = errorsExports.unauthenticated();\n        } else {\n            if (xhr.getStatus() === 402) {\n                newErr = errorsExports.quotaExceeded(location.bucket);\n            } else {\n                if (xhr.getStatus() === 403) {\n                    newErr = errorsExports.unauthorized(location.path);\n                } else {\n                    newErr = err;\n                }\n            }\n        }\n        newErr.setServerResponseProp(err.serverResponseProp());\n        return newErr;\n    };\n}\nfunction objectErrorHandler(location) {\n    var shared = sharedErrorHandler(location);\n\n    return function (xhr, err) {\n        var newErr = shared(xhr, err);\n        if (xhr.getStatus() === 404) {\n            newErr = errorsExports.objectNotFound(location.path);\n        }\n        newErr.setServerResponseProp(err.serverResponseProp());\n        return newErr;\n    };\n}\nfunction getMetadata(authWrapper, location, mappings) {\n    var urlPart = location.fullServerUrl();\n    var url = UrlUtils.makeNormalUrl(urlPart);\n\n    var timeout = authWrapper.maxOperationRetryTime();\n    var requestInfo = new _requestinfo.RequestInfo(url, 'GET', metadataHandler(authWrapper, mappings), timeout);\n    requestInfo.errorHandler = objectErrorHandler(location);\n    return requestInfo;\n}\nfunction updateMetadata(authWrapper, location, metadata, mappings) {\n    var urlPart = location.fullServerUrl();\n    var url = UrlUtils.makeNormalUrl(urlPart);\n\n    var body = MetadataUtils.toResourceString(metadata, mappings);\n\n    var timeout = authWrapper.maxOperationRetryTime();\n    var requestInfo = new _requestinfo.RequestInfo(url, 'PATCH', metadataHandler(authWrapper, mappings), timeout);\n    requestInfo.headers = { 'Content-Type': 'application/json; charset=utf-8' };\n    requestInfo.body = body;\n    requestInfo.errorHandler = objectErrorHandler(location);\n    return requestInfo;\n}\nfunction deleteObject(authWrapper, location) {\n    var urlPart = location.fullServerUrl();\n    var url = UrlUtils.makeNormalUrl(urlPart);\n\n    var timeout = authWrapper.maxOperationRetryTime();\n\n    var requestInfo = new _requestinfo.RequestInfo(url, 'DELETE', function () {}, timeout);\n    requestInfo.successCodes = [200, 204];\n    requestInfo.errorHandler = objectErrorHandler(location);\n    return requestInfo;\n}\nfunction determineContentType_(metadata, blob) {\n    return metadata && metadata['contentType'] || blob && blob.type() || 'application/octet-stream';\n}\nfunction metadataForUpload_(location, blob, opt_metadata) {\n    var metadata = object.clone(opt_metadata);\n    metadata['fullPath'] = location.path;\n    metadata['size'] = blob.size();\n    if (!metadata['contentType']) {\n        metadata['contentType'] = determineContentType_(null, blob);\n    }\n    return metadata;\n}\nfunction multipartUpload(authWrapper, location, mappings, blob, opt_metadata) {\n    var urlPart = location.bucketOnlyServerUrl();\n    var headers = { 'X-Goog-Upload-Protocol': 'multipart' };\n\n    var boundary = function () {\n        var str = '';\n        for (var i = 0; i < 2; i++) {\n            str = str + Math.random().toString().slice(2);\n        }\n        return str;\n    }();\n    headers['Content-Type'] = 'multipart/related; boundary=' + boundary;\n    var metadata = metadataForUpload_(location, blob, opt_metadata);\n    var metadataString = MetadataUtils.toResourceString(metadata, mappings);\n    var preBlobPart = '--' + boundary + '\\r\\n' + 'Content-Type: application/json; charset=utf-8\\r\\n\\r\\n' + metadataString + '\\r\\n--' + boundary + '\\r\\n' + 'Content-Type: ' + metadata['contentType'] + '\\r\\n\\r\\n';\n\n    var body = _blob.FbsBlob.getBlob(preBlobPart, blob, '\\r\\n--' + boundary + '--');\n    if (body === null) {\n        throw errorsExports.cannotSliceBlob();\n    }\n    var urlParams = { 'name': metadata['fullPath'] };\n    var url = UrlUtils.makeUploadUrl(urlPart);\n\n    var timeout = authWrapper.maxUploadRetryTime();\n    var requestInfo = new _requestinfo.RequestInfo(url, 'POST', metadataHandler(authWrapper, mappings), timeout);\n    requestInfo.urlParams = urlParams;\n    requestInfo.headers = headers;\n    requestInfo.body = body.uploadData();\n    requestInfo.errorHandler = sharedErrorHandler(location);\n    return requestInfo;\n}\n/**\n * @param current The number of bytes that have been uploaded so far.\n * @param total The total number of bytes in the upload.\n * @param opt_finalized True if the server has finished the upload.\n * @param opt_metadata The upload metadata, should\n *     only be passed if opt_finalized is true.\n * @struct\n */\n\nvar ResumableUploadStatus = exports.ResumableUploadStatus = function ResumableUploadStatus(current, total, finalized, metadata) {\n    _classCallCheck(this, ResumableUploadStatus);\n\n    this.current = current;\n    this.total = total;\n    this.finalized = !!finalized;\n    this.metadata = metadata || null;\n};\n\nfunction checkResumeHeader_(xhr, opt_allowed) {\n    var status = void 0;\n    try {\n        status = xhr.getResponseHeader('X-Goog-Upload-Status');\n    } catch (e) {\n        handlerCheck(false);\n    }\n\n    handlerCheck(array.contains(opt_allowed || ['active'], status));\n    return status;\n}\nfunction createResumableUpload(authWrapper, location, mappings, blob, opt_metadata) {\n    var urlPart = location.bucketOnlyServerUrl();\n    var metadata = metadataForUpload_(location, blob, opt_metadata);\n    var urlParams = { 'name': metadata['fullPath'] };\n    var url = UrlUtils.makeUploadUrl(urlPart);\n\n    var headers = {\n        'X-Goog-Upload-Protocol': 'resumable',\n        'X-Goog-Upload-Command': 'start',\n        'X-Goog-Upload-Header-Content-Length': blob.size(),\n        'X-Goog-Upload-Header-Content-Type': metadata['contentType'],\n        'Content-Type': 'application/json; charset=utf-8'\n    };\n    var body = MetadataUtils.toResourceString(metadata, mappings);\n    var timeout = authWrapper.maxUploadRetryTime();\n\n    var requestInfo = new _requestinfo.RequestInfo(url, 'POST', function (xhr) {\n        checkResumeHeader_(xhr);\n        var url = void 0;\n        try {\n            url = xhr.getResponseHeader('X-Goog-Upload-URL');\n        } catch (e) {\n            handlerCheck(false);\n        }\n        handlerCheck(type.isString(url));\n        return url;\n    }, timeout);\n    requestInfo.urlParams = urlParams;\n    requestInfo.headers = headers;\n    requestInfo.body = body;\n    requestInfo.errorHandler = sharedErrorHandler(location);\n    return requestInfo;\n}\n/**\n * @param url From a call to fbs.requests.createResumableUpload.\n */\nfunction getResumableUploadStatus(authWrapper, location, url, blob) {\n    var timeout = authWrapper.maxUploadRetryTime();\n    var requestInfo = new _requestinfo.RequestInfo(url, 'POST', function (xhr) {\n        var status = checkResumeHeader_(xhr, ['active', 'final']);\n        var sizeString = void 0;\n        try {\n            sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received');\n        } catch (e) {\n            handlerCheck(false);\n        }\n        var size = parseInt(sizeString, 10);\n        handlerCheck(!isNaN(size));\n        return new ResumableUploadStatus(size, blob.size(), status === 'final');\n    }, timeout);\n    requestInfo.headers = { 'X-Goog-Upload-Command': 'query' };\n    requestInfo.errorHandler = sharedErrorHandler(location);\n    return requestInfo;\n}\n/**\n * Any uploads via the resumable upload API must transfer a number of bytes\n * that is a multiple of this number.\n */\nvar resumableUploadChunkSize = exports.resumableUploadChunkSize = 256 * 1024;\n/**\n * @param url From a call to fbs.requests.createResumableUpload.\n * @param chunkSize Number of bytes to upload.\n * @param opt_status The previous status.\n *     If not passed or null, we start from the beginning.\n * @throws fbs.Error If the upload is already complete, the passed in status\n *     has a final size inconsistent with the blob, or the blob cannot be sliced\n *     for upload.\n */\nfunction continueResumableUpload(location, authWrapper, url, blob, chunkSize, mappings, opt_status, opt_progressCallback) {\n    // TODO(andysoto): standardize on internal asserts\n    // assert(!(opt_status && opt_status.finalized));\n    var status = new ResumableUploadStatus(0, 0);\n    if (opt_status) {\n        status.current = opt_status.current;\n        status.total = opt_status.total;\n    } else {\n        status.current = 0;\n        status.total = blob.size();\n    }\n    if (blob.size() !== status.total) {\n        throw errorsExports.serverFileWrongSize();\n    }\n    var bytesLeft = status.total - status.current;\n    var bytesToUpload = bytesLeft;\n    if (chunkSize > 0) {\n        bytesToUpload = Math.min(bytesToUpload, chunkSize);\n    }\n    var startByte = status.current;\n    var endByte = startByte + bytesToUpload;\n    var uploadCommand = bytesToUpload === bytesLeft ? 'upload, finalize' : 'upload';\n    var headers = {\n        'X-Goog-Upload-Command': uploadCommand,\n        'X-Goog-Upload-Offset': status.current\n    };\n    var body = blob.slice(startByte, endByte);\n    if (body === null) {\n        throw errorsExports.cannotSliceBlob();\n    }\n\n    var timeout = authWrapper.maxUploadRetryTime();\n    var requestInfo = new _requestinfo.RequestInfo(url, 'POST', function (xhr, text) {\n        // TODO(andysoto): Verify the MD5 of each uploaded range:\n        // the 'x-range-md5' header comes back with status code 308 responses.\n        // We'll only be able to bail out though, because you can't re-upload a\n        // range that you previously uploaded.\n        var uploadStatus = checkResumeHeader_(xhr, ['active', 'final']);\n        var newCurrent = status.current + bytesToUpload;\n        var size = blob.size();\n        var metadata = void 0;\n        if (uploadStatus === 'final') {\n            metadata = metadataHandler(authWrapper, mappings)(xhr, text);\n        } else {\n            metadata = null;\n        }\n        return new ResumableUploadStatus(newCurrent, size, uploadStatus === 'final', metadata);\n    }, timeout);\n    requestInfo.headers = headers;\n    requestInfo.body = body.uploadData();\n    requestInfo.progressCallback = opt_progressCallback || null;\n    requestInfo.errorHandler = sharedErrorHandler(location);\n    return requestInfo;\n}\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @enum{number}\n */\nvar ErrorCode = exports.ErrorCode = undefined;\n(function (ErrorCode) {\n    ErrorCode[ErrorCode[\"NO_ERROR\"] = 0] = \"NO_ERROR\";\n    ErrorCode[ErrorCode[\"NETWORK_ERROR\"] = 1] = \"NETWORK_ERROR\";\n    ErrorCode[ErrorCode[\"ABORT\"] = 2] = \"ABORT\";\n})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));\n\n/***/ }),\n/* 26 */,\n/* 27 */,\n/* 28 */,\n/* 29 */,\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.XhrIoPool = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n\n\nvar _xhrio_network = __webpack_require__(48);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Factory-like class for creating XhrIo instances.\n */\nvar XhrIoPool = exports.XhrIoPool = function () {\n    function XhrIoPool() {\n        _classCallCheck(this, XhrIoPool);\n    }\n\n    _createClass(XhrIoPool, [{\n        key: 'createXhrIo',\n        value: function createXhrIo() {\n            return new _xhrio_network.NetworkXhrIo();\n        }\n    }]);\n\n    return XhrIoPool;\n}();\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.ServiceInternals = exports.Service = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n\n\nvar _args = __webpack_require__(11);\n\nvar args = _interopRequireWildcard(_args);\n\nvar _authwrapper = __webpack_require__(39);\n\nvar _location = __webpack_require__(7);\n\nvar _promise_external = __webpack_require__(2);\n\nvar fbsPromiseImpl = _interopRequireWildcard(_promise_external);\n\nvar _request = __webpack_require__(45);\n\nvar RequestExports = _interopRequireWildcard(_request);\n\nvar _reference = __webpack_require__(16);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * A service that provides firebaseStorage.Reference instances.\n * @param opt_url gs:// url to a custom Storage Bucket\n *\n * @struct\n */\nvar Service = exports.Service = function () {\n    function Service(app, pool, url) {\n        _classCallCheck(this, Service);\n\n        this.bucket_ = null;\n\n        this.authWrapper_ = new _authwrapper.AuthWrapper(app, function (authWrapper, loc) {\n            return new _reference.Reference(authWrapper, loc);\n        }, RequestExports.makeRequest, this, pool);\n        this.app_ = app;\n        if (url != null) {\n            this.bucket_ = _location.Location.makeFromBucketSpec(url);\n        } else {\n            var authWrapperBucket = this.authWrapper_.bucket();\n            if (authWrapperBucket != null) {\n                this.bucket_ = new _location.Location(authWrapperBucket, '');\n            }\n        }\n        this.internals_ = new ServiceInternals(this);\n    }\n    /**\n     * Returns a firebaseStorage.Reference for the given path in the default\n     * bucket.\n     */\n\n\n    _createClass(Service, [{\n        key: 'ref',\n        value: function (path) {\n            args.validate('ref', [args.stringSpec(function (path) {\n                if (/^[A-Za-z]+:\\/\\//.test(path)) {\n                    throw 'Expected child path but got a URL, use refFromURL instead.';\n                }\n            }, true)], arguments);\n            if (this.bucket_ == null) {\n                throw new Error('No Storage Bucket defined in Firebase Options.');\n            }\n            var ref = new _reference.Reference(this.authWrapper_, this.bucket_);\n            if (path != null) {\n                return ref.child(path);\n            } else {\n                return ref;\n            }\n        }\n        /**\n         * Returns a firebaseStorage.Reference object for the given absolute URL,\n         * which must be a gs:// or http[s]:// URL.\n         */\n\n    }, {\n        key: 'refFromURL',\n        value: function refFromURL(url) {\n            args.validate('refFromURL', [args.stringSpec(function (p) {\n                if (!/^[A-Za-z]+:\\/\\//.test(p)) {\n                    throw 'Expected full URL but got a child path, use ref instead.';\n                }\n                try {\n                    _location.Location.makeFromUrl(p);\n                } catch (e) {\n                    throw 'Expected valid full URL but got an invalid one.';\n                }\n            }, false)], arguments);\n            return new _reference.Reference(this.authWrapper_, url);\n        }\n    }, {\n        key: 'setMaxUploadRetryTime',\n        value: function setMaxUploadRetryTime(time) {\n            args.validate('setMaxUploadRetryTime', [args.nonNegativeNumberSpec()], arguments);\n            this.authWrapper_.setMaxUploadRetryTime(time);\n        }\n    }, {\n        key: 'setMaxOperationRetryTime',\n        value: function setMaxOperationRetryTime(time) {\n            args.validate('setMaxOperationRetryTime', [args.nonNegativeNumberSpec()], arguments);\n            this.authWrapper_.setMaxOperationRetryTime(time);\n        }\n    }, {\n        key: 'maxUploadRetryTime',\n        get: function get() {\n            return this.authWrapper_.maxUploadRetryTime();\n        }\n    }, {\n        key: 'maxOperationRetryTime',\n        get: function get() {\n            return this.authWrapper_.maxOperationRetryTime();\n        }\n    }, {\n        key: 'app',\n        get: function get() {\n            return this.app_;\n        }\n    }, {\n        key: 'INTERNAL',\n        get: function get() {\n            return this.internals_;\n        }\n    }]);\n\n    return Service;\n}();\n/**\n * @struct\n */\n\n\nvar ServiceInternals = exports.ServiceInternals = function () {\n    function ServiceInternals(service) {\n        _classCallCheck(this, ServiceInternals);\n\n        this.service_ = service;\n    }\n    /**\n     * Called when the associated app is deleted.\n     * @see {!fbs.AuthWrapper.prototype.deleteApp}\n     */\n\n\n    _createClass(ServiceInternals, [{\n        key: 'delete',\n        value: function _delete() {\n            this.service_.authWrapper_.deleteApp();\n            return fbsPromiseImpl.resolve(undefined);\n        }\n    }]);\n\n    return ServiceInternals;\n}();\n\n/***/ }),\n/* 32 */,\n/* 33 */,\n/* 34 */,\n/* 35 */,\n/* 36 */,\n/* 37 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.registerStorage = registerStorage;\n\nvar _string = __webpack_require__(8);\n\nvar _taskenums = __webpack_require__(15);\n\nvar _xhriopool = __webpack_require__(30);\n\nvar _reference = __webpack_require__(16);\n\nvar _service = __webpack_require__(31);\n\nvar _app = __webpack_require__(4);\n\nvar _app2 = _interopRequireDefault(_app);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Type constant for Firebase Storage.\n */\nvar STORAGE_TYPE = 'storage'; /**\n                              * Copyright 2017 Google Inc.\n                              *\n                              * Licensed under the Apache License, Version 2.0 (the \"License\");\n                              * you may not use this file except in compliance with the License.\n                              * You may obtain a copy of the License at\n                              *\n                              *   http://www.apache.org/licenses/LICENSE-2.0\n                              *\n                              * Unless required by applicable law or agreed to in writing, software\n                              * distributed under the License is distributed on an \"AS IS\" BASIS,\n                              * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                              * See the License for the specific language governing permissions and\n                              * limitations under the License.\n                              */\n\nfunction factory(app, unused, opt_url) {\n    return new _service.Service(app, new _xhriopool.XhrIoPool(), opt_url);\n}\nfunction registerStorage(instance) {\n    instance.INTERNAL.registerService(STORAGE_TYPE, factory, {\n        // no-inline\n        'TaskState': _taskenums.TaskState,\n        'TaskEvent': _taskenums.TaskEvent,\n        'StringFormat': _string.StringFormat,\n        'Storage': _service.Service,\n        'Reference': _reference.Reference\n    }, undefined,\n    // Allow multiple storage instances per app.\n    true);\n}\nregisterStorage(_app2.default);\n\n/***/ }),\n/* 38 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.async = async;\n\nvar _promise_external = __webpack_require__(2);\n\nvar promiseimpl = _interopRequireWildcard(_promise_external);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/**\n * Returns a function that invokes f with its arguments asynchronously as a\n * microtask, i.e. as soon as possible after the current script returns back\n * into browser code.\n */\nfunction async(f) {\n    return function () {\n        for (var _len = arguments.length, argsToForward = Array(_len), _key = 0; _key < _len; _key++) {\n            argsToForward[_key] = arguments[_key];\n        }\n\n        promiseimpl.resolve(true).then(function () {\n            f.apply(null, argsToForward);\n        });\n    };\n} /**\n  * Copyright 2017 Google Inc.\n  *\n  * Licensed under the Apache License, Version 2.0 (the \"License\");\n  * you may not use this file except in compliance with the License.\n  * You may obtain a copy of the License at\n  *\n  *   http://www.apache.org/licenses/LICENSE-2.0\n  *\n  * Unless required by applicable law or agreed to in writing, software\n  * distributed under the License is distributed on an \"AS IS\" BASIS,\n  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  * See the License for the specific language governing permissions and\n  * limitations under the License.\n  */\n/**\n * @fileoverview Method for invoking a callback asynchronously.\n */\n\n/***/ }),\n/* 39 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.AuthWrapper = undefined;\n\nvar _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; }; }();\n\nvar _constants = __webpack_require__(6);\n\nvar constants = _interopRequireWildcard(_constants);\n\nvar _error2 = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error2);\n\nvar _failrequest = __webpack_require__(41);\n\nvar _location = __webpack_require__(7);\n\nvar _promise_external = __webpack_require__(2);\n\nvar promiseimpl = _interopRequireWildcard(_promise_external);\n\nvar _requestmap = __webpack_require__(47);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * @param app If null, getAuthToken always resolves with null.\n * @param service The storage service associated with this auth wrapper.\n *     Untyped to avoid circular type dependencies.\n * @struct\n */\nvar AuthWrapper = exports.AuthWrapper = function () {\n    function AuthWrapper(app, maker, requestMaker, service, pool) {\n        _classCallCheck(this, AuthWrapper);\n\n        this.bucket_ = null;\n        this.deleted_ = false;\n        this.app_ = app;\n        if (this.app_ !== null) {\n            var options = this.app_.options;\n            if (type.isDef(options)) {\n                this.bucket_ = AuthWrapper.extractBucket_(options);\n            }\n        }\n        this.storageRefMaker_ = maker;\n        this.requestMaker_ = requestMaker;\n        this.pool_ = pool;\n        this.service_ = service;\n        this.maxOperationRetryTime_ = constants.defaultMaxOperationRetryTime;\n        this.maxUploadRetryTime_ = constants.defaultMaxUploadRetryTime;\n        this.requestMap_ = new _requestmap.RequestMap();\n    }\n\n    _createClass(AuthWrapper, [{\n        key: 'getAuthToken',\n        value: function getAuthToken() {\n            // TODO(andysoto): remove ifDef checks after firebase-app implements stubs\n            // (b/28673818).\n            if (this.app_ !== null && type.isDef(this.app_.INTERNAL) && type.isDef(this.app_.INTERNAL.getToken)) {\n                return this.app_.INTERNAL.getToken().then(function (response) {\n                    if (response !== null) {\n                        return response.accessToken;\n                    } else {\n                        return null;\n                    }\n                }, function () {\n                    return null;\n                });\n            } else {\n                return promiseimpl.resolve(null);\n            }\n        }\n    }, {\n        key: 'bucket',\n        value: function bucket() {\n            if (this.deleted_) {\n                throw errorsExports.appDeleted();\n            } else {\n                return this.bucket_;\n            }\n        }\n        /**\n         * The service associated with this auth wrapper. Untyped to avoid circular\n         * type dependencies.\n         */\n\n    }, {\n        key: 'service',\n        value: function service() {\n            return this.service_;\n        }\n        /**\n         * Returns a new firebaseStorage.Reference object referencing this AuthWrapper\n         * at the given Location.\n         * @param loc The Location.\n         * @return Actually a firebaseStorage.Reference, typing not allowed\n         *     because of circular dependency problems.\n         */\n\n    }, {\n        key: 'makeStorageReference',\n        value: function makeStorageReference(loc) {\n            return this.storageRefMaker_(this, loc);\n        }\n    }, {\n        key: 'makeRequest',\n        value: function makeRequest(requestInfo, authToken) {\n            if (!this.deleted_) {\n                var request = this.requestMaker_(requestInfo, authToken, this.pool_);\n                this.requestMap_.addRequest(request);\n                return request;\n            } else {\n                return new _failrequest.FailRequest(errorsExports.appDeleted());\n            }\n        }\n        /**\n         * Stop running requests and prevent more from being created.\n         */\n\n    }, {\n        key: 'deleteApp',\n        value: function deleteApp() {\n            this.deleted_ = true;\n            this.app_ = null;\n            this.requestMap_.clear();\n        }\n    }, {\n        key: 'maxUploadRetryTime',\n        value: function maxUploadRetryTime() {\n            return this.maxUploadRetryTime_;\n        }\n    }, {\n        key: 'setMaxUploadRetryTime',\n        value: function setMaxUploadRetryTime(time) {\n            this.maxUploadRetryTime_ = time;\n        }\n    }, {\n        key: 'maxOperationRetryTime',\n        value: function maxOperationRetryTime() {\n            return this.maxOperationRetryTime_;\n        }\n    }, {\n        key: 'setMaxOperationRetryTime',\n        value: function setMaxOperationRetryTime(time) {\n            this.maxOperationRetryTime_ = time;\n        }\n    }], [{\n        key: 'extractBucket_',\n        value: function extractBucket_(config) {\n            var bucketString = config[constants.configOption] || null;\n            if (bucketString == null) {\n                return null;\n            }\n            var loc = _location.Location.makeFromBucketSpec(bucketString);\n            return loc.bucket;\n        }\n    }]);\n\n    return AuthWrapper;\n}();\n\n/***/ }),\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.start = start;\nexports.stop = stop;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @param f May be invoked\n *     before the function returns.\n * @param callback Get all the arguments passed to the function\n *     passed to f, including the initial boolean.\n */\nfunction start(f, callback, timeout) {\n    // TODO(andysoto): make this code cleaner (probably refactor into an actual\n    // type instead of a bunch of functions with state shared in the closure)\n    var waitSeconds = 1;\n    // Would type this as \"number\" but that doesn't work for Node so ¯\\_(ツ)_/¯\n    var timeoutId = null;\n    var hitTimeout = false;\n    var cancelState = 0;\n    function canceled() {\n        return cancelState === 2;\n    }\n    var triggeredCallback = false;\n    function triggerCallback() {\n        if (!triggeredCallback) {\n            triggeredCallback = true;\n            callback.apply(null, arguments);\n        }\n    }\n    function callWithDelay(millis) {\n        timeoutId = setTimeout(function () {\n            timeoutId = null;\n            f(handler, canceled());\n        }, millis);\n    }\n    function handler(success) {\n        for (var _len = arguments.length, var_args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n            var_args[_key - 1] = arguments[_key];\n        }\n\n        if (triggeredCallback) {\n            return;\n        }\n        if (success) {\n            triggerCallback.apply(null, arguments);\n            return;\n        }\n        var mustStop = canceled() || hitTimeout;\n        if (mustStop) {\n            triggerCallback.apply(null, arguments);\n            return;\n        }\n        if (waitSeconds < 64) {\n            /* TODO(andysoto): don't back off so quickly if we know we're offline. */\n            waitSeconds *= 2;\n        }\n        var waitMillis = void 0;\n        if (cancelState === 1) {\n            cancelState = 2;\n            waitMillis = 0;\n        } else {\n            waitMillis = (waitSeconds + Math.random()) * 1000;\n        }\n        callWithDelay(waitMillis);\n    }\n    var stopped = false;\n    function stop(wasTimeout) {\n        if (stopped) {\n            return;\n        }\n        stopped = true;\n        if (triggeredCallback) {\n            return;\n        }\n        if (timeoutId !== null) {\n            if (!wasTimeout) {\n                cancelState = 2;\n            }\n            clearTimeout(timeoutId);\n            callWithDelay(0);\n        } else {\n            if (!wasTimeout) {\n                cancelState = 1;\n            }\n        }\n    }\n    callWithDelay(0);\n    setTimeout(function () {\n        hitTimeout = true;\n        stop(true);\n    }, timeout);\n    return stop;\n}\n/**\n * Stops the retry loop from repeating.\n * If the function is currently \"in between\" retries, it is invoked immediately\n * with the second parameter as \"true\". Otherwise, it will be invoked once more\n * after the current invocation finishes iff the current invocation would have\n * triggered another retry.\n */\nfunction stop(id) {\n    id(false);\n}\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.FailRequest = undefined;\n\nvar _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; }; }();\n\nvar _promise_external = __webpack_require__(2);\n\nvar promiseimpl = _interopRequireWildcard(_promise_external);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * A request whose promise always fails.\n * @struct\n * @template T\n */\nvar FailRequest = exports.FailRequest = function () {\n    function FailRequest(error) {\n        _classCallCheck(this, FailRequest);\n\n        this.promise_ = promiseimpl.reject(error);\n    }\n    /** @inheritDoc */\n\n\n    _createClass(FailRequest, [{\n        key: 'getPromise',\n        value: function getPromise() {\n            return this.promise_;\n        }\n        /** @inheritDoc */\n\n    }, {\n        key: 'cancel',\n        value: function cancel() {\n            arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n        }\n    }]);\n\n    return FailRequest;\n}();\n\n/***/ }),\n/* 42 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.getBlob = getBlob;\nexports.sliceBlob = sliceBlob;\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction getBlobBuilder() {\n    if (typeof BlobBuilder !== 'undefined') {\n        return BlobBuilder;\n    } else if (typeof WebKitBlobBuilder !== 'undefined') {\n        return WebKitBlobBuilder;\n    } else {\n        return undefined;\n    }\n}\n/**\n * Concatenates one or more values together and converts them to a Blob.\n *\n * @param var_args The values that will make up the resulting blob.\n * @return The blob.\n */\nfunction getBlob() {\n    var BlobBuilder = getBlobBuilder();\n\n    for (var _len = arguments.length, var_args = Array(_len), _key = 0; _key < _len; _key++) {\n        var_args[_key] = arguments[_key];\n    }\n\n    if (BlobBuilder !== undefined) {\n        var bb = new BlobBuilder();\n        for (var i = 0; i < var_args.length; i++) {\n            bb.append(var_args[i]);\n        }\n        return bb.getBlob();\n    } else {\n        if (type.isNativeBlobDefined()) {\n            return new Blob(var_args);\n        } else {\n            throw Error('This browser doesn\\'t seem to support creating Blobs');\n        }\n    }\n}\n/**\n * Slices the blob. The returned blob contains data from the start byte\n * (inclusive) till the end byte (exclusive). Negative indices cannot be used.\n *\n * @param blob The blob to be sliced.\n * @param start Index of the starting byte.\n * @param end Index of the ending byte.\n * @return The blob slice or null if not supported.\n */\nfunction sliceBlob(blob, start, end) {\n    if (blob.webkitSlice) {\n        return blob.webkitSlice(start, end);\n    } else if (blob.mozSlice) {\n        return blob.mozSlice(start, end);\n    } else if (blob.slice) {\n        return blob.slice(start, end);\n    }\n    return null;\n}\n\n/***/ }),\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.jsonObjectOrNull = jsonObjectOrNull;\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\n/**\n * Returns the Object resulting from parsing the given JSON, or null if the\n * given string does not represent a JSON object.\n */\nfunction jsonObjectOrNull(s) {\n    var obj = void 0;\n    try {\n        obj = JSON.parse(s);\n    } catch (e) {\n        return null;\n    }\n    if (type.isNonArrayObject(obj)) {\n        return obj;\n    } else {\n        return null;\n    }\n} /**\n  * Copyright 2017 Google Inc.\n  *\n  * Licensed under the Apache License, Version 2.0 (the \"License\");\n  * you may not use this file except in compliance with the License.\n  * You may obtain a copy of the License at\n  *\n  *   http://www.apache.org/licenses/LICENSE-2.0\n  *\n  * Unless required by applicable law or agreed to in writing, software\n  * distributed under the License is distributed on an \"AS IS\" BASIS,\n  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  * See the License for the specific language governing permissions and\n  * limitations under the License.\n  */\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.Observer = undefined;\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /**\n                                                                                                                                                          * Copyright 2017 Google Inc.\n                                                                                                                                                          *\n                                                                                                                                                          * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                          * you may not use this file except in compliance with the License.\n                                                                                                                                                          * You may obtain a copy of the License at\n                                                                                                                                                          *\n                                                                                                                                                          *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                          *\n                                                                                                                                                          * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                          * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                          * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                          * See the License for the specific language governing permissions and\n                                                                                                                                                          * limitations under the License.\n                                                                                                                                                          */\n\n\n/**\n * @struct\n */\nvar Observer = exports.Observer = function Observer(nextOrObserver, opt_error, opt_complete) {\n    _classCallCheck(this, Observer);\n\n    var asFunctions = type.isFunction(nextOrObserver) || type.isDef(opt_error) || type.isDef(opt_complete);\n    if (asFunctions) {\n        this.next = nextOrObserver;\n        this.error = opt_error || null;\n        this.complete = opt_complete || null;\n    } else {\n        var observer = nextOrObserver;\n        this.next = observer['next'];\n        this.error = observer['error'];\n        this.complete = observer['complete'];\n    }\n};\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.RequestEndStatus = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n/**\n * @fileoverview Defines methods used to actually send HTTP requests from\n * abstract representations.\n */\n\n\nexports.addAuthHeader_ = addAuthHeader_;\nexports.addVersionHeader_ = addVersionHeader_;\nexports.makeRequest = makeRequest;\n\nvar _array = __webpack_require__(12);\n\nvar array = _interopRequireWildcard(_array);\n\nvar _backoff = __webpack_require__(40);\n\nvar backoff = _interopRequireWildcard(_backoff);\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nvar _object = __webpack_require__(3);\n\nvar object = _interopRequireWildcard(_object);\n\nvar _promise_external = __webpack_require__(2);\n\nvar promiseimpl = _interopRequireWildcard(_promise_external);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nvar _url = __webpack_require__(14);\n\nvar UrlUtils = _interopRequireWildcard(_url);\n\nvar _xhrio = __webpack_require__(25);\n\nvar XhrIoExports = _interopRequireWildcard(_xhrio);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * @struct\n * @template T\n */\nvar NetworkRequest = function () {\n    function NetworkRequest(url, method, headers, body, successCodes, additionalRetryCodes, callback, errorCallback, timeout, progressCallback, pool) {\n        _classCallCheck(this, NetworkRequest);\n\n        this.pendingXhr_ = null;\n        this.backoffId_ = null;\n        this.resolve_ = null;\n        this.reject_ = null;\n        this.canceled_ = false;\n        this.appDelete_ = false;\n        this.url_ = url;\n        this.method_ = method;\n        this.headers_ = headers;\n        this.body_ = body;\n        this.successCodes_ = successCodes.slice();\n        this.additionalRetryCodes_ = additionalRetryCodes.slice();\n        this.callback_ = callback;\n        this.errorCallback_ = errorCallback;\n        this.progressCallback_ = progressCallback;\n        this.timeout_ = timeout;\n        this.pool_ = pool;\n        var self = this;\n        this.promise_ = promiseimpl.make(function (resolve, reject) {\n            self.resolve_ = resolve;\n            self.reject_ = reject;\n            self.start_();\n        });\n    }\n    /**\n     * Actually starts the retry loop.\n     */\n\n\n    _createClass(NetworkRequest, [{\n        key: 'start_',\n        value: function start_() {\n            var self = this;\n            function doTheRequest(backoffCallback, canceled) {\n                if (canceled) {\n                    backoffCallback(false, new RequestEndStatus(false, null, true));\n                    return;\n                }\n                var xhr = self.pool_.createXhrIo();\n                self.pendingXhr_ = xhr;\n                function progressListener(progressEvent) {\n                    var loaded = progressEvent.loaded;\n                    var total = progressEvent.lengthComputable ? progressEvent.total : -1;\n                    if (self.progressCallback_ !== null) {\n                        self.progressCallback_(loaded, total);\n                    }\n                }\n                if (self.progressCallback_ !== null) {\n                    xhr.addUploadProgressListener(progressListener);\n                }\n                xhr.send(self.url_, self.method_, self.body_, self.headers_).then(function (xhr) {\n                    if (self.progressCallback_ !== null) {\n                        xhr.removeUploadProgressListener(progressListener);\n                    }\n                    self.pendingXhr_ = null;\n                    xhr = xhr;\n                    var hitServer = xhr.getErrorCode() === XhrIoExports.ErrorCode.NO_ERROR;\n                    var status = xhr.getStatus();\n                    if (!hitServer || self.isRetryStatusCode_(status)) {\n                        var wasCanceled = xhr.getErrorCode() === XhrIoExports.ErrorCode.ABORT;\n                        backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));\n                        return;\n                    }\n                    var successCode = array.contains(self.successCodes_, status);\n                    backoffCallback(true, new RequestEndStatus(successCode, xhr));\n                });\n            }\n            /**\n             * @param requestWentThrough True if the request eventually went\n             *     through, false if it hit the retry limit or was canceled.\n             */\n            function backoffDone(requestWentThrough, status) {\n                var resolve = self.resolve_;\n                var reject = self.reject_;\n                var xhr = status.xhr;\n                if (status.wasSuccessCode) {\n                    try {\n                        var result = self.callback_(xhr, xhr.getResponseText());\n                        if (type.isJustDef(result)) {\n                            resolve(result);\n                        } else {\n                            resolve();\n                        }\n                    } catch (e) {\n                        reject(e);\n                    }\n                } else {\n                    if (xhr !== null) {\n                        var err = errorsExports.unknown();\n                        err.setServerResponseProp(xhr.getResponseText());\n                        if (self.errorCallback_) {\n                            reject(self.errorCallback_(xhr, err));\n                        } else {\n                            reject(err);\n                        }\n                    } else {\n                        if (status.canceled) {\n                            var _err = self.appDelete_ ? errorsExports.appDeleted() : errorsExports.canceled();\n                            reject(_err);\n                        } else {\n                            var _err2 = errorsExports.retryLimitExceeded();\n                            reject(_err2);\n                        }\n                    }\n                }\n            }\n            if (this.canceled_) {\n                backoffDone(false, new RequestEndStatus(false, null, true));\n            } else {\n                this.backoffId_ = backoff.start(doTheRequest, backoffDone, this.timeout_);\n            }\n        }\n        /** @inheritDoc */\n\n    }, {\n        key: 'getPromise',\n        value: function getPromise() {\n            return this.promise_;\n        }\n        /** @inheritDoc */\n\n    }, {\n        key: 'cancel',\n        value: function cancel(appDelete) {\n            this.canceled_ = true;\n            this.appDelete_ = appDelete || false;\n            if (this.backoffId_ !== null) {\n                backoff.stop(this.backoffId_);\n            }\n            if (this.pendingXhr_ !== null) {\n                this.pendingXhr_.abort();\n            }\n        }\n    }, {\n        key: 'isRetryStatusCode_',\n        value: function isRetryStatusCode_(status) {\n            // The codes for which to retry came from this page:\n            // https://cloud.google.com/storage/docs/exponential-backoff\n            var isExtraRetryCode = array.contains([\n            // Request Timeout: web server didn't receive full request in time.\n            408,\n            // Too Many Requests: you're getting rate-limited, basically.\n            429], status);\n            var isRequestSpecificRetryCode = array.contains(this.additionalRetryCodes_, status);\n            return status >= 500 && status < 600 || isExtraRetryCode || isRequestSpecificRetryCode;\n        }\n    }]);\n\n    return NetworkRequest;\n}();\n/**\n * A collection of information about the result of a network request.\n * @param opt_canceled Defaults to false.\n * @struct\n */\n\n\nvar RequestEndStatus = exports.RequestEndStatus = function RequestEndStatus(wasSuccessCode, xhr, opt_canceled) {\n    _classCallCheck(this, RequestEndStatus);\n\n    this.wasSuccessCode = wasSuccessCode;\n    this.xhr = xhr;\n    this.canceled = !!opt_canceled;\n};\n\nfunction addAuthHeader_(headers, authToken) {\n    if (authToken !== null && authToken.length > 0) {\n        headers['Authorization'] = 'Firebase ' + authToken;\n    }\n}\nfunction addVersionHeader_(headers) {\n    var number = typeof firebase !== 'undefined' ? firebase.SDK_VERSION : 'AppManager';\n    headers['X-Firebase-Storage-Version'] = 'webjs/' + number;\n}\n/**\n * @template T\n */\nfunction makeRequest(requestInfo, authToken, pool) {\n    var queryPart = UrlUtils.makeQueryString(requestInfo.urlParams);\n    var url = requestInfo.url + queryPart;\n    var headers = object.clone(requestInfo.headers);\n    addAuthHeader_(headers, authToken);\n    addVersionHeader_(headers);\n    return new NetworkRequest(url, requestInfo.method, headers, requestInfo.body, requestInfo.successCodes, requestInfo.additionalRetryCodes, requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout, requestInfo.progressCallback, pool);\n}\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar RequestInfo = exports.RequestInfo = function RequestInfo(url, method,\n/**\n * Returns the value with which to resolve the request's promise. Only called\n * if the request is successful. Throw from this function to reject the\n * returned Request's promise with the thrown error.\n * Note: The XhrIo passed to this function may be reused after this callback\n * returns. Do not keep a reference to it in any way.\n */\nhandler, timeout) {\n  _classCallCheck(this, RequestInfo);\n\n  this.url = url;\n  this.method = method;\n  this.handler = handler;\n  this.timeout = timeout;\n  this.urlParams = {};\n  this.headers = {};\n  this.body = null;\n  this.errorHandler = null;\n  /**\n   * Called with the current number of bytes uploaded and total size (-1 if not\n   * computable) of the request body (i.e. used to report upload progress).\n   */\n  this.progressCallback = null;\n  this.successCodes = [200];\n  this.additionalRetryCodes = [];\n};\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.RequestMap = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n\n\nvar _object = __webpack_require__(3);\n\nvar object = _interopRequireWildcard(_object);\n\nvar _constants = __webpack_require__(6);\n\nvar constants = _interopRequireWildcard(_constants);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * @struct\n */\nvar RequestMap = exports.RequestMap = function () {\n    function RequestMap() {\n        _classCallCheck(this, RequestMap);\n\n        this.map_ = {};\n        this.id_ = constants.minSafeInteger;\n    }\n    /**\n     * Registers the given request with this map.\n     * The request is unregistered when it completes.\n     * @param r The request to register.\n     */\n\n\n    _createClass(RequestMap, [{\n        key: 'addRequest',\n        value: function addRequest(r) {\n            var id = this.id_;\n            this.id_++;\n            this.map_[id] = r;\n            var self = this;\n            function unmap() {\n                delete self.map_[id];\n            }\n            r.getPromise().then(unmap, unmap);\n        }\n        /**\n         * Cancels all registered requests.\n         */\n\n    }, {\n        key: 'clear',\n        value: function clear() {\n            object.forEach(this.map_, function (key, val) {\n                if (val) {\n                    val.cancel(true);\n                }\n            });\n            this.map_ = {};\n        }\n    }]);\n\n    return RequestMap;\n}();\n\n/***/ }),\n/* 48 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.NetworkXhrIo = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n\n\nvar _error = __webpack_require__(1);\n\nvar errorsExports = _interopRequireWildcard(_error);\n\nvar _object = __webpack_require__(3);\n\nvar object = _interopRequireWildcard(_object);\n\nvar _promise_external = __webpack_require__(2);\n\nvar promiseimpl = _interopRequireWildcard(_promise_external);\n\nvar _type = __webpack_require__(0);\n\nvar type = _interopRequireWildcard(_type);\n\nvar _xhrio = __webpack_require__(25);\n\nvar XhrIoExports = _interopRequireWildcard(_xhrio);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * We use this instead of goog.net.XhrIo because goog.net.XhrIo is hyuuuuge and\n * doesn't work in React Native on Android.\n */\nvar NetworkXhrIo = exports.NetworkXhrIo = function () {\n    function NetworkXhrIo() {\n        var _this = this;\n\n        _classCallCheck(this, NetworkXhrIo);\n\n        this.sent_ = false;\n        this.xhr_ = new XMLHttpRequest();\n        this.errorCode_ = XhrIoExports.ErrorCode.NO_ERROR;\n        this.sendPromise_ = promiseimpl.make(function (resolve) {\n            _this.xhr_.addEventListener('abort', function () {\n                _this.errorCode_ = XhrIoExports.ErrorCode.ABORT;\n                resolve(_this);\n            });\n            _this.xhr_.addEventListener('error', function () {\n                _this.errorCode_ = XhrIoExports.ErrorCode.NETWORK_ERROR;\n                resolve(_this);\n            });\n            _this.xhr_.addEventListener('load', function () {\n                resolve(_this);\n            });\n        });\n    }\n    /**\n     * @override\n     */\n\n\n    _createClass(NetworkXhrIo, [{\n        key: 'send',\n        value: function send(url, method, opt_body, opt_headers) {\n            var _this2 = this;\n\n            if (this.sent_) {\n                throw errorsExports.internalError('cannot .send() more than once');\n            }\n            this.sent_ = true;\n            this.xhr_.open(method, url, true);\n            if (type.isDef(opt_headers)) {\n                object.forEach(opt_headers, function (key, val) {\n                    _this2.xhr_.setRequestHeader(key, val.toString());\n                });\n            }\n            if (type.isDef(opt_body)) {\n                this.xhr_.send(opt_body);\n            } else {\n                this.xhr_.send();\n            }\n            return this.sendPromise_;\n        }\n        /**\n         * @override\n         */\n\n    }, {\n        key: 'getErrorCode',\n        value: function getErrorCode() {\n            if (!this.sent_) {\n                throw errorsExports.internalError('cannot .getErrorCode() before sending');\n            }\n            return this.errorCode_;\n        }\n        /**\n         * @override\n         */\n\n    }, {\n        key: 'getStatus',\n        value: function getStatus() {\n            if (!this.sent_) {\n                throw errorsExports.internalError('cannot .getStatus() before sending');\n            }\n            try {\n                return this.xhr_.status;\n            } catch (e) {\n                return -1;\n            }\n        }\n        /**\n         * @override\n         */\n\n    }, {\n        key: 'getResponseText',\n        value: function getResponseText() {\n            if (!this.sent_) {\n                throw errorsExports.internalError('cannot .getResponseText() before sending');\n            }\n            return this.xhr_.responseText;\n        }\n        /**\n         * Aborts the request.\n         * @override\n         */\n\n    }, {\n        key: 'abort',\n        value: function abort() {\n            this.xhr_.abort();\n        }\n        /**\n         * @override\n         */\n\n    }, {\n        key: 'getResponseHeader',\n        value: function getResponseHeader(header) {\n            return this.xhr_.getResponseHeader(header);\n        }\n        /**\n         * @override\n         */\n\n    }, {\n        key: 'addUploadProgressListener',\n        value: function addUploadProgressListener(listener) {\n            if (type.isDef(this.xhr_.upload)) {\n                this.xhr_.upload.addEventListener('progress', listener);\n            }\n        }\n        /**\n         * @override\n         */\n\n    }, {\n        key: 'removeUploadProgressListener',\n        value: function removeUploadProgressListener(listener) {\n            if (type.isDef(this.xhr_.upload)) {\n                this.xhr_.upload.removeEventListener('progress', listener);\n            }\n        }\n    }]);\n\n    return NetworkXhrIo;\n}();\n\n/***/ }),\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.UploadTask = undefined;\n\nvar _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; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n/**\n * @fileoverview Defines types for interacting with blob transfer tasks.\n */\n\n\nvar _taskenums = __webpack_require__(15);\n\nvar fbsTaskEnums = _interopRequireWildcard(_taskenums);\n\nvar _observer = __webpack_require__(44);\n\nvar _tasksnapshot = __webpack_require__(50);\n\nvar _args = __webpack_require__(11);\n\nvar fbsArgs = _interopRequireWildcard(_args);\n\nvar _array = __webpack_require__(12);\n\nvar fbsArray = _interopRequireWildcard(_array);\n\nvar _async = __webpack_require__(38);\n\nvar _error = __webpack_require__(1);\n\nvar errors = _interopRequireWildcard(_error);\n\nvar _promise_external = __webpack_require__(2);\n\nvar fbsPromiseimpl = _interopRequireWildcard(_promise_external);\n\nvar _requests = __webpack_require__(24);\n\nvar fbsRequests = _interopRequireWildcard(_requests);\n\nvar _type = __webpack_require__(0);\n\nvar typeUtils = _interopRequireWildcard(_type);\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * Represents a blob being uploaded. Can be used to pause/resume/cancel the\n * upload and manage callbacks for various events.\n */\nvar UploadTask = exports.UploadTask = function () {\n    /**\n     * @param ref The firebaseStorage.Reference object this task came\n     *     from, untyped to avoid cyclic dependencies.\n     * @param blob The blob to upload.\n     */\n    function UploadTask(ref, authWrapper, location, mappings, blob) {\n        var _this = this;\n\n        var metadata = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;\n\n        _classCallCheck(this, UploadTask);\n\n        this.transferred_ = 0;\n        this.needToFetchStatus_ = false;\n        this.needToFetchMetadata_ = false;\n        this.observers_ = [];\n        this.error_ = null;\n        this.uploadUrl_ = null;\n        this.request_ = null;\n        this.chunkMultiplier_ = 1;\n        this.resolve_ = null;\n        this.reject_ = null;\n        this.ref_ = ref;\n        this.authWrapper_ = authWrapper;\n        this.location_ = location;\n        this.blob_ = blob;\n        this.metadata_ = metadata;\n        this.mappings_ = mappings;\n        this.resumable_ = this.shouldDoResumable_(this.blob_);\n        this.state_ = _taskenums.InternalTaskState.RUNNING;\n        this.errorHandler_ = function (error) {\n            _this.request_ = null;\n            _this.chunkMultiplier_ = 1;\n            if (error.codeEquals(errors.Code.CANCELED)) {\n                _this.needToFetchStatus_ = true;\n                _this.completeTransitions_();\n            } else {\n                _this.error_ = error;\n                _this.transition_(_taskenums.InternalTaskState.ERROR);\n            }\n        };\n        this.metadataErrorHandler_ = function (error) {\n            _this.request_ = null;\n            if (error.codeEquals(errors.Code.CANCELED)) {\n                _this.completeTransitions_();\n            } else {\n                _this.error_ = error;\n                _this.transition_(_taskenums.InternalTaskState.ERROR);\n            }\n        };\n        this.promise_ = fbsPromiseimpl.make(function (resolve, reject) {\n            _this.resolve_ = resolve;\n            _this.reject_ = reject;\n            _this.start_();\n        });\n        // Prevent uncaught rejections on the internal promise from bubbling out\n        // to the top level with a dummy handler.\n        this.promise_.then(null, function () {});\n    }\n\n    _createClass(UploadTask, [{\n        key: 'makeProgressCallback_',\n        value: function makeProgressCallback_() {\n            var _this2 = this;\n\n            var sizeBefore = this.transferred_;\n            return function (loaded) {\n                _this2.updateProgress_(sizeBefore + loaded);\n            };\n        }\n    }, {\n        key: 'shouldDoResumable_',\n        value: function shouldDoResumable_(blob) {\n            return blob.size() > 256 * 1024;\n        }\n    }, {\n        key: 'start_',\n        value: function start_() {\n            if (this.state_ !== _taskenums.InternalTaskState.RUNNING) {\n                // This can happen if someone pauses us in a resume callback, for example.\n                return;\n            }\n            if (this.request_ !== null) {\n                return;\n            }\n            if (this.resumable_) {\n                if (this.uploadUrl_ === null) {\n                    this.createResumable_();\n                } else {\n                    if (this.needToFetchStatus_) {\n                        this.fetchStatus_();\n                    } else {\n                        if (this.needToFetchMetadata_) {\n                            // Happens if we miss the metadata on upload completion.\n                            this.fetchMetadata_();\n                        } else {\n                            this.continueUpload_();\n                        }\n                    }\n                }\n            } else {\n                this.oneShotUpload_();\n            }\n        }\n    }, {\n        key: 'resolveToken_',\n        value: function resolveToken_(callback) {\n            var _this3 = this;\n\n            this.authWrapper_.getAuthToken().then(function (authToken) {\n                switch (_this3.state_) {\n                    case _taskenums.InternalTaskState.RUNNING:\n                        callback(authToken);\n                        break;\n                    case _taskenums.InternalTaskState.CANCELING:\n                        _this3.transition_(_taskenums.InternalTaskState.CANCELED);\n                        break;\n                    case _taskenums.InternalTaskState.PAUSING:\n                        _this3.transition_(_taskenums.InternalTaskState.PAUSED);\n                        break;\n                    default:\n                }\n            });\n        }\n        // TODO(andysoto): assert false\n\n    }, {\n        key: 'createResumable_',\n        value: function createResumable_() {\n            var _this4 = this;\n\n            this.resolveToken_(function (authToken) {\n                var requestInfo = fbsRequests.createResumableUpload(_this4.authWrapper_, _this4.location_, _this4.mappings_, _this4.blob_, _this4.metadata_);\n                var createRequest = _this4.authWrapper_.makeRequest(requestInfo, authToken);\n                _this4.request_ = createRequest;\n                createRequest.getPromise().then(function (url) {\n                    _this4.request_ = null;\n                    _this4.uploadUrl_ = url;\n                    _this4.needToFetchStatus_ = false;\n                    _this4.completeTransitions_();\n                }, _this4.errorHandler_);\n            });\n        }\n    }, {\n        key: 'fetchStatus_',\n        value: function fetchStatus_() {\n            var _this5 = this;\n\n            // TODO(andysoto): assert(this.uploadUrl_ !== null);\n            var url = this.uploadUrl_;\n            this.resolveToken_(function (authToken) {\n                var requestInfo = fbsRequests.getResumableUploadStatus(_this5.authWrapper_, _this5.location_, url, _this5.blob_);\n                var statusRequest = _this5.authWrapper_.makeRequest(requestInfo, authToken);\n                _this5.request_ = statusRequest;\n                statusRequest.getPromise().then(function (status) {\n                    status = status;\n                    _this5.request_ = null;\n                    _this5.updateProgress_(status.current);\n                    _this5.needToFetchStatus_ = false;\n                    if (status.finalized) {\n                        _this5.needToFetchMetadata_ = true;\n                    }\n                    _this5.completeTransitions_();\n                }, _this5.errorHandler_);\n            });\n        }\n    }, {\n        key: 'continueUpload_',\n        value: function continueUpload_() {\n            var _this6 = this;\n\n            var chunkSize = fbsRequests.resumableUploadChunkSize * this.chunkMultiplier_;\n            var status = new fbsRequests.ResumableUploadStatus(this.transferred_, this.blob_.size());\n            // TODO(andysoto): assert(this.uploadUrl_ !== null);\n            var url = this.uploadUrl_;\n            this.resolveToken_(function (authToken) {\n                var requestInfo = void 0;\n                try {\n                    requestInfo = fbsRequests.continueResumableUpload(_this6.location_, _this6.authWrapper_, url, _this6.blob_, chunkSize, _this6.mappings_, status, _this6.makeProgressCallback_());\n                } catch (e) {\n                    _this6.error_ = e;\n                    _this6.transition_(_taskenums.InternalTaskState.ERROR);\n                    return;\n                }\n                var uploadRequest = _this6.authWrapper_.makeRequest(requestInfo, authToken);\n                _this6.request_ = uploadRequest;\n                uploadRequest.getPromise().then(function (newStatus) {\n                    _this6.increaseMultiplier_();\n                    _this6.request_ = null;\n                    _this6.updateProgress_(newStatus.current);\n                    if (newStatus.finalized) {\n                        _this6.metadata_ = newStatus.metadata;\n                        _this6.transition_(_taskenums.InternalTaskState.SUCCESS);\n                    } else {\n                        _this6.completeTransitions_();\n                    }\n                }, _this6.errorHandler_);\n            });\n        }\n    }, {\n        key: 'increaseMultiplier_',\n        value: function increaseMultiplier_() {\n            var currentSize = fbsRequests.resumableUploadChunkSize * this.chunkMultiplier_;\n            // Max chunk size is 32M.\n            if (currentSize < 32 * 1024 * 1024) {\n                this.chunkMultiplier_ *= 2;\n            }\n        }\n    }, {\n        key: 'fetchMetadata_',\n        value: function fetchMetadata_() {\n            var _this7 = this;\n\n            this.resolveToken_(function (authToken) {\n                var requestInfo = fbsRequests.getMetadata(_this7.authWrapper_, _this7.location_, _this7.mappings_);\n                var metadataRequest = _this7.authWrapper_.makeRequest(requestInfo, authToken);\n                _this7.request_ = metadataRequest;\n                metadataRequest.getPromise().then(function (metadata) {\n                    _this7.request_ = null;\n                    _this7.metadata_ = metadata;\n                    _this7.transition_(_taskenums.InternalTaskState.SUCCESS);\n                }, _this7.metadataErrorHandler_);\n            });\n        }\n    }, {\n        key: 'oneShotUpload_',\n        value: function oneShotUpload_() {\n            var _this8 = this;\n\n            this.resolveToken_(function (authToken) {\n                var requestInfo = fbsRequests.multipartUpload(_this8.authWrapper_, _this8.location_, _this8.mappings_, _this8.blob_, _this8.metadata_);\n                var multipartRequest = _this8.authWrapper_.makeRequest(requestInfo, authToken);\n                _this8.request_ = multipartRequest;\n                multipartRequest.getPromise().then(function (metadata) {\n                    _this8.request_ = null;\n                    _this8.metadata_ = metadata;\n                    _this8.updateProgress_(_this8.blob_.size());\n                    _this8.transition_(_taskenums.InternalTaskState.SUCCESS);\n                }, _this8.errorHandler_);\n            });\n        }\n    }, {\n        key: 'updateProgress_',\n        value: function updateProgress_(transferred) {\n            var old = this.transferred_;\n            this.transferred_ = transferred;\n            // A progress update can make the \"transferred\" value smaller (e.g. a\n            // partial upload not completed by server, after which the \"transferred\"\n            // value may reset to the value at the beginning of the request).\n            if (this.transferred_ !== old) {\n                this.notifyObservers_();\n            }\n        }\n    }, {\n        key: 'transition_',\n        value: function transition_(state) {\n            if (this.state_ === state) {\n                return;\n            }\n            switch (state) {\n                case _taskenums.InternalTaskState.CANCELING:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.RUNNING ||\n                    //        this.state_ === InternalTaskState.PAUSING);\n                    this.state_ = state;\n                    if (this.request_ !== null) {\n                        this.request_.cancel();\n                    }\n                    break;\n                case _taskenums.InternalTaskState.PAUSING:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.RUNNING);\n                    this.state_ = state;\n                    if (this.request_ !== null) {\n                        this.request_.cancel();\n                    }\n                    break;\n                case _taskenums.InternalTaskState.RUNNING:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.PAUSED ||\n                    //        this.state_ === InternalTaskState.PAUSING);\n                    var wasPaused = this.state_ === _taskenums.InternalTaskState.PAUSED;\n                    this.state_ = state;\n                    if (wasPaused) {\n                        this.notifyObservers_();\n                        this.start_();\n                    }\n                    break;\n                case _taskenums.InternalTaskState.PAUSED:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.PAUSING);\n                    this.state_ = state;\n                    this.notifyObservers_();\n                    break;\n                case _taskenums.InternalTaskState.CANCELED:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.PAUSED ||\n                    //        this.state_ === InternalTaskState.CANCELING);\n                    this.error_ = errors.canceled();\n                    this.state_ = state;\n                    this.notifyObservers_();\n                    break;\n                case _taskenums.InternalTaskState.ERROR:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.RUNNING ||\n                    //        this.state_ === InternalTaskState.PAUSING ||\n                    //        this.state_ === InternalTaskState.CANCELING);\n                    this.state_ = state;\n                    this.notifyObservers_();\n                    break;\n                case _taskenums.InternalTaskState.SUCCESS:\n                    // TODO(andysoto):\n                    // assert(this.state_ === InternalTaskState.RUNNING ||\n                    //        this.state_ === InternalTaskState.PAUSING ||\n                    //        this.state_ === InternalTaskState.CANCELING);\n                    this.state_ = state;\n                    this.notifyObservers_();\n                    break;\n            }\n        }\n    }, {\n        key: 'completeTransitions_',\n        value: function completeTransitions_() {\n            switch (this.state_) {\n                case _taskenums.InternalTaskState.PAUSING:\n                    this.transition_(_taskenums.InternalTaskState.PAUSED);\n                    break;\n                case _taskenums.InternalTaskState.CANCELING:\n                    this.transition_(_taskenums.InternalTaskState.CANCELED);\n                    break;\n                case _taskenums.InternalTaskState.RUNNING:\n                    this.start_();\n                    break;\n                default:\n                    // TODO(andysoto): assert(false);\n                    break;\n            }\n        }\n    }, {\n        key: 'on',\n\n        /**\n         * Adds a callback for an event.\n         * @param type The type of event to listen for.\n         */\n        value: function on(type) {\n            var nextOrObserver = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;\n            var error = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;\n            var completed = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;\n\n            var nextOrObserverMessage = 'Expected a function or an Object with one of ' + '`next`, `error`, `complete` properties.';\n            var nextValidator = fbsArgs.nullFunctionSpec(true).validator;\n            var observerValidator = fbsArgs.looseObjectSpec(null, true).validator;\n            function nextOrObserverValidator(p) {\n                try {\n                    nextValidator(p);\n                    return;\n                } catch (e) {}\n                try {\n                    observerValidator(p);\n                    var anyDefined = typeUtils.isJustDef(p['next']) || typeUtils.isJustDef(p['error']) || typeUtils.isJustDef(p['complete']);\n                    if (!anyDefined) {\n                        throw '';\n                    }\n                } catch (e) {\n                    throw nextOrObserverMessage;\n                }\n            }\n            var specs = [fbsArgs.stringSpec(function () {\n                if (type !== _taskenums.TaskEvent.STATE_CHANGED) {\n                    throw 'Expected one of the event types: [' + _taskenums.TaskEvent.STATE_CHANGED + '].';\n                }\n            }), fbsArgs.looseObjectSpec(nextOrObserverValidator, true), fbsArgs.nullFunctionSpec(true), fbsArgs.nullFunctionSpec(true)];\n            fbsArgs.validate('on', specs, arguments);\n            var self = this;\n            function makeBinder(specs) {\n                return function (nextOrObserver, error) {\n                    if (specs !== null) {\n                        fbsArgs.validate('on', specs, arguments);\n                    }\n                    var observer = new _observer.Observer(nextOrObserver, error, completed);\n                    self.addObserver_(observer);\n                    return function () {\n                        self.removeObserver_(observer);\n                    };\n                };\n            }\n\n            var binderSpecs = [fbsArgs.looseObjectSpec(function (p) {\n                if (p === null) {\n                    throw nextOrObserverMessage;\n                }\n                nextOrObserverValidator(p);\n            }), fbsArgs.nullFunctionSpec(true), fbsArgs.nullFunctionSpec(true)];\n            var typeOnly = !(typeUtils.isJustDef(nextOrObserver) || typeUtils.isJustDef(error) || typeUtils.isJustDef(completed));\n            if (typeOnly) {\n                return makeBinder(binderSpecs);\n            } else {\n                return makeBinder(null)(nextOrObserver, error, completed);\n            }\n        }\n        /**\n         * This object behaves like a Promise, and resolves with its snapshot data\n         * when the upload completes.\n         *     The fulfillment callback. Promise chaining works as normal.\n         * @param onRejected The rejection callback.\n         */\n\n    }, {\n        key: 'then',\n        value: function then(onFulfilled, onRejected) {\n            return this.promise_.then(onFulfilled, onRejected);\n        }\n        /**\n         * Equivalent to calling `then(null, onRejected)`.\n         */\n\n    }, {\n        key: 'catch',\n        value: function _catch(onRejected) {\n            return this.then(null, onRejected);\n        }\n        /**\n         * Adds the given observer.\n         */\n\n    }, {\n        key: 'addObserver_',\n        value: function addObserver_(observer) {\n            this.observers_.push(observer);\n            this.notifyObserver_(observer);\n        }\n        /**\n         * Removes the given observer.\n         */\n\n    }, {\n        key: 'removeObserver_',\n        value: function removeObserver_(observer) {\n            fbsArray.remove(this.observers_, observer);\n        }\n    }, {\n        key: 'notifyObservers_',\n        value: function notifyObservers_() {\n            var _this9 = this;\n\n            this.finishPromise_();\n            var observers = fbsArray.clone(this.observers_);\n            observers.forEach(function (observer) {\n                _this9.notifyObserver_(observer);\n            });\n        }\n    }, {\n        key: 'finishPromise_',\n        value: function finishPromise_() {\n            if (this.resolve_ !== null) {\n                var triggered = true;\n                switch (fbsTaskEnums.taskStateFromInternalTaskState(this.state_)) {\n                    case _taskenums.TaskState.SUCCESS:\n                        (0, _async.async)(this.resolve_.bind(null, this.snapshot))();\n                        break;\n                    case _taskenums.TaskState.CANCELED:\n                    case _taskenums.TaskState.ERROR:\n                        var toCall = this.reject_;\n                        (0, _async.async)(toCall.bind(null, this.error_))();\n                        break;\n                    default:\n                        triggered = false;\n                        break;\n                }\n                if (triggered) {\n                    this.resolve_ = null;\n                    this.reject_ = null;\n                }\n            }\n        }\n    }, {\n        key: 'notifyObserver_',\n        value: function notifyObserver_(observer) {\n            var externalState = fbsTaskEnums.taskStateFromInternalTaskState(this.state_);\n            switch (externalState) {\n                case _taskenums.TaskState.RUNNING:\n                case _taskenums.TaskState.PAUSED:\n                    if (observer.next !== null) {\n                        (0, _async.async)(observer.next.bind(observer, this.snapshot))();\n                    }\n                    break;\n                case _taskenums.TaskState.SUCCESS:\n                    if (observer.complete !== null) {\n                        (0, _async.async)(observer.complete.bind(observer))();\n                    }\n                    break;\n                case _taskenums.TaskState.CANCELED:\n                case _taskenums.TaskState.ERROR:\n                    if (observer.error !== null) {\n                        (0, _async.async)(observer.error.bind(observer, this.error_))();\n                    }\n                    break;\n                default:\n                    // TODO(andysoto): assert(false);\n                    if (observer.error !== null) {\n                        (0, _async.async)(observer.error.bind(observer, this.error_))();\n                    }\n            }\n        }\n        /**\n         * Resumes a paused task. Has no effect on a currently running or failed task.\n         * @return True if the operation took effect, false if ignored.\n         */\n\n    }, {\n        key: 'resume',\n        value: function resume() {\n            fbsArgs.validate('resume', [], arguments);\n            var valid = this.state_ === _taskenums.InternalTaskState.PAUSED || this.state_ === _taskenums.InternalTaskState.PAUSING;\n            if (valid) {\n                this.transition_(_taskenums.InternalTaskState.RUNNING);\n            }\n            return valid;\n        }\n        /**\n         * Pauses a currently running task. Has no effect on a paused or failed task.\n         * @return True if the operation took effect, false if ignored.\n         */\n\n    }, {\n        key: 'pause',\n        value: function pause() {\n            fbsArgs.validate('pause', [], arguments);\n            var valid = this.state_ === _taskenums.InternalTaskState.RUNNING;\n            if (valid) {\n                this.transition_(_taskenums.InternalTaskState.PAUSING);\n            }\n            return valid;\n        }\n        /**\n         * Cancels a currently running or paused task. Has no effect on a complete or\n         * failed task.\n         * @return True if the operation took effect, false if ignored.\n         */\n\n    }, {\n        key: 'cancel',\n        value: function cancel() {\n            fbsArgs.validate('cancel', [], arguments);\n            var valid = this.state_ === _taskenums.InternalTaskState.RUNNING || this.state_ === _taskenums.InternalTaskState.PAUSING;\n            if (valid) {\n                this.transition_(_taskenums.InternalTaskState.CANCELING);\n            }\n            return valid;\n        }\n    }, {\n        key: 'snapshot',\n        get: function get() {\n            var externalState = fbsTaskEnums.taskStateFromInternalTaskState(this.state_);\n            return new _tasksnapshot.UploadTaskSnapshot(this.transferred_, this.blob_.size(), externalState, this.metadata_, this, this.ref_);\n        }\n    }]);\n\n    return UploadTask;\n}();\n\n/***/ }),\n/* 50 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar UploadTaskSnapshot = exports.UploadTaskSnapshot = function () {\n    function UploadTaskSnapshot(bytesTransferred, totalBytes, state, metadata, task, ref) {\n        _classCallCheck(this, UploadTaskSnapshot);\n\n        this.bytesTransferred = bytesTransferred;\n        this.totalBytes = totalBytes;\n        this.state = state;\n        this.metadata = metadata;\n        this.task = task;\n        this.ref = ref;\n    }\n\n    _createClass(UploadTaskSnapshot, [{\n        key: 'downloadURL',\n        get: function get() {\n            if (this.metadata !== null) {\n                var urls = this.metadata['downloadURLs'];\n                if (urls != null && urls[0] != null) {\n                    return urls[0];\n                } else {\n                    return null;\n                }\n            } else {\n                return null;\n            }\n        }\n    }]);\n\n    return UploadTaskSnapshot;\n}();\n\n/***/ })\n],[37]);\n          } catch(error) {\n            throw new Error(\n              'Cannot instantiate firebase-storage.js - ' +\n              'be sure to load firebase-app.js first.'\n            )\n          }\n\n\n// WEBPACK FOOTER //\n// firebase-storage.js","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @return False if the object is undefined or null, true otherwise.\n */\nexport function isDef(p: any): boolean {\n  return p != null;\n}\n\nexport function isJustDef(p: any): boolean {\n  return p !== void 0;\n}\n\nexport function isFunction(p: any): boolean {\n  return typeof p === 'function';\n}\n\nexport function isObject(p: any): boolean {\n  return typeof p === 'object';\n}\n\nexport function isNonNullObject(p: any): boolean {\n  return isObject(p) && p !== null;\n}\n\nexport function isNonArrayObject(p: any): boolean {\n  return isObject(p) && !Array.isArray(p);\n}\n\nexport function isString(p: any): boolean {\n  return typeof p === 'string' || p instanceof String;\n}\n\nexport function isNumber(p: any): boolean {\n  return typeof p === 'number' || p instanceof Number;\n}\n\nexport function isNativeBlob(p: any): boolean {\n  return isNativeBlobDefined() && p instanceof Blob;\n}\n\nexport function isNativeBlobDefined(): boolean {\n  return typeof Blob !== 'undefined';\n}\n\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/type.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport {configOption} from './constants';\n\nexport class FirebaseStorageError implements Error {\n  private code_: string;\n  private message_: string;\n  private serverResponse_: string|null;\n  private name_: string;\n\n  constructor(code: Code, message: string) {\n    this.code_ = prependCode(code);\n    this.message_ = 'Firebase Storage: ' + message;\n    this.serverResponse_ = null;\n    this.name_ = 'FirebaseError';\n  }\n\n  codeProp(): string {\n    return this.code;\n  }\n\n  codeEquals(code: Code): boolean {\n    return prependCode(code) === this.codeProp();\n  }\n\n  serverResponseProp(): string|null {\n    return this.serverResponse_;\n  }\n\n  setServerResponseProp(serverResponse: string|null) {\n    this.serverResponse_ = serverResponse;\n  }\n\n  get name(): string {\n    return this.name_;\n  }\n\n  get code(): string {\n    return this.code_;\n  }\n\n  get message(): string {\n    return this.message_;\n  }\n\n  get serverResponse(): null|string {\n    return this.serverResponse_;\n  }\n}\n\nexport const errors = {};\n\n/**\n * @enum {string}\n */\nexport type Code = string;\nexport const Code = {\n  // Shared between all platforms\n  UNKNOWN: 'unknown',\n  OBJECT_NOT_FOUND: 'object-not-found',\n  BUCKET_NOT_FOUND: 'bucket-not-found',\n  PROJECT_NOT_FOUND: 'project-not-found',\n  QUOTA_EXCEEDED: 'quota-exceeded',\n  UNAUTHENTICATED: 'unauthenticated',\n  UNAUTHORIZED: 'unauthorized',\n  RETRY_LIMIT_EXCEEDED: 'retry-limit-exceeded',\n  INVALID_CHECKSUM: 'invalid-checksum',\n  CANCELED: 'canceled',\n  // JS specific\n  INVALID_EVENT_NAME: 'invalid-event-name',\n  INVALID_URL: 'invalid-url',\n  INVALID_DEFAULT_BUCKET: 'invalid-default-bucket',\n  NO_DEFAULT_BUCKET: 'no-default-bucket',\n  CANNOT_SLICE_BLOB: 'cannot-slice-blob',\n  SERVER_FILE_WRONG_SIZE: 'server-file-wrong-size',\n  NO_DOWNLOAD_URL: 'no-download-url',\n  INVALID_ARGUMENT: 'invalid-argument',\n  INVALID_ARGUMENT_COUNT: 'invalid-argument-count',\n  APP_DELETED: 'app-deleted',\n  INVALID_ROOT_OPERATION: 'invalid-root-operation',\n  INVALID_FORMAT: 'invalid-format',\n  INTERNAL_ERROR: 'internal-error'\n};\n\nexport function prependCode(code: Code): string {\n  return 'storage/' + code;\n}\n\nexport function unknown(): FirebaseStorageError {\n  let message =\n      'An unknown error occurred, please check the error payload for ' +\n      'server response.';\n  return new FirebaseStorageError(Code.UNKNOWN, message);\n}\n\nexport function objectNotFound(path: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.OBJECT_NOT_FOUND, 'Object \\'' + path + '\\' does not exist.');\n}\n\nexport function bucketNotFound(bucket: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.BUCKET_NOT_FOUND, 'Bucket \\'' + bucket + '\\' does not exist.');\n}\n\nexport function projectNotFound(project: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.PROJECT_NOT_FOUND, 'Project \\'' + project + '\\' does not exist.');\n}\n\nexport function quotaExceeded(bucket: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.QUOTA_EXCEEDED,\n      'Quota for bucket \\'' + bucket + '\\' exceeded, please view quota on ' +\n          'https://firebase.google.com/pricing/.');\n}\n\nexport function unauthenticated(): FirebaseStorageError {\n  let message =\n      'User is not authenticated, please authenticate using Firebase ' +\n      'Authentication and try again.';\n  return new FirebaseStorageError(Code.UNAUTHENTICATED, message);\n}\n\nexport function unauthorized(path: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.UNAUTHORIZED,\n      'User does not have permission to access \\'' + path + '\\'.');\n}\n\nexport function retryLimitExceeded(): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.RETRY_LIMIT_EXCEEDED,\n      'Max retry time for operation exceeded, please try again.');\n}\n\nexport function invalidChecksum(\n    path: string, checksum: string, calculated: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.INVALID_CHECKSUM,\n      'Uploaded/downloaded object \\'' + path + '\\' has checksum \\'' + checksum +\n          '\\' which does not match \\'' + calculated +\n          '\\'. Please retry the upload/download.');\n}\n\nexport function canceled(): FirebaseStorageError {\n  return new FirebaseStorageError(Code.CANCELED, 'User canceled the upload/download.');\n}\n\nexport function invalidEventName(name: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.INVALID_EVENT_NAME, 'Invalid event name \\'' + name + '\\'.');\n}\n\nexport function invalidUrl(url: string): FirebaseStorageError {\n  return new FirebaseStorageError(Code.INVALID_URL, 'Invalid URL \\'' + url + '\\'.');\n}\n\nexport function invalidDefaultBucket(bucket: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.INVALID_DEFAULT_BUCKET,\n      'Invalid default bucket \\'' + bucket + '\\'.');\n}\n\nexport function noDefaultBucket(): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.NO_DEFAULT_BUCKET,\n      'No default bucket ' +\n          'found. Did you set the \\'' + configOption +\n          '\\' property when initializing the app?');\n}\n\nexport function cannotSliceBlob(): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.CANNOT_SLICE_BLOB,\n      'Cannot slice blob for upload. Please retry the upload.');\n}\n\nexport function serverFileWrongSize(): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.SERVER_FILE_WRONG_SIZE,\n      'Server recorded incorrect upload file size, please retry the upload.');\n}\n\nexport function noDownloadURL(): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.NO_DOWNLOAD_URL, 'The given file does not have any download URLs.');\n}\n\nexport function invalidArgument(\n    index: number, fnName: string, message: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.INVALID_ARGUMENT,\n      'Invalid argument in `' + fnName + '` at index ' + index + ': ' +\n          message);\n}\n\nexport function invalidArgumentCount(\n    argMin: number, argMax: number, fnName: string, real: number): FirebaseStorageError {\n  let countPart;\n  let plural;\n  if (argMin === argMax) {\n    countPart = argMin;\n    plural = argMin === 1 ? 'argument' : 'arguments';\n  } else {\n    countPart = 'between ' + argMin + ' and ' + argMax;\n    plural = 'arguments';\n  }\n  return new FirebaseStorageError(\n      Code.INVALID_ARGUMENT_COUNT,\n      'Invalid argument count in `' + fnName + '`: Expected ' + countPart +\n          ' ' + plural + ', received ' + real + '.');\n}\n\nexport function appDeleted(): FirebaseStorageError {\n  return new FirebaseStorageError(Code.APP_DELETED, 'The Firebase app was deleted.');\n}\n\n/**\n * @param name The name of the operation that was invalid.\n */\nexport function invalidRootOperation(name: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.INVALID_ROOT_OPERATION,\n      'The operation \\'' + name +\n          '\\' cannot be performed on a root reference, create a non-root ' +\n          'reference using child, such as .child(\\'file.png\\').');\n}\n\n/**\n * @param format The format that was not valid.\n * @param message A message describing the format violation.\n */\nexport function invalidFormat(format: string, message: string): FirebaseStorageError {\n  return new FirebaseStorageError(\n      Code.INVALID_FORMAT,\n      'String does not match format \\'' + format + '\\': ' + message);\n}\n\n/**\n * @param message A message describing the internal error.\n */\nexport function internalError(message: string): FirebaseStorageError {\n  throw new FirebaseStorageError(Code.INTERNAL_ERROR, 'Internal error: ' + message);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/error.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Implements the promise abstraction interface for external\n * (public SDK) packaging, which just passes through to the firebase-app impl.\n */\n\n/**\n * @template T\n * @param {function((function(T): void),\n *                  (function(!Error): void))} resolver\n */\n\nimport { local } from \"../../app/shared_promise\";\n\nexport function make<T>(resolver: (p1: (p1: T) => void, \n                        p2: (p1: Error) => void) => void): Promise<T> {\n  return new local.Promise(resolver);\n}\n\n/**\n * @template T\n */\nexport function resolve<T>(value: T): Promise<T> {\n  return (local.Promise.resolve(value) as Promise<T>);\n}\n\nexport function reject<T>(error: Error): Promise<T> {\n  return (local.Promise.reject(error) as Promise<T>);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/promise_external.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Contains methods for working with objects.\n */\nexport function contains(\n    obj: Object, prop: string): boolean {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nexport function forEach<T>(\n    obj: {[key: string]: T},\n    f: (p1: string, p2: T) => void) {\n  for (let key in obj) {\n    if (contains(obj, key)) {\n      f(key, obj[key]);\n    }\n  }\n}\n\nexport function clone<T>(obj?: {[key: string]: any}|null): T {\n  if (obj == null) {\n    return {} as T;\n  }\n\n  let c: {[name: string]: any} = {};\n  forEach(obj, function(key, val) {\n    c[key] = val;\n  });\n  return c as T;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/object.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Constants used in the Firebase Storage library.\n */\n\n/**\n * Domain and scheme for API calls.\n */\nexport const domainBase: string = 'https://firebasestorage.googleapis.com';\n\n/**\n * Domain and scheme for object downloads.\n */\nexport const downloadBase: string = 'https://firebasestorage.googleapis.com';\n\n/**\n * Base URL for non-upload calls to the API.\n */\nexport const apiBaseUrl: string = '/v0';\n\n/**\n * Base URL for upload calls to the API.\n */\nexport const apiUploadBaseUrl: string = '/v0';\n\nexport function setDomainBase(domainBase: string) {\n  domainBase = domainBase;\n}\n\nexport const configOption: string = 'storageBucket';\n\n/**\n * 1 minute\n */\nexport const shortMaxOperationRetryTime: number = 1 * 60 * 1000;\n\n/**\n * 2 minutes\n */\nexport const defaultMaxOperationRetryTime: number = 2 * 60 * 1000;\n\n/**\n * 10 minutes\n */\nexport const defaultMaxUploadRetryTime: number = 10 * 60 * 100;\n\n/**\n * This is the value of Number.MIN_SAFE_INTEGER, which is not well supported\n * enough for us to use it directly.\n */\nexport const minSafeInteger: number = -9007199254740991;\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/constants.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Functionality related to the parsing/composition of bucket/\n * object location.\n */\nimport * as errorsExports from './error';\nimport {errors} from './error';\n\n/**\n * @struct\n */\nexport class Location {\n  private path_: string;\n\n  constructor(public readonly bucket: string, path: string) {\n    this.path_ = path;\n  }\n\n  get path(): string {\n    return this.path_;\n  }\n\n  fullServerUrl(): string {\n    let encode = encodeURIComponent;\n    return '/b/' + encode(this.bucket) + '/o/' + encode(this.path);\n  }\n\n  bucketOnlyServerUrl(): string {\n    let encode = encodeURIComponent;\n    return '/b/' + encode(this.bucket) + '/o';\n  }\n\n  static makeFromBucketSpec(bucketString: string): Location {\n    let bucketLocation;\n    try {\n      bucketLocation = Location.makeFromUrl(bucketString);\n    } catch (e) {\n      // Not valid URL, use as-is. This lets you put bare bucket names in\n      // config.\n      return new Location(bucketString, '');\n    }\n    if (bucketLocation.path === '') {\n      return bucketLocation;\n    } else {\n      throw errorsExports.invalidDefaultBucket(bucketString);\n    }\n  }\n\n  static makeFromUrl(url: string): Location {\n    let location = null;\n    let bucketDomain = '([A-Za-z0-9.\\\\-]+)';\n\n    function gsModify(loc: Location) {\n      if (loc.path.charAt(loc.path.length - 1) === '/') {\n        loc.path_ = loc.path_.slice(0, -1);\n      }\n    }\n    let gsPath = '(/(.*))?$';\n    let path = '(/([^?#]*).*)?$';\n    let gsRegex = new RegExp('^gs://' + bucketDomain + gsPath, 'i');\n    let gsIndices = {bucket: 1, path: 3};\n\n    function httpModify(loc: Location) {\n      loc.path_ = decodeURIComponent(loc.path);\n    }\n    let version = 'v[A-Za-z0-9_]+';\n    let httpRegex = new RegExp(\n        '^https?://firebasestorage\\\\.googleapis\\\\.com/' + version + '/b/' +\n            bucketDomain + '/o' + path,\n        'i');\n    let httpIndices = {bucket: 1, path: 3};\n    let groups = [\n      {regex: gsRegex, indices: gsIndices, postModify: gsModify},\n      {regex: httpRegex, indices: httpIndices, postModify: httpModify}\n    ];\n    for (let i = 0; i < groups.length; i++) {\n      let group = groups[i];\n      let captures = group.regex.exec(url);\n      if (captures) {\n        let bucketValue = captures[group.indices.bucket];\n        let pathValue = captures[group.indices.path];\n        if (!pathValue) {\n          pathValue = '';\n        }\n        location = new Location(bucketValue, pathValue);\n        group.postModify(location);\n        break;\n      }\n    }\n    if (location == null) {\n      throw errorsExports.invalidUrl(url);\n    }\n    return location;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/location.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as errorsExports from './error';\nimport {errors} from './error';\n\n/**\n * @enum {string}\n */\nexport type StringFormat = string;\nexport const StringFormat = {\n  RAW: 'raw',\n  BASE64: 'base64',\n  BASE64URL: 'base64url',\n  DATA_URL: 'data_url'\n};\n\nexport function formatValidator(stringFormat: string) {\n  switch (stringFormat) {\n    case StringFormat.RAW:\n    case StringFormat.BASE64:\n    case StringFormat.BASE64URL:\n    case StringFormat.DATA_URL:\n      return;\n    default:\n      throw 'Expected one of the event types: [' + StringFormat.RAW + ', ' +\n          StringFormat.BASE64 + ', ' + StringFormat.BASE64URL + ', ' +\n          StringFormat.DATA_URL + '].';\n  }\n}\n\n/**\n * @struct\n */\nexport class StringData {\n  contentType: string|null;\n\n  constructor(public data: Uint8Array, opt_contentType?: string|null) {\n    this.contentType = opt_contentType || null;\n  }\n}\n\nexport function dataFromString(\n    format: StringFormat, string: string): StringData {\n  switch (format) {\n    case StringFormat.RAW:\n      return new StringData(utf8Bytes_(string));\n    case StringFormat.BASE64:\n    case StringFormat.BASE64URL:\n      return new StringData(base64Bytes_(format, string));\n    case StringFormat.DATA_URL:\n      return new StringData(dataURLBytes_(string), dataURLContentType_(string));\n  }\n\n  // assert(false);\n  throw errorsExports.unknown();\n}\n\nexport function utf8Bytes_(string: string): Uint8Array {\n  let b = [];\n  for (let i = 0; i < string.length; i++) {\n    let c = string.charCodeAt(i);\n    if (c <= 127) {\n      b.push(c);\n    } else {\n      if (c <= 2047) {\n        b.push(192 | c >> 6, 128 | c & 63);\n      } else {\n        if ((c & 64512) == 55296) {\n          // The start of a surrogate pair.\n          let valid = i < string.length - 1 &&\n              (string.charCodeAt(i + 1) & 64512) == 56320;\n          if (!valid) {\n            // The second surrogate wasn't there.\n            b.push(239, 191, 189);\n          } else {\n            let hi = c;\n            let lo = string.charCodeAt(++i);\n            c = 65536 | (hi & 1023) << 10 | lo & 1023;\n            b.push(\n                240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63,\n                128 | c & 63);\n          }\n        } else {\n          if ((c & 64512) == 56320) {\n            // Invalid low surrogate.\n            b.push(239, 191, 189);\n          } else {\n            b.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);\n          }\n        }\n      }\n    }\n  }\n  return new Uint8Array(b);\n}\n\nexport function percentEncodedBytes_(string: string): Uint8Array {\n  let decoded;\n  try {\n    decoded = decodeURIComponent(string);\n  } catch (e) {\n    throw errorsExports.invalidFormat(\n        StringFormat.DATA_URL, 'Malformed data URL.');\n  }\n  return utf8Bytes_(decoded);\n}\n\nexport function base64Bytes_(format: StringFormat, string: string): Uint8Array {\n  switch (format) {\n    case StringFormat.BASE64: {\n      let hasMinus = string.indexOf('-') !== -1;\n      let hasUnder = string.indexOf('_') !== -1;\n      if (hasMinus || hasUnder) {\n        let invalidChar = hasMinus ? '-' : '_';\n        throw errorsExports.invalidFormat(\n            format,\n            'Invalid character \\'' + invalidChar +\n                '\\' found: is it base64url encoded?');\n      }\n      break;\n    }\n    case StringFormat.BASE64URL: {\n      let hasPlus = string.indexOf('+') !== -1;\n      let hasSlash = string.indexOf('/') !== -1;\n      if (hasPlus || hasSlash) {\n        let invalidChar = hasPlus ? '+' : '/';\n        throw errorsExports.invalidFormat(\n            format,\n            'Invalid character \\'' + invalidChar +\n                '\\' found: is it base64 encoded?');\n      }\n      string = string.replace(/-/g, '+').replace(/_/g, '/');\n      break;\n    }\n  }\n  let bytes;\n  try {\n    bytes = atob(string);\n  } catch (e) {\n    throw errorsExports.invalidFormat(format, 'Invalid character found');\n  }\n  let array = new Uint8Array(bytes.length);\n  for (let i = 0; i < bytes.length; i++) {\n    array[i] = bytes.charCodeAt(i);\n  }\n  return array;\n}\n\n/**\n * @struct\n */\nclass DataURLParts {\n  base64: boolean = false;\n  contentType: string|null = null;\n  rest: string;\n\n  constructor(dataURL: string) {\n    let matches = dataURL.match(/^data:([^,]+)?,/);\n    if (matches === null) {\n      throw errorsExports.invalidFormat(\n          StringFormat.DATA_URL,\n          'Must be formatted \\'data:[<mediatype>][;base64],<data>');\n    }\n    let middle = matches[1] || null;\n    if (middle != null) {\n      this.base64 = endsWith(middle, ';base64');\n      this.contentType = this.base64 ?\n          middle.substring(0, middle.length - ';base64'.length) :\n          middle;\n    }\n    this.rest = dataURL.substring(dataURL.indexOf(',') + 1);\n  }\n}\n\nexport function dataURLBytes_(string: string): Uint8Array {\n  let parts = new DataURLParts(string);\n  if (parts.base64) {\n    return base64Bytes_(StringFormat.BASE64, parts.rest);\n  } else {\n    return percentEncodedBytes_(parts.rest);\n  }\n}\n\nexport function dataURLContentType_(string: string): string|null {\n  let parts = new DataURLParts(string);\n  return parts.contentType;\n}\n\nfunction endsWith(s: string, end: string): boolean {\n  const longEnough = s.length >= end.length;\n  if (!longEnough) {\n    return false;\n  }\n\n  return s.substring(s.length - end.length) === end;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/string.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as errorsExports from './error';\nimport {errors} from './error';\nimport * as MetadataUtils from './metadata';\nimport * as type from './type';\n\n/**\n * @param name Name of the function.\n * @param specs Argument specs.\n * @param passed The actual arguments passed to the function.\n * @throws {fbs.Error} If the arguments are invalid.\n */\nexport function validate(name: string, specs: ArgSpec[], passed: IArguments) {\n  let minArgs = specs.length;\n  let maxArgs = specs.length;\n  for (let i = 0; i < specs.length; i++) {\n    if (specs[i].optional) {\n      minArgs = i;\n      break;\n    }\n  }\n  let validLength = minArgs <= passed.length && passed.length <= maxArgs;\n  if (!validLength) {\n    throw errorsExports.invalidArgumentCount(\n        minArgs, maxArgs, name, passed.length);\n  }\n  for (let i = 0; i < passed.length; i++) {\n    try {\n      specs[i].validator(passed[i]);\n    } catch (e) {\n      if (e instanceof Error) {\n        throw errorsExports.invalidArgument(i, name, e.message);\n      } else {\n        throw errorsExports.invalidArgument(i, name, e);\n      }\n    }\n  }\n}\n\n/**\n * @struct\n */\nexport class ArgSpec {\n  validator: (p1: any) => void;\n  optional: boolean;\n\n  constructor(\n      validator: (p1: any) => void,\n      opt_optional?: boolean) {\n    let self = this;\n    this.validator = function(p: any) {\n      if (self.optional && !type.isJustDef(p)) {\n        return;\n      }\n      validator(p);\n    };\n    this.optional = !!opt_optional;\n  }\n}\n\nexport function and_(\n    v1: (p1: any) => void,\n    v2: Function): (p1: any) => void {\n  return function(p) {\n    v1(p);\n    v2(p);\n  };\n}\n\nexport function stringSpec(\n    opt_validator?: (p1: any) => void | null,\n    opt_optional?: boolean): ArgSpec {\n  function stringValidator(p: any) {\n    if (!type.isString(p)) {\n      throw 'Expected string.';\n    }\n  }\n  let validator;\n  if (opt_validator) {\n    validator = and_(stringValidator, opt_validator);\n  } else {\n    validator = stringValidator;\n  }\n  return new ArgSpec(validator, opt_optional);\n}\n\nexport function uploadDataSpec(): ArgSpec {\n  function validator(p: any) {\n    let valid = p instanceof Uint8Array || p instanceof ArrayBuffer ||\n        type.isNativeBlobDefined() && p instanceof Blob;\n    if (!valid) {\n      throw 'Expected Blob or File.';\n    }\n  }\n  return new ArgSpec(validator);\n}\n\nexport function metadataSpec(opt_optional?: boolean): ArgSpec {\n  return new ArgSpec(MetadataUtils.metadataValidator, opt_optional);\n}\n\nexport function nonNegativeNumberSpec(): ArgSpec {\n  function validator(p: any) {\n    let valid = type.isNumber(p) && p >= 0;\n    if (!valid) {\n      throw 'Expected a number 0 or greater.';\n    }\n  }\n  return new ArgSpec(validator);\n}\n\nexport function looseObjectSpec(\n    opt_validator?: ((p1: any) => void) | null,\n    opt_optional?: boolean): ArgSpec {\n  function validator(p: any) {\n    let isLooseObject = (p === null) || (type.isDef(p) && p instanceof Object);\n    if (!isLooseObject) {\n      throw 'Expected an Object.';\n    }\n    if (opt_validator !== undefined && opt_validator !== null) {\n      opt_validator(p);\n    }\n  }\n  return new ArgSpec(validator, opt_optional);\n}\n\nexport function nullFunctionSpec(opt_optional?: boolean): ArgSpec {\n  function validator(p: any) {\n    let valid = p === null || type.isFunction(p);\n    if (!valid) {\n      throw 'Expected a Function.';\n    }\n  }\n  return new ArgSpec(validator, opt_optional);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/args.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * Returns true if the object is contained in the array (compared with ===).\n * @template T\n */\nexport function contains<T>(array: T[], elem: T): boolean {\n  return array.indexOf(elem) !== -1;\n}\n\n/**\n * Returns a shallow copy of the array or array-like object (e.g. arguments).\n * @template T\n */\nexport function clone<T>(arraylike: T[]): T[] {\n  return Array.prototype.slice.call(arraylike);\n}\n\n/**\n * Removes the given element from the given array, if it is contained.\n * Directly modifies the passed-in array.\n * @template T\n */\nexport function remove<T>(array: T[], elem: T) {\n  const i = array.indexOf(elem);\n  if (i !== -1) {\n    array.splice(i, 1);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/array.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Documentation for the metadata format\n */\nimport {Metadata} from '../metadata';\n\nimport {AuthWrapper} from './authwrapper';\nimport * as json from './json';\nimport {Location} from './location';\nimport * as path from './path';\nimport * as type from './type';\nimport * as UrlUtils from './url';\n\nexport function noXform_(\n    metadata: Metadata, value: any): any {\n  return value;\n}\n\n/**\n * @struct\n */\nexport class Mapping {\n  local: string;\n  writable: boolean;\n  xform: (p1: Metadata, p2: any) => any;\n\n  constructor(\n      public server: string, opt_local?: string|null, opt_writable?: boolean,\n      opt_xform?: (p1: Metadata, p2: any) => any |\n          null) {\n    this.local = opt_local || server;\n    this.writable = !!opt_writable;\n    this.xform = opt_xform || noXform_;\n  }\n}\ntype Mappings = Mapping[];\n\nexport {Mappings};\n\nlet mappings_: Mappings|null = null;\n\nexport function xformPath(fullPath: any): string {\n  let valid = type.isString(fullPath);\n  if (!valid || fullPath.length < 2) {\n    return fullPath;\n  } else {\n    fullPath = (fullPath as string);\n    return path.lastComponent(fullPath);\n  }\n}\n\nexport function getMappings(): Mappings {\n  if (mappings_) {\n    return mappings_;\n  }\n  let mappings = [];\n  mappings.push(new Mapping('bucket'));\n  mappings.push(new Mapping('generation'));\n  mappings.push(new Mapping('metageneration'));\n  mappings.push(new Mapping('name', 'fullPath', true));\n\n  function mappingsXformPath(\n      metadata: Metadata, fullPath: any): string {\n    return xformPath(fullPath);\n  }\n  let nameMapping = new Mapping('name');\n  nameMapping.xform = mappingsXformPath;\n  mappings.push(nameMapping);\n\n  /**\n   * Coerces the second param to a number, if it is defined.\n   */\n  function xformSize(\n      metadata: Metadata, size: any): number|null|undefined {\n    if (type.isDef(size)) {\n      return +(size as number);\n    } else {\n      return size;\n    }\n  }\n  let sizeMapping = new Mapping('size');\n  sizeMapping.xform = xformSize;\n  mappings.push(sizeMapping);\n  mappings.push(new Mapping('timeCreated'));\n  mappings.push(new Mapping('updated'));\n  mappings.push(new Mapping('md5Hash', null, true));\n  mappings.push(new Mapping('cacheControl', null, true));\n  mappings.push(new Mapping('contentDisposition', null, true));\n  mappings.push(new Mapping('contentEncoding', null, true));\n  mappings.push(new Mapping('contentLanguage', null, true));\n  mappings.push(new Mapping('contentType', null, true));\n  mappings.push(new Mapping('metadata', 'customMetadata', true));\n\n  /**\n   * Transforms a comma-separated string of tokens into a list of download\n   * URLs.\n   */\n  function xformTokens(\n      metadata: Metadata, tokens: any): string[] {\n    let valid = type.isString(tokens) && tokens.length > 0;\n    if (!valid) {\n      // This can happen if objects are uploaded through GCS and retrieved\n      // through list, so we don't want to throw an Error.\n      return [];\n    }\n    let encode = encodeURIComponent;\n    let tokensList = tokens.split(',');\n    let urls = tokensList.map(function(token: string) {\n      let bucket: string = metadata['bucket'] as string;\n      let path: string = metadata['fullPath'] as string;\n      let urlPart = '/b/' + encode(bucket) + '/o/' + encode(path);\n      let base = UrlUtils.makeDownloadUrl(urlPart);\n      let queryString = UrlUtils.makeQueryString({'alt': 'media', 'token': token});\n      return base + queryString;\n    });\n    return urls;\n  }\n  mappings.push(\n      new Mapping('downloadTokens', 'downloadURLs', false, xformTokens));\n  mappings_ = mappings;\n  return mappings_;\n}\n\nexport function addRef(metadata: Metadata, authWrapper: AuthWrapper) {\n  function generateRef() {\n    let bucket: string = metadata['bucket'] as string;\n    let path: string = metadata['fullPath'] as string;\n    let loc = new Location(bucket, path);\n    return authWrapper.makeStorageReference(loc);\n  }\n  Object.defineProperty(metadata, 'ref', {get: generateRef});\n}\n\nexport function fromResource(\n    authWrapper: AuthWrapper, resource: {[name: string]: any},\n    mappings: Mappings): Metadata {\n  let metadata: Metadata = {} as Metadata;\n  metadata['type']  = 'file';\n  let len = mappings.length;\n  for (let i = 0; i < len; i++) {\n    let mapping = mappings[i];\n    metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);\n  }\n  addRef(metadata, authWrapper);\n  return metadata;\n}\n\nexport function fromResourceString(\n    authWrapper: AuthWrapper, resourceString: string,\n    mappings: Mappings): Metadata|null {\n  let obj = json.jsonObjectOrNull(resourceString);\n  if (obj === null) {\n    return null;\n  }\n  let resource = (obj as Metadata);\n  return fromResource(authWrapper, resource, mappings);\n}\n\nexport function toResourceString(\n    metadata: Metadata, mappings: Mappings): string {\n  let resource: {\n    [prop: string]: any\n  } = {};\n  let len = mappings.length;\n  for (let i = 0; i < len; i++) {\n    let mapping = mappings[i];\n    if (mapping.writable) {\n      resource[mapping.server] = metadata[mapping.local];\n    }\n  }\n  return JSON.stringify(resource);\n}\n\nexport function metadataValidator(p: any) {\n  let validType = p && type.isObject(p);\n  if (!validType) {\n    throw 'Expected Metadata object.';\n  }\n  for (let key in p) {\n    let val = p[key];\n    if (key === 'customMetadata') {\n      if (!type.isObject(val)) {\n        throw 'Expected object for \\'customMetadata\\' mapping.';\n      }\n    } else {\n      if (type.isNonNullObject(val)) {\n        throw 'Mapping for \\'' + key + '\\' cannot be an object.';\n      }\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/metadata.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Functions to create and manipulate URLs for the server API.\n */\nimport * as constants from './constants';\nimport * as object from './object';\n\nexport function makeNormalUrl(urlPart: string): string {\n  return constants.domainBase + constants.apiBaseUrl + urlPart;\n}\n\nexport function makeDownloadUrl(urlPart: string): string {\n  return constants.downloadBase + constants.apiBaseUrl + urlPart;\n}\n\nexport function makeUploadUrl(urlPart: string): string {\n  return constants.domainBase + constants.apiUploadBaseUrl + urlPart;\n}\n\nexport function makeQueryString(params: { [key: string]: string }): string {\n  let encode = encodeURIComponent;\n  let queryPart = '?';\n  object.forEach(params, function(key, val) {\n    let nextPart = encode(key) + '=' + encode(val);\n    queryPart = queryPart + nextPart + '&';\n  });\n\n  // Chop off the extra '&' or '?' on the end\n  queryPart = queryPart.slice(0, -1);\n  return queryPart;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/url.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Enumerations used for upload tasks.\n */\n\n/**\n * Enum for task events.\n * @enum {string}\n */\nexport type TaskEvent = string;\nexport const TaskEvent = {\n  /** Triggered whenever the task changes or progress is updated. */\n  STATE_CHANGED: 'state_changed'\n};\n\n/**\n * Internal enum for task state.\n * @enum {string}\n */\nexport type InternalTaskState = string;\nexport const InternalTaskState = {\n  RUNNING: 'running',\n  PAUSING: 'pausing',\n  PAUSED: 'paused',\n  SUCCESS: 'success',\n  CANCELING: 'canceling',\n  CANCELED: 'canceled',\n  ERROR: 'error'\n};\n\n/**\n * External (API-surfaced) enum for task state.\n * @enum {string}\n */\nexport type TaskState = string;\nexport const TaskState = {\n  /** The task is currently transferring data. */\n  RUNNING: 'running',\n  /** The task was paused by the user. */\n  PAUSED: 'paused',\n  /** The task completed successfully. */\n  SUCCESS: 'success',\n  /** The task was canceled. */\n  CANCELED: 'canceled',\n  /** The task failed with an error. */\n  ERROR: 'error'\n};\n\nexport function taskStateFromInternalTaskState(state: InternalTaskState):\n    TaskState {\n  switch (state) {\n    case InternalTaskState.RUNNING:\n    case InternalTaskState.PAUSING:\n    case InternalTaskState.CANCELING:\n      return TaskState.RUNNING;\n    case InternalTaskState.PAUSED:\n      return TaskState.PAUSED;\n    case InternalTaskState.SUCCESS:\n      return TaskState.SUCCESS;\n    case InternalTaskState.CANCELED:\n      return TaskState.CANCELED;\n    case InternalTaskState.ERROR:\n      return TaskState.ERROR;\n    default:\n\n      // TODO(andysoto): assert(false);\n      return TaskState.ERROR;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/taskenums.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Defines the Firebase Storage Reference class.\n */\nimport * as args from './implementation/args';\nimport {AuthWrapper} from './implementation/authwrapper';\nimport {FbsBlob} from './implementation/blob';\nimport * as errorsExports from './implementation/error';\nimport {errors} from './implementation/error';\nimport {Location} from './implementation/location';\nimport * as metadata from './implementation/metadata';\nimport * as object from './implementation/object';\nimport * as path from './implementation/path';\nimport * as requests from './implementation/requests';\nimport * as fbsString from './implementation/string';\nimport {StringFormat} from './implementation/string';\nimport * as type from './implementation/type';\nimport {Metadata} from './metadata';\nimport {Service} from './service';\nimport {UploadTask} from './task';\n\n/**\n * Provides methods to interact with a bucket in the Firebase Storage service.\n * @param location An fbs.location, or the URL at\n *     which to base this object, in one of the following forms:\n *         gs://<bucket>/<object-path>\n *         http[s]://firebasestorage.googleapis.com/\n *                     <api-version>/b/<bucket>/o/<object-path>\n *     Any query or fragment strings will be ignored in the http[s]\n *     format. If no value is passed, the storage object will use a URL based on\n *     the project ID of the base firebase.App instance.\n */\nexport class Reference {\n  protected location: Location;\n\n  constructor(protected authWrapper: AuthWrapper, location: string|Location) {\n    if (location instanceof Location) {\n      this.location = location;\n    } else {\n      this.location = Location.makeFromUrl(location);\n    }\n  }\n\n  /**\n   * @return The URL for the bucket and path this object references,\n   *     in the form gs://<bucket>/<object-path>\n   * @override\n   */\n  toString(): string {\n    args.validate('toString', [], arguments);\n    return 'gs://' + this.location.bucket + '/' + this.location.path;\n  }\n\n  protected newRef(authWrapper: AuthWrapper, location: Location): Reference {\n    return new Reference(authWrapper, location);\n  }\n\n  protected mappings(): metadata.Mappings {\n    return metadata.getMappings();\n  }\n\n  /**\n   * @return A reference to the object obtained by\n   *     appending childPath, removing any duplicate, beginning, or trailing\n   *     slashes.\n   */\n  child(childPath: string): Reference {\n    args.validate('child', [args.stringSpec()], arguments);\n    let newPath = path.child(this.location.path, childPath);\n    let location = new Location(this.location.bucket, newPath);\n    return this.newRef(this.authWrapper, location);\n  }\n\n  /**\n   * @return A reference to the parent of the\n   *     current object, or null if the current object is the root.\n   */\n  get parent(): Reference|null {\n    let newPath = path.parent(this.location.path);\n    if (newPath === null) {\n      return null;\n    }\n    let location = new Location(this.location.bucket, newPath);\n    return this.newRef(this.authWrapper, location);\n  }\n\n  /**\n   * @return An reference to the root of this\n   *     object's bucket.\n   */\n  get root(): Reference {\n    let location = new Location(this.location.bucket, '');\n    return this.newRef(this.authWrapper, location);\n  }\n\n  get bucket(): string {\n    return this.location.bucket;\n  }\n\n  get fullPath(): string {\n    return this.location.path;\n  }\n\n  get name(): string {\n    return path.lastComponent(this.location.path);\n  }\n\n  get storage(): Service {\n    return this.authWrapper.service();\n  }\n\n  /**\n   * Uploads a blob to this object's location.\n   * @param data The blob to upload.\n   * @return An UploadTask that lets you control and\n   *     observe the upload.\n   */\n  put(data: Blob|Uint8Array|ArrayBuffer, metadata: Metadata|null = null): UploadTask {\n    args.validate(\n        'put', [args.uploadDataSpec(), args.metadataSpec(true)], arguments);\n    this.throwIfRoot_('put');\n    return new UploadTask(\n        this, this.authWrapper, this.location, this.mappings(), new FbsBlob(data),\n        metadata);\n  }\n\n  /**\n   * Uploads a string to this object's location.\n   * @param string The string to upload.\n   * @param opt_format The format of the string to upload.\n   * @return An UploadTask that lets you control and\n   *     observe the upload.\n   */\n  putString(string: string, format: StringFormat = StringFormat.RAW, opt_metadata?: Metadata):\n      UploadTask {\n    args.validate(\n        'putString',\n        [\n          args.stringSpec(), args.stringSpec(fbsString.formatValidator, true),\n          args.metadataSpec(true)\n        ],\n        arguments);\n    this.throwIfRoot_('putString');\n    let data = fbsString.dataFromString(format, string);\n    let metadata = object.clone<Metadata>(opt_metadata);\n    if (!type.isDef(metadata['contentType']) && type.isDef(data.contentType)) {\n      metadata['contentType'] = data.contentType;\n    }\n    return new UploadTask(\n        this, this.authWrapper, this.location, this.mappings(),\n        new FbsBlob(data.data, true), metadata);\n  }\n\n  /**\n   * Deletes the object at this location.\n   * @return A promise that resolves if the deletion succeeds.\n   */\n  delete(): Promise<void> {\n    args.validate('delete', [], arguments);\n    this.throwIfRoot_('delete');\n    let self = this;\n    return this.authWrapper.getAuthToken().then(function(authToken) {\n      let requestInfo = requests.deleteObject(self.authWrapper, self.location);\n      return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();\n    });\n  }\n\n  /**\n   *     A promise that resolves with the metadata for this object. If this\n   *     object doesn't exist or metadata cannot be retreived, the promise is\n   *     rejected.\n   */\n  getMetadata(): Promise<Metadata> {\n    args.validate('getMetadata', [], arguments);\n    this.throwIfRoot_('getMetadata');\n    let self = this;\n    return this.authWrapper.getAuthToken().then(function(authToken) {\n      let requestInfo = requests.getMetadata(\n          self.authWrapper, self.location, self.mappings());\n      return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();\n    });\n  }\n\n  /**\n   * Updates the metadata for this object.\n   * @param metadata The new metadata for the object.\n   *     Only values that have been explicitly set will be changed. Explicitly\n   *     setting a value to null will remove the metadata.\n   * @return A promise that resolves\n   *     with the new metadata for this object.\n   *     @see firebaseStorage.Reference.prototype.getMetadata\n   */\n  updateMetadata(metadata: Metadata): Promise<Metadata> {\n    args.validate('updateMetadata', [args.metadataSpec()], arguments);\n    this.throwIfRoot_('updateMetadata');\n    let self = this;\n    return this.authWrapper.getAuthToken().then(function(authToken) {\n      let requestInfo = requests.updateMetadata(\n          self.authWrapper, self.location, metadata, self.mappings());\n      return self.authWrapper.makeRequest(requestInfo, authToken).getPromise();\n    });\n  }\n\n  /**\n   * @return A promise that resolves with the download\n   *     URL for this object.\n   */\n  getDownloadURL(): Promise<string> {\n    args.validate('getDownloadURL', [], arguments);\n    this.throwIfRoot_('getDownloadURL');\n    return this.getMetadata().then(function(metadata) {\n      let url = (metadata['downloadURLs'] as string[])[0];\n      if (type.isDef(url)) {\n        return url;\n      } else {\n        throw errorsExports.noDownloadURL();\n      }\n    });\n  }\n\n  private throwIfRoot_(name: string) {\n    if (this.location.path === '') {\n      throw errorsExports.invalidRootOperation(name);\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/reference.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @file Provides a Blob-like wrapper for various binary types (including the\n * native Blob type). This makes it possible to upload types like ArrayBuffers,\n * making uploads possible in environments without the native Blob type.\n */\nimport * as fs from './fs';\nimport * as string from './string';\nimport {StringFormat} from './string';\nimport * as type from './type';\n\n/**\n * @param opt_elideCopy If true, doesn't copy mutable input data\n *     (e.g. Uint8Arrays). Pass true only if you know the objects will not be\n *     modified after this blob's construction.\n */\nexport class FbsBlob {\n  private data_: Blob|Uint8Array;\n  private size_: number;\n  private type_: string;\n\n  constructor(data: Blob|Uint8Array|ArrayBuffer, opt_elideCopy?: boolean) {\n    let size: number = 0;\n    let blobType: string = '';\n    if (type.isNativeBlob(data)) {\n      this.data_ = (data as Blob);\n      size = (data as Blob).size;\n      blobType = (data as Blob).type;\n    } else if (data instanceof ArrayBuffer) {\n      if (opt_elideCopy) {\n        this.data_ = new Uint8Array(data);\n      } else {\n        this.data_ = new Uint8Array(data.byteLength);\n        this.data_.set(new Uint8Array(data));\n      }\n      size = this.data_.length;\n    } else if (data instanceof Uint8Array) {\n      if (opt_elideCopy) {\n        this.data_ = (data as Uint8Array);\n      } else {\n        this.data_ = new Uint8Array(data.length);\n        this.data_.set((data as Uint8Array));\n      }\n      size = data.length;\n    }\n    this.size_ = size;\n    this.type_ = blobType;\n  }\n\n  size(): number {\n    return this.size_;\n  }\n\n  type(): string {\n    return this.type_;\n  }\n\n  slice(startByte: number, endByte: number): FbsBlob|null {\n    if (type.isNativeBlob(this.data_)) {\n      let realBlob = (this.data_ as Blob);\n      let sliced = fs.sliceBlob(realBlob, startByte, endByte);\n      if (sliced === null) {\n        return null;\n      }\n      return new FbsBlob(sliced);\n    } else {\n      let slice =\n          new Uint8Array((this.data_ as Uint8Array).buffer, startByte, endByte - startByte);\n      return new FbsBlob(slice, true);\n    }\n  }\n\n  static getBlob(...var_args: (string|FbsBlob)[]): FbsBlob|null {\n    if (type.isNativeBlobDefined()) {\n      var blobby: (Blob|Uint8Array|string)[] = var_args.map(function(val: string|FbsBlob): Blob|Uint8Array|string {\n        if (val instanceof FbsBlob) {\n          return val.data_;\n        } else {\n          return val;\n        }\n      });\n      return new FbsBlob(fs.getBlob.apply(null, blobby));\n    } else {\n      let uint8Arrays: Uint8Array[] = var_args.map(function(val: string|FbsBlob): Uint8Array {\n        if (type.isString(val)) {\n          return string.dataFromString(StringFormat.RAW, val as string).data;\n        } else {\n          // Blobs don't exist, so this has to be a Uint8Array.\n          return ((val as FbsBlob).data_ as Uint8Array);\n        }\n      });\n      let finalLength = 0;\n      uint8Arrays.forEach(function(array: Uint8Array): void {\n        finalLength += array.byteLength;\n      });\n      let merged = new Uint8Array(finalLength);\n      let index = 0;\n      uint8Arrays.forEach(function(array: Uint8Array) {\n        for (let i = 0; i < array.length; i++) {\n          merged[index++] = array[i];\n        }\n      });\n      return new FbsBlob(merged, true);\n    }\n  }\n\n  uploadData(): Blob|Uint8Array {\n    return this.data_;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/blob.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Contains helper methods for manipulating paths.\n */\n\n/**\n * @return Null if the path is already at the root.\n */\nexport function parent(path: string): string|null {\n  if (path.length == 0) {\n    return null;\n  }\n  let index = path.lastIndexOf('/');\n  if (index === -1) {\n    return '';\n  }\n  let newPath = path.slice(0, index);\n  return newPath;\n}\n\nexport function child(path: string, childPath: string): string {\n  let canonicalChildPath = childPath.split('/')\n                               .filter(function(component) {\n                                 return component.length > 0;\n                               })\n                               .join('/');\n  if (path.length === 0) {\n    return canonicalChildPath;\n  } else {\n    return path + '/' + canonicalChildPath;\n  }\n}\n\n/**\n * Returns the last component of a path.\n * '/foo/bar' -> 'bar'\n * '/foo/bar/baz/' -> 'baz/'\n * '/a' -> 'a'\n */\nexport function lastComponent(path: string): string {\n  let index = path.lastIndexOf('/', path.length - 2);\n  if (index === -1) {\n    return path;\n  } else {\n    return path.slice(index + 1);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/path.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Defines methods for interacting with the network.\n */\n\nimport {Metadata} from '../metadata';\n\nimport * as array from './array';\nimport {AuthWrapper} from './authwrapper';\nimport {FbsBlob} from './blob';\nimport * as errorsExports from './error';\nimport {FirebaseStorageError} from './error';\nimport {errors} from './error';\nimport {Location} from './location';\nimport * as MetadataUtils from './metadata';\nimport * as object from './object';\nimport {RequestInfo} from './requestinfo';\nimport * as type from './type';\nimport * as UrlUtils from './url';\nimport {XhrIo} from './xhrio';\n\n/**\n * Throws the UNKNOWN FirebaseStorageError if cndn is false.\n */\nexport function handlerCheck(cndn: boolean) {\n  if (!cndn) {\n    throw errorsExports.unknown();\n  }\n}\n\nexport function metadataHandler(\n    authWrapper: AuthWrapper,\n    mappings: MetadataUtils.Mappings): (p1: XhrIo, p2: string) => Metadata {\n  function handler(xhr: XhrIo, text: string): Metadata {\n    let metadata = MetadataUtils.fromResourceString(authWrapper, text, mappings);\n    handlerCheck(metadata !== null);\n    return metadata as Metadata;\n  }\n  return handler;\n}\n\nexport function sharedErrorHandler(location: Location): (\n    p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError {\n  function errorHandler(xhr: XhrIo, err: FirebaseStorageError): FirebaseStorageError {\n    let newErr;\n    if (xhr.getStatus() === 401) {\n      newErr = errorsExports.unauthenticated();\n    } else {\n      if (xhr.getStatus() === 402) {\n        newErr = errorsExports.quotaExceeded(location.bucket);\n      } else {\n        if (xhr.getStatus() === 403) {\n          newErr = errorsExports.unauthorized(location.path);\n        } else {\n          newErr = err;\n        }\n      }\n    }\n    newErr.setServerResponseProp(err.serverResponseProp());\n    return newErr;\n  }\n  return errorHandler;\n}\n\nexport function objectErrorHandler(location: Location): (\n    p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError {\n  let shared = sharedErrorHandler(location);\n\n  function errorHandler(xhr: XhrIo, err: FirebaseStorageError): FirebaseStorageError {\n    let newErr = shared(xhr, err);\n    if (xhr.getStatus() === 404) {\n      newErr = errorsExports.objectNotFound(location.path);\n    }\n    newErr.setServerResponseProp(err.serverResponseProp());\n    return newErr;\n  }\n  return errorHandler;\n}\n\nexport function getMetadata(\n    authWrapper: AuthWrapper, location: Location,\n    mappings: MetadataUtils.Mappings): RequestInfo<Metadata> {\n  let urlPart = location.fullServerUrl();\n  let url = UrlUtils.makeNormalUrl(urlPart);\n  let method = 'GET';\n  let timeout = authWrapper.maxOperationRetryTime();\n  let requestInfo = new RequestInfo(\n      url, method, metadataHandler(authWrapper, mappings), timeout);\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function updateMetadata(\n    authWrapper: AuthWrapper, location: Location, metadata: Metadata,\n    mappings: MetadataUtils.Mappings): RequestInfo<Metadata> {\n  let urlPart = location.fullServerUrl();\n  let url = UrlUtils.makeNormalUrl(urlPart);\n  let method = 'PATCH';\n  let body = MetadataUtils.toResourceString(metadata, mappings);\n  let headers = {'Content-Type': 'application/json; charset=utf-8'};\n  let timeout = authWrapper.maxOperationRetryTime();\n  let requestInfo = new RequestInfo(\n      url, method, metadataHandler(authWrapper, mappings), timeout);\n  requestInfo.headers = headers;\n  requestInfo.body = body;\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function deleteObject(\n    authWrapper: AuthWrapper, location: Location): RequestInfo<void> {\n  let urlPart = location.fullServerUrl();\n  let url = UrlUtils.makeNormalUrl(urlPart);\n  let method = 'DELETE';\n  let timeout = authWrapper.maxOperationRetryTime();\n\n  function handler(xhr: XhrIo, text: string) {}\n  let requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.successCodes = [200, 204];\n  requestInfo.errorHandler = objectErrorHandler(location);\n  return requestInfo;\n}\n\nexport function determineContentType_(\n    metadata: Metadata|null, blob: FbsBlob|null): string {\n  return metadata && metadata['contentType'] || blob && blob.type() ||\n      'application/octet-stream';\n}\n\nexport function metadataForUpload_(\n    location: Location, blob: FbsBlob, opt_metadata?: Metadata|null): Metadata {\n  let metadata = object.clone<Metadata>(opt_metadata);\n  metadata['fullPath'] = location.path;\n  metadata['size'] = blob.size();\n  if (!metadata['contentType']) {\n    metadata['contentType'] = determineContentType_(null, blob);\n  }\n  return metadata;\n}\n\nexport function multipartUpload(\n    authWrapper: AuthWrapper, location: Location, mappings: MetadataUtils.Mappings,\n    blob: FbsBlob, opt_metadata?: Metadata|null): RequestInfo<Metadata> {\n  let urlPart = location.bucketOnlyServerUrl();\n  let headers: { [prop: string]: string } = {'X-Goog-Upload-Protocol': 'multipart'};\n\n  function genBoundary() {\n    let str = '';\n    for (let i = 0; i < 2; i++) {\n      str = str + Math.random().toString().slice(2);\n    }\n    return str;\n  }\n  let boundary = genBoundary();\n  headers['Content-Type'] = 'multipart/related; boundary=' + boundary;\n  let metadata = metadataForUpload_(location, blob, opt_metadata);\n  let metadataString = MetadataUtils.toResourceString(metadata, mappings);\n  let preBlobPart = '--' + boundary + '\\r\\n' +\n      'Content-Type: application/json; charset=utf-8\\r\\n\\r\\n' + metadataString +\n      '\\r\\n--' + boundary + '\\r\\n' +\n      'Content-Type: ' + metadata['contentType'] + '\\r\\n\\r\\n';\n  let postBlobPart = '\\r\\n--' + boundary + '--';\n  let body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);\n  if (body === null) {\n    throw errorsExports.cannotSliceBlob();\n  }\n  let urlParams = {'name': metadata['fullPath']};\n  let url = UrlUtils.makeUploadUrl(urlPart);\n  let method = 'POST';\n  let timeout = authWrapper.maxUploadRetryTime();\n  let requestInfo = new RequestInfo(\n      url, method, metadataHandler(authWrapper, mappings), timeout);\n  requestInfo.urlParams = urlParams;\n  requestInfo.headers = headers;\n  requestInfo.body = body.uploadData();\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n/**\n * @param current The number of bytes that have been uploaded so far.\n * @param total The total number of bytes in the upload.\n * @param opt_finalized True if the server has finished the upload.\n * @param opt_metadata The upload metadata, should\n *     only be passed if opt_finalized is true.\n * @struct\n */\nexport class ResumableUploadStatus {\n  finalized: boolean;\n  metadata: Metadata|null;\n\n  constructor(\n      public current: number,\n      public total: number,\n      finalized?: boolean,\n      metadata?: Metadata|null) {\n    this.finalized = !!finalized;\n    this.metadata = metadata || null;\n  }\n}\n\nexport function checkResumeHeader_(xhr: XhrIo, opt_allowed?: string[]): string {\n  let status;\n  try {\n    status = xhr.getResponseHeader('X-Goog-Upload-Status');\n  } catch (e) {\n    handlerCheck(false);\n  }\n  let allowed = opt_allowed || ['active'];\n  handlerCheck(array.contains(allowed, status));\n  return (status as string);\n}\n\nexport function createResumableUpload(\n    authWrapper: AuthWrapper, location: Location, mappings: MetadataUtils.Mappings,\n    blob: FbsBlob, opt_metadata?: Metadata|null): RequestInfo<string> {\n  let urlPart = location.bucketOnlyServerUrl();\n  let metadata = metadataForUpload_(location, blob, opt_metadata);\n  let urlParams = {'name': metadata['fullPath']};\n  let url = UrlUtils.makeUploadUrl(urlPart);\n  let method = 'POST';\n  let headers = {\n    'X-Goog-Upload-Protocol': 'resumable',\n    'X-Goog-Upload-Command': 'start',\n    'X-Goog-Upload-Header-Content-Length': blob.size(),\n    'X-Goog-Upload-Header-Content-Type': metadata['contentType'],\n    'Content-Type': 'application/json; charset=utf-8'\n  };\n  let body = MetadataUtils.toResourceString(metadata, mappings);\n  let timeout = authWrapper.maxUploadRetryTime();\n\n  function handler(xhr: XhrIo, text: string): string {\n    checkResumeHeader_(xhr);\n    let url;\n    try {\n      url = xhr.getResponseHeader('X-Goog-Upload-URL');\n    } catch (e) {\n      handlerCheck(false);\n    }\n    handlerCheck(type.isString(url));\n    return (url as string);\n  }\n  let requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.urlParams = urlParams;\n  requestInfo.headers = headers;\n  requestInfo.body = body;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n/**\n * @param url From a call to fbs.requests.createResumableUpload.\n */\nexport function getResumableUploadStatus(\n    authWrapper: AuthWrapper, location: Location, url: string,\n    blob: FbsBlob): RequestInfo<ResumableUploadStatus> {\n  let headers = {'X-Goog-Upload-Command': 'query'};\n\n  function handler(xhr: XhrIo, text: string): ResumableUploadStatus {\n    let status = checkResumeHeader_(xhr, ['active', 'final']);\n    let sizeString;\n    try {\n      sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received');\n    } catch (e) {\n      handlerCheck(false);\n    }\n    let size = parseInt(sizeString, 10);\n    handlerCheck(!isNaN(size));\n    return new ResumableUploadStatus(size, blob.size(), status === 'final');\n  }\n  let method = 'POST';\n  let timeout = authWrapper.maxUploadRetryTime();\n  let requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.headers = headers;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n/**\n * Any uploads via the resumable upload API must transfer a number of bytes\n * that is a multiple of this number.\n */\nexport const resumableUploadChunkSize: number = 256 * 1024;\n\n/**\n * @param url From a call to fbs.requests.createResumableUpload.\n * @param chunkSize Number of bytes to upload.\n * @param opt_status The previous status.\n *     If not passed or null, we start from the beginning.\n * @throws fbs.Error If the upload is already complete, the passed in status\n *     has a final size inconsistent with the blob, or the blob cannot be sliced\n *     for upload.\n */\nexport function continueResumableUpload(\n    location: Location, authWrapper: AuthWrapper, url: string, blob: FbsBlob,\n    chunkSize: number, mappings: MetadataUtils.Mappings,\n    opt_status?: ResumableUploadStatus|null,\n    opt_progressCallback?: ((p1: number, p2: number) => void) | null): RequestInfo<ResumableUploadStatus> {\n  // TODO(andysoto): standardize on internal asserts\n  // assert(!(opt_status && opt_status.finalized));\n  let status = new ResumableUploadStatus(0, 0);\n  if (opt_status) {\n    status.current = opt_status.current;\n    status.total = opt_status.total;\n  } else {\n    status.current = 0;\n    status.total = blob.size();\n  }\n  if (blob.size() !== status.total) {\n    throw errorsExports.serverFileWrongSize();\n  }\n  let bytesLeft = status.total - status.current;\n  let bytesToUpload = bytesLeft;\n  if (chunkSize > 0) {\n    bytesToUpload = Math.min(bytesToUpload, chunkSize);\n  }\n  let startByte = status.current;\n  let endByte = startByte + bytesToUpload;\n  let uploadCommand =\n      bytesToUpload === bytesLeft ? 'upload, finalize' : 'upload';\n  let headers = {\n    'X-Goog-Upload-Command': uploadCommand,\n    'X-Goog-Upload-Offset': status.current\n  };\n  let body = blob.slice(startByte, endByte);\n  if (body === null) {\n    throw errorsExports.cannotSliceBlob();\n  }\n\n  function handler(xhr: XhrIo, text: string): ResumableUploadStatus {\n    // TODO(andysoto): Verify the MD5 of each uploaded range:\n    // the 'x-range-md5' header comes back with status code 308 responses.\n    // We'll only be able to bail out though, because you can't re-upload a\n    // range that you previously uploaded.\n    let uploadStatus = checkResumeHeader_(xhr, ['active', 'final']);\n    let newCurrent = status.current + bytesToUpload;\n    let size = blob.size();\n    let metadata;\n    if (uploadStatus === 'final') {\n      metadata = metadataHandler(authWrapper, mappings)(xhr, text);\n    } else {\n      metadata = null;\n    }\n    return new ResumableUploadStatus(\n        newCurrent, size, uploadStatus === 'final', metadata);\n  }\n  let method = 'POST';\n  let timeout = authWrapper.maxUploadRetryTime();\n  let requestInfo = new RequestInfo(url, method, handler, timeout);\n  requestInfo.headers = headers;\n  requestInfo.body = body.uploadData();\n  requestInfo.progressCallback = opt_progressCallback || null;\n  requestInfo.errorHandler = sharedErrorHandler(location);\n  return requestInfo;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/requests.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview A lightweight wrapper around XMLHttpRequest with a\n * goog.net.XhrIo-like interface.\n */\n\nexport type Headers = {[name: string]: (string|number)};\n\nexport interface XhrIo {\n  send(\n      url: string, method: string, opt_body?: ArrayBufferView|Blob|string|null,\n      opt_headers?: Headers): Promise<XhrIo>;\n\n  getErrorCode(): ErrorCode;\n\n  getStatus(): number;\n\n  getResponseText(): string;\n\n  /**\n   * Abort the request.\n   */\n  abort(): void;\n\n  getResponseHeader(header: string): string|null;\n\n  addUploadProgressListener(listener: (p1: Event) => void): void;\n\n  removeUploadProgressListener(listener: (p1: Event) => void): void;\n}\n\n/**\n * @enum{number}\n */\nexport enum ErrorCode {\n  NO_ERROR = 0,\n  NETWORK_ERROR = 1,\n  ABORT = 2\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/xhrio.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Replacement for goog.net.XhrIoPool that works with fbs.XhrIo.\n */\nimport {XhrIo} from './xhrio';\nimport {NetworkXhrIo} from './xhrio_network';\n\n/**\n * Factory-like class for creating XhrIo instances.\n */\nexport class XhrIoPool {\n  createXhrIo(): XhrIo {\n    return new NetworkXhrIo();\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/xhriopool.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as args from './implementation/args';\nimport {AuthWrapper} from './implementation/authwrapper';\nimport {Location} from './implementation/location';\nimport * as fbsPromiseImpl from './implementation/promise_external';\nimport * as RequestExports from './implementation/request';\nimport {Request} from './implementation/request';\nimport {XhrIoPool} from './implementation/xhriopool';\nimport {Reference} from './reference';\nimport { FirebaseApp } from \"../app/firebase_app\";\n\n/**\n * A service that provides firebaseStorage.Reference instances.\n * @param opt_url gs:// url to a custom Storage Bucket\n *\n * @struct\n */\nexport class Service {\n  authWrapper_: AuthWrapper;\n  private app_: FirebaseApp;\n  private bucket_: Location|null = null;\n  private internals_: ServiceInternals;\n\n  constructor(app: FirebaseApp, pool: XhrIoPool, url?: string) {\n    function maker(authWrapper: AuthWrapper, loc: Location) {\n      return new Reference(authWrapper, loc);\n    }\n    this.authWrapper_ =\n        new AuthWrapper(app, maker, RequestExports.makeRequest, this, pool);\n    this.app_ = app;\n    if (url != null) {\n      this.bucket_ = Location.makeFromBucketSpec(url);\n    } else {\n      const authWrapperBucket = this.authWrapper_.bucket();\n      if (authWrapperBucket != null) {\n        this.bucket_ = new Location(authWrapperBucket, '');\n      }\n    }\n    this.internals_ = new ServiceInternals(this);\n  }\n\n  /**\n   * Returns a firebaseStorage.Reference for the given path in the default\n   * bucket.\n   */\n  ref(path?: string): Reference {\n    function validator(path: string) {\n      if (/^[A-Za-z]+:\\/\\//.test(path)) {\n        throw 'Expected child path but got a URL, use refFromURL instead.';\n      }\n    }\n    args.validate('ref', [args.stringSpec(validator, true)], arguments);\n    if (this.bucket_ == null) {\n      throw new Error('No Storage Bucket defined in Firebase Options.');\n    }\n\n    let ref = new Reference(this.authWrapper_, this.bucket_);\n    if (path != null) {\n      return ref.child(path);\n    } else {\n      return ref;\n    }\n  }\n\n  /**\n   * Returns a firebaseStorage.Reference object for the given absolute URL,\n   * which must be a gs:// or http[s]:// URL.\n   */\n  refFromURL(url: string): Reference {\n    function validator(p: string) {\n      if (!/^[A-Za-z]+:\\/\\//.test(p)) {\n        throw 'Expected full URL but got a child path, use ref instead.';\n      }\n      try {\n        Location.makeFromUrl(p);\n      } catch (e) {\n        throw 'Expected valid full URL but got an invalid one.';\n      }\n    }\n    args.validate('refFromURL', [args.stringSpec(validator, false)], arguments);\n    return new Reference(this.authWrapper_, url);\n  }\n\n  get maxUploadRetryTime(): number {\n    return this.authWrapper_.maxUploadRetryTime();\n  }\n\n  setMaxUploadRetryTime(time: number) {\n    args.validate(\n        'setMaxUploadRetryTime', [args.nonNegativeNumberSpec()], arguments);\n    this.authWrapper_.setMaxUploadRetryTime(time);\n  }\n\n  get maxOperationRetryTime(): number {\n    return this.authWrapper_.maxOperationRetryTime();\n  }\n\n  setMaxOperationRetryTime(time: number) {\n    args.validate(\n        'setMaxOperationRetryTime', [args.nonNegativeNumberSpec()], arguments);\n    this.authWrapper_.setMaxOperationRetryTime(time);\n  }\n\n  get app(): FirebaseApp {\n    return this.app_;\n  }\n\n  get INTERNAL(): ServiceInternals {\n    return this.internals_;\n  }\n}\n\n/**\n * @struct\n */\nexport class ServiceInternals {\n  service_: Service;\n\n  constructor(service: Service) {\n    this.service_ = service;\n  }\n\n  /**\n   * Called when the associated app is deleted.\n   * @see {!fbs.AuthWrapper.prototype.deleteApp}\n   */\n  delete(): Promise<void> {\n    this.service_.authWrapper_.deleteApp();\n    return fbsPromiseImpl.resolve<void>(undefined);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/service.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport {StringFormat} from './storage/implementation/string';\nimport {TaskEvent} from './storage/implementation/taskenums';\nimport {TaskState} from './storage/implementation/taskenums';\nimport {XhrIoPool} from './storage/implementation/xhriopool';\nimport {Reference} from './storage/reference';\nimport {Service} from './storage/service';\nimport firebase from './app';\nimport { \n  FirebaseApp, \n  FirebaseServiceFactory \n} from \"./app/firebase_app\";\n/**\n * Type constant for Firebase Storage.\n */\nconst STORAGE_TYPE = 'storage';\n\nfunction factory(app: FirebaseApp, unused: any, opt_url?: string): Service {\n  return new Service(app, new XhrIoPool(), opt_url);\n}\n\nexport function registerStorage(instance) {\n  let namespaceExports = {\n    // no-inline\n    'TaskState': TaskState,\n    'TaskEvent': TaskEvent,\n    'StringFormat': StringFormat,\n    'Storage': Service,\n    'Reference': Reference\n  };\n  instance.INTERNAL.registerService(\n      STORAGE_TYPE, \n      (factory as FirebaseServiceFactory),\n      namespaceExports, \n      undefined,\n      // Allow multiple storage instances per app.\n      true);\n}\n\nregisterStorage(firebase);\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Method for invoking a callback asynchronously.\n */\nimport * as promiseimpl from './promise_external';\n\n/**\n * Returns a function that invokes f with its arguments asynchronously as a\n * microtask, i.e. as soon as possible after the current script returns back\n * into browser code.\n */\nexport function async(f: Function): Function {\n  return function(...argsToForward: any[]) {\n    promiseimpl.resolve(true).then(function() {\n      f.apply(null, argsToForward);\n    });\n  };\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/async.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport {Reference} from '../reference';\nimport {Service} from '../service';\nimport * as constants from './constants';\nimport * as errorsExports from './error';\nimport {errors} from './error';\nimport {FailRequest} from './failrequest';\nimport {Location} from './location';\nimport * as promiseimpl from './promise_external';\nimport {Request} from './request';\nimport {RequestInfo} from './requestinfo';\nimport {requestMaker} from './requestmaker';\nimport {RequestMap} from './requestmap';\nimport * as type from './type';\nimport {XhrIoPool} from './xhriopool';\nimport { FirebaseApp, FirebaseAuthTokenData } from \"../../app/firebase_app\";\n\n/**\n * @param app If null, getAuthToken always resolves with null.\n * @param service The storage service associated with this auth wrapper.\n *     Untyped to avoid circular type dependencies.\n * @struct\n */\nexport class AuthWrapper {\n  private app_: FirebaseApp|null;\n  private bucket_: string|null = null;\n\n  /**\n  maker\n     */\n  private storageRefMaker_:\n      (p1: AuthWrapper, p2: Location) => Reference;\n  private requestMaker_: requestMaker;\n  private pool_: XhrIoPool;\n  private service_: Service;\n  private maxOperationRetryTime_: number;\n  private maxUploadRetryTime_: number;\n  private requestMap_: RequestMap;\n  private deleted_: boolean = false;\n\n  constructor(\n      app: FirebaseApp|null,\n      maker: (p1: AuthWrapper, p2: Location) => Reference,\n      requestMaker: requestMaker, service: Service,\n      pool: XhrIoPool) {\n    this.app_ = app;\n    if (this.app_ !== null) {\n      let options = this.app_.options;\n      if (type.isDef(options)) {\n        this.bucket_ = AuthWrapper.extractBucket_(options);\n      }\n    }\n    this.storageRefMaker_ = maker;\n    this.requestMaker_ = requestMaker;\n    this.pool_ = pool;\n    this.service_ = service;\n    this.maxOperationRetryTime_ = constants.defaultMaxOperationRetryTime;\n    this.maxUploadRetryTime_ = constants.defaultMaxUploadRetryTime;\n    this.requestMap_ = new RequestMap();\n  }\n\n  private static extractBucket_(config: {[prop: string]: any}): string|null {\n    let bucketString = config[constants.configOption] || null;\n    if (bucketString == null) {\n      return null;\n    }\n    let loc: Location = Location.makeFromBucketSpec(bucketString);\n    return loc.bucket;\n  }\n\n  getAuthToken(): Promise<string|null> {\n    // TODO(andysoto): remove ifDef checks after firebase-app implements stubs\n    // (b/28673818).\n    if (this.app_ !== null && type.isDef(this.app_.INTERNAL) &&\n        type.isDef(this.app_.INTERNAL.getToken)) {\n      return this.app_.INTERNAL.getToken().then(\n          function(response: FirebaseAuthTokenData|null): string|null {\n            if (response !== null) {\n              return response.accessToken;\n            } else {\n              return null;\n            }\n          },\n          function(_error) {\n            return null;\n          });\n    } else {\n      return (promiseimpl.resolve(null) as Promise<string|null>);\n    }\n  }\n\n  bucket(): string|null {\n    if (this.deleted_) {\n      throw errorsExports.appDeleted();\n    } else {\n      return this.bucket_;\n    }\n  }\n\n  /**\n   * The service associated with this auth wrapper. Untyped to avoid circular\n   * type dependencies.\n   */\n  service(): Service {\n    return this.service_;\n  }\n\n  /**\n   * Returns a new firebaseStorage.Reference object referencing this AuthWrapper\n   * at the given Location.\n   * @param loc The Location.\n   * @return Actually a firebaseStorage.Reference, typing not allowed\n   *     because of circular dependency problems.\n   */\n  makeStorageReference(loc: Location): Reference {\n    return this.storageRefMaker_(this, loc);\n  }\n\n  makeRequest<T>(requestInfo: RequestInfo<T>, authToken: string|null): Request<T> {\n    if (!this.deleted_) {\n      let request = this.requestMaker_(\n          requestInfo, authToken, this.pool_);\n      this.requestMap_.addRequest(request);\n      return request;\n    } else {\n      return new FailRequest(errorsExports.appDeleted());\n    }\n  }\n\n  /**\n   * Stop running requests and prevent more from being created.\n   */\n  deleteApp() {\n    this.deleted_ = true;\n    this.app_ = null;\n    this.requestMap_.clear();\n  }\n\n  maxUploadRetryTime(): number {\n    return this.maxUploadRetryTime_;\n  }\n\n  setMaxUploadRetryTime(time: number) {\n    this.maxUploadRetryTime_ = time;\n  }\n\n  maxOperationRetryTime(): number {\n    return this.maxOperationRetryTime_;\n  }\n\n  setMaxOperationRetryTime(time: number) {\n    this.maxOperationRetryTime_ = time;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/authwrapper.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Provides a method for running a function with exponential\n * backoff.\n */\ntype id = (p1: boolean) => void;\n\nexport {id};\n\n/**\n * @param f May be invoked\n *     before the function returns.\n * @param callback Get all the arguments passed to the function\n *     passed to f, including the initial boolean.\n */\nexport function start(\n    f: (p1: (success: boolean, ...rest: any[]) => void,\n        canceled: boolean) => void,\n    callback: Function, timeout: number): id {\n  // TODO(andysoto): make this code cleaner (probably refactor into an actual\n  // type instead of a bunch of functions with state shared in the closure)\n  let waitSeconds = 1;\n  // Would type this as \"number\" but that doesn't work for Node so ¯\\_(ツ)_/¯\n  let timeoutId: any = null;\n  let hitTimeout = false;\n  let cancelState = 0;\n\n  function canceled() {\n    return cancelState === 2;\n  }\n  let triggeredCallback = false;\n\n  function triggerCallback() {\n    if (!triggeredCallback) {\n      triggeredCallback = true;\n      callback.apply(null, arguments);\n    }\n  }\n\n  function callWithDelay(millis: number): void {\n    timeoutId = setTimeout(function() {\n      timeoutId = null;\n      f(handler, canceled());\n    }, millis);\n  }\n\n  function handler(success: boolean, ...var_args: any[]):void {\n    if (triggeredCallback) {\n      return;\n    }\n    if (success) {\n      triggerCallback.apply(null, arguments);\n      return;\n    }\n    let mustStop = canceled() || hitTimeout;\n    if (mustStop) {\n      triggerCallback.apply(null, arguments);\n      return;\n    }\n    if (waitSeconds < 64) {\n      /* TODO(andysoto): don't back off so quickly if we know we're offline. */\n      waitSeconds *= 2;\n    }\n    let waitMillis;\n    if (cancelState === 1) {\n      cancelState = 2;\n      waitMillis = 0;\n    } else {\n      waitMillis = (waitSeconds + Math.random()) * 1000;\n    }\n    callWithDelay(waitMillis);\n  }\n  let stopped = false;\n\n  function stop(wasTimeout: boolean): void {\n    if (stopped) {\n      return;\n    }\n    stopped = true;\n    if (triggeredCallback) {\n      return;\n    }\n    if (timeoutId !== null) {\n      if (!wasTimeout) {\n        cancelState = 2;\n      }\n      clearTimeout(timeoutId);\n      callWithDelay(0);\n    } else {\n      if (!wasTimeout) {\n        cancelState = 1;\n      }\n    }\n  }\n  callWithDelay(0);\n  setTimeout(function() {\n    hitTimeout = true;\n    stop(true);\n  }, timeout);\n  return stop;\n}\n\n/**\n * Stops the retry loop from repeating.\n * If the function is currently \"in between\" retries, it is invoked immediately\n * with the second parameter as \"true\". Otherwise, it will be invoked once more\n * after the current invocation finishes iff the current invocation would have\n * triggered another retry.\n */\nexport function stop(id: id) {\n  id(false);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/backoff.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport {FirebaseStorageError} from './error';\nimport * as promiseimpl from './promise_external';\nimport * as RequestExports from './request';\nimport {Request} from './request';\n\n/**\n * A request whose promise always fails.\n * @struct\n * @template T\n */\nexport class FailRequest<T> implements Request<T> {\n  promise_: Promise<T>;\n\n  constructor(error: FirebaseStorageError) {\n    this.promise_ = promiseimpl.reject<T>(error);\n  }\n\n  /** @inheritDoc */\n  getPromise() {\n    return this.promise_;\n  }\n\n  /** @inheritDoc */\n  cancel(appDelete = false) {}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/failrequest.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Some methods copied from goog.fs.\n * We don't include goog.fs because it pulls in a bunch of Deferred code that\n * bloats the size of the released binary.\n */\nimport * as array from './array';\nimport * as type from './type';\n\ndeclare var IBlobBuilder;\ndeclare var BlobBuilder;\ndeclare var WebKitBlobBuilder;\n\nfunction getBlobBuilder(): (typeof IBlobBuilder)|undefined {\n  if (typeof BlobBuilder !== 'undefined') {\n    return BlobBuilder;\n  } else if (typeof WebKitBlobBuilder !== 'undefined') {\n    return WebKitBlobBuilder;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Concatenates one or more values together and converts them to a Blob.\n *\n * @param var_args The values that will make up the resulting blob.\n * @return The blob.\n */\nexport function getBlob(...var_args: (string|Blob|ArrayBuffer)[]): Blob {\n  let BlobBuilder = getBlobBuilder();\n  if (BlobBuilder !== undefined) {\n    let bb = new BlobBuilder();\n    for (let i = 0; i < var_args.length; i++) {\n      bb.append(var_args[i]);\n    }\n    return bb.getBlob();\n  } else {\n    if (type.isNativeBlobDefined()) {\n      return new Blob(var_args);\n    } else {\n      throw Error('This browser doesn\\'t seem to support creating Blobs');\n    }\n  }\n}\n\n/**\n * Slices the blob. The returned blob contains data from the start byte\n * (inclusive) till the end byte (exclusive). Negative indices cannot be used.\n *\n * @param blob The blob to be sliced.\n * @param start Index of the starting byte.\n * @param end Index of the ending byte.\n * @return The blob slice or null if not supported.\n */\nexport function sliceBlob(blob: Blob, start: number, end: number): Blob|null {\n  if ((blob as any).webkitSlice) {\n    return (blob as any).webkitSlice(start, end);\n  } else if ((blob as any).mozSlice) {\n    return (blob as any).mozSlice(start, end);\n  } else if (blob.slice) {\n    return blob.slice(start, end);\n  }\n  return null;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/fs.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as type from './type';\n\n/**\n * Returns the Object resulting from parsing the given JSON, or null if the\n * given string does not represent a JSON object.\n */\nexport function jsonObjectOrNull(s: string): {[name: string]: any}|null {\n  let obj;\n  try {\n    obj = JSON.parse(s);\n  } catch (e) {\n    return null;\n  }\n  if (type.isNonArrayObject(obj)) {\n    return obj;\n  } else {\n    return null;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/json.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as type from './type';\n\ntype NextFn<T> = (value: T) => void;\ntype ErrorFn = (error: Error) => void;\ntype CompleteFn = () => void;\ntype Unsubscribe = () => void;\n\ntype Subscribe<T> =\n    (next: NextFn<T> | {[name: string]: string|null},\n     error?: ErrorFn,\n     complete?: CompleteFn) => Unsubscribe;\n\nexport {NextFn, ErrorFn, CompleteFn, Unsubscribe, Subscribe};\n\n/**\n * @struct\n */\nexport class Observer<T> {\n  next: NextFn<T> | null;\n  error: ErrorFn | null;\n  complete: CompleteFn | null;\n\n  constructor(\n      nextOrObserver: NextFn<T> | {[name: string]: string|null} | null,\n      opt_error?: ErrorFn | null,\n      opt_complete?: CompleteFn | null) {\n    let asFunctions = type.isFunction(nextOrObserver) ||\n        type.isDef(opt_error) || type.isDef(opt_complete);\n    if (asFunctions) {\n      this.next = nextOrObserver as (NextFn<T> | null);\n      this.error = opt_error || null;\n      this.complete = opt_complete || null;\n    } else {\n      const observer = nextOrObserver as {[name: string]: null};\n      this.next = observer['next'] as (NextFn<T> | null);\n      this.error = observer['error'] as (ErrorFn | null);\n      this.complete = observer['complete'] as (CompleteFn | null);\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/observer.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n/**\n * @fileoverview Defines methods used to actually send HTTP requests from\n * abstract representations.\n */\nimport * as array from './array';\nimport * as backoff from './backoff';\nimport * as errorsExports from './error';\nimport {FirebaseStorageError} from './error';\nimport {errors} from './error';\nimport * as object from './object';\nimport * as promiseimpl from './promise_external';\nimport {RequestInfo} from './requestinfo';\nimport * as type from './type';\nimport * as UrlUtils from './url';\nimport * as XhrIoExports from './xhrio';\nimport {Headers, XhrIo} from './xhrio';\nimport {XhrIoPool} from './xhriopool';\nimport { FirebaseNamespace } from \"../../app/firebase_app\";\n\ndeclare var firebase: FirebaseNamespace;\n\n/**\n * @template T\n */\nexport interface Request<T> {\n  getPromise(): Promise<T>;\n\n  /**\n   * Cancels the request. IMPORTANT: the promise may still be resolved with an\n   * appropriate value (if the request is finished before you call this method,\n   * but the promise has not yet been resolved), so don't just assume it will be\n   * rejected if you call this function.\n   * @param appDelete True if the cancelation came from the app being deleted.\n   */\n  cancel(appDelete?: boolean): void;\n}\n\n/**\n * @struct\n * @template T\n */\nclass NetworkRequest<T> implements Request<T> {\n  private url_: string;\n  private method_: string;\n  private headers_: Headers;\n  private body_: string|Blob|Uint8Array|null;\n  private successCodes_: number[];\n  private additionalRetryCodes_: number[];\n  private pendingXhr_: XhrIo|null = null;\n  private backoffId_: backoff.id|null = null;\n  private resolve_: Function|null = null;\n  private reject_: Function|null = null;\n  private canceled_: boolean = false;\n  private appDelete_: boolean = false;\n  private callback_: (p1: XhrIo, p2: string) => T;\n  private errorCallback_: ((p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError) | null;\n  private progressCallback_:\n      ((p1: number, p2: number) => void) | null;\n  private timeout_: number;\n  private pool_: XhrIoPool;\n  promise_: Promise<T>;\n\n  constructor(\n      url: string, method: string, headers: Headers,\n      body: string|Blob|Uint8Array|null, successCodes: number[],\n      additionalRetryCodes: number[],\n      callback: (p1: XhrIo, p2: string) => T,\n      errorCallback: ((p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError) | null, timeout: number,\n      progressCallback: ((p1: number, p2: number) => void) | null,\n      pool: XhrIoPool) {\n    this.url_ = url;\n    this.method_ = method;\n    this.headers_ = headers;\n    this.body_ = body;\n    this.successCodes_ = successCodes.slice();\n    this.additionalRetryCodes_ = additionalRetryCodes.slice();\n    this.callback_ = callback;\n    this.errorCallback_ = errorCallback;\n    this.progressCallback_ = progressCallback;\n    this.timeout_ = timeout;\n    this.pool_ = pool;\n    let self = this;\n    this.promise_ = promiseimpl.make(function(resolve, reject) {\n      self.resolve_ = resolve;\n      self.reject_ = reject;\n      self.start_();\n    });\n  }\n\n  /**\n   * Actually starts the retry loop.\n   */\n  private start_() {\n    let self = this;\n\n    function doTheRequest(\n        backoffCallback: (p1: boolean, ...p2: any[]) => void,\n        canceled: boolean) {\n      if (canceled) {\n        backoffCallback(false, new RequestEndStatus(false, null, true));\n        return;\n      }\n      let xhr = self.pool_.createXhrIo();\n      self.pendingXhr_ = xhr;\n\n      function progressListener(progressEvent: ProgressEvent) {\n        let loaded = progressEvent.loaded;\n        let total = progressEvent.lengthComputable ? progressEvent.total : -1;\n        if (self.progressCallback_ !== null) {\n          self.progressCallback_(loaded, total);\n        }\n      }\n      if (self.progressCallback_ !== null) {\n        xhr.addUploadProgressListener(progressListener);\n      }\n      xhr.send(self.url_, self.method_, self.body_, self.headers_)\n          .then(function(xhr: XhrIo) {\n            if (self.progressCallback_ !== null) {\n              xhr.removeUploadProgressListener(progressListener);\n            }\n            self.pendingXhr_ = null;\n            xhr = (xhr as XhrIo);\n            let hitServer =\n                xhr.getErrorCode() === XhrIoExports.ErrorCode.NO_ERROR;\n            let status = xhr.getStatus();\n            if (!hitServer || self.isRetryStatusCode_(status)) {\n              let wasCanceled =\n                  xhr.getErrorCode() === XhrIoExports.ErrorCode.ABORT;\n              backoffCallback(\n                  false, new RequestEndStatus(false, null, wasCanceled));\n              return;\n            }\n            let successCode = array.contains(self.successCodes_, status);\n            backoffCallback(true, new RequestEndStatus(successCode, xhr));\n          });\n    }\n\n    /**\n     * @param requestWentThrough True if the request eventually went\n     *     through, false if it hit the retry limit or was canceled.\n     */\n    function backoffDone(\n        requestWentThrough: boolean, status: RequestEndStatus) {\n      let resolve = self.resolve_ as Function;\n      let reject = self.reject_ as Function;\n      let xhr = status.xhr as XhrIo;\n      if (status.wasSuccessCode) {\n        try {\n          let result = self.callback_(xhr, xhr.getResponseText());\n          if (type.isJustDef(result)) {\n            resolve(result);\n          } else {\n            resolve();\n          }\n        } catch (e) {\n          reject(e);\n        }\n      } else {\n        if (xhr !== null) {\n          let err = errorsExports.unknown();\n          err.setServerResponseProp(xhr.getResponseText());\n          if (self.errorCallback_) {\n            reject(self.errorCallback_(xhr, err));\n          } else {\n            reject(err);\n          }\n        } else {\n          if (status.canceled) {\n            let err = self.appDelete_ ? errorsExports.appDeleted() :\n                                        errorsExports.canceled();\n            reject(err);\n          } else {\n            let err = errorsExports.retryLimitExceeded();\n            reject(err);\n          }\n        }\n      }\n    }\n    if (this.canceled_) {\n      backoffDone(false, new RequestEndStatus(false, null, true));\n    } else {\n      this.backoffId_ = backoff.start(doTheRequest, backoffDone, this.timeout_);\n    }\n  }\n\n  /** @inheritDoc */\n  getPromise() {\n    return this.promise_;\n  }\n\n  /** @inheritDoc */\n  cancel(appDelete?: boolean) {\n    this.canceled_ = true;\n    this.appDelete_ = appDelete || false;\n    if (this.backoffId_ !== null) {\n      backoff.stop(this.backoffId_);\n    }\n    if (this.pendingXhr_ !== null) {\n      this.pendingXhr_.abort();\n    }\n  }\n\n  private isRetryStatusCode_(status: number): boolean {\n    // The codes for which to retry came from this page:\n    // https://cloud.google.com/storage/docs/exponential-backoff\n    let isFiveHundredCode = status >= 500 && status < 600;\n    let extraRetryCodes = [\n      // Request Timeout: web server didn't receive full request in time.\n      408,\n      // Too Many Requests: you're getting rate-limited, basically.\n      429\n    ];\n    let isExtraRetryCode = array.contains(extraRetryCodes, status);\n    let isRequestSpecificRetryCode =\n        array.contains(this.additionalRetryCodes_, status);\n    return isFiveHundredCode || isExtraRetryCode || isRequestSpecificRetryCode;\n  }\n}\n\n/**\n * A collection of information about the result of a network request.\n * @param opt_canceled Defaults to false.\n * @struct\n */\nexport class RequestEndStatus {\n  /**\n   * True if the request was canceled.\n   */\n  canceled: boolean;\n\n  constructor(\n      public wasSuccessCode: boolean, public xhr: XhrIo|null,\n      opt_canceled?: boolean) {\n    this.canceled = !!opt_canceled;\n  }\n}\n\nexport function addAuthHeader_(headers: Headers, authToken: string|null) {\n  if (authToken !== null && authToken.length > 0) {\n    headers['Authorization'] = 'Firebase ' + authToken;\n  }\n}\n\nexport function addVersionHeader_(headers: Headers) {\n  let number = typeof firebase !== 'undefined' ? firebase.SDK_VERSION : 'AppManager';\n  headers['X-Firebase-Storage-Version'] = 'webjs/' + number;\n}\n\n/**\n * @template T\n */\nexport function makeRequest<T>(\n    requestInfo: RequestInfo<T>, authToken: string|null,\n    pool: XhrIoPool): Request<T> {\n  let queryPart = UrlUtils.makeQueryString(requestInfo.urlParams);\n  let url = requestInfo.url + queryPart;\n  let headers = object.clone<Headers>(requestInfo.headers);\n  addAuthHeader_(headers, authToken);\n  addVersionHeader_(headers);\n  return new NetworkRequest<T>(\n      url, requestInfo.method, headers, requestInfo.body,\n      requestInfo.successCodes, requestInfo.additionalRetryCodes,\n      requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout,\n      requestInfo.progressCallback, pool);\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/request.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport {FirebaseStorageError} from './error';\nimport {Headers, XhrIo} from './xhrio';\n\nexport type UrlParams = {[name: string]: string};\n\nexport class RequestInfo<T> {\n  urlParams: UrlParams = {};\n  headers: Headers = {};\n  body: Blob|string|Uint8Array|null = null;\n\n  errorHandler: ((p1: XhrIo, p2: FirebaseStorageError) => FirebaseStorageError) | null = null;\n\n  /**\n   * Called with the current number of bytes uploaded and total size (-1 if not\n   * computable) of the request body (i.e. used to report upload progress).\n   */\n  progressCallback:\n      ((p1: number, p2: number) => void) | null = null;\n  successCodes: number[] = [200];\n  additionalRetryCodes: number[] = [];\n\n  constructor(\n      public url: string,\n      public method: string,\n      /**\n       * Returns the value with which to resolve the request's promise. Only called\n       * if the request is successful. Throw from this function to reject the\n       * returned Request's promise with the thrown error.\n       * Note: The XhrIo passed to this function may be reused after this callback\n       * returns. Do not keep a reference to it in any way.\n       */\n      public handler: (p1: XhrIo, p2: string) => T,\n      public timeout: number) {}\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/requestinfo.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as object from './object';\nimport * as RequestExports from './request';\nimport {Request} from './request';\nimport * as constants from './constants';\n\n/**\n * @struct\n */\nexport class RequestMap {\n  private map_: {[key: number]: Request<any>} = {};\n  private id_: number;\n\n  constructor() {\n    this.id_ = constants.minSafeInteger;\n  }\n\n  /**\n   * Registers the given request with this map.\n   * The request is unregistered when it completes.\n   * @param r The request to register.\n   */\n  addRequest(r: Request<any>) {\n    let id = this.id_;\n    this.id_++;\n    this.map_[id] = r;\n    let self = this;\n\n    function unmap() {\n      delete self.map_[id];\n    }\n    r.getPromise().then(unmap, unmap);\n  }\n\n  /**\n   * Cancels all registered requests.\n   */\n  clear() {\n    object.forEach(this.map_, (key: string, val: Request<any>) => {\n      if (val) {\n        val.cancel(true);\n      }\n    });\n    this.map_ = {};\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/requestmap.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport * as errorsExports from './error';\nimport * as object from './object';\nimport * as promiseimpl from './promise_external';\nimport * as type from './type';\nimport * as XhrIoExports from './xhrio';\nimport {Headers, XhrIo} from './xhrio';\n\n/**\n * We use this instead of goog.net.XhrIo because goog.net.XhrIo is hyuuuuge and\n * doesn't work in React Native on Android.\n */\nexport class NetworkXhrIo implements XhrIo {\n  private xhr_: XMLHttpRequest;\n  private errorCode_: XhrIoExports.ErrorCode;\n  private sendPromise_: Promise<XhrIo>;\n  private sent_: boolean = false;\n\n  constructor() {\n    this.xhr_ = new XMLHttpRequest();\n    this.errorCode_ = XhrIoExports.ErrorCode.NO_ERROR;\n    this.sendPromise_ = promiseimpl.make((resolve, reject) => {\n      this.xhr_.addEventListener('abort', (event) => {\n        this.errorCode_ = XhrIoExports.ErrorCode.ABORT;\n        resolve(this);\n      });\n      this.xhr_.addEventListener('error', (event) => {\n        this.errorCode_ = XhrIoExports.ErrorCode.NETWORK_ERROR;\n        resolve(this);\n      });\n      this.xhr_.addEventListener('load', (event) => {\n        resolve(this);\n      });\n    });\n  }\n\n  /**\n   * @override\n   */\n  send(\n      url: string, method: string, opt_body?: ArrayBufferView|Blob|string|null,\n      opt_headers?: Headers): Promise<XhrIo> {\n    if (this.sent_) {\n      throw errorsExports.internalError('cannot .send() more than once');\n    }\n    this.sent_ = true;\n    this.xhr_.open(method, url, true);\n    if (type.isDef(opt_headers)) {\n      const headers = (opt_headers as Headers);\n      object.forEach(headers, (key, val) => {\n        this.xhr_.setRequestHeader(key, val.toString());\n      });\n    }\n    if (type.isDef(opt_body)) {\n      this.xhr_.send(opt_body);\n    } else {\n      this.xhr_.send();\n    }\n    return this.sendPromise_;\n  }\n\n  /**\n   * @override\n   */\n  getErrorCode(): XhrIoExports.ErrorCode {\n    if (!this.sent_) {\n      throw errorsExports.internalError(\n          'cannot .getErrorCode() before sending');\n    }\n    return this.errorCode_;\n  }\n\n  /**\n   * @override\n   */\n  getStatus(): number {\n    if (!this.sent_) {\n      throw errorsExports.internalError('cannot .getStatus() before sending');\n    }\n    try {\n      return this.xhr_.status;\n    } catch (e) {\n      return -1;\n    }\n  }\n\n  /**\n   * @override\n   */\n  getResponseText(): string {\n    if (!this.sent_) {\n      throw errorsExports.internalError(\n          'cannot .getResponseText() before sending');\n    }\n    return this.xhr_.responseText;\n  }\n\n  /**\n   * Aborts the request.\n   * @override\n   */\n  abort() {\n    this.xhr_.abort();\n  }\n\n  /**\n   * @override\n   */\n  getResponseHeader(header: string): string|null {\n    return this.xhr_.getResponseHeader(header);\n  }\n\n  /**\n   * @override\n   */\n  addUploadProgressListener(listener: (p1: Event) => void) {\n    if (type.isDef(this.xhr_.upload)) {\n      this.xhr_.upload.addEventListener('progress', listener);\n    }\n  }\n\n  /**\n   * @override\n   */\n  removeUploadProgressListener(listener: (p1: Event) => void) {\n    if (type.isDef(this.xhr_.upload)) {\n      this.xhr_.upload.removeEventListener('progress', listener);\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/implementation/xhrio_network.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Defines types for interacting with blob transfer tasks.\n */\n\nimport {AuthWrapper} from './implementation/authwrapper';\nimport {FbsBlob} from './implementation/blob';\nimport {FirebaseStorageError} from './implementation/error';\nimport {InternalTaskState} from './implementation/taskenums';\nimport {Metadata} from './metadata';\nimport {NextFn, ErrorFn, CompleteFn, Unsubscribe, Observer} from './implementation/observer';\nimport {Request} from './implementation/request';\nimport * as RequestExports from './implementation/request';\nimport {Subscribe} from './implementation/observer';\nimport {TaskEvent, TaskState} from './implementation/taskenums';\nimport {UploadTaskSnapshot} from './tasksnapshot';\nimport * as fbsArgs from './implementation/args';\nimport {ArgSpec} from './implementation/args';\nimport * as fbsArray from './implementation/array';\nimport {async as fbsAsync} from './implementation/async';\nimport {errors as fbsErrors} from './implementation/error';\nimport * as errors from './implementation/error';\nimport {Location} from './implementation/location';\nimport * as fbsMetadata from './implementation/metadata';\nimport * as fbsPromiseimpl from './implementation/promise_external';\nimport {RequestInfo} from './implementation/requestinfo';\nimport * as fbsRequests from './implementation/requests';\nimport * as fbsTaskEnums from './implementation/taskenums';\nimport * as typeUtils from './implementation/type';\nimport {Reference} from './reference';\n\n/**\n * Represents a blob being uploaded. Can be used to pause/resume/cancel the\n * upload and manage callbacks for various events.\n */\nexport class UploadTask {\n  private ref_: Reference;\n  private authWrapper_: AuthWrapper;\n  private location_: Location;\n  private blob_: FbsBlob;\n  private metadata_: Metadata|null;\n  private mappings_: fbsMetadata.Mappings;\n  private transferred_: number = 0;\n  private needToFetchStatus_: boolean = false;\n  private needToFetchMetadata_: boolean = false;\n  private observers_: Observer<UploadTaskSnapshot>[] = [];\n  private resumable_: boolean;\n  private state_: InternalTaskState;\n  private error_: Error|null = null;\n  private uploadUrl_: string|null = null;\n  private request_: Request<any>|null = null;\n  private chunkMultiplier_: number = 1;\n  private errorHandler_: (p1: FirebaseStorageError) => void;\n  private metadataErrorHandler_: (p1: FirebaseStorageError) => void;\n  private resolve_:\n      ((p1: UploadTaskSnapshot) => void) | null = null;\n  private reject_: ((p1: Error) => void) | null = null;\n  private promise_: Promise<UploadTaskSnapshot>;\n\n  /**\n   * @param ref The firebaseStorage.Reference object this task came\n   *     from, untyped to avoid cyclic dependencies.\n   * @param blob The blob to upload.\n   */\n  constructor(\n      ref: Reference, authWrapper: AuthWrapper, location: Location,\n      mappings: fbsMetadata.Mappings, blob: FbsBlob, metadata: Metadata|null = null) {\n    this.ref_ = ref;\n    this.authWrapper_ = authWrapper;\n    this.location_ = location;\n    this.blob_ = blob;\n    this.metadata_ = metadata;\n    this.mappings_ = mappings;\n    this.resumable_ = this.shouldDoResumable_(this.blob_);\n    this.state_ = InternalTaskState.RUNNING;\n    this.errorHandler_ = (error) => {\n      this.request_ = null;\n      this.chunkMultiplier_ = 1;\n      if (error.codeEquals(errors.Code.CANCELED)) {\n        this.needToFetchStatus_ = true;\n        this.completeTransitions_();\n      } else {\n        this.error_ = error;\n        this.transition_(InternalTaskState.ERROR);\n      }\n    };\n    this.metadataErrorHandler_ = (error) => {\n      this.request_ = null;\n      if (error.codeEquals(errors.Code.CANCELED)) {\n        this.completeTransitions_();\n      } else {\n        this.error_ = error;\n        this.transition_(InternalTaskState.ERROR);\n      }\n    };\n    this.promise_ = fbsPromiseimpl.make((resolve, reject) => {\n      this.resolve_ = resolve;\n      this.reject_ = reject;\n      this.start_();\n    });\n\n    // Prevent uncaught rejections on the internal promise from bubbling out\n    // to the top level with a dummy handler.\n    this.promise_.then(null, () => {});\n  }\n\n  private makeProgressCallback_():\n      (p1: number, p2: number) => void {\n    const sizeBefore = this.transferred_;\n    return (loaded, total) => {\n      this.updateProgress_(sizeBefore + loaded);\n    };\n  }\n\n  private shouldDoResumable_(blob: FbsBlob): boolean {\n    return blob.size() > 256 * 1024;\n  }\n\n  private start_() {\n    if (this.state_ !== InternalTaskState.RUNNING) {\n      // This can happen if someone pauses us in a resume callback, for example.\n      return;\n    }\n    if (this.request_ !== null) {\n      return;\n    }\n    if (this.resumable_) {\n      if (this.uploadUrl_ === null) {\n        this.createResumable_();\n      } else {\n        if (this.needToFetchStatus_) {\n          this.fetchStatus_();\n        } else {\n          if (this.needToFetchMetadata_) {\n            // Happens if we miss the metadata on upload completion.\n            this.fetchMetadata_();\n          } else {\n            this.continueUpload_();\n          }\n        }\n      }\n    } else {\n      this.oneShotUpload_();\n    }\n  }\n\n  private resolveToken_(callback: (p1: string|null) => void) {\n    this.authWrapper_.getAuthToken().then((authToken) => {\n      switch (this.state_) {\n        case InternalTaskState.RUNNING:\n          callback(authToken);\n          break;\n        case InternalTaskState.CANCELING:\n          this.transition_(InternalTaskState.CANCELED);\n          break;\n        case InternalTaskState.PAUSING:\n          this.transition_(InternalTaskState.PAUSED);\n          break;\n        default:\n      }\n    });\n  }\n\n  // TODO(andysoto): assert false\n\n  private createResumable_() {\n    this.resolveToken_((authToken) => {\n      const requestInfo = fbsRequests.createResumableUpload(\n          this.authWrapper_, this.location_, this.mappings_, this.blob_,\n          this.metadata_);\n      const createRequest = this.authWrapper_.makeRequest(requestInfo, authToken);\n      this.request_ = createRequest;\n      createRequest.getPromise().then(\n          (url: string) => {\n            this.request_ = null;\n            this.uploadUrl_ = url;\n            this.needToFetchStatus_ = false;\n            this.completeTransitions_();\n          },\n          this.errorHandler_);\n    });\n  }\n\n  private fetchStatus_() {\n    // TODO(andysoto): assert(this.uploadUrl_ !== null);\n    const url = (this.uploadUrl_ as string);\n    this.resolveToken_((authToken) => {\n      const requestInfo = fbsRequests.getResumableUploadStatus(\n          this.authWrapper_, this.location_, url, this.blob_);\n      const statusRequest = this.authWrapper_.makeRequest(requestInfo, authToken);\n      this.request_ = statusRequest;\n      statusRequest.getPromise().then(\n          (status) => {\n            status = (status as fbsRequests.ResumableUploadStatus);\n            this.request_ = null;\n            this.updateProgress_(status.current);\n            this.needToFetchStatus_ = false;\n            if (status.finalized) {\n              this.needToFetchMetadata_ = true;\n            }\n            this.completeTransitions_();\n          },\n          this.errorHandler_);\n    });\n  }\n\n  private continueUpload_() {\n    const chunkSize =\n        fbsRequests.resumableUploadChunkSize * this.chunkMultiplier_;\n    const status = new fbsRequests.ResumableUploadStatus(\n        this.transferred_, this.blob_.size());\n\n    // TODO(andysoto): assert(this.uploadUrl_ !== null);\n    const url = (this.uploadUrl_ as string);\n    this.resolveToken_((authToken) => {\n    let requestInfo;\n      try {\n        requestInfo = fbsRequests.continueResumableUpload(\n            this.location_, this.authWrapper_, url, this.blob_, chunkSize,\n            this.mappings_, status, this.makeProgressCallback_());\n      } catch (e) {\n        this.error_ = e;\n        this.transition_(InternalTaskState.ERROR);\n        return;\n      }\n      const uploadRequest = this.authWrapper_.makeRequest(requestInfo, authToken);\n      this.request_ = uploadRequest;\n      uploadRequest.getPromise().then(\n          (newStatus: fbsRequests.ResumableUploadStatus) => {\n            this.increaseMultiplier_();\n            this.request_ = null;\n            this.updateProgress_(newStatus.current);\n            if (newStatus.finalized) {\n              this.metadata_ = newStatus.metadata;\n              this.transition_(InternalTaskState.SUCCESS);\n            } else {\n              this.completeTransitions_();\n            }\n          },\n          this.errorHandler_);\n    });\n  }\n\n  private increaseMultiplier_() {\n    const currentSize =\n        fbsRequests.resumableUploadChunkSize * this.chunkMultiplier_;\n\n    // Max chunk size is 32M.\n    if (currentSize < 32 * 1024 * 1024) {\n      this.chunkMultiplier_ *= 2;\n    }\n  }\n\n  private fetchMetadata_() {\n    this.resolveToken_((authToken) => {\n      const requestInfo = fbsRequests.getMetadata(\n          this.authWrapper_, this.location_, this.mappings_);\n      const metadataRequest = this.authWrapper_.makeRequest(requestInfo, authToken);\n      this.request_ = metadataRequest;\n      metadataRequest.getPromise().then(\n          (metadata) => {\n            this.request_ = null;\n            this.metadata_ = metadata;\n            this.transition_(InternalTaskState.SUCCESS);\n          },\n          this.metadataErrorHandler_);\n    });\n  }\n\n  private oneShotUpload_() {\n    this.resolveToken_((authToken) => {\n      const requestInfo = fbsRequests.multipartUpload(\n          this.authWrapper_, this.location_, this.mappings_, this.blob_,\n          this.metadata_);\n      const multipartRequest = this.authWrapper_.makeRequest(requestInfo, authToken);\n      this.request_ = multipartRequest;\n      multipartRequest.getPromise().then(\n          (metadata) => {\n            this.request_ = null;\n            this.metadata_ = metadata;\n            this.updateProgress_(this.blob_.size());\n            this.transition_(InternalTaskState.SUCCESS);\n          },\n          this.errorHandler_);\n    });\n  }\n\n  private updateProgress_(transferred: number) {\n    const old = this.transferred_;\n    this.transferred_ = transferred;\n\n    // A progress update can make the \"transferred\" value smaller (e.g. a\n    // partial upload not completed by server, after which the \"transferred\"\n    // value may reset to the value at the beginning of the request).\n    if (this.transferred_ !== old) {\n      this.notifyObservers_();\n    }\n  }\n\n  private transition_(state: InternalTaskState) {\n    if (this.state_ === state) {\n      return;\n    }\n    switch (state) {\n      case InternalTaskState.CANCELING:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING ||\n        //        this.state_ === InternalTaskState.PAUSING);\n        this.state_ = state;\n        if (this.request_ !== null) {\n          this.request_.cancel();\n        }\n        break;\n      case InternalTaskState.PAUSING:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING);\n        this.state_ = state;\n        if (this.request_ !== null) {\n          this.request_.cancel();\n        }\n        break;\n      case InternalTaskState.RUNNING:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.PAUSED ||\n        //        this.state_ === InternalTaskState.PAUSING);\n        const wasPaused = this.state_ === InternalTaskState.PAUSED;\n        this.state_ = state;\n        if (wasPaused) {\n          this.notifyObservers_();\n          this.start_();\n        }\n        break;\n      case InternalTaskState.PAUSED:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.PAUSING);\n        this.state_ = state;\n        this.notifyObservers_();\n        break;\n      case InternalTaskState.CANCELED:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.PAUSED ||\n        //        this.state_ === InternalTaskState.CANCELING);\n        this.error_ = errors.canceled();\n        this.state_ = state;\n        this.notifyObservers_();\n        break;\n      case InternalTaskState.ERROR:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING ||\n        //        this.state_ === InternalTaskState.PAUSING ||\n        //        this.state_ === InternalTaskState.CANCELING);\n        this.state_ = state;\n        this.notifyObservers_();\n        break;\n      case InternalTaskState.SUCCESS:\n\n        // TODO(andysoto):\n        // assert(this.state_ === InternalTaskState.RUNNING ||\n        //        this.state_ === InternalTaskState.PAUSING ||\n        //        this.state_ === InternalTaskState.CANCELING);\n        this.state_ = state;\n        this.notifyObservers_();\n        break;\n    }\n  }\n\n  private completeTransitions_() {\n    switch (this.state_) {\n      case InternalTaskState.PAUSING:\n        this.transition_(InternalTaskState.PAUSED);\n        break;\n      case InternalTaskState.CANCELING:\n        this.transition_(InternalTaskState.CANCELED);\n        break;\n      case InternalTaskState.RUNNING:\n        this.start_();\n        break;\n      default:\n\n        // TODO(andysoto): assert(false);\n        break;\n    }\n  }\n\n  get snapshot(): UploadTaskSnapshot {\n    const externalState =\n        fbsTaskEnums.taskStateFromInternalTaskState(this.state_);\n    return new UploadTaskSnapshot(\n        this.transferred_, this.blob_.size(), externalState, this.metadata_,\n        this, this.ref_);\n  }\n\n  /**\n   * Adds a callback for an event.\n   * @param type The type of event to listen for.\n   */\n  on(type: TaskEvent, nextOrObserver = undefined, error = undefined,\n     completed = undefined): Unsubscribe | Subscribe<UploadTaskSnapshot> {\n    function typeValidator(_p: any) {\n      if (type !== TaskEvent.STATE_CHANGED) {\n        throw `Expected one of the event types: [${TaskEvent.STATE_CHANGED}].`;\n      }\n    }\n    const nextOrObserverMessage =\n        'Expected a function or an Object with one of ' +\n        '`next`, `error`, `complete` properties.';\n    const nextValidator = fbsArgs.nullFunctionSpec(true).validator;\n    const observerValidator = fbsArgs.looseObjectSpec(null, true).validator;\n\n    function nextOrObserverValidator(p: any) {\n      try {\n        nextValidator(p);\n        return;\n      } catch (e) {\n      }\n      try {\n        observerValidator(p);\n        const anyDefined = typeUtils.isJustDef(p['next']) || typeUtils.isJustDef(p['error']) ||\n            typeUtils.isJustDef(p['complete']);\n        if (!anyDefined) {\n          throw '';\n        }\n        return;\n      } catch (e) {\n        throw nextOrObserverMessage;\n      }\n    }\n    const specs = [\n      fbsArgs.stringSpec(typeValidator),\n      fbsArgs.looseObjectSpec(nextOrObserverValidator, true),\n      fbsArgs.nullFunctionSpec(true), fbsArgs.nullFunctionSpec(true)\n    ];\n    fbsArgs.validate('on', specs, arguments);\n    const self = this;\n\n    function makeBinder(specs: ArgSpec[]|null): Subscribe<UploadTaskSnapshot> {\n      function binder(\n          nextOrObserver: NextFn<UploadTaskSnapshot> | {[name: string]: string|null} | null,\n          error?: ErrorFn | null,\n          opt_complete?: CompleteFn | null) {\n        if (specs !== null) {\n          fbsArgs.validate('on', specs, arguments);\n        }\n        const observer = new Observer(nextOrObserver, error, completed);\n        self.addObserver_(observer);\n        return () => {\n          self.removeObserver_(observer);\n        };\n      }\n      return binder;\n    }\n\n    function binderNextOrObserverValidator(p: any) {\n      if (p === null) {\n        throw nextOrObserverMessage;\n      }\n      nextOrObserverValidator(p);\n    }\n    const binderSpecs = [\n      fbsArgs.looseObjectSpec(binderNextOrObserverValidator),\n      fbsArgs.nullFunctionSpec(true), fbsArgs.nullFunctionSpec(true)\n    ];\n    const typeOnly =\n        !(typeUtils.isJustDef(nextOrObserver) || typeUtils.isJustDef(error) ||\n          typeUtils.isJustDef(completed));\n    if (typeOnly) {\n      return makeBinder(binderSpecs);\n    } else {\n      return makeBinder(null)(nextOrObserver, error, completed);\n    }\n  }\n\n  /**\n   * This object behaves like a Promise, and resolves with its snapshot data\n   * when the upload completes.\n   *     The fulfillment callback. Promise chaining works as normal.\n   * @param onRejected The rejection callback.\n   */\n  then<U>(onFulfilled?: ((value: UploadTaskSnapshot) => U | PromiseLike<U>) | null, onRejected?: ((error: any) => U | PromiseLike<U>) | null): Promise<U> {\n      return this.promise_.then<U>(\n        (onFulfilled as (value: UploadTaskSnapshot) => U | PromiseLike<U>),\n        (onRejected as ((error: any) => PromiseLike<U>) | null));\n  }\n\n  /**\n   * Equivalent to calling `then(null, onRejected)`.\n   */\n  catch<T>(onRejected: (p1: Error) => T | PromiseLike<T>): Promise<T> {\n    return this.then(null, onRejected);\n  }\n\n  /**\n   * Adds the given observer.\n   */\n  private addObserver_(observer: Observer<UploadTaskSnapshot>) {\n    this.observers_.push(observer);\n    this.notifyObserver_(observer);\n  }\n\n  /**\n   * Removes the given observer.\n   */\n  private removeObserver_(observer: Observer<UploadTaskSnapshot>) {\n    fbsArray.remove(this.observers_, observer);\n  }\n\n  private notifyObservers_() {\n    this.finishPromise_();\n    const observers = fbsArray.clone(this.observers_);\n    observers.forEach((observer) => {\n      this.notifyObserver_(observer);\n    });\n  }\n\n  private finishPromise_() {\n    if (this.resolve_ !== null) {\n      let triggered = true;\n      switch (fbsTaskEnums.taskStateFromInternalTaskState(this.state_)) {\n        case TaskState.SUCCESS:\n          fbsAsync(this.resolve_.bind(null, this.snapshot))();\n          break;\n        case TaskState.CANCELED:\n        case TaskState.ERROR:\n          const toCall = (this.reject_ as ((p1: Error) => void));\n          fbsAsync(toCall.bind(null, (this.error_ as Error)))();\n          break;\n        default:\n          triggered = false;\n          break;\n      }\n      if (triggered) {\n        this.resolve_ = null;\n        this.reject_ = null;\n      }\n    }\n  }\n\n  private notifyObserver_(observer: Observer<UploadTaskSnapshot>) {\n    const externalState =\n        fbsTaskEnums.taskStateFromInternalTaskState(this.state_);\n    switch (externalState) {\n      case TaskState.RUNNING:\n      case TaskState.PAUSED:\n        if (observer.next !== null) {\n          fbsAsync(observer.next.bind(observer, this.snapshot))();\n        }\n        break;\n      case TaskState.SUCCESS:\n        if (observer.complete !== null) {\n          fbsAsync(observer.complete.bind(observer))();\n        }\n        break;\n      case TaskState.CANCELED:\n      case TaskState.ERROR:\n        if (observer.error !== null) {\n          fbsAsync(observer.error.bind(observer, (this.error_ as Error)))();\n        }\n        break;\n      default:\n\n        // TODO(andysoto): assert(false);\n        if (observer.error !== null) {\n          fbsAsync(observer.error.bind(observer, (this.error_ as Error)))();\n        }\n    }\n  }\n\n  /**\n   * Resumes a paused task. Has no effect on a currently running or failed task.\n   * @return True if the operation took effect, false if ignored.\n   */\n  resume(): boolean {\n    fbsArgs.validate('resume', [], arguments);\n    const valid = this.state_ === InternalTaskState.PAUSED ||\n        this.state_ === InternalTaskState.PAUSING;\n    if (valid) {\n      this.transition_(InternalTaskState.RUNNING);\n    }\n    return valid;\n  }\n\n  /**\n   * Pauses a currently running task. Has no effect on a paused or failed task.\n   * @return True if the operation took effect, false if ignored.\n   */\n  pause(): boolean {\n    fbsArgs.validate('pause', [], arguments);\n    const valid = this.state_ === InternalTaskState.RUNNING;\n    if (valid) {\n      this.transition_(InternalTaskState.PAUSING);\n    }\n    return valid;\n  }\n\n  /**\n   * Cancels a currently running or paused task. Has no effect on a complete or\n   * failed task.\n   * @return True if the operation took effect, false if ignored.\n   */\n  cancel(): boolean {\n    fbsArgs.validate('cancel', [], arguments);\n    const valid = this.state_ === InternalTaskState.RUNNING ||\n        this.state_ === InternalTaskState.PAUSING;\n    if (valid) {\n      this.transition_(InternalTaskState.CANCELING);\n    }\n    return valid;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/task.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport {TaskState} from './implementation/taskenums';\nimport * as type from './implementation/type';\nimport {Metadata} from './metadata';\nimport {Reference} from './reference';\nimport {UploadTask} from './task';\n\nexport class UploadTaskSnapshot {\n  constructor(readonly bytesTransferred: number, readonly totalBytes: number,\n      readonly state: TaskState, readonly metadata: Metadata|null, \n      readonly task: UploadTask, readonly ref: Reference) {}\n\n  get downloadURL(): string|null {\n    if (this.metadata !== null) {\n      let urls = this.metadata['downloadURLs'];\n      if (urls != null && urls[0] != null) {\n        return urls[0];\n      } else {\n        return null;\n      }\n    } else {\n      return null;\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/storage/tasksnapshot.ts"],"sourceRoot":""}