@bitbeater/ecma-utils 2.7.0

package/dist/math.d.ts

@@ -0,0 +1,183 @@
+/**
+ *
+ * @param n number to be rounded round
+ * @param positions decimal positions depth to round
+ * @returns the rounded number
+ */
+export declare function round(n: number, positions?: number): number;
+/**
+ *
+ * @param start start value
+ * @param end end value
+ * @returns the percent difference
+ *
+ * ## Example
+ * ```ts
+ * percDiff(100,90)
+ * // output: -10
+ *
+ * percDiff(90,100)
+ * // output: 10
+ * ```
+ */
+export declare function percDiff(start: number, end: number): number;
+/**
+ *
+ * @param value the value tu be multiplied by the given percent value
+ * @param percent percent value
+ * @returns the value multiplied by percent
+ *
+ * ## Example
+ * ```ts
+ * calculatePercent(100,10)
+ * // output: 110
+ *
+ * calculatePercent(100,-10)
+ * // output: 90
+ * ```
+ */
+export declare function calculatePercent(value: number, percent: number): number;
+/**
+ * ```
+ * Weighted Mean =  Σwx/Σw
+ * ```
+ *
+ * The weighted arithmetic mean is similar to an ordinary arithmetic mean,
+ * except that instead of each of the data points contributing equally to the final average,
+ * some data points contribute more than others.
+ * If all the weights are equal, then the weighted mean is the same as the arithmetic mean.
+ *
+ * @example
+ * ```js
+ * weightedArithmeticMean([[251,0.1], [360, 0.5], [210, 0.7]]);
+ * // => 270.8461538461539
+ * ```
+ *
+ * @link https://en.wikipedia.org/wiki/Weighted_arithmetic_mean
+ */
+export declare function weightedArithmeticMean(value: number[], weight: number[]): number;
+/**
+ * gets the precision of a number (how many decimal digits)
+ *
+ * @example
+ * ```js
+ * getPrecision(2.1)   //1
+ * getPrecision(9.65)  //2
+ * getPrecision(0.479) //3
+ * getPrecision(1) //0
+ * getPrecision(0) //0
+ * ```
+ */
+export declare function getPrecision(n?: number): number;
+/**
+ *
+ * returns the nearest multiple of a number
+ * @example
+ * ```js
+ * getNearestMultiple(17, 5) // 15
+ * getNearestMultiple(11, 2) // 12
+ * getNearestMultiple(8, 5)  // 10
+ * getNearestMultiple(5,  2) // 6
+ * getNearestMultiple(5,  0) // 0
+ * getNearestMultiple(0.5, 0.2) // 0.4
+ * ```
+ */
+export declare function getNearestMultiple(n: number, multiple: number): number;
+/**
+ *
+ * returns the nearest low multiple of a number, the result will always be less or equal to input number
+ * @example
+ * ```js
+ * getNearestLowMultiple(17, 5) // 15
+ * getNearestLowMultiple(11, 2) // 10
+ * getNearestLowMultiple(8, 5)  // 5
+ * getNearestLowMultiple(5,  2) // 4
+ * getNearestLowMultiple(5,  0) // 0
+ * getNearestLowMultiple(0.5, 0.2) // 0.4
+ * getNearestLowMultiple(0.7777777777777, 0.00001) // 0.7777700000000001   cause j♿ can't deal with decimal module
+ * getNearestLowMultiple(0.7777777777777, 0.00001, 5) // 0.77777
+ *
+ * ```
+ */
+export declare function getNearestLowMultiple(n: number, multiple: number, precision?: number): number;
+/**
+ * truncate decimal numbers to decimal places, without rounding
+ * @example
+ * ```js
+ * truncateDecimals(5.469, 2); // => 5.46
+ * truncateDecimals(5.461, 2); // => 5.46
+ * ```
+ */
+export declare function truncateDecimals(n: number, digits: number): number;
+/**
+ *
+ * Create a sequence of numbers, from start value to end value with span
+ *
+ * @example
+ * ```js
+ * numberSequence({start:1, end: 5, span:1})	//	[1,2,3,4,5]
+ * numberSequence({start:1, end: 10, span:2})	//	[1,3,5,7,9]
+ * numberSequence({start:1, end: 5, span:2})	//	[1,3,5]
+ * numberSequence({start:5, end: 1, span:1})	//	[5,4,3,2,1]
+ * numberSequence({start:1, end: -5, span:1})	//	[1,0,-1,-2,-3,-4,-5]
+ * numberSequence({start:5, end: -1, span:1})	//	[5,4,3,2,1,0,-1]
+ * numberSequence({start:0, end: 1, span:0.2})	//	[0,0.2,0.4,0.6000000000000001,0.8,1]
+ * numberSequence({start:0, end: -1, span:0.2})	//	[0,-0.2,-0.4,-0.6000000000000001,-0.8,-1]
+ * numberSequence({start:1, end: -1, span:0.3})	//	[1,0.7,0.4,0.10000000000000009,-0.2,-0.5,-0.7999999999999998]
+ * numberSequence({start:-1, end:-5, span:1})	//	[-1,-2,-3,-4,-5]
+ * numberSequence({start:-5, end:-1, span:1})	//	[-5,-4,-3,-2,-1]
+ * numberSequence({start:-1, end:5, span:1})	//	[-1,0,1,2,3,4,5]
+ * ```
+ */
+export declare function numberSequenceRange(range: {
+    start: number;
+    end: number;
+    span: number;
+}): number[];
+/**
+ *
+ * Create a sequence of numbers, from start value to end value with span
+ *
+ * @example
+ * ```js
+ * numberSequenceByLength({ start: 0, span: 1, length: 10 })	// (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * numberSequenceByLength({ start: 0, span: 1, length: 10, direction: '-' })	// (10) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+ * numberSequenceByLength({ start: 0, span: 0.3, length: 10 })	// (10) [0, 0.3, 0.6, 0.8999999999999999, 1.2, 1.5, 1.7999999999999998, 2.1, 2.4, 2.6999999999999997]
+ * numberSequenceByLength({ start: 1.5, span: 0.3, length: 10, direction: '-' })	// (10) [1.5, 1.2, 0.9, 0.6000000000000001, 0.30000000000000004, 0, -0.2999999999999998, -0.6000000000000001, -0.8999999999999999, -1.1999999999999997]
+ * numberSequenceByLength({ start: -1.5, span: 0.3, length: 10, direction: '+' })	// (10) [-1.5, -1.2, -0.9, -0.6000000000000001, -0.30000000000000004, 0, 0.2999999999999998, 0.6000000000000001, 0.8999999999999999, 1.1999999999999997]
+ * ```
+ */
+export declare function numberSequenceByLength(len: {
+    start: number;
+    span: number;
+    length: number;
+    direction?: '+' | '-';
+}): number[];
+/**
+ *
+ * Create a sequence of fibonaci numbers, from start value to end value
+ *
+ */
+export declare function fibonacis(start: number, end: number): number[];
+/**
+ * @example
+ * ```
+ * null			=>	 0
+ * undefined		=>	 0
+ * NaN			=>	 0
+ * Infinity		=>	 0
+ * -Infinity		=>	 0
+ * new Date()		=>	 0
+ * ''			=>	 0
+ * ' '			=>	 0
+ * '123'			=>	 123
+ * '-123'			=>	 -123
+ * '123.456'		=>	 123
+ * 'abc'			=>	 0
+ *
+ *```
+ * @param val any value
+ * @returns {number}
+ */
+export declare function parseIntOrZero(val: unknown, radix?: number): number;
+//# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG,MAAM,CAGtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,UAElD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAkBhF;AACD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,GAAE,MAAU,GAAG,MAAM,CAElD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAItE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG,MAAM,CAIxF;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAGzD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CASjG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,GAAG,MAAM,EAAE,CAS5H;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAY9D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAOnE"}

