@bitblit/ratchet-common 4.0.80-alpha

package/dist/cjs/lang/geolocation-ratchet.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeolocationRatchet = void 0;
+const require_ratchet_1 = require("./require-ratchet");
+const number_ratchet_1 = require("./number-ratchet");
+const error_ratchet_1 = require("./error-ratchet");
+const logger_1 = require("../logger/logger");
+class GeolocationRatchet {
+    constructor() { }
+    static distanceBetweenLocations(lat1, lon1, lat2, lon2, unit = 'M') {
+        const uU = !!unit ? unit.toUpperCase() : '';
+        if (['M', 'K', 'N', 'F', 'E'].indexOf(uU) === -1) {
+            throw new Error('Invalid unit');
+        }
+        if (lat1 == lat2 && lon1 == lon2) {
+            return 0;
+        }
+        else {
+            const radlat1 = (Math.PI * lat1) / 180;
+            const radlat2 = (Math.PI * lat2) / 180;
+            const theta = lon1 - lon2;
+            const radtheta = (Math.PI * theta) / 180;
+            let dist = Math.sin(radlat1) * Math.sin(radlat2) + Math.cos(radlat1) * Math.cos(radlat2) * Math.cos(radtheta);
+            if (dist > 1) {
+                dist = 1;
+            }
+            dist = Math.acos(dist);
+            dist = (dist * 180) / Math.PI;
+            dist = dist * 60 * 1.1515;
+            if (uU === 'F') {
+                dist *= 5280;
+            }
+            if (uU === 'K') {
+                dist *= 1.609344;
+            }
+            if (uU === 'E') {
+                dist *= 1609.344;
+            }
+            if (uU === 'N') {
+                dist *= 0.8684;
+            }
+            return dist;
+        }
+    }
+    static distanceBetweenRatchetGeoLocations(loc1, loc2, unit = 'M') {
+        return GeolocationRatchet.distanceBetweenLocations(loc1.lat, loc1.lng, loc2.lat, loc2.lng, unit);
+    }
+    static degreeOfLatLngInMiles(latitudeInDecimalDegress = 0) {
+        const latInRads = (latitudeInDecimalDegress * Math.PI) / 180;
+        const cosLat = Math.cos(latInRads);
+        const rval = number_ratchet_1.NumberRatchet.safeNumber((cosLat * 69.172).toFixed(4));
+        return rval;
+    }
+    static milesInDegLatLng(miles, latitudeInDecimalDegress = 0) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(miles);
+        require_ratchet_1.RequireRatchet.true(miles >= 0);
+        const degreeInMiles = GeolocationRatchet.degreeOfLatLngInMiles(latitudeInDecimalDegress);
+        return miles / degreeInMiles;
+    }
+    static centerOfBounds(bounds) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(bounds);
+        return {
+            lat: (bounds.extent.lat + bounds.origin.lat) / 2,
+            lng: (bounds.extent.lng + bounds.origin.lng) / 2,
+        };
+    }
+    static calculateSplits(input, slices, field) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(input);
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(slices);
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(field);
+        input.sort((a, b) => a.origin[field] - b.origin[field]);
+        const centers = input.map((i) => GeolocationRatchet.centerOfBounds(i));
+        const vals = centers.map((c) => c[field]);
+        const splits = [];
+        for (let i = 1; i < vals.length; i++) {
+            const size = vals[i] - vals[i - 1];
+            if (splits.length < slices) {
+                splits.push({ idx: i, size: size });
+                splits.sort((a, b) => a.size - b.size);
+            }
+            else if (size > splits[0].size) {
+                splits[0] = { idx: i, size: size };
+                splits.sort((a, b) => a.size - b.size);
+            }
+            else {
+                logger_1.Logger.silly('Skipping, size : %d, %j', size, splits);
+            }
+        }
+        logger_1.Logger.info('Splits at : %j', splits);
+        splits.sort((a, b) => a.idx - b.idx);
+        return splits;
+    }
+    static clusterGeoBounds(inputVal, latSlices = 2, lngSlices = 5) {
+        let rval = null;
+        if (latSlices * lngSlices < 2) {
+            error_ratchet_1.ErrorRatchet.throwFormattedErr('Cannot set slices to less than 2 : %d x %d', latSlices, lngSlices);
+        }
+        if (!!inputVal) {
+            rval = [];
+            const input = Object.assign([], inputVal);
+            input.sort((a, b) => a.origin.lng - b.origin.lng);
+            const lngSplits = GeolocationRatchet.calculateSplits(inputVal, lngSlices - 1, 'lng');
+            lngSplits.sort((a, b) => a.idx - b.idx);
+            for (let i = 0; i <= lngSplits.length; i++) {
+                const lngStartIdx = i === 0 ? 0 : lngSplits[i - 1].idx;
+                const lngEndIdx = i === lngSplits.length ? input.length : lngSplits[i].idx;
+                const lngBatch = input.slice(lngStartIdx, lngEndIdx);
+                lngBatch.sort((a, b) => a.origin.lat - b.origin.lat);
+                const latSplits = GeolocationRatchet.calculateSplits(lngBatch, latSlices - 1, 'lat');
+                for (let j = 0; j <= latSplits.length; j++) {
+                    const latStartIdx = j == 0 ? 0 : latSplits[j - 1].idx;
+                    const latEndIdx = j === latSplits.length ? lngBatch.length : latSplits[j].idx;
+                    const latBatch = lngBatch.slice(latStartIdx, latEndIdx);
+                    rval.push(GeolocationRatchet.combineBounds(latBatch));
+                }
+            }
+            logger_1.Logger.info('New bounds : %j', rval);
+        }
+        return rval;
+    }
+    static canonicalizeBounds(inp, allowCrossover = false) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(inp, 'RatchetLocationBounds');
+        const minLat = Math.min(inp.extent.lat, inp.origin.lat);
+        const maxLat = Math.max(inp.extent.lat, inp.origin.lat);
+        const minLng = Math.min(inp.extent.lng, inp.origin.lng);
+        const maxLng = Math.max(inp.extent.lng, inp.origin.lng);
+        const latXover = (minLat < 0 && maxLat > 0) || (minLat > 0 && maxLat < 0);
+        const lngXover = (minLat < 0 && maxLat > 0) || (minLat > 0 && maxLat < 0);
+        if (latXover || lngXover) {
+            if (allowCrossover) {
+                return inp;
+            }
+            else {
+                throw new Error('Cannot canonicalize, bounds crosses over boundary');
+            }
+        }
+        const rval = {
+            origin: {
+                lat: minLat,
+                lng: minLng,
+            },
+            extent: {
+                lat: maxLat,
+                lng: maxLng,
+            },
+        };
+        return rval;
+    }
+    static combineBounds(inp) {
+        let rval = null;
+        if (inp && inp.length > 0) {
+            rval = {
+                origin: {
+                    lat: inp.map((i) => i.origin.lat).reduce((a, i) => Math.min(a, i)),
+                    lng: inp.map((i) => i.origin.lng).reduce((a, i) => Math.min(a, i)),
+                },
+                extent: {
+                    lat: inp.map((i) => i.extent.lat).reduce((a, i) => Math.max(a, i)),
+                    lng: inp.map((i) => i.extent.lng).reduce((a, i) => Math.max(a, i)),
+                },
+            };
+        }
+        return rval;
+    }
+    static roundLocation(r, roundDigits) {
+        return {
+            lat: number_ratchet_1.NumberRatchet.safeNumber(r.lat.toFixed(roundDigits)),
+            lng: number_ratchet_1.NumberRatchet.safeNumber(r.lng.toFixed(roundDigits)),
+        };
+    }
+    static locationToBounds(loc, radiusMiles) {
+        const offset = GeolocationRatchet.milesInDegLatLng(radiusMiles, loc.lat);
+        const gfb = {
+            origin: {
+                lat: loc.lat - offset,
+                lng: loc.lng - offset,
+            },
+            extent: {
+                lat: loc.lat + offset,
+                lng: loc.lng + offset,
+            },
+        };
+        return gfb;
+    }
+    static sameLocation(loc1, loc2) {
+        return !!loc1 && !!loc2 && loc1.lat === loc2.lat && loc1.lng === loc2.lng;
+    }
+    static pointInBounds(pt, bound) {
+        return (!!pt &&
+            !!bound &&
+            number_ratchet_1.NumberRatchet.between(pt.lat, bound.origin.lat, bound.extent.lat) &&
+            number_ratchet_1.NumberRatchet.between(pt.lng, bound.origin.lng, bound.extent.lng));
+    }
+    static pointInAnyBound(pt, inBounds, minPointsBeforeMapping = 10) {
+        let rval = false;
+        if (inBounds.length > minPointsBeforeMapping) {
+            const mp = GeolocationRatchet.buildRatchetLocationBoundsMap(inBounds);
+            rval = GeolocationRatchet.pointInRatchetLocationBoundsMap(pt, mp);
+        }
+        else {
+            for (let i = 0; i < inBounds.length && !rval; i++) {
+                rval = GeolocationRatchet.pointInBounds(pt, inBounds[i]);
+            }
+        }
+        return rval;
+    }
+    static pointInRatchetLocationBoundsMap(pt, mp) {
+        let rval = false;
+        const entry = GeolocationRatchet.findRatchetLocationBoundsMapEntry(pt, mp);
+        if (!!entry) {
+            const bounds = entry.bounds;
+            for (let i = 0; i < bounds.length && !rval; i++) {
+                rval = GeolocationRatchet.pointInBounds(pt, bounds[i]);
+            }
+        }
+        return rval;
+    }
+    static findRatchetLocationBoundsMapEntry(pt, mp) {
+        let rval = null;
+        if (pt.lat >= mp.latOffset && pt.lat <= mp.maxLat && pt.lng >= mp.lngOffset && pt.lng <= mp.maxLng) {
+            const ltIdx = Math.trunc(pt.lat) - mp.latOffset;
+            const lngIdx = Math.trunc(pt.lng) - mp.lngOffset;
+            rval = mp.mapping[ltIdx][lngIdx];
+        }
+        return rval;
+    }
+    static buildRatchetLocationBoundsMap(inBounds) {
+        const minLat = inBounds.map((i) => i.origin.lat).reduce((a, i) => Math.min(a, i));
+        const minLng = inBounds.map((i) => i.origin.lng).reduce((a, i) => Math.min(a, i));
+        const maxLat = inBounds.map((i) => i.extent.lat).reduce((a, i) => Math.max(a, i));
+        const maxLng = inBounds.map((i) => i.extent.lng).reduce((a, i) => Math.max(a, i));
+        const latOffset = Math.trunc(minLat) - 1;
+        const lngOffset = Math.trunc(minLng) - 1;
+        const latEntries = Math.trunc(maxLat) - latOffset + 1;
+        const lngEntries = Math.trunc(maxLng) - lngOffset + 1;
+        const mapping = [];
+        for (let i = 0; i < latEntries; i++) {
+            const newRow = [];
+            for (let j = 0; j < lngEntries; j++) {
+                newRow.push({
+                    lat: latOffset + i,
+                    lng: lngOffset + j,
+                    bounds: [],
+                });
+            }
+            mapping.push(newRow);
+        }
+        inBounds.forEach((b) => {
+            for (let i = Math.trunc(b.origin.lat); i <= Math.trunc(b.extent.lat); i++) {
+                const latIdx = i - latOffset;
+                const row = mapping[latIdx];
+                for (let j = Math.trunc(b.origin.lng); j <= Math.trunc(b.extent.lng); j++) {
+                    const lngIdx = j - lngOffset;
+                    row[lngIdx].bounds.push(b);
+                }
+            }
+        });
+        return {
+            latOffset: latOffset,
+            lngOffset: lngOffset,
+            maxLat: latOffset + latEntries,
+            maxLng: lngOffset + lngEntries,
+            mapping: mapping,
+        };
+    }
+}
+exports.GeolocationRatchet = GeolocationRatchet;

