@monterosa/sdk-util 0.17.1-rc.6

package/dist/index.esm5.js

@@ -0,0 +1,846 @@
+import mitt from 'mitt';
+
+/**
+ * @license
+ * subscribe.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-02-22
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var Emitter = /** @class */ (function () {
+    function Emitter() {
+        this.handlers = new Map();
+        this.emitter = mitt();
+    }
+    Emitter.prototype.on = function (event, handler) {
+        var _this = this;
+        var mittHandler = function (args) {
+            handler.apply(void 0, (Array.isArray(args) ? args : [args]));
+        };
+        this.handlers.set(handler, mittHandler);
+        this.emitter.on(event, mittHandler);
+        return function () { return _this.off(event, handler); };
+    };
+    Emitter.prototype.off = function (event, handler) {
+        if (handler === undefined) {
+            this.emitter.off(event);
+            return;
+        }
+        var mittHandler = this.handlers.get(handler);
+        if (mittHandler) {
+            this.emitter.off(event, mittHandler);
+            this.handlers.delete(handler);
+        }
+    };
+    Emitter.prototype.emit = function (event) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.emitter.emit(event, args);
+    };
+    Emitter.prototype.once = function (event, handler) {
+        var _this = this;
+        var mittHandler = function (args) {
+            handler.apply(void 0, (Array.isArray(args) ? args : [args]));
+            _this.off(event, handler);
+        };
+        this.handlers.set(handler, mittHandler);
+        this.emitter.on(event, mittHandler);
+        return function () { return _this.off(event, handler); };
+    };
+    return Emitter;
+}());
+/**
+ * @internal
+ */
+var subscribe = function (emitter, event, callback) {
+    emitter.on(event, callback);
+    return function () { return emitter.off(event, callback); };
+};
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+/**
+ * @license
+ * delay.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-24
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * @internal
+ */
+var delay = function (timeout) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, timeout); })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+
+/**
+ * @license
+ * memoize-promise.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-09-20
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/**
+ * Creates a function that memoizes the result of `func`.
+ *
+ * @internal
+ *
+ * @param func - A function that returns a promise. The results of its work will be memoized.
+ * @param resolver - A function that determines the cache key.
+ * @param config - A configuration object with the following optional properties:
+ *   `clearOnResolve` - Deletes memoized result upon promise resolve. Defaults to `false`.
+ *   `clearOnReject` - Deletes memoized result upon promise reject. Defaults to `true`.
+ */
+var memoizePromise = function (func, resolver, config) {
+    var _a, _b;
+    if (config === void 0) { config = {}; }
+    var clearOnResolve = (_a = config.clearOnResolve) !== null && _a !== void 0 ? _a : false;
+    var clearOnReject = (_b = config.clearOnReject) !== null && _b !== void 0 ? _b : true;
+    var cache = new Map();
+    var memoized = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var key = resolver.apply(void 0, args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        var promise = func.apply(void 0, args);
+        cache.set(key, promise);
+        promise.then(function () { return clearOnResolve && cache.delete(key); });
+        promise.catch(function () { return clearOnReject && cache.delete(key); });
+        return promise;
+    };
+    memoized.cache = cache;
+    return memoized;
+};
+
+/**
+ * @license
+ * global.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-04-21
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/* eslint no-restricted-globals: "off" */
+/**
+ * Global object polyfill.
+ * Based on MDN article: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+ *
+ * @internal
+ *
+ * @returns typeof globalThis
+ */
+function getGlobal() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof globalThis !== 'undefined') {
+        return globalThis;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('Unable to locate global object.');
+}
+
+/**
+ * @license
+ * storage.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-04-21
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var PREFIX = 'monterosa_sdk_';
+var BAIT = 'bait';
+var globals = getGlobal();
+/**
+ * @internal
+ */
+var getKey = function (name) { return "" + PREFIX + name; };
+/**
+ * @internal
+ */
+function getItem(key) {
+    return globals.localStorage.getItem(getKey(key));
+}
+/**
+ * @internal
+ */
+function setItem(key, value) {
+    return globals.localStorage.setItem(getKey(key), value);
+}
+/**
+ * @internal
+ */
+function removeItem(key) {
+    return globals.localStorage.removeItem(getKey(key));
+}
+/**
+ * @internal
+ */
+function clear() {
+    return globals.localStorage.clear();
+}
+/**
+ * Checks locastorage availability.
+ * Based on MDN article: https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API
+ * and Paul Irish gists: https://gist.github.com/paulirish/5558557
+ *
+ * @internal
+ *
+ * @returns boolean
+ */
+function checkAvailability() {
+    try {
+        setItem(BAIT, BAIT);
+        getItem(BAIT);
+        removeItem(BAIT);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+
+/**
+ * @license
+ * error.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2022-03-31
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/* eslint max-classes-per-file: ["error", 2] */
+/**
+ * MonterosaError extends the standard JavaScript `Error` object. It has
+ * an error code so that user can identify the error. Also it has it's own
+ * specific `name` "MonterosaError"
+ */
+var MonterosaError = /** @class */ (function (_super) {
+    __extends(MonterosaError, _super);
+    /**
+     * @param code - Error code string
+     * @param message - A descriptive message for the error
+     */
+    function MonterosaError(code, message) {
+        var _this = _super.call(this, message) || this;
+        /**
+         * The name property represents a name for the type of error.
+         */
+        _this.name = 'MonterosaError';
+        _this.code = code;
+        // Fix For ES5
+        // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        Object.setPrototypeOf(_this, MonterosaError.prototype);
+        return _this;
+    }
+    return MonterosaError;
+}(Error));
+/**
+ * @internal
+ */
+function createError(code, messages) {
+    var params = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        params[_i - 2] = arguments[_i];
+    }
+    var message = messages[code].apply(messages, params);
+    return new MonterosaError(code, message);
+}
+
+/**
+ * @license
+ * throttle.ts
+ * util
+ *
+ * Created by Josep Rodriguez <josep.rodriguez@monterosa.co.uk> on 2022-07-13
+ * Copyright © 2022 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+/* eslint-disable */
+// @ts-nocheck
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+/** Used to match leading and trailing whitespace. */
+var reTrim = /^\s+|\s+$/g;
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max, nativeMin = Math.min;
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ *   console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+var now$1 = function () {
+    return root.Date.now();
+};
+/**
+ * Creates a debounced function that delays invoking `func` until after `wait`
+ * milliseconds have elapsed since the last time the debounced function was
+ * invoked. The debounced function comes with a `cancel` method to cancel
+ * delayed `func` invocations and a `flush` method to immediately invoke them.
+ * Provide `options` to indicate whether `func` should be invoked on the
+ * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+ * with the last arguments provided to the debounced function. Subsequent
+ * calls to the debounced function return the result of the last `func`
+ * invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the debounced function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.debounce` and `_.throttle`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to debounce.
+ * @param {number} [wait=0] The number of milliseconds to delay.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=false]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {number} [options.maxWait]
+ *  The maximum time `func` is allowed to be delayed before it's invoked.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new debounced function.
+ * @example
+ *
+ * // Avoid costly calculations while the window size is in flux.
+ * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+ *
+ * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+ * jQuery(element).on('click', _.debounce(sendMail, 300, {
+ *   'leading': true,
+ *   'trailing': false
+ * }));
+ *
+ * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+ * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+ * var source = new EventSource('/stream');
+ * jQuery(source).on('message', debounced);
+ *
+ * // Cancel the trailing debounced invocation.
+ * jQuery(window).on('popstate', debounced.cancel);
+ */
+function debounce(func, wait, options) {
+    var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+    if (typeof func != 'function') {
+        throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject(options)) {
+        leading = !!options.leading;
+        maxing = 'maxWait' in options;
+        maxWait = maxing
+            ? nativeMax(toNumber(options.maxWait) || 0, wait)
+            : maxWait;
+        trailing = 'trailing' in options ? !!options.trailing : trailing;
+    }
+    function invokeFunc(time) {
+        var args = lastArgs, thisArg = lastThis;
+        lastArgs = lastThis = undefined;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+    }
+    function leadingEdge(time) {
+        // Reset any `maxWait` timer.
+        lastInvokeTime = time;
+        // Start the timer for the trailing edge.
+        timerId = setTimeout(timerExpired, wait);
+        // Invoke the leading edge.
+        return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, result = wait - timeSinceLastCall;
+        return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+    }
+    function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+        // Either this is the first call, activity has stopped and we're at the
+        // trailing edge, the system time has gone backwards and we're treating
+        // it as the trailing edge, or we've hit the `maxWait` limit.
+        return (lastCallTime === undefined ||
+            timeSinceLastCall >= wait ||
+            timeSinceLastCall < 0 ||
+            (maxing && timeSinceLastInvoke >= maxWait));
+    }
+    function timerExpired() {
+        var time = now$1();
+        if (shouldInvoke(time)) {
+            return trailingEdge(time);
+        }
+        // Restart the timer.
+        timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+    function trailingEdge(time) {
+        timerId = undefined;
+        // Only invoke if we have `lastArgs` which means `func` has been
+        // debounced at least once.
+        if (trailing && lastArgs) {
+            return invokeFunc(time);
+        }
+        lastArgs = lastThis = undefined;
+        return result;
+    }
+    function cancel() {
+        if (timerId !== undefined) {
+            clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+    function flush() {
+        return timerId === undefined ? result : trailingEdge(now$1());
+    }
+    function debounced() {
+        var time = now$1(), isInvoking = shouldInvoke(time);
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+            if (timerId === undefined) {
+                return leadingEdge(lastCallTime);
+            }
+            if (maxing) {
+                // Handle invocations in a tight loop.
+                timerId = setTimeout(timerExpired, wait);
+                return invokeFunc(lastCallTime);
+            }
+        }
+        if (timerId === undefined) {
+            timerId = setTimeout(timerExpired, wait);
+        }
+        return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+}
+/**
+ * Creates a throttled function that only invokes `func` at most once per
+ * every `wait` milliseconds. The throttled function comes with a `cancel`
+ * method to cancel delayed `func` invocations and a `flush` method to
+ * immediately invoke them. Provide `options` to indicate whether `func`
+ * should be invoked on the leading and/or trailing edge of the `wait`
+ * timeout. The `func` is invoked with the last arguments provided to the
+ * throttled function. Subsequent calls to the throttled function return the
+ * result of the last `func` invocation.
+ *
+ * **Note:** If `leading` and `trailing` options are `true`, `func` is
+ * invoked on the trailing edge of the timeout only if the throttled function
+ * is invoked more than once during the `wait` timeout.
+ *
+ * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+ * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+ *
+ * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+ * for details over the differences between `_.throttle` and `_.debounce`.
+ *
+ * @internal
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to throttle.
+ * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
+ * @param {Object} [options={}] The options object.
+ * @param {boolean} [options.leading=true]
+ *  Specify invoking on the leading edge of the timeout.
+ * @param {boolean} [options.trailing=true]
+ *  Specify invoking on the trailing edge of the timeout.
+ * @returns {Function} Returns the new throttled function.
+ * @example
+ *
+ * // Avoid excessively updating the position while scrolling.
+ * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
+ *
+ * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
+ * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
+ * jQuery(element).on('click', throttled);
+ *
+ * // Cancel the trailing throttled invocation.
+ * jQuery(window).on('popstate', throttled.cancel);
+ */
+function throttle(func, wait, options) {
+    var leading = true, trailing = true;
+    if (typeof func != 'function') {
+        throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    if (isObject(options)) {
+        leading = 'leading' in options ? !!options.leading : leading;
+        trailing = 'trailing' in options ? !!options.trailing : trailing;
+    }
+    return debounce(func, wait, {
+        leading: leading,
+        maxWait: wait,
+        trailing: trailing,
+    });
+}
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+    var type = typeof value;
+    return !!value && (type == 'object' || type == 'function');
+}
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+    return !!value && typeof value == 'object';
+}
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+    return (typeof value == 'symbol' ||
+        (isObjectLike(value) && objectToString.call(value) == symbolTag));
+}
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+    if (typeof value == 'number') {
+        return value;
+    }
+    if (isSymbol(value)) {
+        return NAN;
+    }
+    if (isObject(value)) {
+        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+        value = isObject(other) ? other + '' : other;
+    }
+    if (typeof value != 'string') {
+        return value === 0 ? value : +value;
+    }
+    value = value.replace(reTrim, '');
+    var isBinary = reIsBinary.test(value);
+    return isBinary || reIsOctal.test(value)
+        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+        : reIsBadHex.test(value)
+            ? NAN
+            : +value;
+}
+
+/**
+ * @license
+ * time.ts
+ * util
+ *
+ * Created by Rygor Kharytanovich <rygor@monterosa.co.uk> on 2025-03-24
+ * Copyright © 2025 Monterosa. All rights reserved.
+ *
+ * More details on the license can be found at https://www.monterosa.co/sdk/license
+ */
+var emitter = new Emitter();
+var serverTimestamp = 0;
+var lastTickTimestamp = 0;
+var tickTimeoutId;
+/**
+ * Returns local timestamp in seconds
+ */
+function getCurrentTimestamp() {
+    return Date.now() / 1000;
+}
+/**
+ * Normalizes the timestamp to reduce fluctuations due to `setTimeout` delays.
+ * Ensures the fractional part is around 0.5 to avoid skipping a second.
+ *
+ * Returns half-second timestamp. It is used to be sure that timestamp will not
+ * fluctuate more than in 1 second after each tick due to longer delays.
+ * https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified
+ *
+ * For example if the initial timestamp has a fractional part 0.9999 then with
+ * the setTimeout (tick) longer than specified we might jump over a one second.
+ * Lets imaging setTimeout took 1.0002 second, then our timestamp will be 2.0001.
+ * Thats why we are trying to keep fractional part in the middle of the second.
+ */
+function getMiddleTimestamp(timestamp) {
+    return Math.floor(timestamp) + 0.5;
+}
+/**
+ * Calculates the delay for the next tick to keep timestamps stable.
+ */
+function calculateNextTickDelay() {
+    var expectedNextTick = getMiddleTimestamp(serverTimestamp) + 1;
+    return (expectedNextTick - serverTimestamp) * 1000;
+}
+/**
+ * Main function that maintains current timestamp
+ */
+function tick() {
+    clearTimeout(tickTimeoutId);
+    var currentTimestamp = getCurrentTimestamp();
+    var timeSinceLastTick = currentTimestamp - lastTickTimestamp;
+    serverTimestamp += timeSinceLastTick;
+    lastTickTimestamp = currentTimestamp;
+    tickTimeoutId = setTimeout(tick, calculateNextTickDelay());
+    emitter.emit('tick', serverTimestamp);
+}
+/**
+ * @internal
+ *
+ * Sets or updates current timestamp
+ *
+ * @param timestamp - Current timestamp in seconds
+ */
+function setTimestamp(timestamp) {
+    lastTickTimestamp = getCurrentTimestamp();
+    serverTimestamp = getMiddleTimestamp(timestamp);
+}
+/**
+ * Returns current timestamp that is preserved by `tick()` function
+ *
+ * @returns Current timestamp in seconds
+ */
+function now() {
+    return Math.floor(serverTimestamp);
+}
+/**
+ * Subscribes listener to the timestamp increment
+ *
+ * @param callback - A handler that executes when the timestamp is incremented
+ *
+ * @returns A function that unsubscribes the listener
+ */
+function onTick(callback) {
+    return subscribe(emitter, 'tick', callback);
+}
+// Initially timestamp is set based on a local date
+// Later on it can be overriden outside at any moment
+// in our case it is populated with the server timestamp
+// which comes from Enmasse session handshake message
+setTimestamp(getCurrentTimestamp());
+// Kicking in timestamp maintaining
+tick();
+
+export { Emitter, MonterosaError, checkAvailability, clear, createError, delay, getGlobal, getItem, getKey, memoizePromise, now, onTick, removeItem, setItem, setTimestamp, subscribe, throttle, tick };
+//# sourceMappingURL=index.esm5.js.map