stormcloud-video-player 0.3.14 → 0.3.16

package/lib/utils/polyfills.cjs

@@ -1,253 +1,418 @@
 "use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __copyProps = function(to, from, except, desc) {
+    if (from && (typeof from === "undefined" ? "undefined" : _type_of(from)) === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/utils/polyfills.ts
 var polyfills_exports = {};
 __export(polyfills_exports, {
-  initializePolyfills: () => initializePolyfills,
-  polyfillArrayFrom: () => polyfillArrayFrom,
-  polyfillObjectAssign: () => polyfillObjectAssign,
-  polyfillPromiseFinally: () => polyfillPromiseFinally,
-  polyfillStringEndsWith: () => polyfillStringEndsWith,
-  polyfillStringIncludes: () => polyfillStringIncludes,
-  polyfillStringStartsWith: () => polyfillStringStartsWith,
-  polyfillTextEncoder: () => polyfillTextEncoder,
-  polyfillURLSearchParams: () => polyfillURLSearchParams
+    initializePolyfills: function() {
+        return initializePolyfills;
+    },
+    polyfillArrayFrom: function() {
+        return polyfillArrayFrom;
+    },
+    polyfillObjectAssign: function() {
+        return polyfillObjectAssign;
+    },
+    polyfillPromiseFinally: function() {
+        return polyfillPromiseFinally;
+    },
+    polyfillStringEndsWith: function() {
+        return polyfillStringEndsWith;
+    },
+    polyfillStringIncludes: function() {
+        return polyfillStringIncludes;
+    },
+    polyfillStringStartsWith: function() {
+        return polyfillStringStartsWith;
+    },
+    polyfillTextEncoder: function() {
+        return polyfillTextEncoder;
+    },
+    polyfillURLSearchParams: function() {
+        return polyfillURLSearchParams;
+    }
 });
 module.exports = __toCommonJS(polyfills_exports);
 function polyfillURLSearchParams() {
-  if (typeof URLSearchParams !== "undefined") {
-    return;
-  }
-  class URLSearchParamsPolyfill {
-    constructor(init) {
-      this.params = /* @__PURE__ */ new Map();
-      if (typeof init === "string") {
-        this.parseQueryString(init);
-      } else if (init instanceof URLSearchParamsPolyfill) {
-        init.forEach((value, key) => {
-          this.append(key, value);
-        });
-      }
+    if (typeof URLSearchParams !== "undefined") {
+        return;
     }
-    parseQueryString(query) {
-      const cleanQuery = query.startsWith("?") ? query.slice(1) : query;
-      if (!cleanQuery) return;
-      cleanQuery.split("&").forEach((param) => {
-        const [key, value] = param.split("=");
-        if (key) {
-          const decodedKey = this.safeDecodeURIComponent(key);
-          const decodedValue = value ? this.safeDecodeURIComponent(value) : "";
-          this.append(decodedKey, decodedValue);
+    var URLSearchParamsPolyfill = /*#__PURE__*/ function() {
+        function URLSearchParamsPolyfill(init) {
+            var _this = this;
+            _class_call_check(this, URLSearchParamsPolyfill);
+            this.params = /* @__PURE__ */ new Map();
+            if (typeof init === "string") {
+                this.parseQueryString(init);
+            } else if (_instanceof(init, URLSearchParamsPolyfill)) {
+                init.forEach(function(value, key) {
+                    _this.append(key, value);
+                });
+            }
         }
-      });
-    }
-    safeDecodeURIComponent(str) {
-      try {
-        return decodeURIComponent(str.replace(/\+/g, " "));
-      } catch (e) {
-        return str;
-      }
-    }
-    append(name, value) {
-      const values = this.params.get(name) || [];
-      values.push(String(value));
-      this.params.set(name, values);
-    }
-    delete(name) {
-      this.params.delete(name);
-    }
-    get(name) {
-      const values = this.params.get(name);
-      return values && values.length > 0 && values[0] !== void 0 ? values[0] : null;
-    }
-    getAll(name) {
-      return this.params.get(name) || [];
-    }
-    has(name) {
-      return this.params.has(name);
-    }
-    set(name, value) {
-      this.params.set(name, [String(value)]);
-    }
-    forEach(callback) {
-      this.params.forEach((values, key) => {
-        values.forEach((value) => {
-          callback(value, key, this);
-        });
-      });
-    }
-    toString() {
-      const parts = [];
-      this.params.forEach((values, key) => {
-        values.forEach((value) => {
-          parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-        });
-      });
-      return parts.join("&");
-    }
-  }
-  window.URLSearchParams = URLSearchParamsPolyfill;
+        _create_class(URLSearchParamsPolyfill, [
+            {
+                key: "parseQueryString",
+                value: function parseQueryString(query) {
+                    var _this = this;
+                    var cleanQuery = query.startsWith("?") ? query.slice(1) : query;
+                    if (!cleanQuery) return;
+                    cleanQuery.split("&").forEach(function(param) {
+                        var _param_split = _sliced_to_array(param.split("="), 2), key = _param_split[0], value = _param_split[1];
+                        if (key) {
+                            var decodedKey = _this.safeDecodeURIComponent(key);
+                            var decodedValue = value ? _this.safeDecodeURIComponent(value) : "";
+                            _this.append(decodedKey, decodedValue);
+                        }
+                    });
+                }
+            },
+            {
+                key: "safeDecodeURIComponent",
+                value: function safeDecodeURIComponent(str) {
+                    try {
+                        return decodeURIComponent(str.replace(/\+/g, " "));
+                    } catch (e) {
+                        return str;
+                    }
+                }
+            },
+            {
+                key: "append",
+                value: function append(name, value) {
+                    var values = this.params.get(name) || [];
+                    values.push(String(value));
+                    this.params.set(name, values);
+                }
+            },
+            {
+                key: "delete",
+                value: function _delete(name) {
+                    this.params.delete(name);
+                }
+            },
+            {
+                key: "get",
+                value: function get(name) {
+                    var values = this.params.get(name);
+                    return values && values.length > 0 && values[0] !== void 0 ? values[0] : null;
+                }
+            },
+            {
+                key: "getAll",
+                value: function getAll(name) {
+                    return this.params.get(name) || [];
+                }
+            },
+            {
+                key: "has",
+                value: function has(name) {
+                    return this.params.has(name);
+                }
+            },
+            {
+                key: "set",
+                value: function set(name, value) {
+                    this.params.set(name, [
+                        String(value)
+                    ]);
+                }
+            },
+            {
+                key: "forEach",
+                value: function forEach(callback) {
+                    var _this = this;
+                    this.params.forEach(function(values, key) {
+                        values.forEach(function(value) {
+                            callback(value, key, _this);
+                        });
+                    });
+                }
+            },
+            {
+                key: "toString",
+                value: function toString() {
+                    var parts = [];
+                    this.params.forEach(function(values, key) {
+                        values.forEach(function(value) {
+                            parts.push("".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value)));
+                        });
+                    });
+                    return parts.join("&");
+                }
+            }
+        ]);
+        return URLSearchParamsPolyfill;
+    }();
+    window.URLSearchParams = URLSearchParamsPolyfill;
 }
 function polyfillTextEncoder() {
-  if (typeof TextEncoder !== "undefined") {
-    return;
-  }
-  class TextEncoderPolyfill {
-    constructor() {
-      this.encoding = "utf-8";
+    if (typeof TextEncoder !== "undefined") {
+        return;
     }
-    encode(str) {
-      const utf8 = [];
-      for (let i = 0; i < str.length; i++) {
-        let charcode = str.charCodeAt(i);
-        if (charcode < 128) {
-          utf8.push(charcode);
-        } else if (charcode < 2048) {
-          utf8.push(192 | charcode >> 6, 128 | charcode & 63);
-        } else if (charcode < 55296 || charcode >= 57344) {
-          utf8.push(
-            224 | charcode >> 12,
-            128 | charcode >> 6 & 63,
-            128 | charcode & 63
-          );
-        } else {
-          i++;
-          charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
-          utf8.push(
-            240 | charcode >> 18,
-            128 | charcode >> 12 & 63,
-            128 | charcode >> 6 & 63,
-            128 | charcode & 63
-          );
+    var TextEncoderPolyfill = /*#__PURE__*/ function() {
+        function TextEncoderPolyfill() {
+            _class_call_check(this, TextEncoderPolyfill);
+            this.encoding = "utf-8";
         }
-      }
-      return new Uint8Array(utf8);
-    }
-  }
-  window.TextEncoder = TextEncoderPolyfill;
+        _create_class(TextEncoderPolyfill, [
+            {
+                key: "encode",
+                value: function encode(str) {
+                    var utf8 = [];
+                    for(var i = 0; i < str.length; i++){
+                        var charcode = str.charCodeAt(i);
+                        if (charcode < 128) {
+                            utf8.push(charcode);
+                        } else if (charcode < 2048) {
+                            utf8.push(192 | charcode >> 6, 128 | charcode & 63);
+                        } else if (charcode < 55296 || charcode >= 57344) {
+                            utf8.push(224 | charcode >> 12, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+                        } else {
+                            i++;
+                            charcode = 65536 + ((charcode & 1023) << 10 | str.charCodeAt(i) & 1023);
+                            utf8.push(240 | charcode >> 18, 128 | charcode >> 12 & 63, 128 | charcode >> 6 & 63, 128 | charcode & 63);
+                        }
+                    }
+                    return new Uint8Array(utf8);
+                }
+            }
+        ]);
+        return TextEncoderPolyfill;
+    }();
+    window.TextEncoder = TextEncoderPolyfill;
 }
 function polyfillPromiseFinally() {
-  if (typeof Promise !== "undefined" && !Promise.prototype.finally) {
-    Promise.prototype.finally = function(callback) {
-      const constructor = this.constructor;
-      return this.then(
-        (value) => constructor.resolve(callback()).then(() => value),
-        (reason) => constructor.resolve(callback()).then(() => {
-          throw reason;
-        })
-      );
-    };
-  }
+    if (typeof Promise !== "undefined" && !Promise.prototype.finally) {
+        Promise.prototype.finally = function(callback) {
+            var constructor = this.constructor;
+            return this.then(function(value) {
+                return constructor.resolve(callback()).then(function() {
+                    return value;
+                });
+            }, function(reason) {
+                return constructor.resolve(callback()).then(function() {
+                    throw reason;
+                });
+            });
+        };
+    }
 }
 function polyfillObjectAssign() {
-  if (typeof Object.assign !== "function") {
-    Object.assign = function(target, ...sources) {
-      if (target == null) {
-        throw new TypeError("Cannot convert undefined or null to object");
-      }
-      const to = Object(target);
-      for (let i = 0; i < sources.length; i++) {
-        const nextSource = sources[i];
-        if (nextSource != null) {
-          for (const nextKey in nextSource) {
-            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
-              to[nextKey] = nextSource[nextKey];
+    if (typeof Object.assign !== "function") {
+        Object.assign = function(target) {
+            for(var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                sources[_key - 1] = arguments[_key];
             }
-          }
-        }
-      }
-      return to;
-    };
-  }
+            if (target == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            var to = Object(target);
+            for(var i = 0; i < sources.length; i++){
+                var nextSource = sources[i];
+                if (nextSource != null) {
+                    for(var nextKey in nextSource){
+                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+                            to[nextKey] = nextSource[nextKey];
+                        }
+                    }
+                }
+            }
+            return to;
+        };
+    }
 }
 function polyfillArrayFrom() {
-  if (!Array.from) {
-    Array.from = function(arrayLike, mapFn, thisArg) {
-      const items = Object(arrayLike);
-      if (arrayLike == null) {
-        throw new TypeError("Array.from requires an array-like object");
-      }
-      const len = items.length >>> 0;
-      const result = new Array(len);
-      for (let i = 0; i < len; i++) {
-        if (mapFn) {
-          result[i] = mapFn.call(thisArg, items[i], i);
-        } else {
-          result[i] = items[i];
-        }
-      }
-      return result;
-    };
-  }
+    if (!Array.from) {
+        Array.from = function(arrayLike, mapFn, thisArg) {
+            var items = Object(arrayLike);
+            if (arrayLike == null) {
+                throw new TypeError("Array.from requires an array-like object");
+            }
+            var len = items.length >>> 0;
+            var result = new Array(len);
+            for(var i = 0; i < len; i++){
+                if (mapFn) {
+                    result[i] = mapFn.call(thisArg, items[i], i);
+                } else {
+                    result[i] = items[i];
+                }
+            }
+            return result;
+        };
+    }
 }
 function polyfillStringStartsWith() {
-  if (!String.prototype.startsWith) {
-    String.prototype.startsWith = function(search, pos) {
-      pos = !pos || pos < 0 ? 0 : +pos;
-      return this.substring(pos, pos + search.length) === search;
-    };
-  }
+    if (!String.prototype.startsWith) {
+        String.prototype.startsWith = function(search, pos) {
+            pos = !pos || pos < 0 ? 0 : +pos;
+            return this.substring(pos, pos + search.length) === search;
+        };
+    }
 }
 function polyfillStringEndsWith() {
-  if (!String.prototype.endsWith) {
-    String.prototype.endsWith = function(search, length) {
-      if (length === void 0 || length > this.length) {
-        length = this.length;
-      }
-      return this.substring(length - search.length, length) === search;
-    };
-  }
+    if (!String.prototype.endsWith) {
+        String.prototype.endsWith = function(search, length) {
+            if (length === void 0 || length > this.length) {
+                length = this.length;
+            }
+            return this.substring(length - search.length, length) === search;
+        };
+    }
 }
 function polyfillStringIncludes() {
-  if (!String.prototype.includes) {
-    String.prototype.includes = function(search, start) {
-      if (typeof start !== "number") {
-        start = 0;
-      }
-      if (start + search.length > this.length) {
-        return false;
-      }
-      return this.indexOf(search, start) !== -1;
-    };
-  }
+    if (!String.prototype.includes) {
+        String.prototype.includes = function(search, start) {
+            if (typeof start !== "number") {
+                start = 0;
+            }
+            if (start + search.length > this.length) {
+                return false;
+            }
+            return this.indexOf(search, start) !== -1;
+        };
+    }
 }
 function initializePolyfills() {
-  polyfillObjectAssign();
-  polyfillArrayFrom();
-  polyfillStringStartsWith();
-  polyfillStringEndsWith();
-  polyfillStringIncludes();
-  polyfillURLSearchParams();
-  polyfillTextEncoder();
-  polyfillPromiseFinally();
+    polyfillObjectAssign();
+    polyfillArrayFrom();
+    polyfillStringStartsWith();
+    polyfillStringEndsWith();
+    polyfillStringIncludes();
+    polyfillURLSearchParams();
+    polyfillTextEncoder();
+    polyfillPromiseFinally();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  initializePolyfills,
-  polyfillArrayFrom,
-  polyfillObjectAssign,
-  polyfillPromiseFinally,
-  polyfillStringEndsWith,
-  polyfillStringIncludes,
-  polyfillStringStartsWith,
-  polyfillTextEncoder,
-  polyfillURLSearchParams
+    initializePolyfills: initializePolyfills,
+    polyfillArrayFrom: polyfillArrayFrom,
+    polyfillObjectAssign: polyfillObjectAssign,
+    polyfillPromiseFinally: polyfillPromiseFinally,
+    polyfillStringEndsWith: polyfillStringEndsWith,
+    polyfillStringIncludes: polyfillStringIncludes,
+    polyfillStringStartsWith: polyfillStringStartsWith,
+    polyfillTextEncoder: polyfillTextEncoder,
+    polyfillURLSearchParams: polyfillURLSearchParams
 });
 //# sourceMappingURL=polyfills.cjs.map