package/dist/cjs/lang/global-ratchet.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalRatchet = void 0;
+const error_ratchet_1 = require("./error-ratchet");
+const require_ratchet_1 = require("./require-ratchet");
+const logger_1 = require("../logger/logger");
+class GlobalRatchet {
+    constructor() { }
+    static fetchGlobalRecord(returnNullOnNone) {
+        var _a;
+        let rval = null;
+        if (process === null || process === void 0 ? void 0 : process.env) {
+            logger_1.Logger.silly('Using process.env as global');
+            rval = process.env;
+        }
+        else if ((_a = global === null || global === void 0 ? void 0 : global.process) === null || _a === void 0 ? void 0 : _a.env) {
+            logger_1.Logger.silly('Using global.process.env as global');
+            rval = global.process.env;
+        }
+        else if (global) {
+            logger_1.Logger.silly('Using process.env as global');
+            rval = global;
+        }
+        if (!rval) {
+            if (returnNullOnNone) {
+                logger_1.Logger.silly('Returning null as global');
+                rval = null;
+            }
+            else {
+                throw error_ratchet_1.ErrorRatchet.fErr('Could not find process.env OR global in scope');
+            }
+        }
+        return rval;
+    }
+    static fetchGlobalVar(envVar) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(envVar, 'envVar');
+        const myGlobal = GlobalRatchet.fetchGlobalRecord();
+        const value = myGlobal[envVar];
+        return value;
+    }
+    static setGlobalVar(envVar, value) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(envVar, 'envVar');
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(value, 'value');
+        const myGlobal = GlobalRatchet.fetchGlobalRecord();
+        myGlobal[envVar] = value;
+    }
+}
+exports.GlobalRatchet = GlobalRatchet;

