first commit

frontend/node_modules/throttle-debounce/CHANGELOG.md

@@ -0,0 +1,97 @@
+# Changelog
+
+## [Unreleased][]
+
+## [5.0.2][] - 2024-06-24
+
+### Fixed
+
+-   Pin karma-webpack to specific version to prevent errors in Node 12
+
+## [5.0.1][] - 2024-06-24
+
+### Changed
+
+-   License to single license (MIT)
+
+## [5.0.0][] - 2022-05-02
+
+### Changed
+
+-   **Breaking**: The optional argument `atBegin` of debounce is now a part of
+    options object instead of a function argument so that debounce API is
+    normalized with throttle API.
+
+### Added
+
+-   Option to cancel only upcoming invocation
+    ([#44](https://github.com/niksy/throttle-debounce/pull/44))
+
+## [4.0.1][] - 2022-04-15
+
+### Fixed
+
+-   Throttle invocation with
+    `{ noLeading: true, noTrailing: true }`([#55](https://github.com/niksy/throttle-debounce/pull/55))
+
+### Added
+
+-   Support for running non-BrowserStack tests (headless browsers tests) in CI
+
+## [4.0.0][] - 2022-04-11
+
+### Changed
+
+-   **Breaking**: Updated browser support, check
+    [Browserslist configuration](https://browserslist.dev/?q=bGFzdCAzIG1ham9yIHZlcnNpb25zLCBzaW5jZSAyMDE5LCBlZGdlID49IDE1LCBub3QgaWUgPiAw)
+-   **Breaking**: All additional options such as `noLeading`, `noTrailing` and
+    `debounceMode` are now part of options object instead of function arguments
+-   Upgrade package
+
+## [3.0.1][] - 2020-11-02
+
+### Fixed
+
+-   Accessing `package.json` being restricted since it’s no longer exported
+    ([#43](https://github.com/niksy/throttle-debounce/pull/43))
+
+## [3.0.0][] - 2020-10-28
+
+### Changed
+
+-   Avoid having bundles like Webpack load the UMD module
+    ([#42](https://github.com/niksy/throttle-debounce/pull/42))
+-   Upgrade package
+
+### Removed
+
+-   **Breaking**: Drop Node 8 support, package is no longer tested against it,
+    but it should still work since there are no code changes
+
+## [2.3.0][] - 2020-08-12
+
+### Added
+
+-   Support for UMD package
+    ([#41](https://github.com/niksy/throttle-debounce/pull/41))
+
+## [2.2.1][] - 2020-06-08
+
+### Changed
+
+-   Upgrade package
+-   Add Browserstack testing
+-   Add more detailed usage example to README
+    ([#36](https://github.com/niksy/throttle-debounce/pull/36))
+-   Use ES2015+ features
+
+[2.2.1]: https://github.com/niksy/throttle-debounce/tree/v2.2.1
+[2.3.0]: https://github.com/niksy/throttle-debounce/tree/v2.3.0
+[3.0.0]: https://github.com/niksy/throttle-debounce/tree/v3.0.0
+[3.0.1]: https://github.com/niksy/throttle-debounce/tree/v3.0.1
+[4.0.0]: https://github.com/niksy/throttle-debounce/tree/v4.0.0
+[4.0.1]: https://github.com/niksy/throttle-debounce/tree/v4.0.1
+[5.0.0]: https://github.com/niksy/throttle-debounce/tree/v5.0.0
+[Unreleased]: https://github.com/niksy/throttle-debounce/compare/v5.0.2...HEAD
+[5.0.2]: https://github.com/niksy/throttle-debounce/compare/v5.0.1...v5.0.2
+[5.0.1]: https://github.com/niksy/throttle-debounce/tree/v5.0.1

frontend/node_modules/throttle-debounce/LICENSE.md

@@ -0,0 +1,45 @@
+Copyright (c) Ivan Nikolić <http://ivannikolic.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---
+
+Copyright (c) 2010 "Cowboy" Ben Alman
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+

frontend/node_modules/throttle-debounce/README.md

@@ -0,0 +1,245 @@
+# throttle-debounce
+
+[![Build Status][ci-img]][ci]
+[![BrowserStack Status][browserstack-img]][browserstack]
+[![Mentioned in Awesome Micro npm Packages][awesome-img]][awesome]
+
+Throttle and debounce functions.
+
+This module is the same as [jquery-throttle-debounce][jquery-throttle-debounce]
+([with some differences](#differences-with-original-module)), but it’s
+transferred to ES Modules and CommonJS format.
+
+## Install
+
+```sh
+npm install throttle-debounce --save
+```
+
+## Usage
+
+### `throttle`
+
+```js
+import { throttle } from 'throttle-debounce';
+
+const throttleFunc = throttle(
+	1000,
+	(num) => {
+		console.log('num:', num);
+	},
+	{ noLeading: false, noTrailing: false }
+);
+
+// Can also be used like this, because noLeading and noTrailing are false by default
+const throttleFunc = throttle(1000, (num) => {
+	console.log('num:', num);
+});
+
+throttleFunc(1); // Will execute the callback
+throttleFunc(2); // Won’t execute callback
+throttleFunc(3); // Won’t execute callback
+
+// Will execute the callback, because noTrailing is false,
+// but if we set noTrailing to true, this callback won’t be executed
+throttleFunc(4);
+
+setTimeout(() => {
+	throttleFunc(10); // Will execute the callback
+}, 1200);
+
+// Output
+// num: 1
+// num: 4
+// num: 10
+```
+
+### `debounce`
+
+```js
+import { debounce } from 'throttle-debounce';
+
+const debounceFunc = debounce(
+	1000,
+	(num) => {
+		console.log('num:', num);
+	},
+	{ atBegin: false }
+);
+
+// Can also be used like this, because atBegin is false by default
+const debounceFunc = debounce(1000, (num) => {
+	console.log('num:', num);
+});
+
+// Won’t execute the callback, because atBegin is false,
+// but if we set atBegin to true, this callback will be executed.
+debounceFunc(1);
+
+debounceFunc(2); // Won’t execute callback
+debounceFunc(3); // Won’t execute callback
+
+// Will execute the callback,
+// but if we set atBegin to true, this callback won’t be executed.
+debounceFunc(4);
+
+setTimeout(() => {
+	debounceFunc(10); // Will execute the callback
+}, 1200);
+
+// Output
+// num: 4
+// num: 10
+```
+
+### Cancelling
+
+Debounce and throttle can both be cancelled by calling the `cancel` function.
+
+```js
+const throttleFunc = throttle(300, () => {
+	// Throttled function
+});
+
+throttleFunc.cancel();
+
+const debounceFunc = debounce(300, () => {
+	// Debounced function
+});
+
+debounceFunc.cancel();
+```
+
+The logic that is being throttled or debounced will no longer be called.
+
+To cancel only one upcoming debounced call, you can pass `upcomingOnly: true`
+option to `cancel` function:
+
+```js
+const debounceFunc = debounce(300, () => {
+	// Debounced function
+});
+
+debounceFunc(); // will not be invoked
+
+debounceFunc.cancel({ upcomingOnly: true });
+
+debounceFunc(); // will be invoked
+```
+
+## API
+
+### throttle(delay, callback, { noLeading, noTrailing, debounceMode })
+
+Returns: `Function`
+
+Throttle execution of a function. Especially useful for rate limiting execution
+of handlers on events like resize and scroll.
+
+#### delay
+
+Type: `Number`
+
+A zero-or-greater delay in milliseconds. For event callbacks, values around 100
+or 250 (or even higher) are most useful.
+
+#### callback
+
+Type: `Function`
+
+A function to be executed after delay milliseconds. The `this` context and all
+arguments are passed through, as-is, to `callback` when the throttled-function
+is executed.
+
+#### noTrailing
+
+Type: `Boolean`
+
+Optional, defaults to false. If noTrailing is true, callback will only execute
+every `delay` milliseconds while the throttled-function is being called. If
+noTrailing is false or unspecified, callback will be executed one final time
+after the last throttled-function call. (After the throttled-function has not
+been called for `delay` milliseconds, the internal counter is reset)
+
+#### noLeading
+
+Type: `Boolean`
+
+Optional, defaults to false. If noLeading is false, the first throttled-function
+call will execute callback immediately. If noLeading is true, the first the
+callback execution will be skipped. It should be noted that callback will never
+executed if both noLeading = true and noTrailing = true.
+
+#### debounceMode
+
+Type: `Boolean`
+
+If `debounceMode` is true (at begin), schedule `clear` to execute after `delay`
+ms. If `debounceMode` is false (at end), schedule `callback` to execute after
+`delay` ms.
+
+### debounce(delay, callback, { atBegin })
+
+Returns: `Function`
+
+Debounce execution of a function. Debouncing, unlike throttling, guarantees that
+a function is only executed a single time, either at the very beginning of a
+series of calls, or at the very end.
+
+#### delay
+
+Type: `Number`
+
+A zero-or-greater delay in milliseconds. For event callbacks, values around 100
+or 250 (or even higher) are most useful.
+
+#### callback
+
+Type: `Function`
+
+A function to be executed after delay milliseconds. The `this` context and all
+arguments are passed through, as-is, to `callback` when the debounced-function
+is executed.
+
+#### atBegin
+
+Type: `Boolean`
+
+Optional, defaults to false. If `atBegin` is false or unspecified, callback will
+only be executed `delay` milliseconds after the last debounced-function call. If
+`atBegin` is true, callback will be executed only at the first
+debounced-function call. (After the throttled-function has not been called for
+`delay` milliseconds, the internal counter is reset).
+
+## Differences with original module
+
+-   Dependancy on jQuery is removed, so if you rely on GUIDs set by jQuery, plan
+    accordingly
+-   There is no standalone version available, so don’t rely on `$.throttle` and
+    `$.debounce` to be available
+
+## Browser support
+
+Tested in Chrome 72, Edge 15, Firefox 65 and should work in all modern browsers
+([support based on Browserslist configuration](https://browserslist.dev/?q=bGFzdCAzIG1ham9yIHZlcnNpb25zLCBzaW5jZSAyMDE5LCBlZGdlID49IDE1LCBub3QgaWUgPiAw)).
+
+## Test
+
+For automated tests, run `npm run test:automated` (append `:watch` for watcher
+support).
+
+## License
+
+<!-- prettier-ignore-start -->
+
+MIT © [Ivan Nikolić](http://ivannikolic.com)
+
+[ci]: https://github.com/niksy/throttle-debounce/actions?query=workflow%3ACI
+[ci-img]: https://github.com/niksy/throttle-debounce/actions/workflows/ci.yml/badge.svg?branch=master
+[browserstack]: https://www.browserstack.com/
+[browserstack-img]: https://img.shields.io/badge/browser%20testing-BrowserStack-informational?logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NCA2NCI+CiAgPGRlZnMvPgogIDxyYWRpYWxHcmFkaWVudCBpZD0iYSIgY3g9IjIwLjk0Mjk3NiIgY3k9IjI4LjA5NDY3ODczIiByPSIzLjc5MTM0MTQxIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+CiAgICA8c3RvcCBvZmZzZXQ9IjAiIHN0b3AtY29sb3I9IiM3OTc5NzkiLz4KICAgIDxzdG9wIG9mZnNldD0iMSIgc3RvcC1jb2xvcj0iIzRjNGM0YyIvPgogIDwvcmFkaWFsR3JhZGllbnQ+CiAgPGcgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTI5LjcyOTIwNCAtNTcuMTg3NjExKSBzY2FsZSgyLjk3MjkyKSI+CiAgICA8Y2lyY2xlIGN4PSIyMC43ODkiIGN5PSIzMC4wMjUiIHI9IjEwLjczOSIgZmlsbD0iI2Y0Yjk2MCIvPgogICAgPGNpcmNsZSBjeD0iMTkuNyIgY3k9IjI4LjkzNiIgcj0iOS43IiBmaWxsPSIjZTY2ZjMyIi8+CiAgICA8Y2lyY2xlIGN4PSIyMS4wMzYiIGN5PSIyNy42OTkiIHI9IjguNDEzIiBmaWxsPSIjZTQzYzQxIi8+CiAgICA8Y2lyY2xlIGN4PSIyMS42NzkiIGN5PSIyOC4zNDIiIHI9IjcuNzIiIGZpbGw9IiNiZGQwNDEiLz4KICAgIDxjaXJjbGUgY3g9IjIxLjEzNSIgY3k9IjI4LjkzNiIgcj0iNy4xNzYiIGZpbGw9IiM2ZGI1NGMiLz4KICAgIDxjaXJjbGUgY3g9IjE5Ljk5NyIgY3k9IjI3Ljc0OCIgcj0iNS45ODgiIGZpbGw9IiNhZWRhZTYiLz4KICAgIDxjaXJjbGUgY3g9IjIwLjkzNyIgY3k9IjI2Ljc1OCIgcj0iNS4wNDgiIGZpbGw9IiM1NmI4ZGUiLz4KICAgIDxjaXJjbGUgY3g9IjIxLjU4IiBjeT0iMjcuNDUxIiByPSI0LjQwNSIgZmlsbD0iIzAwYjFkNSIvPgogICAgPGNpcmNsZSBjeD0iMjAuOTM3IiBjeT0iMjguMDQ1IiByPSIzLjc2MSIgZmlsbD0idXJsKCNhKSIvPgogICAgPGNpcmNsZSBjeD0iMjAuOTM3IiBjeT0iMjguMDQ1IiByPSIzLjc2MSIgZmlsbD0iIzIyMWYxZiIvPgogICAgPGVsbGlwc2UgY3g9Ii0xNS4xNTkiIGN5PSIzMS40MDEiIGZpbGw9IiNmZmYiIHJ4PSIxLjE4OCIgcnk9Ii43NDIiIHRyYW5zZm9ybT0icm90YXRlKC02NS44MzQpIi8+CiAgPC9nPgo8L3N2Zz4K
+[awesome]: https://github.com/parro-it/awesome-micro-npm-packages
+[awesome-img]: https://awesome.re/mentioned-badge.svg
+[jquery-throttle-debounce]: https://github.com/cowboy/jquery-throttle-debounce
+
+<!-- prettier-ignore-end -->

frontend/node_modules/throttle-debounce/cjs/index.js

@@ -0,0 +1,167 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable no-undefined,no-param-reassign,no-shadow */
+
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Function} A new, throttled, function.
+ */
+function throttle (delay, callback, options) {
+  var _ref = options || {},
+    _ref$noTrailing = _ref.noTrailing,
+    noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,
+    _ref$noLeading = _ref.noLeading,
+    noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,
+    _ref$debounceMode = _ref.debounceMode,
+    debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;
+  /*
+   * After wrapper has stopped being called, this timeout ensures that
+   * `callback` is executed at the proper times in `throttle` and `end`
+   * debounce modes.
+   */
+  var timeoutID;
+  var cancelled = false;
+
+  // Keep track of the last time `callback` was executed.
+  var lastExec = 0;
+
+  // Function to clear existing timeout
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  }
+
+  // Function to cancel next exec
+  function cancel(options) {
+    var _ref2 = options || {},
+      _ref2$upcomingOnly = _ref2.upcomingOnly,
+      upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+    clearExistingTimeout();
+    cancelled = !upcomingOnly;
+  }
+
+  /*
+   * The `wrapper` function encapsulates all of the throttling / debouncing
+   * functionality and when executed will limit the rate at which `callback`
+   * is executed.
+   */
+  function wrapper() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+    if (cancelled) {
+      return;
+    }
+
+    // Execute `callback` and update the `lastExec` timestamp.
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, arguments_);
+    }
+
+    /*
+     * If `debounceMode` is true (at begin) this is used to clear the flag
+     * to allow future `callback` executions.
+     */
+    function clear() {
+      timeoutID = undefined;
+    }
+    if (!noLeading && debounceMode && !timeoutID) {
+      /*
+       * Since `wrapper` is being called for the first time and
+       * `debounceMode` is true (at begin), execute `callback`
+       * and noLeading != true.
+       */
+      exec();
+    }
+    clearExistingTimeout();
+    if (debounceMode === undefined && elapsed > delay) {
+      if (noLeading) {
+        /*
+         * In throttle mode with noLeading, if `delay` time has
+         * been exceeded, update `lastExec` and schedule `callback`
+         * to execute after `delay` ms.
+         */
+        lastExec = Date.now();
+        if (!noTrailing) {
+          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+        }
+      } else {
+        /*
+         * In throttle mode without noLeading, if `delay` time has been exceeded, execute
+         * `callback`.
+         */
+        exec();
+      }
+    } else if (noTrailing !== true) {
+      /*
+       * In trailing throttle mode, since `delay` time has not been
+       * exceeded, schedule `callback` to execute `delay` ms after most
+       * recent execution.
+       *
+       * If `debounceMode` is true (at begin), schedule `clear` to execute
+       * after `delay` ms.
+       *
+       * If `debounceMode` is false (at end), schedule `callback` to
+       * execute after `delay` ms.
+       */
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+    }
+  }
+  wrapper.cancel = cancel;
+
+  // Return the wrapper function.
+  return wrapper;
+}
+
+/* eslint-disable no-undefined */
+
+/**
+ * Debounce execution of a function. Debouncing, unlike throttling,
+ * guarantees that a function is only executed a single time, either at the
+ * very beginning of a series of calls, or at the very end.
+ *
+ * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param {Function} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                        to `callback` when the debounced-function is executed.
+ * @param {object} [options] -           An object to configure options.
+ * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+ *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+ *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+ *
+ * @returns {Function} A new, debounced function.
+ */
+function debounce (delay, callback, options) {
+  var _ref = options || {},
+    _ref$atBegin = _ref.atBegin,
+    atBegin = _ref$atBegin === void 0 ? false : _ref$atBegin;
+  return throttle(delay, callback, {
+    debounceMode: atBegin !== false
+  });
+}
+
+exports.debounce = debounce;
+exports.throttle = throttle;
+//# sourceMappingURL=index.js.map

frontend/node_modules/throttle-debounce/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

frontend/node_modules/throttle-debounce/esm/index.js

@@ -0,0 +1,162 @@
+/* eslint-disable no-undefined,no-param-reassign,no-shadow */
+
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Function} A new, throttled, function.
+ */
+function throttle (delay, callback, options) {
+  var _ref = options || {},
+    _ref$noTrailing = _ref.noTrailing,
+    noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,
+    _ref$noLeading = _ref.noLeading,
+    noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,
+    _ref$debounceMode = _ref.debounceMode,
+    debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;
+  /*
+   * After wrapper has stopped being called, this timeout ensures that
+   * `callback` is executed at the proper times in `throttle` and `end`
+   * debounce modes.
+   */
+  var timeoutID;
+  var cancelled = false;
+
+  // Keep track of the last time `callback` was executed.
+  var lastExec = 0;
+
+  // Function to clear existing timeout
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  }
+
+  // Function to cancel next exec
+  function cancel(options) {
+    var _ref2 = options || {},
+      _ref2$upcomingOnly = _ref2.upcomingOnly,
+      upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+    clearExistingTimeout();
+    cancelled = !upcomingOnly;
+  }
+
+  /*
+   * The `wrapper` function encapsulates all of the throttling / debouncing
+   * functionality and when executed will limit the rate at which `callback`
+   * is executed.
+   */
+  function wrapper() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+    if (cancelled) {
+      return;
+    }
+
+    // Execute `callback` and update the `lastExec` timestamp.
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, arguments_);
+    }
+
+    /*
+     * If `debounceMode` is true (at begin) this is used to clear the flag
+     * to allow future `callback` executions.
+     */
+    function clear() {
+      timeoutID = undefined;
+    }
+    if (!noLeading && debounceMode && !timeoutID) {
+      /*
+       * Since `wrapper` is being called for the first time and
+       * `debounceMode` is true (at begin), execute `callback`
+       * and noLeading != true.
+       */
+      exec();
+    }
+    clearExistingTimeout();
+    if (debounceMode === undefined && elapsed > delay) {
+      if (noLeading) {
+        /*
+         * In throttle mode with noLeading, if `delay` time has
+         * been exceeded, update `lastExec` and schedule `callback`
+         * to execute after `delay` ms.
+         */
+        lastExec = Date.now();
+        if (!noTrailing) {
+          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+        }
+      } else {
+        /*
+         * In throttle mode without noLeading, if `delay` time has been exceeded, execute
+         * `callback`.
+         */
+        exec();
+      }
+    } else if (noTrailing !== true) {
+      /*
+       * In trailing throttle mode, since `delay` time has not been
+       * exceeded, schedule `callback` to execute `delay` ms after most
+       * recent execution.
+       *
+       * If `debounceMode` is true (at begin), schedule `clear` to execute
+       * after `delay` ms.
+       *
+       * If `debounceMode` is false (at end), schedule `callback` to
+       * execute after `delay` ms.
+       */
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+    }
+  }
+  wrapper.cancel = cancel;
+
+  // Return the wrapper function.
+  return wrapper;
+}
+
+/* eslint-disable no-undefined */
+
+/**
+ * Debounce execution of a function. Debouncing, unlike throttling,
+ * guarantees that a function is only executed a single time, either at the
+ * very beginning of a series of calls, or at the very end.
+ *
+ * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param {Function} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                        to `callback` when the debounced-function is executed.
+ * @param {object} [options] -           An object to configure options.
+ * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+ *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+ *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+ *
+ * @returns {Function} A new, debounced function.
+ */
+function debounce (delay, callback, options) {
+  var _ref = options || {},
+    _ref$atBegin = _ref.atBegin,
+    atBegin = _ref$atBegin === void 0 ? false : _ref$atBegin;
+  return throttle(delay, callback, {
+    debounceMode: atBegin !== false
+  });
+}
+
+export { debounce, throttle };
+//# sourceMappingURL=index.js.map

frontend/node_modules/throttle-debounce/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

frontend/node_modules/throttle-debounce/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "throttle-debounce",
+  "version": "5.0.2",
+  "description": "Throttle and debounce functions.",
+  "license": "MIT",
+  "author": "Ivan Nikolić <niksy5@gmail.com> (http://ivannikolic.com)",
+  "contributors": [
+    "Ben Alman (http://benalman.com)"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "cjs/index.js",
+  "jsdelivr": "umd/index.js",
+  "unpkg": "umd/index.js",
+  "module": "esm/index.js",
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "umd/",
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup --config rollup.config.js",
+    "lint": "eslint '{index,debounce,throttle,test/**/*}.js'",
+    "module-check": "node -e 'require(\"throttle-debounce\");' && node --input-type=module -e 'import \"throttle-debounce\";'",
+    "prepublishOnly": "npm run build",
+    "postpublish": "GITHUB_TOKEN=$GITHUB_RELEASE_TOKEN github-release-from-changelog",
+    "release": "np --no-release-draft",
+    "test": "npm run test:automated",
+    "test:automated": "BABEL_ENV=test karma start",
+    "test:automated:watch": "npm run test:automated -- --auto-watch --no-single-run",
+    "version": "if [ $(git rev-parse --abbrev-ref HEAD) == 'master' ]; then sed -i '' '/\\[unreleased\\]:/d' CHANGELOG.md && version-changelog CHANGELOG.md && changelog-verify CHANGELOG.md && git add CHANGELOG.md; else echo; fi",
+    "prerelease": "npm run lint && npm run build && npm run module-check"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.2.3",
+    "@babel/core": "^7.2.2",
+    "@babel/plugin-transform-runtime": "^7.2.0",
+    "@babel/preset-env": "^7.12.1",
+    "@babel/runtime": "^7.2.0",
+    "@rollup/plugin-babel": "^5.2.1",
+    "babel-loader": "^8.1.0",
+    "changelog-verify": "^1.1.2",
+    "core-js": "^2.6.5",
+    "eslint": "^8.5.0",
+    "eslint-config-nitpick": "^11.1.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "esm": "^3.0.51",
+    "get-port": "^4.0.0",
+    "get-port-cli": "^2.0.0",
+    "github-release-from-changelog": "^2.1.1",
+    "husky": "^4.3.0",
+    "karma": "^5.2.3",
+    "karma-browserstack-launcher": "^1.6.0",
+    "karma-chrome-launcher": "^3.1.0",
+    "karma-firefox-launcher": "^0.1.7",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-qunit": "^0.1.9",
+    "karma-sourcemap-loader": "^0.3.7",
+    "karma-webpack": "5.0.0",
+    "lint-staged": "^10.4.2",
+    "minimist": "^1.2.0",
+    "node-stdlib-browser": "^1.2.0",
+    "np": "^7.6.0",
+    "prettier": "^2.4.0",
+    "qunitjs": "^1.23.1",
+    "rollup": "^2.32.1",
+    "version-changelog": "^3.1.1",
+    "webpack": "^5.2.0"
+  },
+  "engines": {
+    "node": ">=12.22"
+  },
+  "keywords": [
+    "debounce",
+    "throttle"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/niksy/throttle-debounce.git"
+  },
+  "bugs": {
+    "url": "https://github.com/niksy/throttle-debounce/issues"
+  },
+  "homepage": "https://github.com/niksy/throttle-debounce#readme"
+}

frontend/node_modules/throttle-debounce/umd/index.js

@@ -0,0 +1,173 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.throttleDebounce = {}));
+})(this, (function (exports) { 'use strict';
+
+	/* eslint-disable no-undefined,no-param-reassign,no-shadow */
+
+	/**
+	 * Throttle execution of a function. Especially useful for rate limiting
+	 * execution of handlers on events like resize and scroll.
+	 *
+	 * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+	 *                                            are most useful.
+	 * @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+	 *                                            as-is, to `callback` when the throttled-function is executed.
+	 * @param {object} [options] -              An object to configure options.
+	 * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+	 *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+	 *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+	 *                                            `delay` milliseconds, the internal counter is reset).
+	 * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+	 *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+	 *                                            callback will never executed if both noLeading = true and noTrailing = true.
+	 * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+	 *                                            false (at end), schedule `callback` to execute after `delay` ms.
+	 *
+	 * @returns {Function} A new, throttled, function.
+	 */
+	function throttle (delay, callback, options) {
+	  var _ref = options || {},
+	    _ref$noTrailing = _ref.noTrailing,
+	    noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,
+	    _ref$noLeading = _ref.noLeading,
+	    noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,
+	    _ref$debounceMode = _ref.debounceMode,
+	    debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;
+	  /*
+	   * After wrapper has stopped being called, this timeout ensures that
+	   * `callback` is executed at the proper times in `throttle` and `end`
+	   * debounce modes.
+	   */
+	  var timeoutID;
+	  var cancelled = false;
+
+	  // Keep track of the last time `callback` was executed.
+	  var lastExec = 0;
+
+	  // Function to clear existing timeout
+	  function clearExistingTimeout() {
+	    if (timeoutID) {
+	      clearTimeout(timeoutID);
+	    }
+	  }
+
+	  // Function to cancel next exec
+	  function cancel(options) {
+	    var _ref2 = options || {},
+	      _ref2$upcomingOnly = _ref2.upcomingOnly,
+	      upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+	    clearExistingTimeout();
+	    cancelled = !upcomingOnly;
+	  }
+
+	  /*
+	   * The `wrapper` function encapsulates all of the throttling / debouncing
+	   * functionality and when executed will limit the rate at which `callback`
+	   * is executed.
+	   */
+	  function wrapper() {
+	    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+	      arguments_[_key] = arguments[_key];
+	    }
+	    var self = this;
+	    var elapsed = Date.now() - lastExec;
+	    if (cancelled) {
+	      return;
+	    }
+
+	    // Execute `callback` and update the `lastExec` timestamp.
+	    function exec() {
+	      lastExec = Date.now();
+	      callback.apply(self, arguments_);
+	    }
+
+	    /*
+	     * If `debounceMode` is true (at begin) this is used to clear the flag
+	     * to allow future `callback` executions.
+	     */
+	    function clear() {
+	      timeoutID = undefined;
+	    }
+	    if (!noLeading && debounceMode && !timeoutID) {
+	      /*
+	       * Since `wrapper` is being called for the first time and
+	       * `debounceMode` is true (at begin), execute `callback`
+	       * and noLeading != true.
+	       */
+	      exec();
+	    }
+	    clearExistingTimeout();
+	    if (debounceMode === undefined && elapsed > delay) {
+	      if (noLeading) {
+	        /*
+	         * In throttle mode with noLeading, if `delay` time has
+	         * been exceeded, update `lastExec` and schedule `callback`
+	         * to execute after `delay` ms.
+	         */
+	        lastExec = Date.now();
+	        if (!noTrailing) {
+	          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+	        }
+	      } else {
+	        /*
+	         * In throttle mode without noLeading, if `delay` time has been exceeded, execute
+	         * `callback`.
+	         */
+	        exec();
+	      }
+	    } else if (noTrailing !== true) {
+	      /*
+	       * In trailing throttle mode, since `delay` time has not been
+	       * exceeded, schedule `callback` to execute `delay` ms after most
+	       * recent execution.
+	       *
+	       * If `debounceMode` is true (at begin), schedule `clear` to execute
+	       * after `delay` ms.
+	       *
+	       * If `debounceMode` is false (at end), schedule `callback` to
+	       * execute after `delay` ms.
+	       */
+	      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+	    }
+	  }
+	  wrapper.cancel = cancel;
+
+	  // Return the wrapper function.
+	  return wrapper;
+	}
+
+	/* eslint-disable no-undefined */
+
+	/**
+	 * Debounce execution of a function. Debouncing, unlike throttling,
+	 * guarantees that a function is only executed a single time, either at the
+	 * very beginning of a series of calls, or at the very end.
+	 *
+	 * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+	 * @param {Function} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+	 *                                        to `callback` when the debounced-function is executed.
+	 * @param {object} [options] -           An object to configure options.
+	 * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+	 *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+	 *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+	 *
+	 * @returns {Function} A new, debounced function.
+	 */
+	function debounce (delay, callback, options) {
+	  var _ref = options || {},
+	    _ref$atBegin = _ref.atBegin,
+	    atBegin = _ref$atBegin === void 0 ? false : _ref$atBegin;
+	  return throttle(delay, callback, {
+	    debounceMode: atBegin !== false
+	  });
+	}
+
+	exports.debounce = debounce;
+	exports.throttle = throttle;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.js.map

frontend/node_modules/throttle-debounce/umd/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}