rx-player 3.33.1 → 3.33.3

package/dist/_esm5.processed/utils/resolve_url.js

@@ -13,78 +13,32 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Scheme part of an url (e.g. "http://").
-var schemeRe = /^(?:[a-z]+:)?\/\//i;
-// Captures "/../" or "/./".
-var 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;
-    }
-    var newUrl = [];
-    var oldUrl = url.split("/");
-    for (var i = 0, l = oldUrl.length; i < l; i++) {
-        if (oldUrl[i] === "..") {
-            newUrl.pop();
-        }
-        else if (oldUrl[i] === ".") {
-            continue;
-        }
-        else {
-            newUrl.push(oldUrl[i]);
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
         }
     }
-    return newUrl.join("/");
-}
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import startsWith from "./starts_with";
+// Scheme part of an url (e.g. "http://").
+var schemeRe = /^(?:[a-z]+:)?\/\//i;
 /**
- * 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() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var len = args.length;
-    if (len === 0) {
-        return "";
-    }
-    var base = "";
-    for (var i = 0; i < len; i++) {
-        var 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")
+ * */
+var 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
@@ -114,4 +68,201 @@ 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) {
+    var baseParts = parseURL(base);
+    var relativeParts = parseURL(relative);
+    if (relativeParts.scheme) {
+        return formatURL(relativeParts);
+    }
+    var 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.
+ */
+var 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.
+ */
+var 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);
+    }
+    var matches = url.match(urlComponentRegex);
+    var 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) {
+    var 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) {
+    var segments = path.split(/(?=\/)/);
+    var output = [];
+    for (var i = 0; i < segments.length; i++) {
+        var 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;
+    }
+    var 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() {
+    var _a, _b, _c;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var filteredArgs = args.filter(function (val) { return val !== ""; });
+    var len = filteredArgs.length;
+    if (len === 0) {
+        return "";
+    }
+    if (len === 1) {
+        return (_a = filteredArgs[0]) !== null && _a !== void 0 ? _a : "";
+    }
+    else {
+        var basePart = (_b = filteredArgs[0]) !== null && _b !== void 0 ? _b : "";
+        var relativeParts = (_c = filteredArgs[1]) !== null && _c !== void 0 ? _c : "";
+        var resolvedURL = _resolveURL(basePart, relativeParts);
+        var remainingArgs = filteredArgs.slice(2);
+        return resolveURL.apply(void 0, __spreadArray([resolvedURL], remainingArgs, false));
+    }
+}
 export { getFilenameIndexInUrl };
+export default resolveURL;

package/dist/_esm5.processed/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}
  */

package/dist/_esm5.processed/utils/string_parsing.js

@@ -37,7 +37,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/_esm5.processed/utils/task_canceller.d.ts

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

package/dist/_esm5.processed/utils/task_canceller.js

@@ -297,11 +297,12 @@ export { CancellationSignal };
 var CancellationError = /** @class */ (function (_super) {
     __extends(CancellationError, _super);
     function CancellationError() {
-        var _this = _super.call(this) || this;
+        var _this = this;
+        var message = "This task was cancelled.";
+        _this = _super.call(this, message) || this;
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
         Object.setPrototypeOf(_this, CancellationError.prototype);
         _this.name = "CancellationError";
-        _this.message = "This task was cancelled.";
         return _this;
     }
     return CancellationError;

package/dist/rx-player.d.ts

@@ -1,3 +1,3 @@
 
-import RxPlayer from "./_esm5.processed/index";
+import RxPlayer from "./_esm5.processed/minimal";
 export default RxPlayer;