package/dist/cjs/lang/key-value.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyValue = void 0;
+class KeyValue {
+}
+exports.KeyValue = KeyValue;

package/dist/cjs/lang/last-success-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/lang/map-ratchet.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapRatchet = void 0;
+const logger_1 = require("../logger/logger");
+const error_ratchet_1 = require("./error-ratchet");
+const lodash_1 = require("lodash");
+class MapRatchet {
+    static expandNestedKeys(src) {
+        const rval = {};
+        Object.keys(src).forEach((k) => {
+            (0, lodash_1.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 error_ratchet_1.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_1.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_1.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;
+    }
+}
+exports.MapRatchet = MapRatchet;

package/dist/cjs/lang/no.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.No = void 0;
+class No {
+    static op(...args) {
+    }
+}
+exports.No = No;

package/dist/cjs/lang/number-ratchet.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberRatchet = void 0;
+const logger_1 = require("../logger/logger");
+const require_ratchet_1 = require("./require-ratchet");
+class NumberRatchet {
+    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) {
+        let rval = null;
+        if (input != null) {
+            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_1.Logger.warn('Value is of type %s, returning default', type);
+                rval = ifNotNumber;
+            }
+            if (isNaN(rval)) {
+                logger_1.Logger.debug('Parsed string to NaN - using NaN value from param');
+                rval = ifNotNumber;
+            }
+        }
+        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) {
+        require_ratchet_1.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) {
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(items, 'items');
+        require_ratchet_1.RequireRatchet.notNullOrUndefined(buckets, 'buckets');
+        require_ratchet_1.RequireRatchet.true(items > 0 && items === Math.floor(items), 'Items integer larger than 0');
+        require_ratchet_1.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;
+    }
+}
+exports.NumberRatchet = NumberRatchet;
+NumberRatchet.MAX_LEADING_ZEROS_FORMAT_LENGTH = 1000;

package/dist/cjs/lang/parsed-url.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });