@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/lang/geolocation-ratchet.spec.js

@@ -1,74 +0,0 @@
-import { GeolocationRatchet } from './geolocation-ratchet.js';
-import fs from 'fs';
-import { NumberRatchet } from './number-ratchet.js';
-import path from 'path';
-import { EsmRatchet } from './esm-ratchet.js';
-describe('#geolocationRatchet', function () {
-    it('should canonicalize', function () {
-        expect(GeolocationRatchet.combineBounds([])).toBeNull();
-        expect(GeolocationRatchet.combineBounds(null)).toBeNull();
-    });
-    it('should canonicalize', function () {
-        const bounds = {
-            origin: {
-                lat: 4,
-                lng: 3,
-            },
-            extent: {
-                lat: 2,
-                lng: 5,
-            },
-        };
-        const result = GeolocationRatchet.canonicalizeBounds(bounds);
-        expect(result.origin.lat).toEqual(2);
-        expect(result.origin.lng).toEqual(3);
-        expect(result.extent.lat).toEqual(4);
-        expect(result.extent.lng).toEqual(5);
-    });
-    it('should calc point in bounds', function () {
-        const input = fs
-            .readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/sample_geo_locations.csv'))
-            .toString();
-        const locations = input
-            .split('\n')
-            .map((line) => {
-            const vals = line.split(',');
-            if (!!vals && vals.length === 2) {
-                return {
-                    lat: NumberRatchet.safeNumber(vals[0]),
-                    lng: NumberRatchet.safeNumber(vals[1]),
-                };
-            }
-            else {
-                return null;
-            }
-        })
-            .filter((s) => !!s);
-        const bounds = locations.map((l) => GeolocationRatchet.locationToBounds(l, 10));
-        const mapping = GeolocationRatchet.buildRatchetLocationBoundsMap(bounds);
-        const testPoint1 = locations[100];
-        const testPoint2 = { lng: 5, lat: 5 };
-        const testPoint3 = {
-            lat: 40.7566,
-            lng: -73.9887,
-        };
-        const testPoint4 = {
-            lat: 33.74616,
-            lng: -84.3708,
-        };
-        const testPoint5 = {
-            lat: 37.790336,
-            lng: -122.405399,
-        };
-        const pt1In = GeolocationRatchet.pointInAnyBound(testPoint1, bounds);
-        const pt2In = GeolocationRatchet.pointInAnyBound(testPoint2, bounds);
-        const pt3In = GeolocationRatchet.pointInAnyBound(testPoint3, bounds);
-        const pt4In = GeolocationRatchet.pointInAnyBound(testPoint4, bounds);
-        const pt5In = GeolocationRatchet.pointInRatchetLocationBoundsMap(testPoint5, mapping);
-        expect(pt1In).toBeTruthy();
-        expect(pt2In).toBeFalsy();
-        expect(pt3In).toBeTruthy();
-        expect(pt4In).toBeTruthy();
-        expect(pt5In).toBeTruthy();
-    });
-});

package/lib/lang/global-ratchet.js

@@ -1,43 +0,0 @@
-import { ErrorRatchet } from './error-ratchet.js';
-import { RequireRatchet } from './require-ratchet.js';
-import { Logger } from '../logger/logger.js';
-export class GlobalRatchet {
-    constructor() { }
-    static fetchGlobalRecord(returnNullOnNone) {
-        let rval = null;
-        if (process?.env) {
-            Logger.silly('Using process.env as global');
-            rval = process.env;
-        }
-        else if (global?.process?.env) {
-            Logger.silly('Using global.process.env as global');
-            rval = global.process.env;
-        }
-        else if (global) {
-            Logger.silly('Using process.env as global');
-            rval = global;
-        }
-        if (!rval) {
-            if (returnNullOnNone) {
-                Logger.silly('Returning null as global');
-                rval = null;
-            }
-            else {
-                throw ErrorRatchet.fErr('Could not find process.env OR global in scope');
-            }
-        }
-        return rval;
-    }
-    static fetchGlobalVar(envVar) {
-        RequireRatchet.notNullOrUndefined(envVar, 'envVar');
-        const myGlobal = GlobalRatchet.fetchGlobalRecord();
-        const value = myGlobal[envVar];
-        return value;
-    }
-    static setGlobalVar(envVar, value) {
-        RequireRatchet.notNullOrUndefined(envVar, 'envVar');
-        RequireRatchet.notNullOrUndefined(value, 'value');
-        const myGlobal = GlobalRatchet.fetchGlobalRecord();
-        myGlobal[envVar] = value;
-    }
-}

