@signageos/lib-bundler 23.18.0 → 23.18.1

package/dist/index.cjs

@@ -829,14 +829,14 @@ var AbortControllerShim = (global) => {
       this.dispatchEvent(new global.Event("abort"));
     }
     static abort(reason) {
-      const controller = new AbortController();
+      const controller = new global.AbortController();
       controller.abort(reason);
       return controller.signal;
     }
     // This methods is not spec complaint, because it requires WeakSet.
     // https://github.com/zloirock/core-js/issues/445
     static any(signals) {
-      const controller = new AbortController();
+      const controller = new global.AbortController();
       for (const s of signals) {
         const onAbort = () => {
           controller.abort(s.reason);
@@ -850,7 +850,7 @@ var AbortControllerShim = (global) => {
       if (timeoutMs < 0 || timeoutMs > Number.MAX_SAFE_INTEGER) {
         throw new global.TypeError("AbortSignal.timeout: Argument 1 is out of range for unsigned long long.");
       }
-      const controller = new AbortController();
+      const controller = new global.AbortController();
       global.setTimeout(() => {
         controller.abort(new global.DOMException("The operation timed out.", "TimeoutError"));
       }, timeoutMs);

package/dist/index.mjs

@@ -787,14 +787,14 @@ var AbortControllerShim = (global) => {
       this.dispatchEvent(new global.Event("abort"));
     }
     static abort(reason) {
-      const controller = new AbortController();
+      const controller = new global.AbortController();
       controller.abort(reason);
       return controller.signal;
     }
     // This methods is not spec complaint, because it requires WeakSet.
     // https://github.com/zloirock/core-js/issues/445
     static any(signals) {
-      const controller = new AbortController();
+      const controller = new global.AbortController();
       for (const s of signals) {
         const onAbort = () => {
           controller.abort(s.reason);
@@ -808,7 +808,7 @@ var AbortControllerShim = (global) => {
       if (timeoutMs < 0 || timeoutMs > Number.MAX_SAFE_INTEGER) {
         throw new global.TypeError("AbortSignal.timeout: Argument 1 is out of range for unsigned long long.");
       }
-      const controller = new AbortController();
+      const controller = new global.AbortController();
       global.setTimeout(() => {
         controller.abort(new global.DOMException("The operation timed out.", "TimeoutError"));
       }, timeoutMs);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@signageos/lib-bundler",
-	"version": "23.18.0",
+	"version": "23.18.1",
 	"main": "./dist/index.cjs",
 	"author": "",
 	"license": "MIT",
@@ -9,6 +9,7 @@
 	"files": [
 		"tools",
 		"dist",
+		"polyfills",
 		"package.json"
 	],
 	"exports": {

package/polyfills/AbortController/polyfill.js

@@ -0,0 +1,379 @@
+"use strict";
+function _assert_this_initialized(self1) {
+    if (self1 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self1;
+}
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self1, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self1);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+(function() {
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __esm = function(fn, res) {
+        return function __init() {
+            return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+        };
+    };
+    var __commonJS = function(cb, mod) {
+        return function __require() {
+            return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+                exports: {}
+            }).exports, mod), mod.exports;
+        };
+    };
+    // src/polyfills/utils.ts
+    var getGlobal;
+    var init_utils = __esm({
+        "src/polyfills/utils.ts": function() {
+            "use strict";
+            getGlobal = function() {
+                return typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : new Function("return this")();
+            };
+        }
+    });
+    // src/polyfills/AbortController/AbortController.ts
+    var AbortControllerShim;
+    var init_AbortController = __esm({
+        "src/polyfills/AbortController/AbortController.ts": function() {
+            "use strict";
+            AbortControllerShim = function(global2) {
+                var SECRET = {};
+                var AbortSignal = /*#__PURE__*/ function(_global2_EventTarget) {
+                    _inherits(AbortSignal, _global2_EventTarget);
+                    var _super = _create_super(AbortSignal);
+                    function AbortSignal(secret) {
+                        _class_call_check(this, AbortSignal);
+                        var _this;
+                        _this = _super.call(this);
+                        _define_property(_assert_this_initialized(_this), "_reason", void 0);
+                        _define_property(_assert_this_initialized(_this), "_onabort", null);
+                        if (secret !== SECRET) {
+                            throw new global2.TypeError("Illegal constructor.");
+                        }
+                        return _this;
+                    }
+                    _create_class(AbortSignal, [
+                        {
+                            key: "aborted",
+                            get: function get() {
+                                return this._reason !== void 0;
+                            }
+                        },
+                        {
+                            key: "reason",
+                            get: function get() {
+                                return this._reason;
+                            }
+                        },
+                        {
+                            key: "onabort",
+                            get: function get() {
+                                return this._onabort;
+                            },
+                            set: function set(callback) {
+                                if (this._onabort) {
+                                    this.removeEventListener("abort", this._onabort);
+                                }
+                                this._onabort = callback;
+                                this.addEventListener("abort", callback, {
+                                    once: true
+                                });
+                            }
+                        },
+                        {
+                            key: "addEventListener",
+                            value: function addEventListener(type, callback, options) {
+                                return _get(_get_prototype_of(AbortSignal.prototype), "addEventListener", this).call(this, type, callback, typeof options === "boolean" ? {
+                                    capture: options,
+                                    once: true
+                                } : _object_spread_props(_object_spread({}, options), {
+                                    once: true
+                                }));
+                            }
+                        },
+                        {
+                            key: "throwIfAborted",
+                            value: function throwIfAborted() {
+                                if (this._reason !== void 0) {
+                                    throw this._reason;
+                                }
+                            }
+                        },
+                        {
+                            key: "__dispatchAbort",
+                            value: function __dispatchAbort(reason) {
+                                if (this._reason) {
+                                    return;
+                                }
+                                if (reason === void 0) {
+                                    reason = new global2.DOMException("The operation was aborted.", "AbortError");
+                                }
+                                this._reason = reason;
+                                this.dispatchEvent(new global2.Event("abort"));
+                            }
+                        }
+                    ], [
+                        {
+                            key: "abort",
+                            value: function abort(reason) {
+                                var controller = new global2.AbortController();
+                                controller.abort(reason);
+                                return controller.signal;
+                            }
+                        },
+                        {
+                            key: "any",
+                            value: // This methods is not spec complaint, because it requires WeakSet.
+                            // https://github.com/zloirock/core-js/issues/445
+                            function any(signals) {
+                                var controller = new global2.AbortController();
+                                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    var _loop = function() {
+                                        var s = _step.value;
+                                        var onAbort = function() {
+                                            controller.abort(s.reason);
+                                            s.removeEventListener("abort", onAbort);
+                                        };
+                                        s.addEventListener("abort", onAbort, {
+                                            once: true
+                                        });
+                                    };
+                                    for(var _iterator = signals[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 controller.signal;
+                            }
+                        },
+                        {
+                            key: "timeout",
+                            value: function timeout(timeoutMs) {
+                                if (timeoutMs < 0 || timeoutMs > Number.MAX_SAFE_INTEGER) {
+                                    throw new global2.TypeError("AbortSignal.timeout: Argument 1 is out of range for unsigned long long.");
+                                }
+                                var controller = new global2.AbortController();
+                                global2.setTimeout(function() {
+                                    controller.abort(new global2.DOMException("The operation timed out.", "TimeoutError"));
+                                }, timeoutMs);
+                                return controller.signal;
+                            }
+                        }
+                    ]);
+                    return AbortSignal;
+                }(global2.EventTarget);
+                var AbortController = /*#__PURE__*/ function() {
+                    function AbortController() {
+                        _class_call_check(this, AbortController);
+                        _define_property(this, "signal", void 0);
+                        this.signal = new AbortSignal(SECRET);
+                    }
+                    _create_class(AbortController, [
+                        {
+                            key: "abort",
+                            value: function abort(reason) {
+                                this.signal.__dispatchAbort(reason);
+                            }
+                        }
+                    ]);
+                    return AbortController;
+                }();
+                return {
+                    AbortController: AbortController,
+                    AbortSignal: AbortSignal
+                };
+            };
+        }
+    });
+    // src/polyfills/AbortController/polyfill.ts
+    var require_polyfill = __commonJS({
+        "src/polyfills/AbortController/polyfill.ts": function() {
+            init_utils();
+            init_AbortController();
+            (function() {
+                var g = getGlobal();
+                var shim = AbortControllerShim(g);
+                if (g.AbortController === void 0) {
+                    g.AbortController = shim.AbortController;
+                    g.AbortSignal = shim.AbortSignal;
+                }
+                if (!g.AbortSignal.abort) {
+                    g.AbortSignal.abort = shim.AbortSignal.abort;
+                }
+                if (!g.AbortSignal.timeout) {
+                    g.AbortSignal.timeout = shim.AbortSignal.timeout;
+                }
+                if (!g.AbortSignal.any) {
+                    g.AbortSignal.any = shim.AbortSignal.any;
+                }
+                if (!g.AbortSignal.prototype.throwIfAborted) {
+                    g.AbortSignal.prototype.throwIfAborted = shim.AbortSignal.prototype.throwIfAborted;
+                }
+            })();
+        }
+    });
+    require_polyfill();
+})();