@nice2dev/ui-graphics 1.3.14 → 1.3.16

package/dist/esm/node_modules/lib0/map.js

@@ -1,101 +1,37 @@
-/**
- * Utility module to work with key-value stores.
- *
- * @module map
- */
-
-/**
- * @template K
- * @template V
- * @typedef {Map<K,V>} GlobalMap
- */
-
-/**
- * Creates a new Map instance.
- *
- * @function
- * @return {Map<any, any>}
- *
- * @function
- */
-const create = () => new Map();
-
-/**
- * Copy a Map object into a fresh Map object.
- *
- * @function
- * @template K,V
- * @param {Map<K,V>} m
- * @return {Map<K,V>}
- */
-const copy = m => {
+const create = () => /* @__PURE__ */ new Map();
+const copy = (m) => {
   const r = create();
-  m.forEach((v, k) => { r.set(k, v); });
-  return r
+  m.forEach((v, k) => {
+    r.set(k, v);
+  });
+  return r;
 };
-
-/**
- * Get map property. Create T if property is undefined and set T on map.
- *
- * ```js
- * const listeners = map.setIfUndefined(events, 'eventName', set.create)
- * listeners.add(listener)
- * ```
- *
- * @function
- * @template {Map<any, any>} MAP
- * @template {MAP extends Map<any,infer V> ? function():V : unknown} CF
- * @param {MAP} map
- * @param {MAP extends Map<infer K,any> ? K : unknown} key
- * @param {CF} createT
- * @return {ReturnType<CF>}
- */
-const setIfUndefined = (map, key, createT) => {
-  let set = map.get(key);
-  if (set === undefined) {
-    map.set(key, set = createT());
+const setIfUndefined = (map2, key, createT) => {
+  let set = map2.get(key);
+  if (set === void 0) {
+    map2.set(key, set = createT());
   }
-  return set
+  return set;
 };
-
-/**
- * Creates an Array and populates it with the content of all key-value pairs using the `f(value, key)` function.
- *
- * @function
- * @template K
- * @template V
- * @template R
- * @param {Map<K,V>} m
- * @param {function(V,K):R} f
- * @return {Array<R>}
- */
 const map = (m, f) => {
   const res = [];
   for (const [key, value] of m) {
     res.push(f(value, key));
   }
-  return res
+  return res;
 };
-
-/**
- * Tests whether any key-value pairs pass the test implemented by `f(value, key)`.
- *
- * @todo should rename to some - similarly to Array.some
- *
- * @function
- * @template K
- * @template V
- * @param {Map<K,V>} m
- * @param {function(V,K):boolean} f
- * @return {boolean}
- */
 const any = (m, f) => {
   for (const [key, value] of m) {
     if (f(value, key)) {
-      return true
+      return true;
     }
   }
-  return false
+  return false;
+};
+export {
+  any,
+  copy,
+  create,
+  map,
+  setIfUndefined
 };
-
-export { any, copy, create, map, setIfUndefined };

package/dist/esm/node_modules/lib0/math.js

@@ -1,36 +1,14 @@
-/**
- * Common Math expressions.
- *
- * @module math
- */
-
 const floor = Math.floor;
 const abs = Math.abs;
-
-/**
- * @function
- * @param {number} a
- * @param {number} b
- * @return {number} The smaller element of a and b
- */
 const min = (a, b) => a < b ? a : b;
-
-/**
- * @function
- * @param {number} a
- * @param {number} b
- * @return {number} The bigger element of a and b
- */
 const max = (a, b) => a > b ? a : b;
-
 const pow = Math.pow;
-
-/**
- * Check whether n is negative, while considering the -0 edge case. While `-0 < 0` is false, this
- * function returns true for -0,-1,,.. and returns false for 0,1,2,...
- * @param {number} n
- * @return {boolean} Wether n is negative. This function also distinguishes between -0 and +0
- */
-const isNegativeZero = n => n !== 0 ? n < 0 : 1 / n < 0;
-
-export { abs, floor, isNegativeZero, max, min, pow };
+const isNegativeZero = (n) => n !== 0 ? n < 0 : 1 / n < 0;
+export {
+  abs,
+  floor,
+  isNegativeZero,
+  max,
+  min,
+  pow
+};

package/dist/esm/node_modules/lib0/number.js

@@ -1,16 +1,9 @@
-import { floor } from './math.js';
-
-/**
- * Utility helpers for working with numbers.
- *
- * @module number
- */
-
-
+import { floor } from "./math.js";
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
-
-/* c8 ignore next */
-const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && floor(num) === num);
-
-export { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER, isInteger };
+const isInteger = Number.isInteger || ((num) => typeof num === "number" && isFinite(num) && floor(num) === num);
+export {
+  MAX_SAFE_INTEGER,
+  MIN_SAFE_INTEGER,
+  isInteger
+};

package/dist/esm/node_modules/lib0/object.js

@@ -1,118 +1,57 @@
-import { equals } from './trait/equality.js';
-
-/**
- * @param {any} o
- * @return {o is { [k:string]:any }}
- */
-const isObject = o => typeof o === 'object';
-
-/**
- * Object.assign
- */
+import { equals } from "./trait/equality.js";
+const isObject = (o) => typeof o === "object";
 const assign = Object.assign;
-
-/**
- * @param {Object<string,any>} obj
- */
 const keys = Object.keys;
-
-/**
- * @template V
- * @param {{[k:string]:V}} obj
- * @param {function(V,string):any} f
- */
 const forEach = (obj, f) => {
   for (const key in obj) {
     f(obj[key], key);
   }
 };
-
-/**
- * @todo implement mapToArray & map
- *
- * @template R
- * @param {Object<string,any>} obj
- * @param {function(any,string):R} f
- * @return {Array<R>}
- */
 const map = (obj, f) => {
   const results = [];
   for (const key in obj) {
     results.push(f(obj[key], key));
   }
-  return results
+  return results;
 };
-
-/**
- * @param {Object<string,any>} obj
- * @return {number}
- */
-const size = obj => keys(obj).length;
-
-/**
- * @param {Object|null|undefined} obj
- */
-const isEmpty = obj => {
-  // eslint-disable-next-line no-unreachable-loop
+const size = (obj) => keys(obj).length;
+const isEmpty = (obj) => {
   for (const _k in obj) {
-    return false
+    return false;
   }
-  return true
+  return true;
 };
-
-/**
- * @template {{ [key:string|number|symbol]: any }} T
- * @param {T} obj
- * @param {(v:T[keyof T],k:keyof T)=>boolean} f
- * @return {boolean}
- */
 const every = (obj, f) => {
   for (const key in obj) {
     if (!f(obj[key], key)) {
-      return false
+      return false;
     }
   }
-  return true
+  return true;
 };
-
-/**
- * Calls `Object.prototype.hasOwnProperty`.
- *
- * @param {any} obj
- * @param {string|number|symbol} key
- * @return {boolean}
- */
 const hasProperty = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-
-/**
- * @param {Object<string,any>} a
- * @param {Object<string,any>} b
- * @return {boolean}
- */
-const equalFlat = (a, b) => a === b || (size(a) === size(b) && every(a, (val, key) => (val !== undefined || hasProperty(b, key)) && equals(b[key], val)));
-
-/**
- * Make an object immutable. This hurts performance and is usually not needed if you perform good
- * coding practices.
- */
+const equalFlat = (a, b) => a === b || size(a) === size(b) && every(a, (val, key) => (val !== void 0 || hasProperty(b, key)) && equals(b[key], val));
 const freeze = Object.freeze;
-
-/**
- * Make an object and all its children immutable.
- * This *really* hurts performance and is usually not needed if you perform good coding practices.
- *
- * @template {any} T
- * @param {T} o
- * @return {Readonly<T>}
- */
 const deepFreeze = (o) => {
   for (const key in o) {
     const c = o[key];
-    if (typeof c === 'object' || typeof c === 'function') {
+    if (typeof c === "object" || typeof c === "function") {
       deepFreeze(o[key]);
     }
   }
-  return freeze(o)
+  return freeze(o);
+};
+export {
+  assign,
+  deepFreeze,
+  equalFlat,
+  every,
+  forEach,
+  freeze,
+  hasProperty,
+  isEmpty,
+  isObject,
+  keys,
+  map,
+  size
 };
-
-export { assign, deepFreeze, equalFlat, every, forEach, freeze, hasProperty, isEmpty, isObject, keys, map, size };

package/dist/esm/node_modules/lib0/observable.js

@@ -1,73 +1,58 @@
-import { create, setIfUndefined } from './map.js';
-import { create as create$1 } from './set.js';
-import { from } from './array.js';
-
-/**
- * Observable class prototype.
- *
- * @module observable
- */
-
-
-/**
- * Handles named events.
- * @experimental
- *
- * This is basically a (better typed) duplicate of Observable, which will replace Observable in the
- * next release.
- *
- * @template {{[key in keyof EVENTS]: function(...any):void}} EVENTS
- */
+import { create, setIfUndefined } from "./map.js";
+import { create as create$1 } from "./set.js";
+import { from } from "./array.js";
 class ObservableV2 {
-  constructor () {
-    /**
-     * Some desc.
-     * @type {Map<string, Set<any>>}
-     */
+  constructor() {
     this._observers = create();
   }
-
   /**
    * @template {keyof EVENTS & string} NAME
    * @param {NAME} name
    * @param {EVENTS[NAME]} f
    */
-  on (name, f) {
-    setIfUndefined(this._observers, /** @type {string} */ (name), create$1).add(f);
-    return f
+  on(name, f) {
+    setIfUndefined(
+      this._observers,
+      /** @type {string} */
+      name,
+      create$1
+    ).add(f);
+    return f;
   }
-
   /**
    * @template {keyof EVENTS & string} NAME
    * @param {NAME} name
    * @param {EVENTS[NAME]} f
    */
-  once (name, f) {
-    /**
-     * @param  {...any} args
-     */
+  once(name, f) {
     const _f = (...args) => {
-      this.off(name, /** @type {any} */ (_f));
+      this.off(
+        name,
+        /** @type {any} */
+        _f
+      );
       f(...args);
     };
-    this.on(name, /** @type {any} */ (_f));
+    this.on(
+      name,
+      /** @type {any} */
+      _f
+    );
   }
-
   /**
    * @template {keyof EVENTS & string} NAME
    * @param {NAME} name
    * @param {EVENTS[NAME]} f
    */
-  off (name, f) {
+  off(name, f) {
     const observers = this._observers.get(name);
-    if (observers !== undefined) {
+    if (observers !== void 0) {
       observers.delete(f);
       if (observers.size === 0) {
         this._observers.delete(name);
       }
     }
   }
-
   /**
    * Emit a named event. All registered event listeners that listen to the
    * specified name will receive the event.
@@ -78,69 +63,48 @@ class ObservableV2 {
    * @param {NAME} name The event name.
    * @param {Parameters<EVENTS[NAME]>} args The arguments that are applied to the event listener.
    */
-  emit (name, args) {
-    // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
-    return from((this._observers.get(name) || create()).values()).forEach(f => f(...args))
+  emit(name, args) {
+    return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args));
   }
-
-  destroy () {
+  destroy() {
     this._observers = create();
   }
 }
-
-/* c8 ignore start */
-/**
- * Handles named events.
- *
- * @deprecated
- * @template N
- */
 class Observable {
-  constructor () {
-    /**
-     * Some desc.
-     * @type {Map<N, any>}
-     */
+  constructor() {
     this._observers = create();
   }
-
   /**
    * @param {N} name
    * @param {function} f
    */
-  on (name, f) {
+  on(name, f) {
     setIfUndefined(this._observers, name, create$1).add(f);
   }
-
   /**
    * @param {N} name
    * @param {function} f
    */
-  once (name, f) {
-    /**
-     * @param  {...any} args
-     */
+  once(name, f) {
     const _f = (...args) => {
       this.off(name, _f);
       f(...args);
     };
     this.on(name, _f);
   }
-
   /**
    * @param {N} name
    * @param {function} f
    */
-  off (name, f) {
+  off(name, f) {
     const observers = this._observers.get(name);
-    if (observers !== undefined) {
+    if (observers !== void 0) {
       observers.delete(f);
       if (observers.size === 0) {
         this._observers.delete(name);
       }
     }
   }
-
   /**
    * Emit a named event. All registered event listeners that listen to the
    * specified name will receive the event.
@@ -150,15 +114,14 @@ class Observable {
    * @param {N} name The event name.
    * @param {Array<any>} args The arguments that are applied to the event listener.
    */
-  emit (name, args) {
-    // copy all listeners to an array first to make sure that no event is emitted to listeners that are subscribed while the event handler is called.
-    return from((this._observers.get(name) || create()).values()).forEach(f => f(...args))
+  emit(name, args) {
+    return from((this._observers.get(name) || create()).values()).forEach((f) => f(...args));
   }
-
-  destroy () {
+  destroy() {
     this._observers = create();
   }
 }
-/* c8 ignore end */
-
-export { Observable, ObservableV2 };
+export {
+  Observable,
+  ObservableV2
+};

package/dist/esm/node_modules/lib0/pair.js

@@ -1,29 +1,15 @@
-/**
- * Working with value pairs.
- *
- * @module pair
- */
-
-/**
- * @template L,R
- */
 class Pair {
   /**
    * @param {L} left
    * @param {R} right
    */
-  constructor (left, right) {
+  constructor(left, right) {
     this.left = left;
     this.right = right;
   }
 }
-
-/**
- * @template L,R
- * @param {L} left
- * @param {R} right
- * @return {Pair<L,R>}
- */
 const create = (left, right) => new Pair(left, right);
-
-export { Pair, create };
+export {
+  Pair,
+  create
+};

package/dist/esm/node_modules/lib0/prng.js

@@ -1,86 +1,25 @@
-import { fromCharCode } from './string.js';
-import { floor } from './math.js';
-
-/**
- * Fast Pseudo Random Number Generators.
- *
- * Given a seed a PRNG generates a sequence of numbers that cannot be reasonably predicted.
- * Two PRNGs must generate the same random sequence of numbers if  given the same seed.
- *
- * @module prng
- */
-
-
-/**
- * Generates a single random bool.
- *
- * @param {PRNG} gen A random number generator.
- * @return {Boolean} A random boolean
- */
-const bool = gen => (gen.next() >= 0.5);
-
-/**
- * Generates a random integer with 53 bit resolution.
- *
- * @param {PRNG} gen A random number generator.
- * @param {Number} min The lower bound of the allowed return values (inclusive).
- * @param {Number} max The upper bound of the allowed return values (inclusive).
- * @return {Number} A random integer on [min, max]
- */
+import { fromCharCode } from "./string.js";
+import { floor } from "./math.js";
+const bool = (gen) => gen.next() >= 0.5;
 const int53 = (gen, min, max) => floor(gen.next() * (max + 1 - min) + min);
-
-/**
- * Generates a random integer with 32 bit resolution.
- *
- * @param {PRNG} gen A random number generator.
- * @param {Number} min The lower bound of the allowed return values (inclusive).
- * @param {Number} max The upper bound of the allowed return values (inclusive).
- * @return {Number} A random integer on [min, max]
- */
 const int32 = (gen, min, max) => floor(gen.next() * (max + 1 - min) + min);
-
-/**
- * @deprecated
- * Optimized version of prng.int32. It has the same precision as prng.int32, but should be preferred when
- * openaring on smaller ranges.
- *
- * @param {PRNG} gen A random number generator.
- * @param {Number} min The lower bound of the allowed return values (inclusive).
- * @param {Number} max The upper bound of the allowed return values (inclusive). The max inclusive number is `binary.BITS31-1`
- * @return {Number} A random integer on [min, max]
- */
 const int31 = (gen, min, max) => int32(gen, min, max);
-
-/**
- * @param {PRNG} gen
- * @return {string} A single letter (a-z)
- */
-const letter = gen => fromCharCode(int31(gen, 97, 122));
-
-/**
- * @param {PRNG} gen
- * @param {number} [minLen=0]
- * @param {number} [maxLen=20]
- * @return {string} A random word (0-20 characters) without spaces consisting of letters (a-z)
- */
+const letter = (gen) => fromCharCode(int31(gen, 97, 122));
 const word = (gen, minLen = 0, maxLen = 20) => {
   const len = int31(gen, minLen, maxLen);
-  let str = '';
+  let str = "";
   for (let i = 0; i < len; i++) {
     str += letter(gen);
   }
-  return str
+  return str;
 };
-
-/**
- * Returns one element of a given array.
- *
- * @param {PRNG} gen A random number generator.
- * @param {Array<T>} array Non empty Array of possible values.
- * @return {T} One of the values of the supplied Array.
- * @template T
- */
 const oneOf = (gen, array) => array[int31(gen, 0, array.length - 1)];
-/* c8 ignore stop */
-
-export { bool, int31, int32, int53, letter, oneOf, word };
+export {
+  bool,
+  int31,
+  int32,
+  int53,
+  letter,
+  oneOf,
+  word
+};