package/dist/math.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.round = round;
+exports.percDiff = percDiff;
+exports.calculatePercent = calculatePercent;
+exports.weightedArithmeticMean = weightedArithmeticMean;
+exports.getPrecision = getPrecision;
+exports.getNearestMultiple = getNearestMultiple;
+exports.getNearestLowMultiple = getNearestLowMultiple;
+exports.truncateDecimals = truncateDecimals;
+exports.numberSequenceRange = numberSequenceRange;
+exports.numberSequenceByLength = numberSequenceByLength;
+exports.fibonacis = fibonacis;
+exports.parseIntOrZero = parseIntOrZero;
+/**
+ *
+ * @param n number to be rounded round
+ * @param positions decimal positions depth to round
+ * @returns the rounded number
+ */
+function round(n, positions = 0) {
+    const exp = Math.pow(10, positions);
+    return Math.round(n * exp) / exp;
+}
+/**
+ *
+ * @param start start value
+ * @param end end value
+ * @returns the percent difference
+ *
+ * ## Example
+ * ```ts
+ * percDiff(100,90)
+ * // output: -10
+ *
+ * percDiff(90,100)
+ * // output: 10
+ * ```
+ */
+function percDiff(start, end) {
+    return (end - start) / (start / 100);
+}
+/**
+ *
+ * @param value the value tu be multiplied by the given percent value
+ * @param percent percent value
+ * @returns the value multiplied by percent
+ *
+ * ## Example
+ * ```ts
+ * calculatePercent(100,10)
+ * // output: 110
+ *
+ * calculatePercent(100,-10)
+ * // output: 90
+ * ```
+ */
+function calculatePercent(value, percent) {
+    return value + value * (percent / 100);
+}
+/**
+ * ```
+ * Weighted Mean =  Σwx/Σw
+ * ```
+ *
+ * The weighted arithmetic mean is similar to an ordinary arithmetic mean,
+ * except that instead of each of the data points contributing equally to the final average,
+ * some data points contribute more than others.
+ * If all the weights are equal, then the weighted mean is the same as the arithmetic mean.
+ *
+ * @example
+ * ```js
+ * weightedArithmeticMean([[251,0.1], [360, 0.5], [210, 0.7]]);
+ * // => 270.8461538461539
+ * ```
+ *
+ * @link https://en.wikipedia.org/wiki/Weighted_arithmetic_mean
+ */
+function weightedArithmeticMean(value, weight) {
+    /**
+     *
+     * I tried to optimize the performance to the maximum, to do this:
+     * - I used the var because it is slightly faster than the let
+     * - the for loop also in this case is slightly faster than the while, and much faster than the methods of the array reduce or the forEach
+     * - Looping the array backwards is slightly faster than looping it from the start: https://stackoverflow.com/questions/8689573/why-is-iterating-through-an-array-backwards-faster-than-forwards
+     */
+    var totWeightedValue = 0;
+    var totWeight = 0;
+    for (var i = value.length - 1; i >= 0; i--) {
+        totWeightedValue += value[i] * weight[i];
+        totWeight += weight[i];
+    }
+    return totWeightedValue / totWeight;
+}
+/**
+ * gets the precision of a number (how many decimal digits)
+ *
+ * @example
+ * ```js
+ * getPrecision(2.1)   //1
+ * getPrecision(9.65)  //2
+ * getPrecision(0.479) //3
+ * getPrecision(1) //0
+ * getPrecision(0) //0
+ * ```
+ */
+function getPrecision(n = 0) {
+    return n?.toString()?.split('.')?.[1]?.length || 0;
+}
+/**
+ *
+ * returns the nearest multiple of a number
+ * @example
+ * ```js
+ * getNearestMultiple(17, 5) // 15
+ * getNearestMultiple(11, 2) // 12
+ * getNearestMultiple(8, 5)  // 10
+ * getNearestMultiple(5,  2) // 6
+ * getNearestMultiple(5,  0) // 0
+ * getNearestMultiple(0.5, 0.2) // 0.4
+ * ```
+ */
+function getNearestMultiple(n, multiple) {
+    const log = n % multiple || n;
+    if (log >= multiple / 2)
+        return n + multiple - log;
+    return n - log;
+}
+/**
+ *
+ * returns the nearest low multiple of a number, the result will always be less or equal to input number
+ * @example
+ * ```js
+ * getNearestLowMultiple(17, 5) // 15
+ * getNearestLowMultiple(11, 2) // 10
+ * getNearestLowMultiple(8, 5)  // 5
+ * getNearestLowMultiple(5,  2) // 4
+ * getNearestLowMultiple(5,  0) // 0
+ * getNearestLowMultiple(0.5, 0.2) // 0.4
+ * getNearestLowMultiple(0.7777777777777, 0.00001) // 0.7777700000000001   cause j♿ can't deal with decimal module
+ * getNearestLowMultiple(0.7777777777777, 0.00001, 5) // 0.77777
+ *
+ * ```
+ */
+function getNearestLowMultiple(n, multiple, precision = 0) {
+    var multiplier = 10 ** precision;
+    var integer = n * multiplier;
+    return (integer - (integer % (multiple * multiplier))) / multiplier;
+}
+/**
+ * truncate decimal numbers to decimal places, without rounding
+ * @example
+ * ```js
+ * truncateDecimals(5.469, 2); // => 5.46
+ * truncateDecimals(5.461, 2); // => 5.46
+ * ```
+ */
+function truncateDecimals(n, digits) {
+    const multiplier = Math.pow(10, digits);
+    return Math.floor(n * multiplier) / multiplier;
+}
+/**
+ *
+ * Create a sequence of numbers, from start value to end value with span
+ *
+ * @example
+ * ```js
+ * numberSequence({start:1, end: 5, span:1})	//	[1,2,3,4,5]
+ * numberSequence({start:1, end: 10, span:2})	//	[1,3,5,7,9]
+ * numberSequence({start:1, end: 5, span:2})	//	[1,3,5]
+ * numberSequence({start:5, end: 1, span:1})	//	[5,4,3,2,1]
+ * numberSequence({start:1, end: -5, span:1})	//	[1,0,-1,-2,-3,-4,-5]
+ * numberSequence({start:5, end: -1, span:1})	//	[5,4,3,2,1,0,-1]
+ * numberSequence({start:0, end: 1, span:0.2})	//	[0,0.2,0.4,0.6000000000000001,0.8,1]
+ * numberSequence({start:0, end: -1, span:0.2})	//	[0,-0.2,-0.4,-0.6000000000000001,-0.8,-1]
+ * numberSequence({start:1, end: -1, span:0.3})	//	[1,0.7,0.4,0.10000000000000009,-0.2,-0.5,-0.7999999999999998]
+ * numberSequence({start:-1, end:-5, span:1})	//	[-1,-2,-3,-4,-5]
+ * numberSequence({start:-5, end:-1, span:1})	//	[-5,-4,-3,-2,-1]
+ * numberSequence({start:-1, end:5, span:1})	//	[-1,0,1,2,3,4,5]
+ * ```
+ */
+function numberSequenceRange(range) {
+    const { start: start, end: end, span } = { ...range };
+    const length = Math.floor(Math.abs(start - end) / span);
+    const retVal = new Array(length);
+    if (start < end)
+        for (var i = length + 1; i;)
+            retVal[--i] = start + span * i;
+    else
+        for (var i = length + 1; i;)
+            retVal[--i] = start - span * i;
+    return retVal;
+}
+/**
+ *
+ * Create a sequence of numbers, from start value to end value with span
+ *
+ * @example
+ * ```js
+ * numberSequenceByLength({ start: 0, span: 1, length: 10 })	// (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+ * numberSequenceByLength({ start: 0, span: 1, length: 10, direction: '-' })	// (10) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+ * numberSequenceByLength({ start: 0, span: 0.3, length: 10 })	// (10) [0, 0.3, 0.6, 0.8999999999999999, 1.2, 1.5, 1.7999999999999998, 2.1, 2.4, 2.6999999999999997]
+ * numberSequenceByLength({ start: 1.5, span: 0.3, length: 10, direction: '-' })	// (10) [1.5, 1.2, 0.9, 0.6000000000000001, 0.30000000000000004, 0, -0.2999999999999998, -0.6000000000000001, -0.8999999999999999, -1.1999999999999997]
+ * numberSequenceByLength({ start: -1.5, span: 0.3, length: 10, direction: '+' })	// (10) [-1.5, -1.2, -0.9, -0.6000000000000001, -0.30000000000000004, 0, 0.2999999999999998, 0.6000000000000001, 0.8999999999999999, 1.1999999999999997]
+ * ```
+ */
+function numberSequenceByLength(len) {
+    const { start, span, length, direction } = { ...len };
+    const retVal = new Array(length);
+    if (direction === '-')
+        for (var i = 0; i < length; i++)
+            retVal[i] = start - span * i;
+    else
+        for (var i = 0; i < length; i++)
+            retVal[i] = start + span * i;
+    return retVal;
+}
+/**
+ *
+ * Create a sequence of fibonaci numbers, from start value to end value
+ *
+ */
+function fibonacis(start, end) {
+    const retVal = [];
+    var lastFib = start || 1;
+    var currentFib = start * 2 || 1;
+    while (true) {
+        if (lastFib > end)
+            return retVal;
+        const tmpLast = lastFib;
+        lastFib = currentFib;
+        currentFib = currentFib + tmpLast;
+        retVal.push(tmpLast);
+    }
+}
+/**
+ * @example
+ * ```
+ * null			=>	 0
+ * undefined		=>	 0
+ * NaN			=>	 0
+ * Infinity		=>	 0
+ * -Infinity		=>	 0
+ * new Date()		=>	 0
+ * ''			=>	 0
+ * ' '			=>	 0
+ * '123'			=>	 123
+ * '-123'			=>	 -123
+ * '123.456'		=>	 123
+ * 'abc'			=>	 0
+ *
+ *```
+ * @param val any value
+ * @returns {number}
+ */
+function parseIntOrZero(val, radix) {
+    //@ts-ignore
+    const retVal = Number.parseInt(val, radix);
+    if (isNaN(retVal))
+        return 0;
+    return retVal;
+}
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":";;AAMA,sBAGC;AAiBD,4BAEC;AAiBD,4CAEC;AAoBD,wDAkBC;AAaD,oCAEC;AAeD,gDAIC;AAkBD,sDAIC;AAUD,4CAGC;AAsBD,kDASC;AAeD,wDASC;AAOD,8BAYC;AAuBD,wCAOC;AAlQD;;;;;GAKG;AACH,SAAgB,KAAK,CAAC,CAAS,EAAE,SAAS,GAAG,CAAC;IAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC;IACpC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,QAAQ,CAAC,KAAa,EAAE,GAAW;IAClD,OAAO,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,gBAAgB,CAAC,KAAa,EAAE,OAAe;IAC9D,OAAO,KAAK,GAAG,KAAK,GAAG,CAAC,OAAO,GAAG,GAAG,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,sBAAsB,CAAC,KAAe,EAAE,MAAgB;IACvE;;;;;;OAMG;IAEH,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,gBAAgB,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACzC,SAAS,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IAED,OAAO,gBAAgB,GAAG,SAAS,CAAC;AACrC,CAAC;AACD;;;;;;;;;;;GAWG;AACH,SAAgB,YAAY,CAAC,IAAY,CAAC;IACzC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC;AACpD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,kBAAkB,CAAC,CAAS,EAAE,QAAgB;IAC7D,MAAM,GAAG,GAAG,CAAC,GAAG,QAAQ,IAAI,CAAC,CAAC;IAC9B,IAAI,GAAG,IAAI,QAAQ,GAAG,CAAC;QAAE,OAAO,CAAC,GAAG,QAAQ,GAAG,GAAG,CAAC;IACnD,OAAO,CAAC,GAAG,GAAG,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,qBAAqB,CAAC,CAAS,EAAE,QAAgB,EAAE,SAAS,GAAG,CAAC;IAC/E,IAAI,UAAU,GAAG,EAAE,IAAI,SAAS,CAAC;IACjC,IAAI,OAAO,GAAG,CAAC,GAAG,UAAU,CAAC;IAC7B,OAAO,CAAC,OAAO,GAAG,CAAC,OAAO,GAAG,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;AACrE,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,gBAAgB,CAAC,CAAS,EAAE,MAAc;IACzD,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IACxC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,UAAU,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,mBAAmB,CAAC,KAAmD;IACtF,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;IAEtD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IACxD,MAAM,MAAM,GAAG,IAAI,KAAK,CAAS,MAAM,CAAC,CAAC;IAEzC,IAAI,KAAK,GAAG,GAAG;QAAE,KAAK,IAAI,CAAC,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC;YAAI,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC;;QACzE,KAAK,IAAI,CAAC,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC;YAAI,MAAM,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC;IAClE,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,sBAAsB,CAAC,GAA2E;IACjH,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,CAAC;IAEtD,MAAM,MAAM,GAAG,IAAI,KAAK,CAAS,MAAM,CAAC,CAAC;IAEzC,IAAI,SAAS,KAAK,GAAG;QAAE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE;YAAE,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC;;QAChF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE;YAAE,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC;IAEnE,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAC,KAAa,EAAE,GAAW;IACnD,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC;IACzB,IAAI,UAAU,GAAG,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC;IAEhC,OAAO,IAAI,EAAE,CAAC;QACb,IAAI,OAAO,GAAG,GAAG;YAAE,OAAO,MAAM,CAAC;QACjC,MAAM,OAAO,GAAG,OAAO,CAAC;QACxB,OAAO,GAAG,UAAU,CAAC;QACrB,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;QAClC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,SAAgB,cAAc,CAAC,GAAY,EAAE,KAAc;IAC1D,YAAY;IACZ,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAE3C,IAAI,KAAK,CAAC,MAAM,CAAC;QAAE,OAAO,CAAC,CAAC;IAE5B,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/net/http.d.ts

