socket-function 1.1.49 → 1.2.1

package/src/formatting/dist/format.ts.cache

@@ -0,0 +1,396 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.formatPercent = exports.formatDate = exports.formatVeryNiceDateTime = exports.formatNiceDateTime = exports.formatFileTimestampLocal = exports.formatDateTimeDetailed = exports.formatDateTime = exports.formatBinaryNumber = exports.formatNumber = exports.formatMaxDecimals = exports.getTargetDecimals = exports.formatTime = void 0;
+function formatTime(milliseconds, maxAbsoluteValue) {
+    if (typeof milliseconds !== "number")
+        return "";
+    if (milliseconds === 0)
+        return "0ms";
+    if (milliseconds < 0) {
+        return "-" + formatTime(-milliseconds, maxAbsoluteValue);
+    }
+    let scale = milliseconds;
+    if (maxAbsoluteValue) {
+        scale = Math.max(scale, maxAbsoluteValue);
+    }
+    if (scale < 1 / 1000) {
+        return formatMaxDecimals(milliseconds * 1000 * 1000, 3) + "ns";
+    }
+    else if (scale < 1) {
+        return formatMaxDecimals(milliseconds * 1000, 3) + "us";
+    }
+    else if (scale < 1000) {
+        return formatMaxDecimals(milliseconds, 3) + "ms";
+        // Use seconds until we have 10 minutes, as decimal minutes are confusing
+    }
+    else if (scale < 1000 * 60 * 10) {
+        return formatMaxDecimals(milliseconds / 1000, 3) + "s";
+    }
+    else if (scale < 1000 * 60 * 60) {
+        return formatMaxDecimals(milliseconds / 1000 / 60, 3) + "m";
+    }
+    else if (scale < 1000 * 60 * 60 * 24) {
+        return formatMaxDecimals(milliseconds / 1000 / 60 / 60, 3) + "h";
+        // } else if (milliseconds < 1000 * 60 * 60 * 24 * 10) {
+        //     let remaining = Math.round(milliseconds / 1000);
+        //     let seconds = remaining % 60;
+        //     remaining -= seconds;
+        //     remaining /= 60;
+        //     let minutes = remaining % 60;
+        //     remaining -= minutes;
+        //     remaining /= 60;
+        //     let hours = remaining;
+        //     remaining -= hours;
+        //     remaining /= 24;
+        //     let days = remaining;
+        //     let time = `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+        //     if (days > 0) {
+        //         if (days === 1) {
+        //             time = `1 day ${time}`;
+        //         } else {
+        //             time = `${days} days ${time}`;
+        //         }
+        //     }
+        //     return time;
+    }
+    else {
+        let days = Math.round(milliseconds / 1000 / 60 / 60 / 24);
+        return `${days} days`;
+    }
+}
+exports.formatTime = formatTime;
+function getTargetDecimals(maxAbsoluteValue, targetDigits) {
+    let intDigits = Math.floor(Math.log10(maxAbsoluteValue) + 1);
+    if (intDigits < 0)
+        intDigits = 1;
+    let decimalDigits = targetDigits - intDigits;
+    // Happens if the number is so close to having too many digits that Math.log10 rounds it over.
+    if (decimalDigits < 0) {
+        decimalDigits = 0;
+    }
+    return decimalDigits;
+}
+exports.getTargetDecimals = getTargetDecimals;
+/** Adds decimal digits to reach digits. If the number is simply too large, it won't remove
+ *      digits, there will instead just be no decimal point.
+ */
+function formatMaxDecimals(num, targetDigits, maxAbsoluteValue, exactDecimals) {
+    var _a;
+    if (typeof num !== "number")
+        return "0";
+    // toFixed has a max of 100 digits
+    if (targetDigits > 100)
+        targetDigits = 100;
+    if (!Number.isFinite(num))
+        return num.toFixed(targetDigits);
+    if (num < 0)
+        return formatMaxDecimals(-num, targetDigits, maxAbsoluteValue, exactDecimals);
+    // TIMING:
+    //  ~50ns   toString
+    //  ~400ns  toLocaleString
+    //  ~500ns  toLocaleString("en-us")
+    //  ~20us   toLocaleString("en-us", { maximumFractionDigits: 2 })
+    // So, we are avoiding using toLocaleString, for now.
+    maxAbsoluteValue = maxAbsoluteValue !== null && maxAbsoluteValue !== void 0 ? maxAbsoluteValue : Math.abs(num);
+    let targetDecimals = exactDecimals !== null && exactDecimals !== void 0 ? exactDecimals : getTargetDecimals(maxAbsoluteValue, targetDigits);
+    let text = num.toFixed(targetDecimals);
+    let parts = text.split(".");
+    let integer = parts[0];
+    let decimals = (_a = parts[1]) !== null && _a !== void 0 ? _a : "";
+    if (exactDecimals) {
+        while (decimals.length < exactDecimals) {
+            decimals += "0";
+        }
+    }
+    else {
+        while (decimals[decimals.length - 1] === "0") {
+            decimals = decimals.slice(0, -1);
+        }
+    }
+    let output = "";
+    // NOTE: ONLY add comma groups if it is > 4 digits. As 4234K is easily read, and commas
+    //  only really matter for numbers such as 4234523K, which is hard to read.
+    if (integer.length > 4) {
+        for (let i = integer.length; i > 0; i -= 3) {
+            let start = i - 3;
+            if (start < 0)
+                start = 0;
+            let str = integer.slice(start, i);
+            if (output) {
+                output = "," + output;
+            }
+            output = str + output;
+        }
+    }
+    else {
+        output = integer;
+    }
+    if (decimals) {
+        output += "." + decimals;
+    }
+    return output;
+}
+exports.formatMaxDecimals = formatMaxDecimals;
+/** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values
+ *      TODO: Support uK, uM and uB suffixes for very small numbers?
+ *      <= 6 characters (<= 5 if positive)
+ */
+function formatNumber(count, maxAbsoluteValue, noDecimal, specialCurrency) {
+    if (typeof count !== "number")
+        return "0";
+    if (count < 0) {
+        return "-" + formatNumber(-count, maxAbsoluteValue, noDecimal, specialCurrency);
+    }
+    maxAbsoluteValue = maxAbsoluteValue !== null && maxAbsoluteValue !== void 0 ? maxAbsoluteValue : Math.abs(count);
+    let maxDecimals = 3;
+    // NOTE: We don't switch units as soon as we possible can, because...
+    //  3.594 vs 3.584 is harder to quickly distinguish compared to 3594 and 3584,
+    //  the decimal simply makes it harder to read, and larger.
+    // NOTE: This number should prevent us from ever using 5 digits, so that we never need commas
+    //  For example, if the factor is 10 then, 9999.5 is kept with a divisor of 1, and then rounds up to
+    //  "10,000". So we want any value which rounds up at 5 digits to be put in the next group (and having
+    //  extra values put in the next group is fine, as we won't show the decimal value anyways, so it only
+    //  means 9999 wraps around to 10K a bit faster).
+    const extraFactor = 9.99949999;
+    let divisor = 1;
+    let suffix = "";
+    let currencyDecimalsNeeded = false;
+    if (maxAbsoluteValue < 0.00000001) {
+        maxDecimals = 12;
+    }
+    else if (maxAbsoluteValue < 0.0000001) {
+        maxDecimals = 11;
+    }
+    else if (maxAbsoluteValue < 0.000001) {
+        maxDecimals = 10;
+    }
+    else if (maxAbsoluteValue < 0.00001) {
+        maxDecimals = 9;
+    }
+    else if (maxAbsoluteValue < 0.0001) {
+        maxDecimals = 8;
+    }
+    else if (maxAbsoluteValue < 0.001) {
+        maxDecimals = 7;
+    }
+    else if (maxAbsoluteValue < 0.01) {
+        maxDecimals = 6;
+    }
+    else if (maxAbsoluteValue < 0.1) {
+        maxDecimals = 5;
+    }
+    else if (maxAbsoluteValue < 1000 * extraFactor) {
+        if (specialCurrency) {
+            currencyDecimalsNeeded = true;
+        }
+    }
+    else if (maxAbsoluteValue < 1000 * 1000 * extraFactor) {
+        suffix = "K";
+        divisor = 1000;
+    }
+    else if (maxAbsoluteValue < 1000 * 1000 * 1000 * extraFactor) {
+        suffix = "M";
+        divisor = 1000 * 1000;
+    }
+    else if (maxAbsoluteValue < 1000 * 1000 * 1000 * 1000 * extraFactor) {
+        suffix = "B";
+        divisor = 1000 * 1000 * 1000;
+    }
+    else if (maxAbsoluteValue < 1000 * 1000 * 1000 * 1000 * 1000 * extraFactor) {
+        suffix = "T";
+        divisor = 1000 * 1000 * 1000 * 1000;
+    }
+    else {
+        suffix = "Q";
+        divisor = 1000 * 1000 * 1000 * 1000 * 1000;
+    }
+    count /= divisor;
+    maxAbsoluteValue /= divisor;
+    if (noDecimal) {
+        maxDecimals = 0;
+    }
+    return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;
+}
+exports.formatNumber = formatNumber;
+function formatBinaryNumber(count, maxAbsoluteValue, noDecimal, specialCurrency) {
+    if (typeof count !== "number")
+        return "0";
+    if (count < 0) {
+        return "-" + formatNumber(-count, maxAbsoluteValue, noDecimal, specialCurrency);
+    }
+    maxAbsoluteValue = maxAbsoluteValue !== null && maxAbsoluteValue !== void 0 ? maxAbsoluteValue : Math.abs(count);
+    // NOTE: We don't switch units as soon as we possible can, because...
+    //  3.594 vs 3.584 is harder to quickly distinguish compared to 3594 and 3584,
+    //  the decimal simply makes it harder to read, and larger.
+    // NOTE: This number should prevent us from ever using 5 digits, so that we never need commas
+    //  For example, if the factor is 10 then, 9999.5 is kept with a divisor of 1, and then rounds up to
+    //  "10,000". So we want any value which rounds up at 5 digits to be put in the next group (and having
+    //  extra values put in the next group is fine, as we won't show the decimal value anyways, so it only
+    //  means 9999 wraps around to 10K a bit faster).
+    const extraFactor = 9.99949999;
+    let divisor = 1;
+    let suffix = "";
+    let currencyDecimalsNeeded = false;
+    if (maxAbsoluteValue < 1024 * extraFactor) {
+        if (specialCurrency) {
+            currencyDecimalsNeeded = true;
+        }
+    }
+    else if (maxAbsoluteValue < 1024 * 1024 * extraFactor) {
+        suffix = "K";
+        divisor = 1024;
+    }
+    else if (maxAbsoluteValue < 1024 * 1024 * 1024 * extraFactor) {
+        suffix = "M";
+        divisor = 1024 * 1024;
+    }
+    else {
+        suffix = "G";
+        divisor = 1024 * 1024 * 1024;
+    }
+    count /= divisor;
+    maxAbsoluteValue /= divisor;
+    let maxDecimals = noDecimal ? 0 : 3;
+    return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;
+}
+exports.formatBinaryNumber = formatBinaryNumber;
+/** YYYY/MM/DD HH:MM:SS PM/AM */
+function formatDateTime(time) {
+    function p(s) {
+        return s.toString().padStart(2, "0");
+    }
+    let date = new Date(time);
+    let hours = date.getHours();
+    let minutes = date.getMinutes();
+    let seconds = date.getSeconds();
+    let ampm = hours >= 12 ? "PM" : "AM";
+    hours = hours % 12;
+    hours = hours ? hours : 12; // the hour '0' should be '12'
+    let strTime = p(hours) + ":" + p(minutes) + ":" + p(seconds) + " " + ampm;
+    return date.getFullYear() + "/" + p(date.getMonth() + 1) + "/" + p(date.getDate()) + " " + strTime;
+}
+exports.formatDateTime = formatDateTime;
+function formatDateTimeDetailed(time) {
+    function p(s) {
+        return s.toString().padStart(2, "0");
+    }
+    let date = new Date(time);
+    let hours = date.getHours();
+    let minutes = date.getMinutes();
+    let seconds = date.getSeconds();
+    let milliseconds = date.getMilliseconds();
+    let millisecondsString = milliseconds.toString().padStart(3, "0");
+    let timeString = time.toString();
+    let decimalIndex = timeString.indexOf(".");
+    if (decimalIndex !== -1) {
+        let fractionalPart = timeString.substring(decimalIndex + 1);
+        millisecondsString += fractionalPart;
+    }
+    let ampm = hours >= 12 ? "PM" : "AM";
+    hours = hours % 12;
+    hours = hours ? hours : 12; // the hour '0' should be '12'
+    let strTime = p(hours) + ":" + p(minutes) + ":" + p(seconds) + "." + millisecondsString + " " + ampm;
+    return date.getFullYear() + "/" + p(date.getMonth() + 1) + "/" + p(date.getDate()) + " " + strTime;
+}
+exports.formatDateTimeDetailed = formatDateTimeDetailed;
+// Lookup table for common timezone abbreviations by UTC offset (in minutes)
+const timezoneAbbreviations = {
+    // UTC and GMT
+    "0": "UTC",
+    // US/Canada timezones
+    "300": "EST", // UTC-5 (Eastern Standard Time)
+    "240": "EDT", // UTC-4 (Eastern Daylight Time)
+    "360": "CST", // UTC-6 (Central Standard Time) 
+    "420": "MST", // UTC-7 (Mountain Standard Time)
+    "480": "PST", // UTC-8 (Pacific Standard Time)
+    // European timezones
+    "-60": "CET", // UTC+1 (Central European Time)
+    "-120": "CEST", // UTC+2 (Central European Summer Time)
+    // Other common timezones
+    "-480": "CST", // UTC+8 (China Standard Time)
+    "-540": "JST", // UTC+9 (Japan Standard Time)
+    "-330": "IST", // UTC+5:30 (India Standard Time)
+    "-570": "ACST", // UTC+9:30 (Australian Central Standard Time)
+    "-600": "AEST", // UTC+10 (Australian Eastern Standard Time)
+};
+// YYYY-MM-DD_HH-MM-SS.mmm TIMEZONE
+function formatFileTimestampLocal(time) {
+    function p(s) {
+        return s.toString().padStart(2, "0");
+    }
+    let date = new Date(time);
+    let year = date.getFullYear();
+    let month = p(date.getMonth() + 1);
+    let day = p(date.getDate());
+    let hours = p(date.getHours());
+    let minutes = p(date.getMinutes());
+    let seconds = p(date.getSeconds());
+    let milliseconds = date.getMilliseconds();
+    let millisecondsString = milliseconds.toString().padStart(3, "0");
+    let timeString = time.toString();
+    let decimalIndex = timeString.indexOf(".");
+    if (decimalIndex !== -1) {
+        let fractionalPart = timeString.substring(decimalIndex + 1);
+        millisecondsString += fractionalPart;
+    }
+    // Get timezone offset in minutes (negative of getTimezoneOffset because it returns opposite sign)
+    let timezoneOffsetMinutes = date.getTimezoneOffset();
+    // Look up the abbreviation or fallback to numeric format
+    let timezoneString = timezoneAbbreviations[timezoneOffsetMinutes.toString()];
+    if (!timezoneString) {
+        // Fallback: format as ±HHMM
+        let offsetSign = timezoneOffsetMinutes >= 0 ? "+" : "-";
+        let offsetHours = p(Math.floor(Math.abs(timezoneOffsetMinutes) / 60));
+        let offsetMins = p(Math.abs(timezoneOffsetMinutes) % 60);
+        timezoneString = `${offsetSign}${offsetHours}${offsetMins}`;
+    }
+    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}.${millisecondsString}_${timezoneString}`;
+}
+exports.formatFileTimestampLocal = formatFileTimestampLocal;
+/** 2024 January 1, Monday, 12:53:02pm */
+function formatNiceDateTime(time) {
+    function p(s) {
+        return s.toString().padStart(2, "0");
+    }
+    let date = new Date(time);
+    let hours = date.getHours();
+    let minutes = date.getMinutes();
+    let seconds = date.getSeconds();
+    let ampm = hours >= 12 ? "pm" : "am";
+    hours = hours % 12;
+    hours = hours ? hours : 12; // the hour '0' should be '12'
+    let strTime = p(hours) + ":" + p(minutes) + ":" + p(seconds) + ampm;
+    let days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+    return date.getFullYear() + " " + date.toLocaleString("default", { month: "long" }) + " " + date.getDate() + ", " + days[date.getDay()] + ", " + strTime;
+}
+exports.formatNiceDateTime = formatNiceDateTime;
+/** 2024 January 1, Monday, 12:53:02pm (4 months ago)  */
+function formatVeryNiceDateTime(time) {
+    if (!time) {
+        return "";
+    }
+    if (typeof time !== "number") {
+        return String(time);
+    }
+    return `${formatNiceDateTime(time)} (${formatTime(Date.now() - time)})`;
+}
+exports.formatVeryNiceDateTime = formatVeryNiceDateTime;
+/** YYYY/MM/DD */
+function formatDate(time) {
+    function p(s) {
+        return s.toString().padStart(2, "0");
+    }
+    let date = new Date(time);
+    return date.getFullYear() + "/" + p(date.getMonth() + 1) + "/" + p(date.getDate());
+}
+exports.formatDate = formatDate;
+/** <= 6 characters (<= 5 if positive) */
+function formatPercent(value) {
+    if (Number.isNaN(value))
+        return "0%";
+    // 1 decimal point, so we have 5 characters (just like formatNumber returns 5 characters)
+    return Math.round(value * 1000) / 10 + "%";
+}
+exports.formatPercent = formatPercent;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"format.js","sourceRoot":"","sources":["format.ts"],"names":[],"mappings":"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","sourcesContent":["export function formatTime(milliseconds: number | undefined, maxAbsoluteValue?: number): string {\n    if (typeof milliseconds !== \"number\") return \"\";\n    if (milliseconds === 0) return \"0ms\";\n    if (milliseconds < 0) {\n        return \"-\" + formatTime(-milliseconds, maxAbsoluteValue);\n    }\n    let scale = milliseconds;\n    if (maxAbsoluteValue) {\n        scale = Math.max(scale, maxAbsoluteValue);\n    }\n    if (scale < 1 / 1000) {\n        return formatMaxDecimals(milliseconds * 1000 * 1000, 3) + \"ns\";\n    } else if (scale < 1) {\n        return formatMaxDecimals(milliseconds * 1000, 3) + \"us\";\n    } else if (scale < 1000) {\n        return formatMaxDecimals(milliseconds, 3) + \"ms\";\n        // Use seconds until we have 10 minutes, as decimal minutes are confusing\n    } else if (scale < 1000 * 60 * 10) {\n        return formatMaxDecimals(milliseconds / 1000, 3) + \"s\";\n    } else if (scale < 1000 * 60 * 60) {\n        return formatMaxDecimals(milliseconds / 1000 / 60, 3) + \"m\";\n    } else if (scale < 1000 * 60 * 60 * 24) {\n        return formatMaxDecimals(milliseconds / 1000 / 60 / 60, 3) + \"h\";\n        // } else if (milliseconds < 1000 * 60 * 60 * 24 * 10) {\n        //     let remaining = Math.round(milliseconds / 1000);\n        //     let seconds = remaining % 60;\n        //     remaining -= seconds;\n        //     remaining /= 60;\n        //     let minutes = remaining % 60;\n        //     remaining -= minutes;\n        //     remaining /= 60;\n        //     let hours = remaining;\n        //     remaining -= hours;\n        //     remaining /= 24;\n        //     let days = remaining;\n        //     let time = `${hours.toString().padStart(2, \"0\")}:${minutes.toString().padStart(2, \"0\")}:${seconds.toString().padStart(2, \"0\")}`;\n        //     if (days > 0) {\n        //         if (days === 1) {\n        //             time = `1 day ${time}`;\n        //         } else {\n        //             time = `${days} days ${time}`;\n        //         }\n        //     }\n        //     return time;\n    } else {\n        let days = Math.round(milliseconds / 1000 / 60 / 60 / 24);\n        return `${days} days`;\n    }\n}\n\nexport function getTargetDecimals(maxAbsoluteValue: number, targetDigits: number) {\n    let intDigits = Math.floor(Math.log10(maxAbsoluteValue) + 1);\n    if (intDigits < 0) intDigits = 1;\n    let decimalDigits = targetDigits - intDigits;\n    // Happens if the number is so close to having too many digits that Math.log10 rounds it over.\n    if (decimalDigits < 0) {\n        decimalDigits = 0;\n    }\n    return decimalDigits;\n}\n\n/** Adds decimal digits to reach digits. If the number is simply too large, it won't remove\n *      digits, there will instead just be no decimal point.\n */\nexport function formatMaxDecimals(num: number, targetDigits: number, maxAbsoluteValue?: number, exactDecimals?: number): string {\n    if (typeof num !== \"number\") return \"0\";\n    // toFixed has a max of 100 digits\n    if (targetDigits > 100) targetDigits = 100;\n    if (!Number.isFinite(num)) return num.toFixed(targetDigits);\n\n    if (num < 0) return formatMaxDecimals(-num, targetDigits, maxAbsoluteValue, exactDecimals);\n\n    // TIMING:\n    //  ~50ns   toString\n    //  ~400ns  toLocaleString\n    //  ~500ns  toLocaleString(\"en-us\")\n    //  ~20us   toLocaleString(\"en-us\", { maximumFractionDigits: 2 })\n    // So, we are avoiding using toLocaleString, for now.\n\n    maxAbsoluteValue = maxAbsoluteValue ?? Math.abs(num);\n\n    let targetDecimals = exactDecimals ?? getTargetDecimals(maxAbsoluteValue, targetDigits);\n    let text = num.toFixed(targetDecimals);\n    let parts = text.split(\".\");\n    let integer = parts[0];\n    let decimals = parts[1] ?? \"\";\n\n    if (exactDecimals) {\n        while (decimals.length < exactDecimals) {\n            decimals += \"0\";\n        }\n    } else {\n        while (decimals[decimals.length - 1] === \"0\") {\n            decimals = decimals.slice(0, -1);\n        }\n    }\n\n    let output = \"\";\n\n    // NOTE: ONLY add comma groups if it is > 4 digits. As 4234K is easily read, and commas\n    //  only really matter for numbers such as 4234523K, which is hard to read.\n    if (integer.length > 4) {\n        for (let i = integer.length; i > 0; i -= 3) {\n            let start = i - 3;\n            if (start < 0) start = 0;\n            let str = integer.slice(start, i);\n            if (output) {\n                output = \",\" + output;\n            }\n            output = str + output;\n        }\n    } else {\n        output = integer;\n    }\n\n    if (decimals) {\n        output += \".\" + decimals;\n    }\n\n    return output;\n}\n\n/** Actually formats any number, including decimals, by using K, M and B suffixes to get smaller values\n *      TODO: Support uK, uM and uB suffixes for very small numbers?\n *      <= 6 characters (<= 5 if positive)\n */\nexport function formatNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string {\n    if (typeof count !== \"number\") return \"0\";\n    if (count < 0) {\n        return \"-\" + formatNumber(-count, maxAbsoluteValue, noDecimal, specialCurrency);\n    }\n\n    maxAbsoluteValue = maxAbsoluteValue ?? Math.abs(count);\n\n    let maxDecimals = 3;\n\n    // NOTE: We don't switch units as soon as we possible can, because...\n    //  3.594 vs 3.584 is harder to quickly distinguish compared to 3594 and 3584,\n    //  the decimal simply makes it harder to read, and larger.\n    // NOTE: This number should prevent us from ever using 5 digits, so that we never need commas\n    //  For example, if the factor is 10 then, 9999.5 is kept with a divisor of 1, and then rounds up to\n    //  \"10,000\". So we want any value which rounds up at 5 digits to be put in the next group (and having\n    //  extra values put in the next group is fine, as we won't show the decimal value anyways, so it only\n    //  means 9999 wraps around to 10K a bit faster).\n    const extraFactor = 9.99949999;\n    let divisor = 1;\n    let suffix = \"\";\n    let currencyDecimalsNeeded = false;\n    if (maxAbsoluteValue < 0.00000001) {\n        maxDecimals = 12;\n    } else if (maxAbsoluteValue < 0.0000001) {\n        maxDecimals = 11;\n    } else if (maxAbsoluteValue < 0.000001) {\n        maxDecimals = 10;\n    } else if (maxAbsoluteValue < 0.00001) {\n        maxDecimals = 9;\n    } else if (maxAbsoluteValue < 0.0001) {\n        maxDecimals = 8;\n    } else if (maxAbsoluteValue < 0.001) {\n        maxDecimals = 7;\n    } else if (maxAbsoluteValue < 0.01) {\n        maxDecimals = 6;\n    } else if (maxAbsoluteValue < 0.1) {\n        maxDecimals = 5;\n    } else if (maxAbsoluteValue < 1000 * extraFactor) {\n        if (specialCurrency) {\n            currencyDecimalsNeeded = true;\n        }\n    } else if (maxAbsoluteValue < 1000 * 1000 * extraFactor) {\n        suffix = \"K\";\n        divisor = 1000;\n    } else if (maxAbsoluteValue < 1000 * 1000 * 1000 * extraFactor) {\n        suffix = \"M\";\n        divisor = 1000 * 1000;\n    } else if (maxAbsoluteValue < 1000 * 1000 * 1000 * 1000 * extraFactor) {\n        suffix = \"B\";\n        divisor = 1000 * 1000 * 1000;\n    } else if (maxAbsoluteValue < 1000 * 1000 * 1000 * 1000 * 1000 * extraFactor) {\n        suffix = \"T\";\n        divisor = 1000 * 1000 * 1000 * 1000;\n    } else {\n        suffix = \"Q\";\n        divisor = 1000 * 1000 * 1000 * 1000 * 1000;\n    }\n    count /= divisor;\n    maxAbsoluteValue /= divisor;\n    if (noDecimal) {\n        maxDecimals = 0;\n    }\n\n    return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;\n}\n\nexport function formatBinaryNumber(count: number | undefined, maxAbsoluteValue?: number, noDecimal?: boolean, specialCurrency?: boolean): string {\n    if (typeof count !== \"number\") return \"0\";\n    if (count < 0) {\n        return \"-\" + formatNumber(-count, maxAbsoluteValue, noDecimal, specialCurrency);\n    }\n\n    maxAbsoluteValue = maxAbsoluteValue ?? Math.abs(count);\n\n    // NOTE: We don't switch units as soon as we possible can, because...\n    //  3.594 vs 3.584 is harder to quickly distinguish compared to 3594 and 3584,\n    //  the decimal simply makes it harder to read, and larger.\n    // NOTE: This number should prevent us from ever using 5 digits, so that we never need commas\n    //  For example, if the factor is 10 then, 9999.5 is kept with a divisor of 1, and then rounds up to\n    //  \"10,000\". So we want any value which rounds up at 5 digits to be put in the next group (and having\n    //  extra values put in the next group is fine, as we won't show the decimal value anyways, so it only\n    //  means 9999 wraps around to 10K a bit faster).\n    const extraFactor = 9.99949999;\n    let divisor = 1;\n    let suffix = \"\";\n    let currencyDecimalsNeeded = false;\n    if (maxAbsoluteValue < 1024 * extraFactor) {\n        if (specialCurrency) {\n            currencyDecimalsNeeded = true;\n        }\n    } else if (maxAbsoluteValue < 1024 * 1024 * extraFactor) {\n        suffix = \"K\";\n        divisor = 1024;\n    } else if (maxAbsoluteValue < 1024 * 1024 * 1024 * extraFactor) {\n        suffix = \"M\";\n        divisor = 1024 * 1024;\n    } else {\n        suffix = \"G\";\n        divisor = 1024 * 1024 * 1024;\n    }\n    count /= divisor;\n    maxAbsoluteValue /= divisor;\n\n    let maxDecimals = noDecimal ? 0 : 3;\n\n    return formatMaxDecimals(count, maxDecimals, maxAbsoluteValue, currencyDecimalsNeeded ? 2 : undefined) + suffix;\n}\n\n/** YYYY/MM/DD HH:MM:SS PM/AM */\nexport function formatDateTime(time: number) {\n    function p(s: number) {\n        return s.toString().padStart(2, \"0\");\n    }\n    let date = new Date(time);\n    let hours = date.getHours();\n    let minutes = date.getMinutes();\n    let seconds = date.getSeconds();\n    let ampm = hours >= 12 ? \"PM\" : \"AM\";\n    hours = hours % 12;\n    hours = hours ? hours : 12; // the hour '0' should be '12'\n    let strTime = p(hours) + \":\" + p(minutes) + \":\" + p(seconds) + \" \" + ampm;\n    return date.getFullYear() + \"/\" + p(date.getMonth() + 1) + \"/\" + p(date.getDate()) + \" \" + strTime;\n}\n\nexport function formatDateTimeDetailed(time: number) {\n    function p(s: number) {\n        return s.toString().padStart(2, \"0\");\n    }\n    let date = new Date(time);\n    let hours = date.getHours();\n    let minutes = date.getMinutes();\n    let seconds = date.getSeconds();\n    let milliseconds = date.getMilliseconds();\n    let millisecondsString = milliseconds.toString().padStart(3, \"0\");\n\n    let timeString = time.toString();\n    let decimalIndex = timeString.indexOf(\".\");\n    if (decimalIndex !== -1) {\n        let fractionalPart = timeString.substring(decimalIndex + 1);\n        millisecondsString += fractionalPart;\n    }\n\n    let ampm = hours >= 12 ? \"PM\" : \"AM\";\n    hours = hours % 12;\n    hours = hours ? hours : 12; // the hour '0' should be '12'\n    let strTime = p(hours) + \":\" + p(minutes) + \":\" + p(seconds) + \".\" + millisecondsString + \" \" + ampm;\n    return date.getFullYear() + \"/\" + p(date.getMonth() + 1) + \"/\" + p(date.getDate()) + \" \" + strTime;\n}\n\n\n// Lookup table for common timezone abbreviations by UTC offset (in minutes)\nconst timezoneAbbreviations: { [offsetMinutes: string]: string } = {\n    // UTC and GMT\n    \"0\": \"UTC\",\n\n    // US/Canada timezones\n    \"300\": \"EST\",     // UTC-5 (Eastern Standard Time)\n    \"240\": \"EDT\",     // UTC-4 (Eastern Daylight Time)\n    \"360\": \"CST\",     // UTC-6 (Central Standard Time) \n    \"420\": \"MST\",     // UTC-7 (Mountain Standard Time)\n    \"480\": \"PST\",     // UTC-8 (Pacific Standard Time)\n\n    // European timezones\n    \"-60\": \"CET\",     // UTC+1 (Central European Time)\n    \"-120\": \"CEST\",   // UTC+2 (Central European Summer Time)\n\n    // Other common timezones\n    \"-480\": \"CST\",    // UTC+8 (China Standard Time)\n    \"-540\": \"JST\",    // UTC+9 (Japan Standard Time)\n    \"-330\": \"IST\",    // UTC+5:30 (India Standard Time)\n    \"-570\": \"ACST\",   // UTC+9:30 (Australian Central Standard Time)\n    \"-600\": \"AEST\",   // UTC+10 (Australian Eastern Standard Time)\n};\n\n\n// YYYY-MM-DD_HH-MM-SS.mmm TIMEZONE\nexport function formatFileTimestampLocal(time: number): string {\n    function p(s: number) {\n        return s.toString().padStart(2, \"0\");\n    }\n\n    let date = new Date(time);\n    let year = date.getFullYear();\n    let month = p(date.getMonth() + 1);\n    let day = p(date.getDate());\n    let hours = p(date.getHours());\n    let minutes = p(date.getMinutes());\n    let seconds = p(date.getSeconds());\n    let milliseconds = date.getMilliseconds();\n    let millisecondsString = milliseconds.toString().padStart(3, \"0\");\n\n    let timeString = time.toString();\n    let decimalIndex = timeString.indexOf(\".\");\n    if (decimalIndex !== -1) {\n        let fractionalPart = timeString.substring(decimalIndex + 1);\n        millisecondsString += fractionalPart;\n    }\n    // Get timezone offset in minutes (negative of getTimezoneOffset because it returns opposite sign)\n    let timezoneOffsetMinutes = date.getTimezoneOffset();\n\n    // Look up the abbreviation or fallback to numeric format\n    let timezoneString = timezoneAbbreviations[timezoneOffsetMinutes.toString()];\n    if (!timezoneString) {\n        // Fallback: format as ±HHMM\n        let offsetSign = timezoneOffsetMinutes >= 0 ? \"+\" : \"-\";\n        let offsetHours = p(Math.floor(Math.abs(timezoneOffsetMinutes) / 60));\n        let offsetMins = p(Math.abs(timezoneOffsetMinutes) % 60);\n        timezoneString = `${offsetSign}${offsetHours}${offsetMins}`;\n    }\n\n    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}.${millisecondsString}_${timezoneString}`;\n}\n\n/** 2024 January 1, Monday, 12:53:02pm */\nexport function formatNiceDateTime(time: number) {\n    function p(s: number) {\n        return s.toString().padStart(2, \"0\");\n    }\n    let date = new Date(time);\n    let hours = date.getHours();\n    let minutes = date.getMinutes();\n    let seconds = date.getSeconds();\n    let ampm = hours >= 12 ? \"pm\" : \"am\";\n    hours = hours % 12;\n    hours = hours ? hours : 12; // the hour '0' should be '12'\n    let strTime = p(hours) + \":\" + p(minutes) + \":\" + p(seconds) + ampm;\n    let days = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"];\n    return date.getFullYear() + \" \" + date.toLocaleString(\"default\", { month: \"long\" }) + \" \" + date.getDate() + \", \" + days[date.getDay()] + \", \" + strTime;\n}\n\n/** 2024 January 1, Monday, 12:53:02pm (4 months ago)  */\nexport function formatVeryNiceDateTime(time: number) {\n    if (!time) {\n        return \"\";\n    }\n    if (typeof time !== \"number\") {\n        return String(time);\n    }\n    return `${formatNiceDateTime(time)} (${formatTime(Date.now() - time)})`;\n}\n\n/** YYYY/MM/DD */\nexport function formatDate(time: number) {\n    function p(s: number) {\n        return s.toString().padStart(2, \"0\");\n    }\n    let date = new Date(time);\n    return date.getFullYear() + \"/\" + p(date.getMonth() + 1) + \"/\" + p(date.getDate());\n}\n\n/** <= 6 characters (<= 5 if positive) */\nexport function formatPercent(value: number) {\n    if (Number.isNaN(value)) return \"0%\";\n    // 1 decimal point, so we have 5 characters (just like formatNumber returns 5 characters)\n    return Math.round(value * 1000) / 10 + \"%\";\n}"]}
+ /* _JS_SOURCE_HASH = "1a242c2d04f98b2c5c8746dc03300531a8b55c3e768824c54557a7e20934086a"; */

