https://smarttvcast-screenmirroring.web.app/__/firebase/9.6.11/firebase-storage.js

1import { getApp, _getProvider, _registerComponent, registerVersion, SDK_VERSION } from 'https://www.gstatic.com/firebasejs/9.6.11/firebase-app.js';
2
3/**
4 * @license
5 * Copyright 2017 Google LLC
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *   http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20/**
21 * @license
22 * Copyright 2017 Google LLC
23 *
24 * Licensed under the Apache License, Version 2.0 (the "License");
25 * you may not use this file except in compliance with the License.
26 * You may obtain a copy of the License at
27 *
28 *   http://www.apache.org/licenses/LICENSE-2.0
29 *
30 * Unless required by applicable law or agreed to in writing, software
31 * distributed under the License is distributed on an "AS IS" BASIS,
32 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
33 * See the License for the specific language governing permissions and
34 * limitations under the License.
35 */
36const stringToByteArray$1 = function (str) {
37    // TODO(user): Use native implementations if/when available
38    const out = [];
39    let p = 0;
40    for (let i = 0; i < str.length; i++) {
41        let c = str.charCodeAt(i);
42        if (c < 128) {
43            out[p++] = c;
44        }
45        else if (c < 2048) {
46            out[p++] = (c >> 6) | 192;
47            out[p++] = (c & 63) | 128;
48        }
49        else if ((c & 0xfc00) === 0xd800 &&
50            i + 1 < str.length &&
51            (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
52            // Surrogate Pair
53            c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);
54            out[p++] = (c >> 18) | 240;
55            out[p++] = ((c >> 12) & 63) | 128;
56            out[p++] = ((c >> 6) & 63) | 128;
57            out[p++] = (c & 63) | 128;
58        }
59        else {
60            out[p++] = (c >> 12) | 224;
61            out[p++] = ((c >> 6) & 63) | 128;
62            out[p++] = (c & 63) | 128;
63        }
64    }
65    return out;
66};
67/**
68 * Turns an array of numbers into the string given by the concatenation of the
69 * characters to which the numbers correspond.
70 * @param bytes Array of numbers representing characters.
71 * @return Stringification of the array.
72 */
73const byteArrayToString = function (bytes) {
74    // TODO(user): Use native implementations if/when available
75    const out = [];
76    let pos = 0, c = 0;
77    while (pos < bytes.length) {
78        const c1 = bytes[pos++];
79        if (c1 < 128) {
80            out[c++] = String.fromCharCode(c1);
81        }
82        else if (c1 > 191 && c1 < 224) {
83            const c2 = bytes[pos++];
84            out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
85        }
86        else if (c1 > 239 && c1 < 365) {
87            // Surrogate Pair
88            const c2 = bytes[pos++];
89            const c3 = bytes[pos++];
90            const c4 = bytes[pos++];
91            const u = (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -
92                0x10000;
93            out[c++] = String.fromCharCode(0xd800 + (u >> 10));
94            out[c++] = String.fromCharCode(0xdc00 + (u & 1023));
95        }
96        else {
97            const c2 = bytes[pos++];
98            const c3 = bytes[pos++];
99            out[c++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
100        }
101    }
102    return out.join('');
103};
104// We define it as an object literal instead of a class because a class compiled down to es5 can't
105// be treeshaked. https://github.com/rollup/rollup/issues/1691
106// Static lookup maps, lazily populated by init_()
107const base64 = {
108    /**
109     * Maps bytes to characters.
110     */
111    byteToCharMap_: null,
112    /**
113     * Maps characters to bytes.
114     */
115    charToByteMap_: null,
116    /**
117     * Maps bytes to websafe characters.
118     * @private
119     */
120    byteToCharMapWebSafe_: null,
121    /**
122     * Maps websafe characters to bytes.
123     * @private
124     */
125    charToByteMapWebSafe_: null,
126    /**
127     * Our default alphabet, shared between
128     * ENCODED_VALS and ENCODED_VALS_WEBSAFE
129     */
130    ENCODED_VALS_BASE: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',
131    /**
132     * Our default alphabet. Value 64 (=) is special; it means "nothing."
133     */
134    get ENCODED_VALS() {
135        return this.ENCODED_VALS_BASE + '+/=';
136    },
137    /**
138     * Our websafe alphabet.
139     */
140    get ENCODED_VALS_WEBSAFE() {
141        return this.ENCODED_VALS_BASE + '-_.';
142    },
143    /**
144     * Whether this browser supports the atob and btoa functions. This extension
145     * started at Mozilla but is now implemented by many browsers. We use the
146     * ASSUME_* variables to avoid pulling in the full useragent detection library
147     * but still allowing the standard per-browser compilations.
148     *
149     */
150    HAS_NATIVE_SUPPORT: typeof atob === 'function',
151    /**
152     * Base64-encode an array of bytes.
153     *
154     * @param input An array of bytes (numbers with
155     *     value in [0, 255]) to encode.
156     * @param webSafe Boolean indicating we should use the
157     *     alternative alphabet.
158     * @return The base64 encoded string.
159     */
160    encodeByteArray(input, webSafe) {
161        if (!Array.isArray(input)) {
162            throw Error('encodeByteArray takes an array as a parameter');
163        }
164        this.init_();
165        const byteToCharMap = webSafe
166            ? this.byteToCharMapWebSafe_
167            : this.byteToCharMap_;
168        const output = [];
169        for (let i = 0; i < input.length; i += 3) {
170            const byte1 = input[i];
171            const haveByte2 = i + 1 < input.length;
172            const byte2 = haveByte2 ? input[i + 1] : 0;
173            const haveByte3 = i + 2 < input.length;
174            const byte3 = haveByte3 ? input[i + 2] : 0;
175            const outByte1 = byte1 >> 2;
176            const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
177            let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
178            let outByte4 = byte3 & 0x3f;
179            if (!haveByte3) {
180                outByte4 = 64;
181                if (!haveByte2) {
182                    outByte3 = 64;
183                }
184            }
185            output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
186        }
187        return output.join('');
188    },
189    /**
190     * Base64-encode a string.
191     *
192     * @param input A string to encode.
193     * @param webSafe If true, we should use the
194     *     alternative alphabet.
195     * @return The base64 encoded string.
196     */
197    encodeString(input, webSafe) {
198        // Shortcut for Mozilla browsers that implement
199        // a native base64 encoder in the form of "btoa/atob"
200        if (this.HAS_NATIVE_SUPPORT && !webSafe) {
201            return btoa(input);
202        }
203        return this.encodeByteArray(stringToByteArray$1(input), webSafe);
204    },
205    /**
206     * Base64-decode a string.
207     *
208     * @param input to decode.
209     * @param webSafe True if we should use the
210     *     alternative alphabet.
211     * @return string representing the decoded value.
212     */
213    decodeString(input, webSafe) {
214        // Shortcut for Mozilla browsers that implement
215        // a native base64 encoder in the form of "btoa/atob"
216        if (this.HAS_NATIVE_SUPPORT && !webSafe) {
217            return atob(input);
218        }
219        return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
220    },
221    /**
222     * Base64-decode a string.
223     *
224     * In base-64 decoding, groups of four characters are converted into three
225     * bytes.  If the encoder did not apply padding, the input length may not
226     * be a multiple of 4.
227     *
228     * In this case, the last group will have fewer than 4 characters, and
229     * padding will be inferred.  If the group has one or two characters, it decodes
230     * to one byte.  If the group has three characters, it decodes to two bytes.
231     *
232     * @param input Input to decode.
233     * @param webSafe True if we should use the web-safe alphabet.
234     * @return bytes representing the decoded value.
235     */
236    decodeStringToByteArray(input, webSafe) {
237        this.init_();
238        const charToByteMap = webSafe
239            ? this.charToByteMapWebSafe_
240            : this.charToByteMap_;
241        const output = [];
242        for (let i = 0; i < input.length;) {
243            const byte1 = charToByteMap[input.charAt(i++)];

684function invalidArgument(message) {
685    return new StorageError("invalid-argument" /* INVALID_ARGUMENT */, message);
686}
687function appDeleted() {
688    return new StorageError("app-deleted" /* APP_DELETED */, 'The Firebase app was deleted.');
689}
690/**
691 * @param name - The name of the operation that was invalid.
692 *
693 * @internal
694 */
695function invalidRootOperation(name) {
696    return new StorageError("invalid-root-operation" /* INVALID_ROOT_OPERATION */, "The operation '" +
697        name +
698        "' cannot be performed on a root reference, create a non-root " +
699        "reference using child, such as .child('file.png').");
700}
701/**
702 * @param format - The format that was not valid.
703 * @param message - A message describing the format violation.
704 */
705function invalidFormat(format, message) {
706    return new StorageError("invalid-format" /* INVALID_FORMAT */, "String does not match format '" + format + "': " + message);
707}
708/**
709 * @param message - A message describing the internal error.
710 */
711function internalError(message) {
712    throw new StorageError("internal-error" /* INTERNAL_ERROR */, 'Internal error: ' + message);
713}
714
715/**
716 * @license
717 * Copyright 2017 Google LLC
718 *
719 * Licensed under the Apache License, Version 2.0 (the "License");
720 * you may not use this file except in compliance with the License.
721 * You may obtain a copy of the License at
722 *
723 *   http://www.apache.org/licenses/LICENSE-2.0
724 *
725 * Unless required by applicable law or agreed to in writing, software
726 * distributed under the License is distributed on an "AS IS" BASIS,
727 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
728 * See the License for the specific language governing permissions and
729 * limitations under the License.
730 */
731/**
732 * Firebase Storage location data.
733 *
734 * @internal
735 */
736class Location {
737    constructor(bucket, path) {
738        this.bucket = bucket;
739        this.path_ = path;
740    }
741    get path() {
742        return this.path_;
743    }
744    get isRoot() {
745        return this.path.length === 0;
746    }
747    fullServerUrl() {
748        const encode = encodeURIComponent;
749        return '/b/' + encode(this.bucket) + '/o/' + encode(this.path);
750    }
751    bucketOnlyServerUrl() {
752        const encode = encodeURIComponent;
753        return '/b/' + encode(this.bucket) + '/o';
754    }
755    static makeFromBucketSpec(bucketString, host) {
756        let bucketLocation;
757        try {
758            bucketLocation = Location.makeFromUrl(bucketString, host);
759        }
760        catch (e) {
761            // Not valid URL, use as-is. This lets you put bare bucket names in
762            // config.
763            return new Location(bucketString, '');
764        }
765        if (bucketLocation.path === '') {
766            return bucketLocation;
767        }
768        else {
769            throw invalidDefaultBucket(bucketString);
770        }
771    }
772    static makeFromUrl(url, host) {
773        let location = null;
774        const bucketDomain = '([A-Za-z0-9.\\-_]+)';
775        function gsModify(loc) {
776            if (loc.path.charAt(loc.path.length - 1) === '/') {
777                loc.path_ = loc.path_.slice(0, -1);
778            }
779        }
780        const gsPath = '(/(.*))?$';
781        const gsRegex = new RegExp('^gs://' + bucketDomain + gsPath, 'i');
782        const gsIndices = { bucket: 1, path: 3 };
783        function httpModify(loc) {
784            loc.path_ = decodeURIComponent(loc.path);
785        }
786        const version = 'v[A-Za-z0-9_]+';
787        const firebaseStorageHost = host.replace(/[.]/g, '\\.');
788        const firebaseStoragePath = '(/([^?#]*).*)?$';
789        const firebaseStorageRegExp = new RegExp(`^https?://${firebaseStorageHost}/${version}/b/${bucketDomain}/o${firebaseStoragePath}`, 'i');
790        const firebaseStorageIndices = { bucket: 1, path: 3 };
791        const cloudStorageHost = host === DEFAULT_HOST
792            ? '(?:storage.googleapis.com|storage.cloud.google.com)'
793            : host;
794        const cloudStoragePath = '([^?#]*)';
795        const cloudStorageRegExp = new RegExp(`^https?://${cloudStorageHost}/${bucketDomain}/${cloudStoragePath}`, 'i');
796        const cloudStorageIndices = { bucket: 1, path: 2 };
797        const groups = [
798            { regex: gsRegex, indices: gsIndices, postModify: gsModify },
799            {
800                regex: firebaseStorageRegExp,
801                indices: firebaseStorageIndices,
802                postModify: httpModify
803            },
804            {
805                regex: cloudStorageRegExp,
806                indices: cloudStorageIndices,
807                postModify: httpModify
808            }
809        ];
810        for (let i = 0; i < groups.length; i++) {
811            const group = groups[i];
812            const captures = group.regex.exec(url);
813            if (captures) {
814                const bucketValue = captures[group.indices.bucket];
815                let pathValue = captures[group.indices.path];
816                if (!pathValue) {
817                    pathValue = '';
818                }
819                location = new Location(bucketValue, pathValue);
820                group.postModify(location);
821                break;
822            }
823        }
824        if (location == null) {

875    // TODO: find a way to exclude Node type definition for storage because storage only works in browser
876    // eslint-disable-next-line @typescript-eslint/no-explicit-any
877    let retryTimeoutId = null;
878    // eslint-disable-next-line @typescript-eslint/no-explicit-any
879    let globalTimeoutId = null;
880    let hitTimeout = false;
881    let cancelState = 0;
882    function canceled() {
883        return cancelState === 2;
884    }
885    let triggeredCallback = false;
886    function triggerCallback(...args) {
887        if (!triggeredCallback) {
888            triggeredCallback = true;
889            callback.apply(null, args);
890        }
891    }
892    function callWithDelay(millis) {
893        retryTimeoutId = setTimeout(() => {
894            retryTimeoutId = null;
895            f(handler, canceled());
896        }, millis);
897    }
898    function clearGlobalTimeout() {
899        if (globalTimeoutId) {
900            clearTimeout(globalTimeoutId);
901        }
902    }
903    function handler(success, ...args) {
904        if (triggeredCallback) {
905            clearGlobalTimeout();
906            return;
907        }
908        if (success) {
909            clearGlobalTimeout();
910            triggerCallback.call(null, success, ...args);
911            return;
912        }
913        const mustStop = canceled() || hitTimeout;
914        if (mustStop) {
915            clearGlobalTimeout();
916            triggerCallback.call(null, success, ...args);
917            return;
918        }
919        if (waitSeconds < 64) {
920            /* TODO(andysoto): don't back off so quickly if we know we're offline. */
921            waitSeconds *= 2;
922        }
923        let waitMillis;
924        if (cancelState === 1) {
925            cancelState = 2;
926            waitMillis = 0;
927        }
928        else {
929            waitMillis = (waitSeconds + Math.random()) * 1000;
930        }
931        callWithDelay(waitMillis);
932    }
933    let stopped = false;
934    function stop(wasTimeout) {
935        if (stopped) {
936            return;
937        }
938        stopped = true;
939        clearGlobalTimeout();
940        if (triggeredCallback) {
941            return;
942        }
943        if (retryTimeoutId !== null) {
944            if (!wasTimeout) {
945                cancelState = 2;
946            }
947            clearTimeout(retryTimeoutId);
948            callWithDelay(0);
949        }
950        else {
951            if (!wasTimeout) {
952                cancelState = 1;
953            }
954        }
955    }
956    callWithDelay(0);
957    globalTimeoutId = setTimeout(() => {
958        hitTimeout = true;
959        stop(true);
960    }, timeout);
961    return stop;
962}
963/**
964 * Stops the retry loop from repeating.
965 * If the function is currently "in between" retries, it is invoked immediately
966 * with the second parameter as "true". Otherwise, it will be invoked once more
967 * after the current invocation finishes iff the current invocation would have
968 * triggered another retry.
969 */
970function stop(id) {
971    id(false);
972}
973
974/**
975 * @license
976 * Copyright 2017 Google LLC
977 *
978 * Licensed under the Apache License, Version 2.0 (the "License");
979 * you may not use this file except in compliance with the License.
980 * You may obtain a copy of the License at
981 *
982 *   http://www.apache.org/licenses/LICENSE-2.0
983 *
984 * Unless required by applicable law or agreed to in writing, software
985 * distributed under the License is distributed on an "AS IS" BASIS,
986 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
987 * See the License for the specific language governing permissions and
988 * limitations under the License.
989 */
990function isJustDef(p) {
991    return p !== void 0;
992}
993// eslint-disable-next-line @typescript-eslint/ban-types
994function isFunction(p) {
995    return typeof p === 'function';
996}
997function isNonArrayObject(p) {
998    return typeof p === 'object' && !Array.isArray(p);
999}
1000function isString(p) {
1001    return typeof p === 'string' || p instanceof String;
1002}
1003function isNativeBlob(p) {
1004    return isNativeBlobDefined() && p instanceof Blob;
1005}
1006function isNativeBlobDefined() {
1007    return typeof Blob !== 'undefined';
1008}
1009function validateNumber(argument, minValue, maxValue, value) {
1010    if (value < minValue) {
1011        throw invalidArgument(`Invalid value for '${argument}'. Expected ${minValue} or greater.`);
1012    }
1013    if (value > maxValue) {
1014        throw invalidArgument(`Invalid value for '${argument}'. Expected ${maxValue} or less.`);
1015    }
1016}
1017
1018/**
1019 * @license
1020 * Copyright 2017 Google LLC
1021 *
1022 * Licensed under the Apache License, Version 2.0 (the "License");
1023 * you may not use this file except in compliance with the License.
1024 * You may obtain a copy of the License at
1025 *
1026 *   http://www.apache.org/licenses/LICENSE-2.0
1027 *
1028 * Unless required by applicable law or agreed to in writing, software
1029 * distributed under the License is distributed on an "AS IS" BASIS,
1030 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1031 * See the License for the specific language governing permissions and
1032 * limitations under the License.
1033 */
1034function makeUrl(urlPart, host, protocol) {
1035    let origin = host;
1036    if (protocol == null) {
1037        origin = `https://${host}`;
1038    }
1039    return `${protocol}://${origin}/v0${urlPart}`;
1040}
1041function makeQueryString(params) {
1042    const encode = encodeURIComponent;
1043    let queryPart = '?';
1044    for (const key in params) {
1045        if (params.hasOwnProperty(key)) {
1046            const nextPart = encode(key) + '=' + encode(params[key]);
1047            queryPart = queryPart + nextPart + '&';
1048        }
1049    }
1050    // Chop off the extra '&' or '?' on the end
1051    queryPart = queryPart.slice(0, -1);
1052    return queryPart;
1053}
1054
1055/**
1056 * @license
1057 * Copyright 2017 Google LLC
1058 *
1059 * Licensed under the Apache License, Version 2.0 (the "License");
1060 * you may not use this file except in compliance with the License.
1061 * You may obtain a copy of the License at
1062 *
1063 *   http://www.apache.org/licenses/LICENSE-2.0
1064 *
1065 * Unless required by applicable law or agreed to in writing, software
1066 * distributed under the License is distributed on an "AS IS" BASIS,
1067 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1068 * See the License for the specific language governing permissions and
1069 * limitations under the License.
1070 */
1071/**
1072 * Error codes for requests made by the the XhrIo wrapper.
1073 */
1074var ErrorCode;
1075(function (ErrorCode) {
1076    ErrorCode[ErrorCode["NO_ERROR"] = 0] = "NO_ERROR";
1077    ErrorCode[ErrorCode["NETWORK_ERROR"] = 1] = "NETWORK_ERROR";
1078    ErrorCode[ErrorCode["ABORT"] = 2] = "ABORT";
1079})(ErrorCode || (ErrorCode = {}));
1080
1081/**
1082 * @license
1083 * Copyright 2017 Google LLC
1084 *
1085 * Licensed under the Apache License, Version 2.0 (the "License");
1086 * you may not use this file except in compliance with the License.
1087 * You may obtain a copy of the License at
1088 *
1089 *   http://www.apache.org/licenses/LICENSE-2.0
1090 *
1091 * Unless required by applicable law or agreed to in writing, software
1092 * distributed under the License is distributed on an "AS IS" BASIS,
1093 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1094 * See the License for the specific language governing permissions and
1095 * limitations under the License.
1096 */
1097/**
1098 * Handles network logic for all Storage Requests, including error reporting and
1099 * retries with backoff.
1100 *
1101 * @param I - the type of the backend's network response.
1102 * @param - O the output type used by the rest of the SDK. The conversion
1103 * happens in the specified `callback_`.
1104 */
1105class NetworkRequest {
1106    constructor(url_, method_, headers_, body_, successCodes_, additionalRetryCodes_, callback_, errorCallback_, timeout_, progressCallback_, connectionFactory_) {
1107        this.url_ = url_;
1108        this.method_ = method_;
1109        this.headers_ = headers_;
1110        this.body_ = body_;
1111        this.successCodes_ = successCodes_;
1112        this.additionalRetryCodes_ = additionalRetryCodes_;
1113        this.callback_ = callback_;
1114        this.errorCallback_ = errorCallback_;
1115        this.timeout_ = timeout_;
1116        this.progressCallback_ = progressCallback_;
1117        this.connectionFactory_ = connectionFactory_;
1118        this.pendingConnection_ = null;
1119        this.backoffId_ = null;
1120        this.canceled_ = false;
1121        this.appDelete_ = false;
1122        this.promise_ = new Promise((resolve, reject) => {
1123            this.resolve_ = resolve;
1124            this.reject_ = reject;
1125            this.start_();
1126        });
1127    }
1128    /**
1129     * Actually starts the retry loop.
1130     */
1131    start_() {
1132        const doTheRequest = (backoffCallback, canceled) => {
1133            if (canceled) {
1134                backoffCallback(false, new RequestEndStatus(false, null, true));
1135                return;
1136            }
1137            const connection = this.connectionFactory_();
1138            this.pendingConnection_ = connection;
1139            const progressListener = progressEvent => {
1140                const loaded = progressEvent.loaded;
1141                const total = progressEvent.lengthComputable
1142                    ? progressEvent.total
1143                    : -1;
1144                if (this.progressCallback_ !== null) {
1145                    this.progressCallback_(loaded, total);
1146                }
1147            };
1148            if (this.progressCallback_ !== null) {
1149                connection.addUploadProgressListener(progressListener);
1150            }
1151            // connection.send() never rejects, so we don't need to have a error handler or use catch on the returned promise.
1152            // eslint-disable-next-line @typescript-eslint/no-floating-promises
1153            connection
1154                .send(this.url_, this.method_, this.body_, this.headers_)
1155                .then(() => {
1156                if (this.progressCallback_ !== null) {
1157                    connection.removeUploadProgressListener(progressListener);
1158                }
1159                this.pendingConnection_ = null;
1160                const hitServer = connection.getErrorCode() === ErrorCode.NO_ERROR;
1161                const status = connection.getStatus();
1162                if (!hitServer || this.isRetryStatusCode_(status)) {
1163                    const wasCanceled = connection.getErrorCode() === ErrorCode.ABORT;
1164                    backoffCallback(false, new RequestEndStatus(false, null, wasCanceled));
1165                    return;
1166                }
1167                const successCode = this.successCodes_.indexOf(status) !== -1;
1168                backoffCallback(true, new RequestEndStatus(successCode, connection));
1169            });
1170        };
1171        /**
1172         * @param requestWentThrough - True if the request eventually went
1173         *     through, false if it hit the retry limit or was canceled.
1174         */
1175        const backoffDone = (requestWentThrough, status) => {
1176            const resolve = this.resolve_;
1177            const reject = this.reject_;
1178            const connection = status.connection;
1179            if (status.wasSuccessCode) {
1180                try {
1181                    const result = this.callback_(connection, connection.getResponse());
1182                    if (isJustDef(result)) {
1183                        resolve(result);
1184                    }
1185                    else {
1186                        resolve();
1187                    }
1188                }
1189                catch (e) {
1190                    reject(e);
1191                }
1192            }
1193            else {
1194                if (connection !== null) {
1195                    const err = unknown();
1196                    err.serverResponse = connection.getErrorText();
1197                    if (this.errorCallback_) {
1198                        reject(this.errorCallback_(connection, err));
1199                    }
1200                    else {
1201                        reject(err);
1202                    }
1203                }
1204                else {
1205                    if (status.canceled) {
1206                        const err = this.appDelete_ ? appDeleted() : canceled();
1207                        reject(err);
1208                    }
1209                    else {
1210                        const err = retryLimitExceeded();
1211                        reject(err);
1212                    }
1213                }
1214            }
1215        };
1216        if (this.canceled_) {
1217            backoffDone(false, new RequestEndStatus(false, null, true));
1218        }
1219        else {
1220            this.backoffId_ = start(doTheRequest, backoffDone, this.timeout_);
1221        }
1222    }
1223    /** @inheritDoc */
1224    getPromise() {
1225        return this.promise_;
1226    }
1227    /** @inheritDoc */
1228    cancel(appDelete) {
1229        this.canceled_ = true;
1230        this.appDelete_ = appDelete || false;
1231        if (this.backoffId_ !== null) {
1232            stop(this.backoffId_);
1233        }
1234        if (this.pendingConnection_ !== null) {
1235            this.pendingConnection_.abort();
1236        }
1237    }
1238    isRetryStatusCode_(status) {
1239        // The codes for which to retry came from this page:
1240        // https://cloud.google.com/storage/docs/exponential-backoff
1241        const isFiveHundredCode = status >= 500 && status < 600;
1242        const extraRetryCodes = [
1243            // Request Timeout: web server didn't receive full request in time.
1244            408,
1245            // Too Many Requests: you're getting rate-limited, basically.
1246            429
1247        ];
1248        const isExtraRetryCode = extraRetryCodes.indexOf(status) !== -1;
1249        const isRequestSpecificRetryCode = this.additionalRetryCodes_.indexOf(status) !== -1;
1250        return isFiveHundredCode || isExtraRetryCode || isRequestSpecificRetryCode;
1251    }
1252}
1253/**
1254 * A collection of information about the result of a network request.
1255 * @param opt_canceled - Defaults to false.
1256 */
1257class RequestEndStatus {
1258    constructor(wasSuccessCode, connection, canceled) {
1259        this.wasSuccessCode = wasSuccessCode;
1260        this.connection = connection;
1261        this.canceled = !!canceled;
1262    }
1263}
1264function addAuthHeader_(headers, authToken) {
1265    if (authToken !== null && authToken.length > 0) {
1266        headers['Authorization'] = 'Firebase ' + authToken;
1267    }
1268}
1269function addVersionHeader_(headers, firebaseVersion) {
1270    headers['X-Firebase-Storage-Version'] =
1271        'webjs/' + (firebaseVersion !== null && firebaseVersion !== void 0 ? firebaseVersion : 'AppManager');
1272}
1273function addGmpidHeader_(headers, appId) {
1274    if (appId) {
1275        headers['X-Firebase-GMPID'] = appId;
1276    }
1277}
1278function addAppCheckHeader_(headers, appCheckToken) {
1279    if (appCheckToken !== null) {
1280        headers['X-Firebase-AppCheck'] = appCheckToken;
1281    }
1282}
1283function makeRequest(requestInfo, appId, authToken, appCheckToken, requestFactory, firebaseVersion) {
1284    const queryPart = makeQueryString(requestInfo.urlParams);
1285    const url = requestInfo.url + queryPart;
1286    const headers = Object.assign({}, requestInfo.headers);
1287    addGmpidHeader_(headers, appId);
1288    addAuthHeader_(headers, authToken);
1289    addVersionHeader_(headers, firebaseVersion);
1290    addAppCheckHeader_(headers, appCheckToken);
1291    return new NetworkRequest(url, requestInfo.method, headers, requestInfo.body, requestInfo.successCodes, requestInfo.additionalRetryCodes, requestInfo.handler, requestInfo.errorHandler, requestInfo.timeout, requestInfo.progressCallback, requestFactory);
1292}
1293
1294/**
1295 * @license
1296 * Copyright 2017 Google LLC
1297 *
1298 * Licensed under the Apache License, Version 2.0 (the "License");
1299 * you may not use this file except in compliance with the License.
1300 * You may obtain a copy of the License at
1301 *
1302 *   http://www.apache.org/licenses/LICENSE-2.0
1303 *
1304 * Unless required by applicable law or agreed to in writing, software
1305 * distributed under the License is distributed on an "AS IS" BASIS,
1306 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1307 * See the License for the specific language governing permissions and
1308 * limitations under the License.
1309 */
1310function getBlobBuilder() {
1311    if (typeof BlobBuilder !== 'undefined') {
1312        return BlobBuilder;
1313    }
1314    else if (typeof WebKitBlobBuilder !== 'undefined') {
1315        return WebKitBlobBuilder;
1316    }
1317    else {
1318        return undefined;
1319    }
1320}
1321/**
1322 * Concatenates one or more values together and converts them to a Blob.
1323 *
1324 * @param args The values that will make up the resulting blob.
1325 * @return The blob.
1326 */
1327function getBlob$1(...args) {
1328    const BlobBuilder = getBlobBuilder();
1329    if (BlobBuilder !== undefined) {
1330        const bb = new BlobBuilder();
1331        for (let i = 0; i < args.length; i++) {
1332            bb.append(args[i]);
1333        }
1334        return bb.getBlob();
1335    }
1336    else {
1337        if (isNativeBlobDefined()) {
1338            return new Blob(args);
1339        }
1340        else {
1341            throw new StorageError("unsupported-environment" /* UNSUPPORTED_ENVIRONMENT */, "This browser doesn't seem to support creating Blobs");
1342        }
1343    }
1344}
1345/**
1346 * Slices the blob. The returned blob contains data from the start byte
1347 * (inclusive) till the end byte (exclusive). Negative indices cannot be used.
1348 *
1349 * @param blob The blob to be sliced.
1350 * @param start Index of the starting byte.
1351 * @param end Index of the ending byte.
1352 * @return The blob slice or null if not supported.
1353 */
1354function sliceBlob(blob, start, end) {
1355    if (blob.webkitSlice) {
1356        return blob.webkitSlice(start, end);
1357    }
1358    else if (blob.mozSlice) {
1359        return blob.mozSlice(start, end);
1360    }
1361    else if (blob.slice) {
1362        return blob.slice(start, end);
1363    }
1364    return null;
1365}
1366
1367/**
1368 * @license
1369 * Copyright 2021 Google LLC
1370 *
1371 * Licensed under the Apache License, Version 2.0 (the "License");
1372 * you may not use this file except in compliance with the License.
1373 * You may obtain a copy of the License at
1374 *
1375 *   http://www.apache.org/licenses/LICENSE-2.0
1376 *
1377 * Unless required by applicable law or agreed to in writing, software
1378 * distributed under the License is distributed on an "AS IS" BASIS,
1379 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1380 * See the License for the specific language governing permissions and
1381 * limitations under the License.
1382 */
1383/** Converts a Base64 encoded string to a binary string. */
1384function decodeBase64(encoded) {
1385    return atob(encoded);
1386}
1387
1388/**
1389 * @license
1390 * Copyright 2017 Google LLC
1391 *
1392 * Licensed under the Apache License, Version 2.0 (the "License");
1393 * you may not use this file except in compliance with the License.
1394 * You may obtain a copy of the License at
1395 *
1396 *   http://www.apache.org/licenses/LICENSE-2.0
1397 *
1398 * Unless required by applicable law or agreed to in writing, software
1399 * distributed under the License is distributed on an "AS IS" BASIS,
1400 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1401 * See the License for the specific language governing permissions and
1402 * limitations under the License.
1403 */
1404/**
1405 * An enumeration of the possible string formats for upload.
1406 * @public
1407 */
1408const StringFormat = {
1409    /**
1410     * Indicates the string should be interpreted "raw", that is, as normal text.
1411     * The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte
1412     * sequence.
1413     * Example: The string 'Hello! \\ud83d\\ude0a' becomes the byte sequence
1414     * 48 65 6c 6c 6f 21 20 f0 9f 98 8a
1415     */
1416    RAW: 'raw',
1417    /**
1418     * Indicates the string should be interpreted as base64-encoded data.
1419     * Padding characters (trailing '='s) are optional.
1420     * Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence
1421     * ad 69 8e fb e1 3a b7 bf eb 97
1422     */
1423    BASE64: 'base64',
1424    /**
1425     * Indicates the string should be interpreted as base64url-encoded data.
1426     * Padding characters (trailing '='s) are optional.
1427     * Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence
1428     * ad 69 8e fb e1 3a b7 bf eb 97
1429     */
1430    BASE64URL: 'base64url',
1431    /**
1432     * Indicates the string is a data URL, such as one obtained from
1433     * canvas.toDataURL().
1434     * Example: the string 'data:application/octet-stream;base64,aaaa'
1435     * becomes the byte sequence
1436     * 69 a6 9a
1437     * (the content-type "application/octet-stream" is also applied, but can
1438     * be overridden in the metadata object).
1439     */
1440    DATA_URL: 'data_url'
1441};
1442class StringData {
1443    constructor(data, contentType) {
1444        this.data = data;
1445        this.contentType = contentType || null;
1446    }
1447}
1448/**
1449 * @internal
1450 */
1451function dataFromString(format, stringData) {
1452    switch (format) {
1453        case StringFormat.RAW:
1454            return new StringData(utf8Bytes_(stringData));
1455        case StringFormat.BASE64:
1456        case StringFormat.BASE64URL:
1457            return new StringData(base64Bytes_(format, stringData));
1458        case StringFormat.DATA_URL:
1459            return new StringData(dataURLBytes_(stringData), dataURLContentType_(stringData));
1460        // do nothing
1461    }
1462    // assert(false);
1463    throw unknown();
1464}
1465function utf8Bytes_(value) {
1466    const b = [];
1467    for (let i = 0; i < value.length; i++) {
1468        let c = value.charCodeAt(i);
1469        if (c <= 127) {
1470            b.push(c);
1471        }
1472        else {
1473            if (c <= 2047) {
1474                b.push(192 | (c >> 6), 128 | (c & 63));
1475            }
1476            else {
1477                if ((c & 64512) === 55296) {
1478                    // The start of a surrogate pair.
1479                    const valid = i < value.length - 1 && (value.charCodeAt(i + 1) & 64512) === 56320;
1480                    if (!valid) {
1481                        // The second surrogate wasn't there.
1482                        b.push(239, 191, 189);
1483                    }
1484                    else {
1485                        const hi = c;
1486                        const lo = value.charCodeAt(++i);
1487                        c = 65536 | ((hi & 1023) << 10) | (lo & 1023);
1488                        b.push(240 | (c >> 18), 128 | ((c >> 12) & 63), 128 | ((c >> 6) & 63), 128 | (c & 63));
1489                    }
1490                }
1491                else {
1492                    if ((c & 64512) === 56320) {
1493                        // Invalid low surrogate.
1494                        b.push(239, 191, 189);
1495                    }
1496                    else {
1497                        b.push(224 | (c >> 12), 128 | ((c >> 6) & 63), 128 | (c & 63));
1498                    }
1499                }
1500            }
1501        }
1502    }
1503    return new Uint8Array(b);
1504}
1505function percentEncodedBytes_(value) {
1506    let decoded;
1507    try {
1508        decoded = decodeURIComponent(value);
1509    }
1510    catch (e) {
1511        throw invalidFormat(StringFormat.DATA_URL, 'Malformed data URL.');
1512    }
1513    return utf8Bytes_(decoded);
1514}
1515function base64Bytes_(format, value) {
1516    switch (format) {
1517        case StringFormat.BASE64: {
1518            const hasMinus = value.indexOf('-') !== -1;
1519            const hasUnder = value.indexOf('_') !== -1;
1520            if (hasMinus || hasUnder) {
1521                const invalidChar = hasMinus ? '-' : '_';
1522                throw invalidFormat(format, "Invalid character '" +
1523                    invalidChar +
1524                    "' found: is it base64url encoded?");
1525            }
1526            break;
1527        }
1528        case StringFormat.BASE64URL: {
1529            const hasPlus = value.indexOf('+') !== -1;
1530            const hasSlash = value.indexOf('/') !== -1;
1531            if (hasPlus || hasSlash) {
1532                const invalidChar = hasPlus ? '+' : '/';
1533                throw invalidFormat(format, "Invalid character '" + invalidChar + "' found: is it base64 encoded?");
1534            }
1535            value = value.replace(/-/g, '+').replace(/_/g, '/');
1536            break;
1537        }
1538        // do nothing
1539    }
1540    let bytes;
1541    try {
1542        bytes = decodeBase64(value);
1543    }
1544    catch (e) {
1545        throw invalidFormat(format, 'Invalid character found');
1546    }
1547    const array = new Uint8Array(bytes.length);
1548    for (let i = 0; i < bytes.length; i++) {
1549        array[i] = bytes.charCodeAt(i);
1550    }
1551    return array;
1552}
1553class DataURLParts {
1554    constructor(dataURL) {
1555        this.base64 = false;
1556        this.contentType = null;
1557        const matches = dataURL.match(/^data:([^,]+)?,/);
1558        if (matches === null) {
1559            throw invalidFormat(StringFormat.DATA_URL, "Must be formatted 'data:[<mediatype>][;base64],<data>");
1560        }
1561        const middle = matches[1] || null;
1562        if (middle != null) {
1563            this.base64 = endsWith(middle, ';base64');
1564            this.contentType = this.base64
1565                ? middle.substring(0, middle.length - ';base64'.length)
1566                : middle;
1567        }
1568        this.rest = dataURL.substring(dataURL.indexOf(',') + 1);
1569    }
1570}
1571function dataURLBytes_(dataUrl) {
1572    const parts = new DataURLParts(dataUrl);
1573    if (parts.base64) {
1574        return base64Bytes_(StringFormat.BASE64, parts.rest);
1575    }
1576    else {
1577        return percentEncodedBytes_(parts.rest);
1578    }
1579}
1580function dataURLContentType_(dataUrl) {
1581    const parts = new DataURLParts(dataUrl);
1582    return parts.contentType;
1583}
1584function endsWith(s, end) {
1585    const longEnough = s.length >= end.length;
1586    if (!longEnough) {
1587        return false;
1588    }
1589    return s.substring(s.length - end.length) === end;
1590}
1591
1592/**
1593 * @license
1594 * Copyright 2017 Google LLC
1595 *
1596 * Licensed under the Apache License, Version 2.0 (the "License");
1597 * you may not use this file except in compliance with the License.
1598 * You may obtain a copy of the License at
1599 *
1600 *   http://www.apache.org/licenses/LICENSE-2.0
1601 *
1602 * Unless required by applicable law or agreed to in writing, software
1603 * distributed under the License is distributed on an "AS IS" BASIS,
1604 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1605 * See the License for the specific language governing permissions and
1606 * limitations under the License.
1607 */
1608/**
1609 * @param opt_elideCopy - If true, doesn't copy mutable input data
1610 *     (e.g. Uint8Arrays). Pass true only if you know the objects will not be
1611 *     modified after this blob's construction.
1612 *
1613 * @internal
1614 */
1615class FbsBlob {
1616    constructor(data, elideCopy) {
1617        let size = 0;
1618        let blobType = '';
1619        if (isNativeBlob(data)) {
1620            this.data_ = data;
1621            size = data.size;
1622            blobType = data.type;
1623        }
1624        else if (data instanceof ArrayBuffer) {
1625            if (elideCopy) {
1626                this.data_ = new Uint8Array(data);
1627            }
1628            else {
1629                this.data_ = new Uint8Array(data.byteLength);
1630                this.data_.set(new Uint8Array(data));
1631            }
1632            size = this.data_.length;
1633        }
1634        else if (data instanceof Uint8Array) {
1635            if (elideCopy) {
1636                this.data_ = data;
1637            }
1638            else {
1639                this.data_ = new Uint8Array(data.length);
1640                this.data_.set(data);
1641            }
1642            size = data.length;
1643        }
1644        this.size_ = size;
1645        this.type_ = blobType;
1646    }
1647    size() {
1648        return this.size_;
1649    }
1650    type() {
1651        return this.type_;
1652    }
1653    slice(startByte, endByte) {
1654        if (isNativeBlob(this.data_)) {
1655            const realBlob = this.data_;
1656            const sliced = sliceBlob(realBlob, startByte, endByte);
1657            if (sliced === null) {
1658                return null;
1659            }
1660            return new FbsBlob(sliced);
1661        }
1662        else {
1663            const slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);
1664            return new FbsBlob(slice, true);
1665        }
1666    }
1667    static getBlob(...args) {
1668        if (isNativeBlobDefined()) {
1669            const blobby = args.map((val) => {
1670                if (val instanceof FbsBlob) {
1671                    return val.data_;
1672                }
1673                else {
1674                    return val;
1675                }
1676            });
1677            return new FbsBlob(getBlob$1.apply(null, blobby));
1678        }
1679        else {
1680            const uint8Arrays = args.map((val) => {
1681                if (isString(val)) {
1682                    return dataFromString(StringFormat.RAW, val).data;
1683                }
1684                else {
1685                    // Blobs don't exist, so this has to be a Uint8Array.
1686                    return val.data_;
1687                }
1688            });
1689            let finalLength = 0;
1690            uint8Arrays.forEach((array) => {
1691                finalLength += array.byteLength;
1692            });
1693            const merged = new Uint8Array(finalLength);
1694            let index = 0;
1695            uint8Arrays.forEach((array) => {
1696                for (let i = 0; i < array.length; i++) {
1697                    merged[index++] = array[i];
1698                }
1699            });
1700            return new FbsBlob(merged, true);
1701        }
1702    }
1703    uploadData() {
1704        return this.data_;
1705    }
1706}
1707
1708/**
1709 * @license
1710 * Copyright 2017 Google LLC
1711 *
1712 * Licensed under the Apache License, Version 2.0 (the "License");

1880    return mappings_;
1881}
1882function addRef(metadata, service) {
1883    function generateRef() {
1884        const bucket = metadata['bucket'];
1885        const path = metadata['fullPath'];
1886        const loc = new Location(bucket, path);
1887        return service._makeStorageReference(loc);
1888    }
1889    Object.defineProperty(metadata, 'ref', { get: generateRef });
1890}
1891function fromResource(service, resource, mappings) {
1892    const metadata = {};
1893    metadata['type'] = 'file';
1894    const len = mappings.length;
1895    for (let i = 0; i < len; i++) {
1896        const mapping = mappings[i];
1897        metadata[mapping.local] = mapping.xform(metadata, resource[mapping.server]);
1898    }
1899    addRef(metadata, service);
1900    return metadata;
1901}
1902function fromResourceString(service, resourceString, mappings) {
1903    const obj = jsonObjectOrNull(resourceString);
1904    if (obj === null) {
1905        return null;
1906    }
1907    const resource = obj;
1908    return fromResource(service, resource, mappings);
1909}
1910function downloadUrlFromResourceString(metadata, resourceString, host, protocol) {
1911    const obj = jsonObjectOrNull(resourceString);
1912    if (obj === null) {
1913        return null;
1914    }
1915    if (!isString(obj['downloadTokens'])) {
1916        // This can happen if objects are uploaded through GCS and retrieved
1917        // through list, so we don't want to throw an Error.
1918        return null;
1919    }
1920    const tokens = obj['downloadTokens'];
1921    if (tokens.length === 0) {
1922        return null;
1923    }
1924    const encode = encodeURIComponent;
1925    const tokensList = tokens.split(',');
1926    const urls = tokensList.map((token) => {
1927        const bucket = metadata['bucket'];
1928        const path = metadata['fullPath'];
1929        const urlPart = '/b/' + encode(bucket) + '/o/' + encode(path);
1930        const base = makeUrl(urlPart, host, protocol);
1931        const queryString = makeQueryString({
1932            alt: 'media',
1933            token
1934        });
1935        return base + queryString;
1936    });
1937    return urls[0];
1938}
1939function toResourceString(metadata, mappings) {
1940    const resource = {};
1941    const len = mappings.length;
1942    for (let i = 0; i < len; i++) {
1943        const mapping = mappings[i];
1944        if (mapping.writable) {
1945            resource[mapping.server] = metadata[mapping.local];
1946        }
1947    }
1948    return JSON.stringify(resource);
1949}
1950
1951/**
1952 * @license
1953 * Copyright 2019 Google LLC
1954 *
1955 * Licensed under the Apache License, Version 2.0 (the "License");
1956 * you may not use this file except in compliance with the License.
1957 * You may obtain a copy of the License at
1958 *
1959 *   http://www.apache.org/licenses/LICENSE-2.0
1960 *
1961 * Unless required by applicable law or agreed to in writing, software
1962 * distributed under the License is distributed on an "AS IS" BASIS,
1963 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1964 * See the License for the specific language governing permissions and
1965 * limitations under the License.
1966 */
1967const PREFIXES_KEY = 'prefixes';
1968const ITEMS_KEY = 'items';
1969function fromBackendResponse(service, bucket, resource) {
1970    const listResult = {
1971        prefixes: [],
1972        items: [],
1973        nextPageToken: resource['nextPageToken']
1974    };
1975    if (resource[PREFIXES_KEY]) {
1976        for (const path of resource[PREFIXES_KEY]) {
1977            const pathWithoutTrailingSlash = path.replace(/\/$/, '');
1978            const reference = service._makeStorageReference(new Location(bucket, pathWithoutTrailingSlash));
1979            listResult.prefixes.push(reference);
1980        }
1981    }
1982    if (resource[ITEMS_KEY]) {
1983        for (const item of resource[ITEMS_KEY]) {
1984            const reference = service._makeStorageReference(new Location(bucket, item['name']));
1985            listResult.items.push(reference);
1986        }
1987    }
1988    return listResult;
1989}
1990function fromResponseString(service, bucket, resourceString) {
1991    const obj = jsonObjectOrNull(resourceString);
1992    if (obj === null) {
1993        return null;
1994    }
1995    const resource = obj;
1996    return fromBackendResponse(service, bucket, resource);
1997}
1998
1999/**
2000 * Contains a fully specified request.
2001 *
2002 * @param I - the type of the backend's network response.
2003 * @param O - the output response type used by the rest of the SDK.
2004 */
2005class RequestInfo {
2006    constructor(url, method, 
2007    /**
2008     * Returns the value with which to resolve the request's promise. Only called
2009     * if the request is successful. Throw from this function to reject the
2010     * returned Request's promise with the thrown error.
2011     * Note: The XhrIo passed to this function may be reused after this callback
2012     * returns. Do not keep a reference to it in any way.
2013     */
2014    handler, timeout) {
2015        this.url = url;
2016        this.method = method;
2017        this.handler = handler;
2018        this.timeout = timeout;
2019        this.urlParams = {};
2020        this.headers = {};
2021        this.body = null;
2022        this.errorHandler = null;
2023        /**
2024         * Called with the current number of bytes uploaded and total size (-1 if not
2025         * computable) of the request body (i.e. used to report upload progress).
2026         */
2027        this.progressCallback = null;
2028        this.successCodes = [200];
2029        this.additionalRetryCodes = [];
2030    }
2031}
2032
2033/**
2034 * @license
2035 * Copyright 2017 Google LLC
2036 *
2037 * Licensed under the Apache License, Version 2.0 (the "License");
2038 * you may not use this file except in compliance with the License.
2039 * You may obtain a copy of the License at
2040 *
2041 *   http://www.apache.org/licenses/LICENSE-2.0
2042 *
2043 * Unless required by applicable law or agreed to in writing, software
2044 * distributed under the License is distributed on an "AS IS" BASIS,
2045 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2046 * See the License for the specific language governing permissions and
2047 * limitations under the License.
2048 */
2049/**
2050 * Throws the UNKNOWN StorageError if cndn is false.
2051 */
2052function handlerCheck(cndn) {
2053    if (!cndn) {
2054        throw unknown();
2055    }
2056}
2057function metadataHandler(service, mappings) {
2058    function handler(xhr, text) {
2059        const metadata = fromResourceString(service, text, mappings);
2060        handlerCheck(metadata !== null);
2061        return metadata;
2062    }
2063    return handler;
2064}
2065function listHandler(service, bucket) {
2066    function handler(xhr, text) {
2067        const listResult = fromResponseString(service, bucket, text);
2068        handlerCheck(listResult !== null);
2069        return listResult;
2070    }
2071    return handler;
2072}
2073function downloadUrlHandler(service, mappings) {
2074    function handler(xhr, text) {
2075        const metadata = fromResourceString(service, text, mappings);
2076        handlerCheck(metadata !== null);
2077        return downloadUrlFromResourceString(metadata, text, service.host, service._protocol);
2078    }
2079    return handler;
2080}
2081function sharedErrorHandler(location) {
2082    function errorHandler(xhr, err) {
2083        let newErr;
2084        if (xhr.getStatus() === 401) {
2085            if (
2086            // This exact message string is the only consistent part of the
2087            // server's error response that identifies it as an App Check error.
2088            xhr.getErrorText().includes('Firebase App Check token is invalid')) {
2089                newErr = unauthorizedApp();
2090            }
2091            else {
2092                newErr = unauthenticated();
2093            }
2094        }
2095        else {
2096            if (xhr.getStatus() === 402) {
2097                newErr = quotaExceeded(location.bucket);
2098            }
2099            else {
2100                if (xhr.getStatus() === 403) {
2101                    newErr = unauthorized(location.path);
2102                }
2103                else {
2104                    newErr = err;
2105                }
2106            }
2107        }
2108        newErr.serverResponse = err.serverResponse;
2109        return newErr;
2110    }
2111    return errorHandler;
2112}
2113function objectErrorHandler(location) {
2114    const shared = sharedErrorHandler(location);
2115    function errorHandler(xhr, err) {
2116        let newErr = shared(xhr, err);
2117        if (xhr.getStatus() === 404) {
2118            newErr = objectNotFound(location.path);
2119        }
2120        newErr.serverResponse = err.serverResponse;
2121        return newErr;
2122    }
2123    return errorHandler;
2124}
2125function getMetadata$2(service, location, mappings) {
2126    const urlPart = location.fullServerUrl();
2127    const url = makeUrl(urlPart, service.host, service._protocol);
2128    const method = 'GET';
2129    const timeout = service.maxOperationRetryTime;
2130    const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
2131    requestInfo.errorHandler = objectErrorHandler(location);
2132    return requestInfo;
2133}
2134function list$2(service, location, delimiter, pageToken, maxResults) {
2135    const urlParams = {};
2136    if (location.isRoot) {
2137        urlParams['prefix'] = '';
2138    }
2139    else {
2140        urlParams['prefix'] = location.path + '/';
2141    }
2142    if (delimiter && delimiter.length > 0) {
2143        urlParams['delimiter'] = delimiter;
2144    }
2145    if (pageToken) {
2146        urlParams['pageToken'] = pageToken;
2147    }
2148    if (maxResults) {
2149        urlParams['maxResults'] = maxResults;
2150    }
2151    const urlPart = location.bucketOnlyServerUrl();
2152    const url = makeUrl(urlPart, service.host, service._protocol);
2153    const method = 'GET';
2154    const timeout = service.maxOperationRetryTime;
2155    const requestInfo = new RequestInfo(url, method, listHandler(service, location.bucket), timeout);
2156    requestInfo.urlParams = urlParams;
2157    requestInfo.errorHandler = sharedErrorHandler(location);
2158    return requestInfo;
2159}
2160function getBytes$1(service, location, maxDownloadSizeBytes) {
2161    const urlPart = location.fullServerUrl();
2162    const url = makeUrl(urlPart, service.host, service._protocol) + '?alt=media';
2163    const method = 'GET';
2164    const timeout = service.maxOperationRetryTime;
2165    const requestInfo = new RequestInfo(url, method, (_, data) => data, timeout);
2166    requestInfo.errorHandler = objectErrorHandler(location);
2167    if (maxDownloadSizeBytes !== undefined) {
2168        requestInfo.headers['Range'] = `bytes=0-${maxDownloadSizeBytes}`;
2169        requestInfo.successCodes = [200 /* OK */, 206 /* Partial Content */];
2170    }
2171    return requestInfo;
2172}
2173function getDownloadUrl(service, location, mappings) {
2174    const urlPart = location.fullServerUrl();
2175    const url = makeUrl(urlPart, service.host, service._protocol);
2176    const method = 'GET';
2177    const timeout = service.maxOperationRetryTime;
2178    const requestInfo = new RequestInfo(url, method, downloadUrlHandler(service, mappings), timeout);
2179    requestInfo.errorHandler = objectErrorHandler(location);
2180    return requestInfo;
2181}
2182function updateMetadata$2(service, location, metadata, mappings) {
2183    const urlPart = location.fullServerUrl();
2184    const url = makeUrl(urlPart, service.host, service._protocol);
2185    const method = 'PATCH';
2186    const body = toResourceString(metadata, mappings);
2187    const headers = { 'Content-Type': 'application/json; charset=utf-8' };
2188    const timeout = service.maxOperationRetryTime;
2189    const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
2190    requestInfo.headers = headers;
2191    requestInfo.body = body;
2192    requestInfo.errorHandler = objectErrorHandler(location);
2193    return requestInfo;
2194}
2195function deleteObject$2(service, location) {
2196    const urlPart = location.fullServerUrl();
2197    const url = makeUrl(urlPart, service.host, service._protocol);
2198    const method = 'DELETE';
2199    const timeout = service.maxOperationRetryTime;
2200    function handler(_xhr, _text) { }
2201    const requestInfo = new RequestInfo(url, method, handler, timeout);
2202    requestInfo.successCodes = [200, 204];
2203    requestInfo.errorHandler = objectErrorHandler(location);
2204    return requestInfo;
2205}
2206function determineContentType_(metadata, blob) {
2207    return ((metadata && metadata['contentType']) ||
2208        (blob && blob.type()) ||
2209        'application/octet-stream');
2210}
2211function metadataForUpload_(location, blob, metadata) {
2212    const metadataClone = Object.assign({}, metadata);
2213    metadataClone['fullPath'] = location.path;
2214    metadataClone['size'] = blob.size();
2215    if (!metadataClone['contentType']) {
2216        metadataClone['contentType'] = determineContentType_(null, blob);
2217    }
2218    return metadataClone;
2219}
2220/**
2221 * Prepare RequestInfo for uploads as Content-Type: multipart.
2222 */
2223function multipartUpload(service, location, mappings, blob, metadata) {
2224    const urlPart = location.bucketOnlyServerUrl();
2225    const headers = {
2226        'X-Goog-Upload-Protocol': 'multipart'
2227    };
2228    function genBoundary() {
2229        let str = '';
2230        for (let i = 0; i < 2; i++) {
2231            str = str + Math.random().toString().slice(2);
2232        }
2233        return str;
2234    }
2235    const boundary = genBoundary();
2236    headers['Content-Type'] = 'multipart/related; boundary=' + boundary;
2237    const metadata_ = metadataForUpload_(location, blob, metadata);
2238    const metadataString = toResourceString(metadata_, mappings);
2239    const preBlobPart = '--' +
2240        boundary +
2241        '\r\n' +
2242        'Content-Type: application/json; charset=utf-8\r\n\r\n' +
2243        metadataString +
2244        '\r\n--' +
2245        boundary +
2246        '\r\n' +
2247        'Content-Type: ' +
2248        metadata_['contentType'] +
2249        '\r\n\r\n';
2250    const postBlobPart = '\r\n--' + boundary + '--';
2251    const body = FbsBlob.getBlob(preBlobPart, blob, postBlobPart);
2252    if (body === null) {
2253        throw cannotSliceBlob();
2254    }
2255    const urlParams = { name: metadata_['fullPath'] };
2256    const url = makeUrl(urlPart, service.host, service._protocol);
2257    const method = 'POST';
2258    const timeout = service.maxUploadRetryTime;
2259    const requestInfo = new RequestInfo(url, method, metadataHandler(service, mappings), timeout);
2260    requestInfo.urlParams = urlParams;
2261    requestInfo.headers = headers;
2262    requestInfo.body = body.uploadData();
2263    requestInfo.errorHandler = sharedErrorHandler(location);
2264    return requestInfo;
2265}
2266/**
2267 * @param current The number of bytes that have been uploaded so far.
2268 * @param total The total number of bytes in the upload.
2269 * @param opt_finalized True if the server has finished the upload.
2270 * @param opt_metadata The upload metadata, should
2271 *     only be passed if opt_finalized is true.
2272 */
2273class ResumableUploadStatus {
2274    constructor(current, total, finalized, metadata) {
2275        this.current = current;
2276        this.total = total;
2277        this.finalized = !!finalized;
2278        this.metadata = metadata || null;
2279    }
2280}
2281function checkResumeHeader_(xhr, allowed) {
2282    let status = null;
2283    try {
2284        status = xhr.getResponseHeader('X-Goog-Upload-Status');
2285    }
2286    catch (e) {
2287        handlerCheck(false);
2288    }
2289    const allowedStatus = allowed || ['active'];
2290    handlerCheck(!!status && allowedStatus.indexOf(status) !== -1);
2291    return status;
2292}
2293function createResumableUpload(service, location, mappings, blob, metadata) {
2294    const urlPart = location.bucketOnlyServerUrl();
2295    const metadataForUpload = metadataForUpload_(location, blob, metadata);
2296    const urlParams = { name: metadataForUpload['fullPath'] };
2297    const url = makeUrl(urlPart, service.host, service._protocol);
2298    const method = 'POST';
2299    const headers = {
2300        'X-Goog-Upload-Protocol': 'resumable',
2301        'X-Goog-Upload-Command': 'start',
2302        'X-Goog-Upload-Header-Content-Length': `${blob.size()}`,
2303        'X-Goog-Upload-Header-Content-Type': metadataForUpload['contentType'],
2304        'Content-Type': 'application/json; charset=utf-8'
2305    };
2306    const body = toResourceString(metadataForUpload, mappings);
2307    const timeout = service.maxUploadRetryTime;
2308    function handler(xhr) {
2309        checkResumeHeader_(xhr);
2310        let url;
2311        try {
2312            url = xhr.getResponseHeader('X-Goog-Upload-URL');
2313        }
2314        catch (e) {
2315            handlerCheck(false);
2316        }
2317        handlerCheck(isString(url));
2318        return url;
2319    }
2320    const requestInfo = new RequestInfo(url, method, handler, timeout);
2321    requestInfo.urlParams = urlParams;
2322    requestInfo.headers = headers;
2323    requestInfo.body = body;
2324    requestInfo.errorHandler = sharedErrorHandler(location);
2325    return requestInfo;
2326}
2327/**
2328 * @param url From a call to fbs.requests.createResumableUpload.
2329 */
2330function getResumableUploadStatus(service, location, url, blob) {
2331    const headers = { 'X-Goog-Upload-Command': 'query' };
2332    function handler(xhr) {
2333        const status = checkResumeHeader_(xhr, ['active', 'final']);
2334        let sizeString = null;
2335        try {
2336            sizeString = xhr.getResponseHeader('X-Goog-Upload-Size-Received');
2337        }
2338        catch (e) {
2339            handlerCheck(false);
2340        }
2341        if (!sizeString) {
2342            // null or empty string
2343            handlerCheck(false);
2344        }
2345        const size = Number(sizeString);
2346        handlerCheck(!isNaN(size));
2347        return new ResumableUploadStatus(size, blob.size(), status === 'final');
2348    }
2349    const method = 'POST';
2350    const timeout = service.maxUploadRetryTime;
2351    const requestInfo = new RequestInfo(url, method, handler, timeout);
2352    requestInfo.headers = headers;
2353    requestInfo.errorHandler = sharedErrorHandler(location);
2354    return requestInfo;
2355}
2356/**
2357 * Any uploads via the resumable upload API must transfer a number of bytes
2358 * that is a multiple of this number.
2359 */
2360const RESUMABLE_UPLOAD_CHUNK_SIZE = 256 * 1024;
2361/**
2362 * @param url From a call to fbs.requests.createResumableUpload.
2363 * @param chunkSize Number of bytes to upload.
2364 * @param status The previous status.
2365 *     If not passed or null, we start from the beginning.
2366 * @throws fbs.Error If the upload is already complete, the passed in status
2367 *     has a final size inconsistent with the blob, or the blob cannot be sliced
2368 *     for upload.
2369 */
2370function continueResumableUpload(location, service, url, blob, chunkSize, mappings, status, progressCallback) {
2371    // TODO(andysoto): standardize on internal asserts
2372    // assert(!(opt_status && opt_status.finalized));
2373    const status_ = new ResumableUploadStatus(0, 0);
2374    if (status) {
2375        status_.current = status.current;
2376        status_.total = status.total;
2377    }
2378    else {
2379        status_.current = 0;
2380        status_.total = blob.size();
2381    }
2382    if (blob.size() !== status_.total) {
2383        throw serverFileWrongSize();
2384    }
2385    const bytesLeft = status_.total - status_.current;
2386    let bytesToUpload = bytesLeft;
2387    if (chunkSize > 0) {
2388        bytesToUpload = Math.min(bytesToUpload, chunkSize);
2389    }
2390    const startByte = status_.current;
2391    const endByte = startByte + bytesToUpload;
2392    const uploadCommand = bytesToUpload === bytesLeft ? 'upload, finalize' : 'upload';
2393    const headers = {
2394        'X-Goog-Upload-Command': uploadCommand,
2395        'X-Goog-Upload-Offset': `${status_.current}`
2396    };
2397    const body = blob.slice(startByte, endByte);
2398    if (body === null) {
2399        throw cannotSliceBlob();
2400    }
2401    function handler(xhr, text) {
2402        // TODO(andysoto): Verify the MD5 of each uploaded range:
2403        // the 'x-range-md5' header comes back with status code 308 responses.
2404        // We'll only be able to bail out though, because you can't re-upload a
2405        // range that you previously uploaded.
2406        const uploadStatus = checkResumeHeader_(xhr, ['active', 'final']);
2407        const newCurrent = status_.current + bytesToUpload;
2408        const size = blob.size();
2409        let metadata;
2410        if (uploadStatus === 'final') {
2411            metadata = metadataHandler(service, mappings)(xhr, text);
2412        }
2413        else {
2414            metadata = null;
2415        }
2416        return new ResumableUploadStatus(newCurrent, size, uploadStatus === 'final', metadata);
2417    }
2418    const method = 'POST';
2419    const timeout = service.maxUploadRetryTime;
2420    const requestInfo = new RequestInfo(url, method, handler, timeout);
2421    requestInfo.headers = headers;
2422    requestInfo.body = body.uploadData();
2423    requestInfo.progressCallback = progressCallback || null;
2424    requestInfo.errorHandler = sharedErrorHandler(location);
2425    return requestInfo;
2426}
2427
2428/**
2429 * @license
2430 * Copyright 2017 Google LLC
2431 *
2432 * Licensed under the Apache License, Version 2.0 (the "License");

2577                this.errorCode_ = ErrorCode.NETWORK_ERROR;
2578                resolve();
2579            });
2580            this.xhr_.addEventListener('load', () => {
2581                resolve();
2582            });
2583        });
2584    }
2585    send(url, method, body, headers) {
2586        if (this.sent_) {
2587            throw internalError('cannot .send() more than once');
2588        }
2589        this.sent_ = true;
2590        this.xhr_.open(method, url, true);
2591        if (headers !== undefined) {
2592            for (const key in headers) {
2593                if (headers.hasOwnProperty(key)) {
2594                    this.xhr_.setRequestHeader(key, headers[key].toString());
2595                }
2596            }
2597        }
2598        if (body !== undefined) {
2599            this.xhr_.send(body);
2600        }
2601        else {
2602            this.xhr_.send();
2603        }
2604        return this.sendPromise_;
2605    }
2606    getErrorCode() {
2607        if (!this.sent_) {
2608            throw internalError('cannot .getErrorCode() before sending');
2609        }
2610        return this.errorCode_;
2611    }
2612    getStatus() {
2613        if (!this.sent_) {
2614            throw internalError('cannot .getStatus() before sending');
2615        }
2616        try {
2617            return this.xhr_.status;
2618        }
2619        catch (e) {
2620            return -1;
2621        }
2622    }
2623    getResponse() {
2624        if (!this.sent_) {
2625            throw internalError('cannot .getResponse() before sending');
2626        }
2627        return this.xhr_.response;
2628    }
2629    getErrorText() {
2630        if (!this.sent_) {
2631            throw internalError('cannot .getErrorText() before sending');
2632        }
2633        return this.xhr_.statusText;
2634    }
2635    /** Aborts the request. */
2636    abort() {
2637        this.xhr_.abort();
2638    }
2639    getResponseHeader(header) {
2640        return this.xhr_.getResponseHeader(header);
2641    }
2642    addUploadProgressListener(listener) {
2643        if (this.xhr_.upload != null) {
2644            this.xhr_.upload.addEventListener('progress', listener);
2645        }
2646    }
2647    removeUploadProgressListener(listener) {
2648        if (this.xhr_.upload != null) {
2649            this.xhr_.upload.removeEventListener('progress', listener);
2650        }
2651    }
2652}
2653class XhrTextConnection extends XhrConnection {
2654    initXhr() {
2655        this.xhr_.responseType = 'text';
2656    }
2657}
2658function newTextConnection() {
2659    return new XhrTextConnection();
2660}
2661class XhrBytesConnection extends XhrConnection {
2662    initXhr() {
2663        this.xhr_.responseType = 'arraybuffer';
2664    }
2665}
2666function newBytesConnection() {
2667    return new XhrBytesConnection();
2668}
2669class XhrBlobConnection extends XhrConnection {
2670    initXhr() {
2671        this.xhr_.responseType = 'blob';
2672    }
2673}
2674function newBlobConnection() {
2675    return new XhrBlobConnection();
2676}
2677
2678/**
2679 * @license
2680 * Copyright 2017 Google LLC
2681 *
2682 * Licensed under the Apache License, Version 2.0 (the "License");
2683 * you may not use this file except in compliance with the License.
2684 * You may obtain a copy of the License at
2685 *
2686 *   http://www.apache.org/licenses/LICENSE-2.0
2687 *
2688 * Unless required by applicable law or agreed to in writing, software
2689 * distributed under the License is distributed on an "AS IS" BASIS,
2690 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2691 * See the License for the specific language governing permissions and
2692 * limitations under the License.
2693 */
2694/**
2695 * Represents a blob being uploaded. Can be used to pause/resume/cancel the
2696 * upload and manage callbacks for various events.
2697 * @internal
2698 */
2699class UploadTask {
2700    /**
2701     * @param ref - The firebaseStorage.Reference object this task came
2702     *     from, untyped to avoid cyclic dependencies.
2703     * @param blob - The blob to upload.
2704     */
2705    constructor(ref, blob, metadata = null) {
2706        /**
2707         * Number of bytes transferred so far.
2708         */
2709        this._transferred = 0;
2710        this._needToFetchStatus = false;
2711        this._needToFetchMetadata = false;
2712        this._observers = [];
2713        this._error = undefined;
2714        this._uploadUrl = undefined;
2715        this._request = undefined;
2716        this._chunkMultiplier = 1;
2717        this._resolve = undefined;
2718        this._reject = undefined;
2719        this._ref = ref;
2720        this._blob = blob;
2721        this._metadata = metadata;
2722        this._mappings = getMappings();
2723        this._resumable = this._shouldDoResumable(this._blob);
2724        this._state = "running" /* RUNNING */;
2725        this._errorHandler = error => {
2726            this._request = undefined;
2727            this._chunkMultiplier = 1;