@@ -0,0 +1,22 @@
+export type RetryCallBack = (error: Error, request: Request | string | URL, response?: Response, retry?: HttpRetryOptions) => void;
+export interface HttpRetryOptions {
+    retryCount?: number;
+    retryDelay?: number;
+    maxRetries?: number;
+    onRetry?: RetryCallBack;
+}
+export interface RequestOptions {
+    retry?: HttpRetryOptions;
+    timeout?: number;
+}
+export type HttpRequest = Request | string | URL;
+export declare function cookieStringToObject(cookie: string): {
+    [key: string]: string;
+};
+export declare function cookieObjectToString(cookie: {
+    [key: string]: string;
+}): string;
+export declare function cookieArrayToString(cookies: [string, string]): string;
+export declare function http(req: HttpRequest, init?: RequestInit, options?: RequestOptions): Promise<Response>;
+export declare function toURL(httpRequest: HttpRequest): URL;
+//# sourceMappingURL=http.d.ts.map

package/dist/net/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/net/http.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,GAAG,EAAE,QAAQ,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAC;AAEnI,MAAM,WAAW,gBAAgB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,aAAa,CAAC;CACxB;AACD,MAAM,WAAW,cAAc;IAC9B,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,GAAG,GAAG,CAAC;AAEjD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAS9E;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,MAAM,CAM9E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAMrE;AAQD,wBAAgB,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,GAAE,WAAgB,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,CAoB1G;AAED,wBAAgB,KAAK,CAAC,WAAW,EAAE,WAAW,GAAG,GAAG,CAGnD"}