package/lib/lang/global-ratchet.spec.js

@@ -1,14 +0,0 @@
-import { GlobalRatchet } from './global-ratchet.js';
-import { StringRatchet } from './string-ratchet.js';
-describe('#globalRatchet', function () {
-    it('fetch and set global variables', async () => {
-        const tester = StringRatchet.createType4Guid();
-        const tester2 = StringRatchet.createType4Guid();
-        process.env['GLOBALTEST'] = tester;
-        const value = GlobalRatchet.fetchGlobalVar('GLOBALTEST');
-        expect(value).toEqual(tester);
-        GlobalRatchet.setGlobalVar('GLOBALTEST', tester2);
-        const value2 = GlobalRatchet.fetchGlobalVar('GLOBALTEST');
-        expect(value2).toEqual(tester2);
-    });
-});

package/lib/lang/key-value.js

@@ -1,4 +0,0 @@
-export class KeyValue {
-    key;
-    value;
-}

package/lib/lang/last-success-provider.js

@@ -1 +0,0 @@
-export {};

package/lib/lang/map-ratchet.js

@@ -1,164 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { ErrorRatchet } from './error-ratchet.js';
-import { set } from 'lodash-es';
-export class MapRatchet {
-    static expandNestedKeys(src) {
-        const rval = {};
-        Object.keys(src).forEach((k) => {
-            set(rval, k, src[k]);
-        });
-        return rval;
-    }
-    static mapByUniqueProperty(input, propName) {
-        if (!input || !propName) {
-            throw new Error('Neither input nor propName can be null');
-        }
-        const rval = new Map();
-        input.forEach((i) => {
-            const val = !!i ? i[propName] : null;
-            if (val === null || val === undefined) {
-                throw new Error('No value for ' + propName + ' found in ' + JSON.stringify(i));
-            }
-            if (rval.has(val)) {
-                throw new Error('Multiple values found for ' + val);
-            }
-            rval.set(val, i);
-        });
-        return rval;
-    }
-    static groupByProperty(input, propName) {
-        if (!input || !propName) {
-            throw new Error('Neither input nor propName can be null');
-        }
-        const rval = new Map();
-        input.forEach((i) => {
-            const val = !!i ? i[propName] : null;
-            if (val === null || val === undefined) {
-                throw ErrorRatchet.fErr('No value for %s found in %j', propName, i);
-            }
-            if (!rval.has(val)) {
-                rval.set(val, []);
-            }
-            rval.get(val).push(i);
-        });
-        return rval;
-    }
-    static findValue(toSearch, path) {
-        if (!path || path.length == 0) {
-            return toSearch;
-        }
-        else {
-            if (toSearch) {
-                return MapRatchet.findValue(toSearch[path[0]], path.slice(1));
-            }
-            else {
-                return null;
-            }
-        }
-    }
-    static findValueDotPath(toSearch, dotPath) {
-        if (!dotPath || dotPath.length == 0) {
-            return toSearch;
-        }
-        else {
-            if (toSearch) {
-                return MapRatchet.findValue(toSearch, dotPath.split('.'));
-            }
-            else {
-                return null;
-            }
-        }
-    }
-    static simpleDeepCompare(object1, object2) {
-        if (object1 == null && object2 == null)
-            return true;
-        if (object1 == null || object2 == null)
-            return false;
-        return JSON.stringify(object1) == JSON.stringify(object2);
-    }
-    static toKeyValueList(value) {
-        const returnArray = [];
-        for (const k of Object.keys(value)) {
-            returnArray.push({
-                key: k,
-                value: value[k],
-            });
-        }
-        return returnArray;
-    }
-    static fromKeyValueList(list) {
-        const rval = {};
-        list.forEach((a) => (rval[a.key] = a.value));
-        return rval;
-    }
-    static cleanup(obj, stripZero = false, stripNull = true, stripUndefined = true, stripEmptyString = true) {
-        if (obj === null || obj === undefined || typeof obj !== 'object') {
-            return obj;
-        }
-        const o = JSON.parse(JSON.stringify(obj));
-        Object.keys(o).forEach((key) => {
-            if (o[key] && typeof o[key] === 'object') {
-                if (Array.isArray(o[key])) {
-                    for (let i = 0; i < o[key].length; i++) {
-                        o[key][i] = MapRatchet.cleanup(o[key][i]);
-                    }
-                }
-                else {
-                    o[key] = MapRatchet.cleanup(o[key]);
-                }
-            }
-            else if ((o[key] === undefined && stripUndefined) ||
-                (o[key] === null && stripNull) ||
-                (o[key] === '' && stripEmptyString) ||
-                (o[key] === 0 && stripZero)) {
-                delete o[key];
-            }
-            else {
-                o[key] = o[key];
-            }
-        });
-        return o;
-    }
-    static extractValueFromMapIgnoreCase(src, key) {
-        let rval = null;
-        if (src && key) {
-            const finder = key.toLowerCase();
-            Object.keys(src).forEach((s) => {
-                if (s.toLowerCase() === finder) {
-                    const newVal = src[s];
-                    if (rval) {
-                        Logger.warn('Multiple entries found for %s (replacing %s with %s', key, rval, newVal);
-                    }
-                    rval = newVal;
-                }
-            });
-        }
-        return rval;
-    }
-    static safeCallFunction(ob, fnName) {
-        let rval = false;
-        if (!!ob && !!ob[fnName] && typeof ob[fnName] === 'function') {
-            try {
-                ob[fnName]();
-                rval = true;
-            }
-            catch (err) {
-                Logger.warn('Error calling %s on %s : %s', fnName, ob, err, err);
-            }
-        }
-        return rval;
-    }
-    static caseInsensitiveAccess(ob, keyName) {
-        let rval = null;
-        if (!!ob && !!keyName) {
-            rval = ob[keyName];
-            if (!rval) {
-                const keyNameCI = Object.keys(ob).find((f) => f.toLowerCase() === keyName.toLowerCase());
-                if (!!keyNameCI) {
-                    rval = ob[keyNameCI];
-                }
-            }
-        }
-        return rval;
-    }
-}