package/src/formatting/dist/logColors.ts.cache

@@ -0,0 +1,28 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.magenta = exports.gray = exports.white = exports.yellow = exports.green = exports.red = exports.blue = void 0;
+const misc_1 = require("../misc");
+const colors_1 = require("./colors");
+function ansiHSL(h, s, l, text) {
+    let { r, g, b } = (0, colors_1.hslToRGB)({ h, s, l });
+    return ansiRGB(r, g, b, text);
+}
+function ansiRGB(r, g, b, text) {
+    if ((0, misc_1.isNode)()) {
+        return `\x1b[38;5;${16 + (36 * Math.round(r / 255 * 5)) + (6 * Math.round(g / 255 * 5)) + Math.round(b / 255 * 5)}m${text}\x1b[0m`;
+    }
+    return `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+const lightness = 68;
+exports.blue = ansiHSL.bind(null, 235, 100, lightness);
+exports.red = ansiHSL.bind(null, 0, 100, lightness);
+const green = (text) => `\x1b[32m${text}\x1b[0m`;
+exports.green = green;
+const yellow = (text) => `\x1b[33m${text}\x1b[0m`;
+exports.yellow = yellow;
+exports.white = ansiHSL.bind(null, 0, 0, 80);
+exports.gray = ansiHSL.bind(null, 0, 0, 50);
+const magenta = (text) => `\x1b[35m${text}\x1b[0m`;
+exports.magenta = magenta;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "6a2e2841af8c356adef89cbab8659ff16801bdc6d2121166f6d08e7f6395d393"; */

package/src/lz4/dist/LZ4.ts.cache

@@ -0,0 +1,53 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.LZ4 = void 0;
+// NOTE: Even if we wanted to use the production version, we couldn't because it's not compatible with the client-side code, because they decided to do a file read to load in their WebAssembly. 
+const lz4_wasm_nodejs_1 = __importDefault(require("./lz4_wasm_nodejs"));
+const measure_1 = require("../profiling/measure");
+class LZ4 {
+    static compress(data) {
+        return this.compressUntracked(data);
+    }
+    static compressUntracked(data) {
+        try {
+            return Buffer.from(lz4_wasm_nodejs_1.default.compress(data));
+        }
+        catch (e) {
+            // Rethrow non errors as properly wrapped errors
+            if (!(e && e instanceof Error)) {
+                throw new Error(`Error compressing LZ4: ${e}`);
+            }
+            throw e;
+        }
+    }
+    static decompress(data) {
+        try {
+            return Buffer.from(lz4_wasm_nodejs_1.default.decompress(data));
+        }
+        catch (e) {
+            // Rethrow non errors as properly wrapped errors
+            if (!(e && e instanceof Error)) {
+                throw new Error(`Error decompressing LZ4: ${e}`);
+            }
+            throw e;
+        }
+    }
+}
+exports.LZ4 = LZ4;
+__decorate([
+    measure_1.measureFnc
+], LZ4, "compress", null);
+__decorate([
+    measure_1.measureFnc
+], LZ4, "decompress", null);
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "d9a6623efbf85b9a38828fb6c3eee7d40e28387f215cb27e405eb1b47eb66e8d"; */