package/dist/net/http.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cookieStringToObject = cookieStringToObject;
+exports.cookieObjectToString = cookieObjectToString;
+exports.cookieArrayToString = cookieArrayToString;
+exports.http = http;
+exports.toURL = toURL;
+const math_1 = require("../math");
+const promises_1 = require("../promises");
+function cookieStringToObject(cookie) {
+    const cookies = {};
+    const parts = cookie.split(';');
+    for (const part of parts) {
+        const equlIndex = part.indexOf('=');
+        const [key, value] = [part.slice(0, equlIndex), part.slice(equlIndex + 1)];
+        cookies[key.trim()] = value.trim();
+    }
+    return cookies;
+}
+function cookieObjectToString(cookie) {
+    const parts = [];
+    for (const key in cookie) {
+        parts.push(`${key}=${cookie[key]}`);
+    }
+    return parts.join('; ');
+}
+function cookieArrayToString(cookies) {
+    const parts = [];
+    for (const cookie of cookies) {
+        parts.push(`${cookie[0]}=${cookie[1]}`);
+    }
+    return parts.join('; ');
+}
+class HttpError extends Error {
+    constructor(response) {
+        super(response.statusText);
+        this.response = response;
+    }
+}
+function http(req, init = {}, options) {
+    const { reqTimeOutTimer, controller } = requestTimeout(options);
+    if (init.signal)
+        controller?.signal?.addEventListener('abort', e => init.signal?.dispatchEvent(e));
+    else
+        init.signal = controller?.signal;
+    return fetch(req, init)
+        .finally(() => clearTimeout(reqTimeOutTimer))
+        .then((response) => {
+        if (response.ok)
+            return response;
+        throw new HttpError(response);
+    })
+        .catch((error) => {
+        error?.response?.body?.cancel();
+        if ((0, math_1.parseIntOrZero)(options?.retry?.retryCount) >= (0, math_1.parseIntOrZero)(options?.retry?.maxRetries) - 1)
+            throw error;
+        options.retry.retryCount = (0, math_1.parseIntOrZero)(options?.retry?.retryCount);
+        options.retry.retryCount++;
+        options?.retry?.onRetry?.(error, req, error?.response, options?.retry);
+        return (0, promises_1.delay)((0, math_1.parseIntOrZero)(options?.retry?.retryDelay)).then(() => http(req, init, options));
+    });
+}
+function toURL(httpRequest) {
+    // @ts-ignore
+    return new URL(httpRequest?.url || httpRequest.toString());
+}
+function requestTimeout(options) {
+    if (!options?.timeout)
+        return {};
+    const controller = new AbortController();
+    const reqTimeOutTimer = setTimeout(() => controller.abort(), options.timeout);
+    return { reqTimeOutTimer, controller };
+}
+//# sourceMappingURL=http.js.map