package/lib/lang/map-ratchet.spec.js

@@ -1,90 +0,0 @@
-import { MapRatchet } from './map-ratchet.js';
-describe('#toKeyValueList', function () {
-    it('should expand a maps nested keys', function () {
-        const test = { 'a.b': 'c', 'c.d[0].e': 2 };
-        const out = MapRatchet.expandNestedKeys(test);
-        expect(out).toBeTruthy();
-        expect(out.a).toBeTruthy();
-        expect(out.a.b).toBeTruthy();
-        expect(out.a.b).toEqual('c');
-        expect(out.c).toBeTruthy();
-        expect(out.c.d).toBeTruthy();
-        expect(out.c.d.length).toEqual(1);
-        expect(out.c.d[0].e).toBeTruthy();
-        expect(out.c.d[0].e).toEqual(2);
-    });
-    it('should convert a map to a key-value list and back', function () {
-        const test = { key1: 'value1', key2: 'value2' };
-        const kvl = MapRatchet.toKeyValueList(test);
-        expect(kvl.length).toEqual(2);
-        const back = MapRatchet.fromKeyValueList(kvl);
-        expect(back['key1']).toEqual('value1');
-        expect(back['key2']).toEqual('value2');
-    });
-    it('should remove null and empty strings but not 0', function () {
-        const test = {
-            key1: '',
-            key2: null,
-            key3: 0,
-            key4: 'fine',
-            key5: {
-                key6: null,
-                key7: 'also_fine',
-            },
-        };
-        const clean = MapRatchet.cleanup(test);
-        expect(Object.keys(clean).length).toEqual(3);
-        expect(Object.keys(clean).indexOf('key1')).toEqual(-1);
-        expect(Object.keys(clean).indexOf('key2')).toEqual(-1);
-        expect(Object.keys(clean).indexOf('key3')).toBeGreaterThan(-1);
-        expect(Object.keys(clean).indexOf('key4')).toBeGreaterThan(-1);
-        expect(Object.keys(clean).indexOf('key5')).toBeGreaterThan(-1);
-        expect(clean['key5']['key7']).toEqual('also_fine');
-    });
-    it('should extract values ignoring case', function () {
-        const test = {
-            'this-Test': 'a',
-            test22: 'b',
-        };
-        expect(MapRatchet.extractValueFromMapIgnoreCase(test, 'THIS-TEST')).toEqual('a');
-        expect(MapRatchet.extractValueFromMapIgnoreCase(test, 'tEst22')).toEqual('b');
-    });
-    it('should group values', function () {
-        const test = [
-            {
-                id: 1,
-                type: 'a',
-            },
-            {
-                id: 2,
-                type: 'a',
-            },
-            {
-                id: 3,
-                type: 'b',
-            },
-        ];
-        const grouped = MapRatchet.groupByProperty(test, 'type');
-        expect(grouped).toBeTruthy();
-        const aGroup = grouped.get('a');
-        expect(aGroup).toBeTruthy();
-        expect(aGroup.length).toEqual(2);
-        expect(grouped.has('b')).toBeTruthy();
-        expect(grouped.has('c')).toBeFalsy();
-    });
-    it('should fetch a value with a case-insensitive key', function () {
-        const testOb = {
-            test1: 'a',
-            Test2: 'b',
-            test3: 'c',
-            Test3: 'd',
-        };
-        expect(MapRatchet.caseInsensitiveAccess(null, null)).toBeNull();
-        expect(MapRatchet.caseInsensitiveAccess({}, null)).toBeNull();
-        expect(MapRatchet.caseInsensitiveAccess(null, 'a')).toBeNull();
-        expect(MapRatchet.caseInsensitiveAccess(testOb, 'test1')).toEqual('a');
-        expect(MapRatchet.caseInsensitiveAccess(testOb, 'test2')).toEqual('b');
-        expect(MapRatchet.caseInsensitiveAccess(testOb, 'TEST2')).toEqual('b');
-        expect(MapRatchet.caseInsensitiveAccess(testOb, 'test3')).toEqual('c');
-    });
-});

