rx-player 4.1.0-dev.2024040900 → 4.1.0-dev.2024070800

package/dist/es2017/utils/request/fetch.js

@@ -21,6 +21,7 @@ import RequestError, { RequestErrorTypes } from "./request_error";
 const _Headers = typeof Headers === "function" ? Headers : null;
 const _AbortController = typeof AbortController === "function" ? AbortController : null;
 export default function fetchRequest(options) {
+    var _a, _b;
     let headers;
     if (!isNullOrUndefined(options.headers)) {
         if (isNullOrUndefined(_Headers)) {
@@ -83,6 +84,19 @@ export default function fetchRequest(options) {
         fetchOpts.headers = headers;
     }
     fetchOpts.signal = !isNullOrUndefined(abortController) ? abortController.signal : null;
+    if (log.hasLevel("DEBUG")) {
+        let logLine = "FETCH: Sending GET " + options.url;
+        if (options.timeout !== undefined) {
+            logLine += " to=" + String(options.timeout / 1000);
+        }
+        if (options.connectionTimeout !== undefined) {
+            logLine += " cto=" + String(options.connectionTimeout / 1000);
+        }
+        if (((_a = options.headers) === null || _a === void 0 ? void 0 : _a.Range) !== undefined) {
+            logLine += " Range=" + ((_b = options.headers) === null || _b === void 0 ? void 0 : _b.Range);
+        }
+        log.debug(logLine);
+    }
     return fetch(options.url, fetchOpts)
         .then((response) => {
         if (connectionTimeoutId !== undefined) {

package/dist/es2017/utils/request/index.d.ts

@@ -13,8 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fetchRequest, { fetchIsSupported, IFetchedDataObject, IFetchedStreamComplete } from "./fetch";
-import RequestError, { RequestErrorTypes, ISerializedRequestError, IRequestErrorType } from "./request_error";
-import xhr, { IRequestOptions, IProgressInfo, IRequestResponse } from "./xhr";
+import type { IFetchedDataObject, IFetchedStreamComplete } from "./fetch";
+import fetchRequest, { fetchIsSupported } from "./fetch";
+import type { ISerializedRequestError, IRequestErrorType } from "./request_error";
+import RequestError, { RequestErrorTypes } from "./request_error";
+import type { IRequestOptions, IProgressInfo, IRequestResponse } from "./xhr";
+import xhr from "./xhr";
 export default xhr;
-export { fetchIsSupported, fetchRequest, IFetchedDataObject, IFetchedStreamComplete, IProgressInfo, IRequestOptions, IRequestResponse, xhr, RequestError, RequestErrorTypes, ISerializedRequestError, IRequestErrorType, };
+export type { IFetchedDataObject, IFetchedStreamComplete, IProgressInfo, IRequestOptions, IRequestResponse, ISerializedRequestError, IRequestErrorType, };
+export { fetchIsSupported, fetchRequest, xhr, RequestError, RequestErrorTypes };
+//# sourceMappingURL=index.d.ts.map

package/dist/es2017/utils/request/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/request/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,YAAY,EAAE,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACzD,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAClF,OAAO,YAAY,EAAE,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAC9E,OAAO,GAAG,MAAM,OAAO,CAAC;AAExB,eAAe,GAAG,CAAC;AACnB,YAAY,EACV,kBAAkB,EAClB,sBAAsB,EACtB,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,GAClB,CAAC;AACF,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/es2017/utils/request/index.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import fetchRequest, { fetchIsSupported, } from "./fetch";
-import RequestError, { RequestErrorTypes, } from "./request_error";
+import fetchRequest, { fetchIsSupported } from "./fetch";
+import RequestError, { RequestErrorTypes } from "./request_error";
 import xhr from "./xhr";
 export default xhr;
-export { fetchIsSupported, fetchRequest, xhr, RequestError, RequestErrorTypes, };
+export { fetchIsSupported, fetchRequest, xhr, RequestError, RequestErrorTypes };

package/dist/es2017/utils/request/request_error.d.ts

@@ -25,7 +25,6 @@
 export default class RequestError extends Error {
     readonly name: "RequestError";
     readonly type: IRequestErrorType;
-    readonly message: string;
     readonly url: string;
     readonly status: number;
     /**
@@ -45,3 +44,4 @@ export interface ISerializedRequestError {
 export type IRequestErrorType = "TIMEOUT" | "ERROR_EVENT" | "PARSE_ERROR" | "ERROR_HTTP_CODE";
 declare const RequestErrorTypes: Record<IRequestErrorType, IRequestErrorType>;
 export { RequestErrorTypes };
+//# sourceMappingURL=request_error.d.ts.map

package/dist/es2017/utils/request/request_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request_error.d.ts","sourceRoot":"","sources":["../../../../src/utils/request/request_error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,KAAK;IAC7C,SAAgB,IAAI,EAAE,cAAc,CAAC;IACrC,SAAgB,IAAI,EAAE,iBAAiB,CAAC;IACxC,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAE/B;;;;OAIG;gBACS,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB;IA6BzD,SAAS,IAAI,uBAAuB;CAG5C;AAED,yEAAyE;AACzE,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,iBAAiB,CAAC;CACzB;AAED,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,aAAa,GACb,aAAa,GACb,iBAAiB,CAAC;AAEtB,QAAA,MAAM,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,EAAE,iBAAiB,CAKnE,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/es2017/utils/request/request_error.js

@@ -29,28 +29,29 @@ export default class RequestError extends Error {
      * @param {string} type
      */
     constructor(url, status, type) {
-        super();
-        // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
-        Object.setPrototypeOf(this, RequestError.prototype);
-        this.name = "RequestError";
-        this.url = url;
-        this.status = status;
-        this.type = type;
+        let message;
         switch (type) {
             case "TIMEOUT":
-                this.message = "The request timed out";
+                message = "The request timed out";
                 break;
             case "ERROR_EVENT":
-                this.message = "An error prevented the request to be performed successfully";
+                message = "An error prevented the request to be performed successfully";
                 break;
             case "PARSE_ERROR":
-                this.message = "An error happened while formatting the response data";
+                message = "An error happened while formatting the response data";
                 break;
             case "ERROR_HTTP_CODE":
-                this.message =
-                    "An HTTP status code indicating failure was received: " + String(this.status);
+                message =
+                    "An HTTP status code indicating failure was received: " + String(status);
                 break;
         }
+        super(message);
+        // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+        Object.setPrototypeOf(this, RequestError.prototype);
+        this.name = "RequestError";
+        this.url = url;
+        this.status = status;
+        this.type = type;
     }
     serialize() {
         return { url: this.url, status: this.status, type: this.type };

package/dist/es2017/utils/request/xhr.d.ts

@@ -99,3 +99,4 @@ export interface IProgressInfo {
     url: string;
     totalSize?: number | undefined;
 }
+//# sourceMappingURL=xhr.d.ts.map

package/dist/es2017/utils/request/xhr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr.d.ts","sourceRoot":"","sources":["../../../../src/utils/request/xhr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,KAAK,EAAqB,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAK/E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,OAAO,EAAE,eAAe,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE,GAAG,MAAM,CAAC,GACvD,OAAO,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAC7C,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,OAAO,EAAE,eAAe,CAAC,aAAa,CAAC,GACtC,OAAO,CAAC,gBAAgB,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC;AACzD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,OAAO,EAAE,eAAe,CAAC,UAAU,CAAC,GACnC,OAAO,CAAC,gBAAgB,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC;AACnD,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,OAAO,EAAE,eAAe,CAAC,MAAM,CAAC,GAC/B,OAAO,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAC7C,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,OAAO,EAAE,eAAe,CAAC,MAAM,CAAC,GAC/B,OAAO,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;AA8M3C,iCAAiC;AACjC,MAAM,WAAW,eAAe,CAAC,YAAY;IAC3C,+BAA+B;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,OAAO,CAAC,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1D,qCAAqC;IACrC,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IACxC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;;OAIG;IACH,YAAY,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC9C;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;CAC1D;AAED,sEAAsE;AACtE,MAAM,WAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC;IACpC,kDAAkD;IAClD,eAAe,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,YAAY,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,YAAY,EAAE,CAAC,CAAC;IAChB,+EAA+E;IAC/E,YAAY,EAAE,CAAC,CAAC;IAChB,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC"}

package/dist/es2017/utils/request/xhr.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import log from "../../log";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
 import getMonotonicTimeStamp from "../monotonic_timestamp";
@@ -154,6 +155,22 @@ export default function request(options) {
                 }
             }
         };
+        if (log.hasLevel("DEBUG")) {
+            let logLine = "XHR: Sending GET " + url;
+            if (options.responseType !== undefined) {
+                logLine += " type=" + options.responseType;
+            }
+            if (timeout !== undefined) {
+                logLine += " to=" + String(timeout / 1000);
+            }
+            if (connectionTimeout !== undefined) {
+                logLine += " cto=" + String(connectionTimeout / 1000);
+            }
+            if ((headers === null || headers === void 0 ? void 0 : headers.Range) !== undefined) {
+                logLine += " Range=" + (headers === null || headers === void 0 ? void 0 : headers.Range);
+            }
+            log.debug(logLine);
+        }
         xhr.send();
         /**
          * Clear resources and timers created to handle cancellation and timeouts.

package/dist/es2017/utils/resolve_url.d.ts

@@ -13,16 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * Construct an url from the arguments given.
- * Basically:
- *   - The last arguments that contains a scheme (e.g. "http://") is the base
- *     of the url.
- *   - every subsequent string arguments are concatened to it.
- * @param {...string|undefined} args
- * @returns {string}
- */
-export default function resolveURL(...args: Array<string | undefined>): string;
 /**
  * In a given URL, find the index at which the filename begins.
  * That is, this function finds the index of the last `/` character and returns
@@ -32,4 +22,18 @@ export default function resolveURL(...args: Array<string | undefined>): string;
  * @returns {number}
  */
 declare function getFilenameIndexInUrl(url: string): number;
+/**
+ * Resolves multiple URL segments using the RFC 3986 URL resolution algorithm.
+ *
+ * This function takes a variable number of URL segments and resolves them
+ * sequentially according to the RFC 3986 URL resolution algorithm.
+ * First argument is the base URL.
+ * Empty string arguments are ignored.
+ *
+ * @param {...(string|undefined)} args - The URL segments to resolve.
+ * @returns {string} The resolved URL as a string.
+ */
+export declare function resolveURL(...args: Array<string | undefined>): string;
 export { getFilenameIndexInUrl };
+export default resolveURL;
+//# sourceMappingURL=resolve_url.d.ts.map

package/dist/es2017/utils/resolve_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve_url.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve_url.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAuBH;;;;;;;GAOG;AACH,iBAAS,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAuBlD;AAsLD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,CAerE;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,eAAe,UAAU,CAAC"}

package/dist/es2017/utils/resolve_url.js

@@ -13,74 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import startsWith from "./starts_with";
 // Scheme part of an url (e.g. "http://").
 const schemeRe = /^(?:[a-z]+:)?\/\//i;
-// Captures "/../" or "/./".
-const selfDirRe = /\/\.{1,2}\//;
 /**
- * Resolve self directory and previous directory references to obtain a
- * "normalized" url.
- * @example "https://foo.bar/baz/booz/../biz" => "https://foo.bar/baz/biz"
- * @param {string} url
- * @returns {string}
- */
-function _normalizeUrl(url) {
-    // fast path if no ./ or ../ are present in the url
-    if (!selfDirRe.test(url)) {
-        return url;
-    }
-    const newUrl = [];
-    const oldUrl = url.split("/");
-    for (let i = 0, l = oldUrl.length; i < l; i++) {
-        if (oldUrl[i] === "..") {
-            newUrl.pop();
-        }
-        else if (oldUrl[i] === ".") {
-            continue;
-        }
-        else {
-            newUrl.push(oldUrl[i]);
-        }
-    }
-    return newUrl.join("/");
-}
-/**
- * Construct an url from the arguments given.
- * Basically:
- *   - The last arguments that contains a scheme (e.g. "http://") is the base
- *     of the url.
- *   - every subsequent string arguments are concatened to it.
- * @param {...string|undefined} args
- * @returns {string}
- */
-export default function resolveURL(...args) {
-    const len = args.length;
-    if (len === 0) {
-        return "";
-    }
-    let base = "";
-    for (let i = 0; i < len; i++) {
-        let part = args[i];
-        if (typeof part !== "string" || part === "") {
-            continue;
-        }
-        if (schemeRe.test(part)) {
-            base = part;
-        }
-        else {
-            // trim if begins with "/"
-            if (part[0] === "/") {
-                part = part.substring(1);
-            }
-            // trim if ends with "/"
-            if (base[base.length - 1] === "/") {
-                base = base.substring(0, base.length - 1);
-            }
-            base = base + "/" + part;
-        }
-    }
-    return _normalizeUrl(base);
-}
+ * Match the different components of an URL.
+ *
+ *     foo://example.com:8042/over/there?name=ferret#nose
+       \_/   \______________/\_________/ \_________/ \__/
+        |           |            |            |        |
+      scheme     authority       path        query   fragment
+ * 1st match is the scheme: (e.g. "foo://")
+ * 2nd match is the authority (e.g "example.com:8042")
+ * 3rd match is the path (e.g "/over/there")
+ * 4th match is the query params (e.g "name=ferret")
+ * 5th match is the fragment (e.g "nose")
+ * */
+const urlComponentRegex = /^(?:([^:\/?#]+):)?(?:\/\/([^\/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/;
 /**
  * In a given URL, find the index at which the filename begins.
  * That is, this function finds the index of the last `/` character and returns
@@ -110,4 +59,196 @@ function getFilenameIndexInUrl(url) {
     }
     return indexOfLastSlash + 1;
 }
+/**
+ * Resolve the output URL from the baseURL and the relative reference as
+ * specified by RFC 3986 section 5.
+ * @param base
+ * @param relative
+ * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5
+ * @example base: http://example.com | relative: /b/c | output: http://example.com/b/c
+ * @returns the resolved url
+ */
+function _resolveURL(base, relative) {
+    const baseParts = parseURL(base);
+    const relativeParts = parseURL(relative);
+    if (relativeParts.scheme) {
+        return formatURL(relativeParts);
+    }
+    const target = {
+        scheme: baseParts.scheme,
+        authority: baseParts.authority,
+        path: "",
+        query: relativeParts.query,
+        fragment: relativeParts.fragment,
+    };
+    if (relativeParts.authority) {
+        target.authority = relativeParts.authority;
+        target.path = removeDotSegment(relativeParts.path);
+        return formatURL(target);
+    }
+    if (relativeParts.path === "") {
+        target.path = baseParts.path;
+        if (!relativeParts.query) {
+            target.query = baseParts.query;
+        }
+    }
+    else {
+        if (startsWith(relativeParts.path, "/")) {
+            // path is absolute
+            target.path = removeDotSegment(relativeParts.path);
+        }
+        else {
+            // path is relative
+            target.path = removeDotSegment(mergePaths(baseParts, relativeParts.path));
+        }
+    }
+    return formatURL(target);
+}
+/**
+ * Cache to store already parsed URLs to avoid unnecessary computation when parsing the same URL again.
+ */
+const parsedUrlCache = new Map();
+/**
+ * Sets the maximum number of entries allowed in the parsedUrlCache map.
+ * This limit helps prevent excessive memory usage. The value is arbitrary.
+ */
+const MAX_URL_CACHE_ENTRIES = 200;
+/**
+ * Parses a URL into its components.
+ * @param {string} url - The URL to parse.
+ * @returns {IParsedURL} The parsed URL components.
+ */
+function parseURL(url) {
+    var _a, _b, _c, _d, _e;
+    if (parsedUrlCache.has(url)) {
+        return parsedUrlCache.get(url);
+    }
+    const matches = url.match(urlComponentRegex);
+    let parsed;
+    if (matches === null) {
+        parsed = {
+            scheme: "",
+            authority: "",
+            path: "",
+            query: "",
+            fragment: "",
+        };
+    }
+    else {
+        parsed = {
+            scheme: (_a = matches[1]) !== null && _a !== void 0 ? _a : "",
+            authority: (_b = matches[2]) !== null && _b !== void 0 ? _b : "",
+            path: (_c = matches[3]) !== null && _c !== void 0 ? _c : "",
+            query: (_d = matches[4]) !== null && _d !== void 0 ? _d : "",
+            fragment: (_e = matches[5]) !== null && _e !== void 0 ? _e : "",
+        };
+    }
+    if (parsedUrlCache.size >= MAX_URL_CACHE_ENTRIES) {
+        parsedUrlCache.clear();
+    }
+    parsedUrlCache.set(url, parsed);
+    return parsed;
+}
+/**
+ * Formats a parsed URL into a string.
+ * @param {IParsedURL} parts - The parsed URL components.
+ * @returns {string} The formatted URL string.
+ */
+function formatURL(parts) {
+    let url = "";
+    if (parts.scheme) {
+        url += parts.scheme + ":";
+    }
+    if (parts.authority) {
+        url += "//" + parts.authority;
+    }
+    url += parts.path;
+    if (parts.query) {
+        url += "?" + parts.query;
+    }
+    if (parts.fragment) {
+        url += "#" + parts.fragment;
+    }
+    return url;
+}
+/**
+ * Removes "." and ".." from the URL path, as described by the algorithm
+ * in RFC 3986 Section 5.2.4. Remove Dot Segments
+ * @param {string} path - The URL path
+ * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+ * @returns The path with dot segments removed.
+ * @example "/baz/booz/../biz" => "/baz/biz"
+ */
+function removeDotSegment(path) {
+    const segments = path.split(/(?=\/)/);
+    const output = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (segment === ".." || segment === "." || segment === "") {
+            continue;
+        }
+        if (segment === "/..") {
+            output.pop();
+            // if it's last segment push a trailing "/"
+            if (i === segments.length - 1) {
+                output.push("/");
+            }
+            continue;
+        }
+        if (segment === "/.") {
+            // if it's last segment push a trailing "/"
+            if (i === segments.length - 1) {
+                output.push("/");
+            }
+            continue;
+        }
+        output.push(segment);
+    }
+    return output.join("");
+}
+/**
+ * Merges a base URL path with a relative URL path, as described by
+ * the algorithm merge paths in RFC 3986 Section 5.2.3. Merge Paths
+ * @param {IParsedURL} baseParts - The parsed base URL components.
+ * @param {string} relativePath - The relative URL path.
+ * @returns {string} The merged URL path.
+ * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.3
+ */
+function mergePaths(baseParts, relativePath) {
+    if (baseParts.authority && baseParts.path === "") {
+        return "/" + relativePath;
+    }
+    const basePath = baseParts.path;
+    return basePath.substring(0, basePath.lastIndexOf("/") + 1) + relativePath;
+}
+/**
+ * Resolves multiple URL segments using the RFC 3986 URL resolution algorithm.
+ *
+ * This function takes a variable number of URL segments and resolves them
+ * sequentially according to the RFC 3986 URL resolution algorithm.
+ * First argument is the base URL.
+ * Empty string arguments are ignored.
+ *
+ * @param {...(string|undefined)} args - The URL segments to resolve.
+ * @returns {string} The resolved URL as a string.
+ */
+export function resolveURL(...args) {
+    var _a, _b, _c;
+    const filteredArgs = args.filter((val) => val !== "");
+    const len = filteredArgs.length;
+    if (len === 0) {
+        return "";
+    }
+    if (len === 1) {
+        return (_a = filteredArgs[0]) !== null && _a !== void 0 ? _a : "";
+    }
+    else {
+        const basePart = (_b = filteredArgs[0]) !== null && _b !== void 0 ? _b : "";
+        const relativeParts = (_c = filteredArgs[1]) !== null && _c !== void 0 ? _c : "";
+        const resolvedURL = _resolveURL(basePart, relativeParts);
+        const remainingArgs = filteredArgs.slice(2);
+        return resolveURL(resolvedURL, ...remainingArgs);
+    }
+}
 export { getFilenameIndexInUrl };
+export default resolveURL;

package/dist/es2017/utils/retry_promise_with_backoff.d.ts

@@ -52,3 +52,4 @@ export interface IBackoffOptions {
     errorSelector?: (error: unknown, retryCount: number) => Error;
     onRetry?: (error: unknown, retryCount: number) => void;
 }
+//# sourceMappingURL=retry_promise_with_backoff.d.ts.map

package/dist/es2017/utils/retry_promise_with_backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry_promise_with_backoff.d.ts","sourceRoot":"","sources":["../../../src/utils/retry_promise_with_backoff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,CAAC,EAC/C,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACzB,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,CAAC,CAAC,CAiCZ;AACD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,UAIpF;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC1C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,KAAK,KAAK,CAAC;IAC9D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACxD"}

package/dist/es2017/utils/sleep.d.ts

@@ -8,3 +8,4 @@
  * @returns {Promise}
  */
 export default function sleep(timeInMs: number): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/es2017/utils/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../src/utils/sleep.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI7D"}

package/dist/es2017/utils/slice_uint8array.d.ts

@@ -25,3 +25,4 @@
 declare function uint8ArraySlice(arr: Uint8Array, start: number, end?: number): Uint8Array;
 declare const _default: typeof uint8ArraySlice;
 export default _default;
+//# sourceMappingURL=slice_uint8array.d.ts.map

package/dist/es2017/utils/slice_uint8array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice_uint8array.d.ts","sourceRoot":"","sources":["../../../src/utils/slice_uint8array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAeH;;;;;;;;GAQG;AACH,iBAAS,eAAe,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAEjF;;AAED,wBAEe"}

package/dist/es2017/utils/sorted_list.d.ts

@@ -125,3 +125,4 @@ export default class SortedList<T> {
      */
     pop(): T | undefined;
 }
+//# sourceMappingURL=sorted_list.d.ts.map

package/dist/es2017/utils/sorted_list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sorted_list.d.ts","sourceRoot":"","sources":["../../../src/utils/sorted_list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyB;IACpD,OAAO,CAAC,MAAM,CAAM;IAEpB;;OAEG;gBACS,eAAe,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAKnD;;;;;;;;OAQG;IACI,GAAG,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,GAAG,IAAI;IAsBlC;;;OAGG;IACI,MAAM,IAAI,MAAM;IAIvB;;;;;;;;;;OAUG;IACI,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC;IAOrB,OAAO,IAAI,CAAC,EAAE;IAIrB;;;;;;;;OAQG;IACI,SAAS,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,GAAG,SAAS;IAI5D;;;;OAIG;IACI,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO;IAI/B;;;;OAIG;IACI,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS;IASpD;;;;;;;OAOG;IACI,IAAI,IAAI,CAAC,GAAG,SAAS;IAI5B;;;;;;;OAOG;IACI,IAAI,IAAI,CAAC,GAAG,SAAS;IAI5B;;;;OAIG;IACI,KAAK,IAAI,CAAC,GAAG,SAAS;IAI7B;;;;OAIG;IACI,GAAG,IAAI,CAAC,GAAG,SAAS;CAiD5B"}

package/dist/es2017/utils/starts_with.d.ts

@@ -24,3 +24,4 @@
  * @returns {boolean}
  */
 export default function startsWith(completeString: string, searchString: string, position?: number): boolean;
+//# sourceMappingURL=starts_with.d.ts.map

package/dist/es2017/utils/starts_with.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starts_with.d.ts","sourceRoot":"","sources":["../../../src/utils/starts_with.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAYT"}

package/dist/es2017/utils/string_parsing.d.ts

@@ -22,7 +22,7 @@
 declare function strToUtf16LE(str: string): Uint8Array;
 /**
  * Convert a string to an Uint8Array containing the corresponding UTF-16 code
- * units in little-endian.
+ * units in big-endian.
  * @param {string} str
  * @returns {Uint8Array}
  */
@@ -86,3 +86,4 @@ declare function readNullTerminatedString(buffer: Uint8Array, offset: number): {
     string: string;
 };
 export { bytesToHex, hexToBytes, strToUtf8, utf8ToStr, strToUtf16LE, utf16LEToStr, strToBeUtf16, beUtf16ToStr, guidToUuid, readNullTerminatedString, };
+//# sourceMappingURL=string_parsing.d.ts.map

package/dist/es2017/utils/string_parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_parsing.d.ts","sourceRoot":"","sources":["../../../src/utils/string_parsing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAYH;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAS7C;AAED;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAS7C;AAED;;;;GAIG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAqB/C;AAED;;;;GAIG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAqB/C;AAED;;;;;GAKG;AACH,iBAAS,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAgG1C;AA0CD;;;;GAIG;AACH,iBAAS,SAAS,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAoD3C;AAED;;;;;GAKG;AACH,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAO3C;AAED;;;;;;GAMG;AACH,iBAAS,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,GAAE,MAAW,GAAG,MAAM,CAU/D;AAED;;;;;GAKG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAgChD;AAED;;;;;;GAMG;AACH,iBAAS,wBAAwB,CAC/B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,CAYA;AAED,OAAO,EACL,UAAU,EACV,UAAU,EACV,SAAS,EACT,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,wBAAwB,GACzB,CAAC"}

package/dist/es2017/utils/string_parsing.js

@@ -36,7 +36,7 @@ function strToUtf16LE(str) {
 }
 /**
  * Convert a string to an Uint8Array containing the corresponding UTF-16 code
- * units in little-endian.
+ * units in big-endian.
  * @param {string} str
  * @returns {Uint8Array}
  */

package/dist/es2017/utils/sync_or_async.d.ts

@@ -68,3 +68,4 @@ declare const SyncOrAsync: {
     createAsync<T_1>(val: Promise<T_1>): ISyncOrAsyncValue<T_1>;
 };
 export default SyncOrAsync;
+//# sourceMappingURL=sync_or_async.d.ts.map

package/dist/es2017/utils/sync_or_async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync_or_async.d.ts","sourceRoot":"","sources":["../../../src/utils/sync_or_async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC;;;OAGG;IACH,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC;IACpB;;;;OAIG;IACH,eAAe,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/B;AAED,QAAA,MAAM,WAAW;IACf;;;;OAIG;;IAUH;;;;OAIG;;CAaJ,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/es2017/utils/task_canceller.d.ts

@@ -258,6 +258,6 @@ export type ICancellationListener = (error: CancellationError) => void;
  */
 export declare class CancellationError extends Error {
     readonly name: "CancellationError";
-    readonly message: string;
     constructor();
 }
+//# sourceMappingURL=task_canceller.d.ts.map

package/dist/es2017/utils/task_canceller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task_canceller.d.ts","sourceRoot":"","sources":["../../../src/utils/task_canceller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC;;;;OAIG;IACH,SAAgB,MAAM,EAAE,kBAAkB,CAAC;IAC3C;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAU;IACzB;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAqC;IAErD;;;;OAIG;;IAQH;;;OAGG;IACI,MAAM,IAAI,OAAO;IAIxB;;;;;;;;;;;;;OAaG;IACI,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAQ3D;;;;;;;;;;OAUG;IACI,MAAM,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,IAAI;IASjD;;;;;;OAMG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAGpD;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B;;;;;;;;OAQG;IACI,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAEnD;;;;;OAKG;IACH,OAAO,CAAC,UAAU,CAA4C;IAE9D;;;OAGG;IACH,OAAO,CAAC,YAAY,CAAU;IAE9B;;;;;OAKG;gBACS,gBAAgB,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI;IAsBvE;;;;OAIG;IACI,WAAW,IAAI,OAAO;IAI7B;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,QAAQ,CAAC,EAAE,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAUtD;;;;;;;OAOG;IACI,UAAU,CAAC,EAAE,EAAE,qBAAqB,GAAG,IAAI;CAOnD;AAED;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAEvE;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAgB,IAAI,EAAE,mBAAmB,CAAC;;CAU3C"}

package/dist/es2017/utils/task_canceller.js

@@ -273,11 +273,11 @@ export class CancellationSignal {
  */
 export class CancellationError extends Error {
     constructor() {
-        super();
+        const message = "This task was cancelled.";
+        super(message);
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
         Object.setPrototypeOf(this, CancellationError.prototype);
         this.name = "CancellationError";
-        this.message = "This task was cancelled.";
     }
 }
 /**

package/dist/es2017/utils/warn_once.d.ts

@@ -21,3 +21,4 @@
  * @param {string} message
  */
 export default function warnOnce(message: string): void;
+//# sourceMappingURL=warn_once.d.ts.map

package/dist/es2017/utils/warn_once.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn_once.d.ts","sourceRoot":"","sources":["../../../src/utils/warn_once.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAMtD"}

package/dist/es2017/utils/weak_map_memory.d.ts

@@ -68,3 +68,4 @@ export default class WeakMapMemory<T extends object, U> {
      */
     destroy(obj: T): void;
 }
+//# sourceMappingURL=weak_map_memory.d.ts.map

package/dist/es2017/utils/weak_map_memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weak_map_memory.d.ts","sourceRoot":"","sources":["../../../src/utils/weak_map_memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,MAAM,CAAC,OAAO,OAAO,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC;IACpD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAgB;IAEhC;;OAEG;gBACS,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC;IAK7B;;;OAGG;IACI,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAWrB;;OAEG;IACI,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;CAG7B"}

package/dist/es2017/utils/wrapInPromise.d.ts

@@ -5,3 +5,4 @@
  * @returns {Promise}
  */
 export default function wrapInPromise<T>(val: () => T | Promise<T>): Promise<T>;
+//# sourceMappingURL=wrapInPromise.d.ts.map

package/dist/es2017/utils/wrapInPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapInPromise.d.ts","sourceRoot":"","sources":["../../../src/utils/wrapInPromise.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAe9E"}