@bitblit/ratchet-common 4.0.98-alpha → 4.0.102-alpha

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

@@ -1,159 +0,0 @@
-"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, 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_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;
-            }
-        }
-        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) {
-        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

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

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

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromiseRatchet = void 0;
-const logger_1 = require("../logger/logger");
-const array_ratchet_1 = require("./array-ratchet");
-const timeout_token_1 = require("./timeout-token");
-const stop_watch_1 = require("./stop-watch");
-const logger_level_name_1 = require("../logger/logger-level-name");
-class PromiseRatchet {
-    static resolveOnEvent(evtSrc, okEvtNames, errEvtNames = [], rval = null) {
-        if (!evtSrc || !okEvtNames || okEvtNames.length === 0 || !evtSrc['on']) {
-            Promise.reject('Cannot continue - missing source object or name, or the object is not an event source');
-        }
-        return new Promise((res, rej) => {
-            okEvtNames.forEach((e) => {
-                evtSrc.on(e, () => {
-                    res(rval);
-                });
-            });
-            if (!!errEvtNames) {
-                errEvtNames.forEach((e) => {
-                    evtSrc.on(e, (err) => {
-                        rej(err);
-                    });
-                });
-            }
-        });
-    }
-    static timeout(srcPromise, title, timeoutMS) {
-        return Promise.race([srcPromise, PromiseRatchet.createTimeoutPromise(title, timeoutMS)]);
-    }
-    static createTimeoutPromise(title, timeoutMS) {
-        return new Promise((resolve, reject) => {
-            const id = setTimeout(() => {
-                clearTimeout(id);
-                const rval = new timeout_token_1.TimeoutToken(title, timeoutMS);
-                resolve(rval);
-            }, timeoutMS);
-        });
-    }
-    static async wait(time) {
-        await PromiseRatchet.createTimeoutPromise('Wait ' + time, time);
-        logger_1.Logger.silly('Finished wait of %d ms', time);
-    }
-    static dumpResult(result, autoDebug = false) {
-        logger_1.Logger.info('Success, result was : \n\n%s\n\n', JSON.stringify(result));
-        if (autoDebug) {
-            debugger;
-        }
-        process.exit(0);
-    }
-    static dumpError(err, autoDebug = false) {
-        logger_1.Logger.warn('Failure, err was : \n\n%s\n\n  --  \n\n%s\n\n', JSON.stringify(err), String(err));
-        console.trace();
-        if (autoDebug) {
-            debugger;
-        }
-        process.exit(1);
-    }
-    static logErrorAndReturnNull(err, autoDebug = false) {
-        logger_1.Logger.warn('Failure, err was : \n\n%s\n\n  --  \n\n%s\n\n', JSON.stringify(err), String(err));
-        if (autoDebug) {
-            debugger;
-        }
-        return null;
-    }
-    static runPromiseAndDump(promise) {
-        promise.then(PromiseRatchet.dumpResult).catch(PromiseRatchet.dumpError);
-    }
-    static async waitFor(testFunction, expectedValue, intervalMS, maxCycles, label = 'waitFor', count = 0) {
-        if (expectedValue == null || intervalMS < 50 || maxCycles < 1 || count < 0 || typeof testFunction != 'function') {
-            logger_1.Logger.warn('%s: Invalid configuration for waitFor - exiting immediately', label);
-            logger_1.Logger.warn('ExpectedValue : %s ; interval: %d ; maxCycles: %d ; test : %s', expectedValue, intervalMS, maxCycles, typeof testFunction);
-            return false;
-        }
-        let curVal = null;
-        try {
-            curVal = testFunction(count);
-        }
-        catch (err) {
-            logger_1.Logger.warn('%s: Caught error while waiting, giving up', label);
-            return false;
-        }
-        if (curVal === null) {
-            logger_1.Logger.debug('%s:CurVal was null - aborting', label);
-            return false;
-        }
-        else if (curVal == expectedValue) {
-            logger_1.Logger.debug('%s:Found expected value', label);
-            return true;
-        }
-        else if (count > maxCycles) {
-            logger_1.Logger.debug('%s:Exceeded max cycles, giving up', label);
-            return false;
-        }
-        else {
-            logger_1.Logger.debug('%s : value not reached yet, waiting (count = %d of %d)', label, count, maxCycles);
-            await PromiseRatchet.wait(intervalMS);
-            return PromiseRatchet.waitFor(testFunction, expectedValue, intervalMS, maxCycles, label, count + 1);
-        }
-    }
-    static async runBoundedParallel(promiseFn, params, context, maxConcurrent = 1, logLevel = logger_level_name_1.LoggerLevelName.debug) {
-        const sw = new stop_watch_1.StopWatch();
-        let rval = [];
-        let remain = params;
-        logger_1.Logger.logByLevel(logLevel, 'Processing %d total elements %d at a time', params.length, maxConcurrent);
-        const ctx = context || this;
-        let processed = 0;
-        const totalCount = remain.length;
-        while (remain.length > 0) {
-            const curBatch = remain.slice(0, Math.min(remain.length, maxConcurrent));
-            remain = remain.slice(curBatch.length);
-            const proms = curBatch.map((c) => promiseFn.apply(ctx, c));
-            const output = await Promise.all(proms);
-            processed += proms.length;
-            rval = rval.concat(output);
-            const pct = processed / totalCount;
-            logger_1.Logger.logByLevel(logLevel, '%d elements remain : %s', remain.length, sw.dumpExpected(pct));
-        }
-        sw.log();
-        return rval;
-    }
-    static async runBoundedParallelSingleParam(promiseFn, params, context, maxConcurrent = 1, logLevel = logger_level_name_1.LoggerLevelName.debug) {
-        const wrappedParams = array_ratchet_1.ArrayRatchet.wrapElementsInArray(params);
-        return PromiseRatchet.runBoundedParallel(promiseFn, wrappedParams, context, maxConcurrent, logLevel);
-    }
-    static async asyncForEachSerial(array, callback) {
-        for (let index = 0; index < array.length; index++) {
-            await callback(array[index], index, array);
-        }
-    }
-    static async asyncForEachParallel(array, callback) {
-        const proms = [];
-        for (let index = 0; index < array.length; index++) {
-            proms.push(callback(array[index], index, array));
-        }
-        await Promise.all(proms);
-    }
-    constructor() {
-    }
-}
-exports.PromiseRatchet = PromiseRatchet;

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

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequireRatchet = void 0;
-const error_ratchet_1 = require("./error-ratchet");
-class RequireRatchet {
-    static isNullOrUndefined(ob) {
-        return ob === null || ob === undefined;
-    }
-    static notNullOrUndefined(ob, name = 'object') {
-        if (RequireRatchet.isNullOrUndefined(ob)) {
-            throw new Error(name + ' may not be null or undefined');
-        }
-    }
-    static notNullUndefinedOrOnlyWhitespaceString(ob, name = 'string') {
-        if (RequireRatchet.isNullOrUndefined(ob) || ob.trim() === '') {
-            throw new Error(name + ' may not be null or undefined or only whitespace string');
-        }
-    }
-    static notNullUndefinedOrEmptyArray(ob, name = 'string') {
-        if (RequireRatchet.isNullOrUndefined(ob) || ob.length === 0) {
-            throw new Error(name + ' may not be null or undefined or an empty array');
-        }
-    }
-    static equal(ob1, ob2, message = 'Values must be equal') {
-        if (ob1 !== ob2) {
-            throw new Error(message);
-        }
-    }
-    static true(ob, message = 'Value must be true') {
-        RequireRatchet.equal(ob, true, message);
-    }
-    static noNullOrUndefinedValuesInArray(arr, expectedLength = null, customMsg = null) {
-        RequireRatchet.notNullOrUndefined(arr, 'Source array may not be null');
-        if (expectedLength !== null && arr.length !== expectedLength) {
-            error_ratchet_1.ErrorRatchet.throwFormattedErr('Expected array of length %d but was %d %s', expectedLength, arr.length, customMsg);
-        }
-        for (let i = 0; i < arr.length; i++) {
-            if (RequireRatchet.isNullOrUndefined(arr[i])) {
-                error_ratchet_1.ErrorRatchet.throwFormattedErr('Array index %d was null or undefined %s', i, customMsg);
-            }
-        }
-    }
-    static noNullOrUndefinedValuesInRestArgs(expectedLength, ...restArgs) {
-        RequireRatchet.notNullOrUndefined(restArgs, 'Source array may not be null');
-        if (expectedLength !== null && restArgs.length !== expectedLength) {
-            error_ratchet_1.ErrorRatchet.throwFormattedErr('Expected array of length %d but was %d', expectedLength, restArgs.length);
-        }
-        for (let i = 0; i < restArgs.length; i++) {
-            if (RequireRatchet.isNullOrUndefined(restArgs[i])) {
-                error_ratchet_1.ErrorRatchet.throwFormattedErr('Array index %d was null or undefined', i);
-            }
-        }
-    }
-    static constructorArgumentsMatchLengthAndAreNonNull() {
-        const args = Array.from(arguments);
-        const len = this.constructor.length;
-        return RequireRatchet.noNullOrUndefinedValuesInArray(args, len);
-    }
-}
-exports.RequireRatchet = RequireRatchet;

package/dist/cjs/lang/stop-watch.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StopWatch = void 0;
-const duration_ratchet_1 = require("./duration-ratchet");
-const string_ratchet_1 = require("./string-ratchet");
-const require_ratchet_1 = require("./require-ratchet");
-const logger_level_name_1 = require("../logger/logger-level-name");
-const logger_1 = require("../logger/logger");
-class StopWatch {
-    constructor(label = string_ratchet_1.StringRatchet.createRandomHexString(4)) {
-        this.label = label;
-        this.starts = new Map();
-        this.ends = new Map();
-        this.createTime = Date.now();
-    }
-    start(name) {
-        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        const now = Date.now();
-        this.starts.set(string_ratchet_1.StringRatchet.trimToNull(name), now);
-        return now;
-    }
-    stop(name) {
-        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        const now = Date.now();
-        this.ends.set(string_ratchet_1.StringRatchet.trimToNull(name), now);
-        return now;
-    }
-    reset(name) {
-        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        this.starts.delete(string_ratchet_1.StringRatchet.trimToNull(name));
-        this.ends.delete(string_ratchet_1.StringRatchet.trimToNull(name));
-    }
-    hasTimer(name) {
-        require_ratchet_1.RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(name, 'name');
-        return this.starts.has(name);
-    }
-    log(name, shortForm, logLevel = logger_level_name_1.LoggerLevelName.info) {
-        logger_1.Logger.logByLevel(logLevel, this.dump(name, shortForm));
-    }
-    logExpected(pctComplete, name, shortForm, logLevel = logger_level_name_1.LoggerLevelName.info) {
-        logger_1.Logger.logByLevel(logLevel, this.dumpExpected(pctComplete, name, shortForm));
-    }
-    dump(name, shortForm) {
-        let rval = this.label + ' ';
-        const cleanName = string_ratchet_1.StringRatchet.trimToNull(name);
-        if (cleanName && !this.hasTimer(cleanName)) {
-            rval += 'No such timer : ' + cleanName;
-        }
-        else {
-            const start = name ? this.starts.get(cleanName) : this.createTime;
-            const end = name ? this.ends.get(cleanName) : Date.now();
-            rval += (cleanName || 'Default') + ' ';
-            if (!!start && !!end) {
-                rval += 'completed in ' + duration_ratchet_1.DurationRatchet.formatMsDuration(end - start, !shortForm);
-            }
-            else if (!!start) {
-                rval += 'running for ' + duration_ratchet_1.DurationRatchet.formatMsDuration(Date.now() - start, !shortForm);
-            }
-        }
-        return rval;
-    }
-    dumpExpected(pctComplete, name, shortForm) {
-        let rval = this.label + ' ';
-        const cleanName = string_ratchet_1.StringRatchet.trimToNull(name);
-        if (cleanName && !this.hasTimer(cleanName)) {
-            rval += 'No such timer : ' + cleanName;
-        }
-        else {
-            if (!pctComplete || pctComplete <= 0) {
-                rval += 'Cannot generate output for 0 percent complete';
-            }
-            else if (pctComplete > 1) {
-                rval += 'Cannot generate output for percent > 1';
-            }
-            else {
-                rval += (cleanName || 'Default') + ' ';
-                const start = name ? this.starts.get(cleanName) : this.createTime;
-                const end = name ? this.ends.get(cleanName) : Date.now();
-                if (!!start && !!end) {
-                    rval += 'completed in ' + duration_ratchet_1.DurationRatchet.formatMsDuration(end - start, !shortForm);
-                }
-                else if (!!start) {
-                    const now = Date.now();
-                    const elapsedMS = now - start;
-                    const expectedTotalMS = elapsedMS / pctComplete;
-                    const remainMS = expectedTotalMS - elapsedMS;
-                    rval +=
-                        'running for ' +
-                            duration_ratchet_1.DurationRatchet.formatMsDuration(elapsedMS, !shortForm) +
-                            ' approx ' +
-                            duration_ratchet_1.DurationRatchet.formatMsDuration(remainMS, !shortForm) +
-                            ' remaining';
-                }
-            }
-        }
-        return rval;
-    }
-    elapsedMS(name) {
-        let rval = null;
-        const cleanName = string_ratchet_1.StringRatchet.trimToNull(name);
-        if (cleanName && !this.hasTimer(cleanName)) {
-            rval = null;
-        }
-        else {
-            const start = name ? this.starts.get(cleanName) : this.createTime;
-            const end = name ? this.ends.get(cleanName) : Date.now();
-            if (!!start && !!end) {
-                rval = end - start;
-            }
-            else if (!!start) {
-                rval = Date.now() - start;
-            }
-        }
-        return rval;
-    }
-}
-exports.StopWatch = StopWatch;

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

@@ -1,195 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringRatchet = void 0;
-const require_ratchet_1 = require("./require-ratchet");
-class StringRatchet {
-    static stringToUint8Array(val) {
-        return val ? new TextEncoder().encode(val) : null;
-    }
-    static uint8ArrayToString(val) {
-        return val ? new TextDecoder().decode(val) : null;
-    }
-    static attemptJsonParse(val) {
-        let rval = null;
-        if (StringRatchet.trimToNull(val)) {
-            try {
-                rval = JSON.parse(val);
-            }
-            catch (err) {
-                rval = null;
-            }
-        }
-        return rval;
-    }
-    static canParseAsJson(val) {
-        return !!StringRatchet.attemptJsonParse(val);
-    }
-    static allUnique(input) {
-        let rval = true;
-        if (input) {
-            const check = new Set();
-            for (let i = 0; i < input.length && rval; i++) {
-                const test = input.charAt(i);
-                rval = !check.has(test);
-                check.add(test);
-            }
-        }
-        return rval;
-    }
-    static allPermutationsOfLength(len, alphabet) {
-        const rval = [];
-        if (len > 0 && alphabet && alphabet.length > 0) {
-            require_ratchet_1.RequireRatchet.true(StringRatchet.allUnique(alphabet), 'Alphabet must be unique');
-            const step = len === 1 ? [''] : StringRatchet.allPermutationsOfLength(len - 1, alphabet);
-            for (let i = 0; i < alphabet.length; i++) {
-                step.forEach((s) => rval.push(alphabet.charAt(i) + s));
-            }
-        }
-        return rval;
-    }
-    static createType4Guid() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    }
-    static createRandomHexString(len = 10) {
-        let r = '';
-        for (let i = 0; i < len; i++) {
-            r += Math.floor(Math.random() * 16).toString(16);
-        }
-        return r;
-    }
-    static canonicalize(value) {
-        let rval = value ? value.toLowerCase() : '';
-        rval = rval.replace(' ', '-');
-        StringRatchet.RFC_3986_RESERVED.forEach((s) => {
-            rval = rval.replace(s, '');
-        });
-        return rval;
-    }
-    static formatBytes(bytes, decimals = 2) {
-        if (bytes == 0)
-            return '0 Bytes';
-        const k = 1024, dm = decimals || 2, sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'], i = Math.floor(Math.log(bytes) / Math.log(k));
-        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
-    }
-    static safeString(input) {
-        let rval = null;
-        if (input != null) {
-            const type = typeof input;
-            if (type == 'string') {
-                rval = input;
-            }
-            else {
-                rval = String(input);
-            }
-        }
-        return rval;
-    }
-    static stringContainsOnlyNumbers(input) {
-        const rval = /^[0-9]+$/.test(input);
-        return rval;
-    }
-    static stringContainsOnlyAlphanumeric(input) {
-        const rval = /^[0-9a-zA-Z]+$/.test(input);
-        return rval;
-    }
-    static stringContainsOnlyHex(input) {
-        const rval = /^[0-9a-fA-F]+$/.test(input);
-        return rval;
-    }
-    static stringContainsOnly(inVal, validCharsIn) {
-        const input = !inVal ? '' : inVal;
-        const validChars = !validCharsIn ? '' : validCharsIn;
-        let rval = true;
-        for (let i = 0; i < input.length && rval; i++) {
-            rval = validChars.indexOf(input.charAt(i)) >= 0;
-        }
-        return rval;
-    }
-    static obscure(input, prefixLength = 2, suffixLength = 2) {
-        if (!input) {
-            return input;
-        }
-        const len = input.length;
-        let pl = prefixLength;
-        let sl = suffixLength;
-        while (len > 0 && len < pl + sl + 1) {
-            pl = Math.max(0, pl - 1);
-            sl = Math.max(0, sl - 1);
-        }
-        const rem = len - (pl + sl);
-        let rval = '';
-        rval += input.substring(0, pl);
-        for (let i = 0; i < rem; i++) {
-            rval += '*';
-        }
-        rval += input.substring(len - sl);
-        return rval;
-    }
-    static leadingZeros(inVal, size) {
-        const pad = '00000000000000000000000000000000000000000000000000';
-        let negative = false;
-        let sVal = String(inVal);
-        if (sVal.startsWith('-')) {
-            negative = true;
-            sVal = sVal.substring(1);
-        }
-        if (size > pad.length) {
-            throw new Error('Cannot format number that large');
-        }
-        let rval = (pad + sVal).slice(-1 * size);
-        if (negative) {
-            rval = '-' + rval;
-        }
-        return rval;
-    }
-    static trimToEmpty(input) {
-        const t = input ? StringRatchet.safeString(input) : '';
-        return t.trim();
-    }
-    static trimToNull(input) {
-        const x = StringRatchet.trimToEmpty(input);
-        return x.length > 0 ? x : null;
-    }
-    static trimAllStringPropertiesToNullInPlace(input) {
-        return StringRatchet.trimAllStringPropertiesInPlace(input, false);
-    }
-    static trimAllStringPropertiesToEmptyInPlace(input) {
-        return StringRatchet.trimAllStringPropertiesInPlace(input, true);
-    }
-    static trimAllStringPropertiesInPlace(input, toEmpty) {
-        const dealKeys = Object.keys(input);
-        dealKeys.forEach((key) => {
-            const val = input[key];
-            if (val != null && typeof val === 'string') {
-                input[key] = toEmpty ? StringRatchet.trimToEmpty(input[key]) : StringRatchet.trimToNull(input[key]);
-            }
-        });
-        return input;
-    }
-    static stripNonNumeric(input) {
-        let rval = input;
-        if (input != null && !StringRatchet.stringContainsOnlyNumbers(input)) {
-            rval = '';
-            for (let i = 0; i < input.length; i++) {
-                const c = input.charAt(i);
-                if (StringRatchet.stringContainsOnlyNumbers(c) || (i === 0 && c === '-')) {
-                    rval += c;
-                }
-            }
-        }
-        return rval;
-    }
-    static csvSafe(input) {
-        let rval = StringRatchet.trimToEmpty(StringRatchet.safeString(input));
-        rval.split('"').join('\\"');
-        if (rval.indexOf(',') !== -1 || rval.indexOf('"') !== -1 || rval.indexOf("'") !== -1) {
-            rval = '"' + rval + '"';
-        }
-        return rval;
-    }
-}
-exports.StringRatchet = StringRatchet;
-StringRatchet.RFC_3986_RESERVED = ['!', '*', "'", '(', ')', ';', ':', '@', '&', '=', '+', '$', ',', '/', '?', '#', '[', ']', '%'];