package/lib/lang/no.js

@@ -1,4 +0,0 @@
-export class No {
-    static op(...args) {
-    }
-}

package/lib/lang/no.spec.js

@@ -1,7 +0,0 @@
-import { PromiseRatchet } from './promise-ratchet.js';
-import { No } from './no.js';
-describe('#no', function () {
-    it('should do nothing', () => {
-        PromiseRatchet.wait(100).then(No.op);
-    });
-});

package/lib/lang/number-ratchet.js

@@ -1,155 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { RequireRatchet } from './require-ratchet.js';
-export class NumberRatchet {
-    static MAX_LEADING_ZEROS_FORMAT_LENGTH = 1000;
-    static toFixedDecimalNumber(input, placesAfterPoint) {
-        const v = NumberRatchet.safeNumber(input);
-        return v === null || v === undefined ? v : NumberRatchet.safeNumber(v.toFixed(placesAfterPoint));
-    }
-    static leadingZeros(val, size) {
-        const sVal = String(val);
-        if (sVal.length < size) {
-            let pad = '0000';
-            if (size > NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH) {
-                throw 'Cannot format number that large (max length is ' + NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH + ')';
-            }
-            while (pad.length < size) {
-                pad = pad + pad;
-            }
-            return (pad + sVal).slice(-1 * size);
-        }
-        else {
-            return sVal;
-        }
-    }
-    static between(inTest, inP1, inP2) {
-        const test = NumberRatchet.safeNumber(inTest);
-        const p1 = NumberRatchet.safeNumber(inP1);
-        const p2 = NumberRatchet.safeNumber(inP2);
-        return (test >= p1 && test <= p2) || (test >= p2 && test <= p1);
-    }
-    static safeNumber(input, ifNotNumber = null, useDefaultForNullAndUndefined) {
-        let rval = undefined;
-        if (input !== null && input !== undefined) {
-            const type = typeof input;
-            if (type == 'number') {
-                rval = input;
-            }
-            else if (type == 'string') {
-                if (input.trim().length === 0) {
-                    rval = ifNotNumber;
-                }
-                else {
-                    rval = Number.parseFloat(input);
-                }
-            }
-            else {
-                Logger.warn('Value is of type %s, returning default', type);
-                rval = ifNotNumber;
-            }
-            if (isNaN(rval)) {
-                Logger.debug('Parsed string to NaN - using NaN value from param');
-                rval = ifNotNumber;
-            }
-        }
-        else {
-            rval = useDefaultForNullAndUndefined ? ifNotNumber : input;
-        }
-        return rval;
-    }
-    static numberCSVToList(inputCSV) {
-        let rval = null;
-        if (inputCSV) {
-            rval = inputCSV.split(',').map((s) => {
-                return NumberRatchet.safeNumber(s.trim());
-            });
-            rval = rval.filter((r) => typeof r === 'number' && !isNaN(r));
-        }
-        return rval;
-    }
-    static fitToWindow(val, b1, b2) {
-        let rval = val;
-        if (val === null || b1 === null || b2 === null || b1 < 0 || b2 < 0 || val < 0) {
-            throw new Error('All values must be non-null and larger than 0');
-        }
-        const low = Math.min(b1, b2);
-        const high = Math.max(b1, b2);
-        const windowSize = high - low;
-        if (high === low) {
-            rval = high;
-        }
-        else {
-            while (rval < low) {
-                rval += windowSize;
-            }
-            while (rval > high) {
-                rval -= windowSize;
-            }
-        }
-        return rval;
-    }
-    static groupNumbersIntoContiguousRanges(inputData, minRangeSize = 3) {
-        RequireRatchet.notNullOrUndefined(inputData);
-        const input = Object.assign([], inputData);
-        input.sort((a, b) => a - b);
-        const singles = [];
-        const ranges = [];
-        let start = 0;
-        for (let i = 1; i < input.length; i++) {
-            if (input[i] === input[i - 1] + 1) {
-            }
-            else {
-                if (start === i - 1) {
-                    singles.push(input[i - 1]);
-                }
-                else {
-                    const rangeSize = i - start;
-                    if (rangeSize < minRangeSize) {
-                        for (let j = start; j < i; j++) {
-                            singles.push(input[j]);
-                        }
-                    }
-                    else {
-                        ranges.push({
-                            min: input[start],
-                            max: input[i - 1],
-                        });
-                    }
-                }
-                start = i;
-            }
-        }
-        return {
-            singles: singles,
-            ranges: ranges,
-        };
-    }
-    static distributeItemsEvenly(items, buckets) {
-        RequireRatchet.notNullOrUndefined(items, 'items');
-        RequireRatchet.notNullOrUndefined(buckets, 'buckets');
-        RequireRatchet.true(items > 0 && items === Math.floor(items), 'Items integer larger than 0');
-        RequireRatchet.true(buckets > 0 && buckets === Math.floor(buckets), 'Buckets integer larger than 0');
-        const offset = buckets / items;
-        const rval = [];
-        for (let i = 0; i < buckets; i++) {
-            rval.push(0);
-        }
-        let loc = 0;
-        let rem = items;
-        while (rem > 0) {
-            rval[Math.floor(loc) % buckets]++;
-            rem--;
-            loc += offset;
-        }
-        return rval;
-    }
-    static createRange(minInclusive, maxExclusive, step = 1) {
-        const rval = [];
-        let val = minInclusive;
-        while (val < maxExclusive) {
-            rval.push(val);
-            val += step;
-        }
-        return rval;
-    }
-}

package/lib/lang/number-ratchet.spec.js

@@ -1,118 +0,0 @@
-import { NumberRatchet } from './number-ratchet.js';
-import fs from 'fs';
-import path from 'path';
-import { EsmRatchet } from './esm-ratchet.js';
-describe('#toFixedDecimalNumber', function () {
-    it('should convert "5.1234 to 5.12', function () {
-        expect(NumberRatchet.toFixedDecimalNumber(5.1234, 2)).toEqual(5.12);
-        expect(NumberRatchet.toFixedDecimalNumber('5.1234', 2)).toEqual(5.12);
-    });
-    it('should convert "5.5678 to 5.57', function () {
-        expect(NumberRatchet.toFixedDecimalNumber(5.5678, 2)).toEqual(5.57);
-        expect(NumberRatchet.toFixedDecimalNumber('5.5678', 2)).toEqual(5.57);
-    });
-});
-describe('#leadingZeros', function () {
-    it('should convert "5" to 05', function () {
-        const result = NumberRatchet.leadingZeros('5', 2);
-        expect(result).toEqual('05');
-    });
-    it('should leave 166 alone', function () {
-        const result = NumberRatchet.leadingZeros('166', 2);
-        expect(result).toEqual('166');
-    });
-});
-describe('#safeToNumber', function () {
-    it('should convert "55" to 55', function () {
-        const result = NumberRatchet.safeNumber('55');
-        expect(result).toEqual(55);
-    });
-    it('should leave 66 alone', function () {
-        const result = NumberRatchet.safeNumber(66);
-        expect(result).toEqual(66);
-    });
-    it('should return the default when it cannot parse', function () {
-        const result = NumberRatchet.safeNumber({ test: 'test' }, 42);
-        expect(result).toEqual(42);
-    });
-    it('should return the default for the empty string', function () {
-        const result = NumberRatchet.safeNumber({ test: '' }, 42);
-        expect(result).toEqual(42);
-    });
-    it('should return the default for null/undefined if set true', function () {
-        const result = NumberRatchet.safeNumber(null, 42, true);
-        expect(result).toEqual(42);
-        const result2 = NumberRatchet.safeNumber(undefined, 46, true);
-        expect(result2).toEqual(46);
-    });
-    it('should return the passed value for null/undefined if set false', function () {
-        const result = NumberRatchet.safeNumber(null, 42, false);
-        expect(result).toEqual(null);
-        const result2 = NumberRatchet.safeNumber(undefined, 46, false);
-        expect(result2).toEqual(undefined);
-    });
-    it('should return the passed value for null/undefined if not set', function () {
-        const result = NumberRatchet.safeNumber(null, 42);
-        expect(result).toEqual(null);
-        const result2 = NumberRatchet.safeNumber(undefined, 46);
-        expect(result2).toEqual(undefined);
-    });
-});
-describe('#parseCSV', function () {
-    it('should convert "1,2,3" to [1,2,3]', function () {
-        const result = NumberRatchet.numberCSVToList('1,2,3');
-        expect(result.length).toEqual(3);
-    });
-    it('should convert " 1, 2,3  " to [1,2,3]', function () {
-        const result = NumberRatchet.numberCSVToList(' 1, 2,3 ');
-        expect(result.length).toEqual(3);
-    });
-    it('should convert " a1, 2,b  " to [2]', function () {
-        const result = NumberRatchet.numberCSVToList(' a1, 2,b  ');
-        expect(result.length).toEqual(1);
-        expect(result[0]).toEqual(2);
-    });
-});
-describe('#fitToWindow', function () {
-    it('should fit input to the window', function () {
-        expect(NumberRatchet.fitToWindow(5, 8, 10)).toEqual(9);
-        expect(NumberRatchet.fitToWindow(8, 2, 10)).toEqual(8);
-        expect(NumberRatchet.fitToWindow(8, 9, 9)).toEqual(9);
-        expect(NumberRatchet.fitToWindow(12, 2, 10)).toEqual(4);
-    });
-});
-describe('#groupNumbersIntoContiguousRanges', function () {
-    it('should group numbers', function () {
-        let input = JSON.parse(fs.readFileSync(path.join(EsmRatchet.fetchDirName(import.meta.url), '../../../../test-data/number_set.json')).toString());
-        input = input.map((i) => NumberRatchet.safeNumber(i));
-        const grouped = NumberRatchet.groupNumbersIntoContiguousRanges(input, 5);
-        expect(grouped).toBeTruthy();
-    });
-});
-describe('#distributeItemsEvenly', function () {
-    it('should distribute evenly', function () {
-        const test1 = NumberRatchet.distributeItemsEvenly(4, 6);
-        expect(test1).toBeTruthy();
-        const test2 = NumberRatchet.distributeItemsEvenly(12, 6);
-        expect(test2).toBeTruthy();
-        const test3 = NumberRatchet.distributeItemsEvenly(5, 6);
-        expect(test3).toBeTruthy();
-        const test4 = NumberRatchet.distributeItemsEvenly(192, 11);
-        expect(test4).toBeTruthy();
-        const test5 = NumberRatchet.distributeItemsEvenly(11, 192);
-        expect(test5).toBeTruthy();
-    });
-});
-describe('#createRange', function () {
-    it('should create ranges', function () {
-        const test1 = NumberRatchet.createRange(0, 5, 1);
-        expect(test1).toBeTruthy();
-        expect(test1.length).toEqual(5);
-        const test2 = NumberRatchet.createRange(1, 5, 1);
-        expect(test2).toBeTruthy();
-        expect(test2.length).toEqual(4);
-        const test3 = NumberRatchet.createRange(0, 10, 2);
-        expect(test3).toBeTruthy();
-        expect(test3.length).toEqual(5);
-    });
-});

package/lib/lang/parsed-url.js

@@ -1 +0,0 @@
-export {};