package/dist/net/http.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.js","sourceRoot":"","sources":["../../src/net/http.ts"],"names":[],"mappings":"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"}

package/dist/object.d.ts

@@ -0,0 +1,98 @@
+export interface PathKeysOptions {
+    ignoreFunctions?: boolean;
+    unfoldArrays?: boolean;
+    omitFirstLevel: boolean;
+}
+/**
+ * Returns an array of a given object's keys paths (own and nested key names) in a reccursive manner, iterated in the same order that a normal loop would.
+ *
+ * @example ```ts
+ * const object={
+ * 	str:"hello",
+ * 	nr:1,
+ * 	fn: (a:number,b:number)=> a+b,
+ * 	arr:[1,2,3],
+ * 	nestedObject:{
+ * 		str:"world",
+ * 		nr:2,
+ * 		fn: (a:number,b:number)=> a+b,
+ * 		arr:[4.5],
+ * 	}
+ * };
+ *
+ * getPathKeys(object)
+ *
+ * // RETURNS:
+ * // [  'str',
+ * //	 'nr',
+ * //	 'fn',
+ * //	 'arr',
+ * //	 'nestedObject',
+ * //	 'nestedObject.str',
+ * //	 'nestedObject.nr',
+ * //	 'nestedObject.fn',
+ * //	 'nestedObject.arr' ]
+ * ```
+ *
+ * @example ```ts
+ * const object={
+ * 	str:"hello",
+ * 	nestedObject:{
+ * 		str:"world",
+ * 		nr:2,
+ * 		fn: (a:number,b:number)=> a+b,
+ * 		arr:[4.5],
+ * 	}
+ * };
+ *
+ * getPathKeys(object,{omitFirstLevel:true})
+ *
+ * // RETURNS:
+ * // [  'str',
+ * //	 'nestedObject.str',
+ * //	 'nestedObject.nr',
+ * //	 'nestedObject.fn',
+ * //	 'nestedObject.arr' ]
+ * ```
+ *
+ * @param obj object from which to derive the paths
+ * @param options options object
+ * @returns
+ */
+export declare function getPathKeys(obj: any, options?: PathKeysOptions): string[];
+/**
+ * Checks if a value is a plain object (not null, not array, not date, not promise, not function)
+ *
+ * @param v value to check
+ * @returns boolean indicating if the value is a plain object
+ *
+ * @example
+ * ```ts
+ * isPlainObject({}) // => true
+ * isPlainObject({ a: 1, b: { c: 2 } }) // => true
+ * isPlainObject(() => {}) // => false
+ * isPlainObject(null) // => false
+ * isPlainObject(undefined) // => false
+ * isPlainObject([]) // => false
+ * isPlainObject(new Date()) // => false
+ * isPlainObject("hello") // => false
+ * isPlainObject(123) // => false
+ * isPlainObject(true) // => false
+ * isPlainObject(Symbol("sym")) // => false
+ * isPlainObject(BigInt(123)) // => false
+ * isPlainObject(Promise.resolve(123)) // => false
+ * ```
+ */
+export declare function isPlainObject(v: unknown): v is Object;
+/**
+ * returns the keys of an object as an array, with proper typing.
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const keys = keysOf(obj); // ['a', 'b', 'c']
+ * ```
+ * @param o
+ * @returns
+ */
+export declare function keysOf<T extends object>(o: T): (keyof T)[];
+//# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC/B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,EAAE,CA2BzE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAE1D"}