@tstdl/base 0.85.13 → 0.86.0-beta1

package/utils/base64.js

@@ -1,159 +1,172 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var base64_exports = {};
-__export(base64_exports, {
-  base64ToBase64Url: () => base64ToBase64Url,
-  base64UrlToBase64: () => base64UrlToBase64,
-  decodeBase64: () => decodeBase64,
-  decodeBase64Url: () => decodeBase64Url,
-  encodeBase64: () => encodeBase64,
-  encodeBase64Url: () => encodeBase64Url,
-  stringToUtf8Array: () => stringToUtf8Array,
-  utf8ArrayToString: () => utf8ArrayToString
-});
-module.exports = __toCommonJS(base64_exports);
-var import_supports = require("../supports.js");
-var import_binary = require("./binary.js");
-var import_type_guards = require("./type-guards.js");
-function encodeBase64(array, bytesOffset, bytesLength) {
-  let arrayBuffer;
-  let offset;
-  let length;
-  if ((0, import_type_guards.isArrayBuffer)(array)) {
-    arrayBuffer = array;
-  } else {
-    arrayBuffer = array.buffer;
-    offset = bytesOffset ?? array.byteOffset;
-    length = bytesLength ?? array.byteLength;
-  }
-  if (import_supports.supportsBuffer) {
-    const buffer = Buffer.from(arrayBuffer, offset, length);
-    const base64 = buffer.toString("base64");
-    return base64;
-  }
-  return encodeBase64Fallback(array);
+/* eslint-disable no-bitwise */
+import { supportsBuffer } from '../supports.js';
+import { toUint8Array } from './binary.js';
+import { isArrayBuffer, isDefined } from './type-guards.js';
+export function encodeBase64(array, bytesOffset, bytesLength) {
+    let arrayBuffer;
+    let offset;
+    let length;
+    if (isArrayBuffer(array)) {
+        arrayBuffer = array;
+    }
+    else {
+        arrayBuffer = array.buffer;
+        offset = bytesOffset ?? array.byteOffset;
+        length = bytesLength ?? array.byteLength;
+    }
+    if (supportsBuffer) {
+        const buffer = Buffer.from(arrayBuffer, offset, length);
+        const base64 = buffer.toString('base64');
+        return base64;
+    }
+    return encodeBase64Fallback(array);
 }
-function decodeBase64(base64) {
-  if (import_supports.supportsBuffer) {
-    const buffer = Buffer.from(base64, "base64");
-    return buffer;
-  }
-  return decodeBase64Fallback(base64);
+export function decodeBase64(base64) {
+    if (supportsBuffer) {
+        const buffer = Buffer.from(base64, 'base64');
+        return buffer;
+    }
+    return decodeBase64Fallback(base64);
 }
-function encodeBase64Url(array, bytesOffset, length) {
-  return base64ToBase64Url(encodeBase64(array, bytesOffset, length));
+export function encodeBase64Url(array, bytesOffset, length) {
+    return base64ToBase64Url(encodeBase64(array, bytesOffset, length));
 }
-function decodeBase64Url(base64Url) {
-  return decodeBase64(base64UrlToBase64(base64Url));
+export function decodeBase64Url(base64Url) {
+    return decodeBase64(base64UrlToBase64(base64Url));
 }
-function base64ToBase64Url(input) {
-  return input.replace(/=/ug, "").replace(/\+/ug, "-").replace(/\//ug, "_");
+export function base64ToBase64Url(input) {
+    return input
+        .replace(/=/ug, '') // eslint-disable-line no-div-regex
+        .replace(/\+/ug, '-')
+        .replace(/\//ug, '_');
 }
-function base64UrlToBase64(input) {
-  return input.padEnd(input.length + (4 - input.length % 4) % 4, "=").replace(/-/ug, "+").replace(/_/ug, "/");
+export function base64UrlToBase64(input) {
+    return input.padEnd(input.length + ((4 - (input.length % 4)) % 4), '=')
+        .replace(/-/ug, '+')
+        .replace(/_/ug, '/');
 }
 function encodeBase64Fallback(data) {
-  const bytes = (0, import_binary.toUint8Array)(data);
-  let nMod3 = 2;
-  let base64 = "";
-  let nUint24 = 0;
-  for (let index = 0; index < bytes.length; index++) {
-    nMod3 = index % 3;
-    nUint24 |= bytes[index] << (16 >>> nMod3 & 24);
-    if (nMod3 === 2 || bytes.length - index === 1) {
-      base64 += String.fromCharCode(uint6ToBase64(nUint24 >>> 18 & 63), uint6ToBase64(nUint24 >>> 12 & 63), uint6ToBase64(nUint24 >>> 6 & 63), uint6ToBase64(nUint24 & 63));
-      nUint24 = 0;
+    const bytes = toUint8Array(data);
+    let nMod3 = 2;
+    let base64 = '';
+    let nUint24 = 0;
+    for (let index = 0; index < bytes.length; index++) {
+        nMod3 = index % 3;
+        nUint24 |= bytes[index] << ((16 >>> nMod3) & 24);
+        if (nMod3 === 2 || bytes.length - index === 1) {
+            base64 += String.fromCharCode(uint6ToBase64((nUint24 >>> 18) & 63), uint6ToBase64((nUint24 >>> 12) & 63), uint6ToBase64((nUint24 >>> 6) & 63), uint6ToBase64(nUint24 & 63));
+            nUint24 = 0;
+        }
     }
-  }
-  return base64.substring(0, base64.length - 2 + nMod3) + (nMod3 == 2 ? "" : nMod3 == 1 ? "=" : "==");
+    return base64.substring(0, base64.length - 2 + nMod3) + (nMod3 == 2 ? '' : nMod3 == 1 ? '=' : '==');
 }
 function decodeBase64Fallback(base64, blockSize) {
-  const clearedBase64 = base64.replace(/[^A-Za-z0-9+/]/ug, "");
-  const inputLength = clearedBase64.length;
-  const outputLength = (0, import_type_guards.isDefined)(blockSize) ? Math.ceil((inputLength * 3 + 1 >> 2) / blockSize) * blockSize : inputLength * 3 + 1 >> 2;
-  const bytes = new Uint8Array(outputLength);
-  let nUint24 = 0;
-  let nOutIdx = 0;
-  for (let index = 0; index < inputLength; index++) {
-    const nMod4 = index & 3;
-    nUint24 |= base64ToUint6(clearedBase64.charCodeAt(index)) << 6 * (3 - nMod4);
-    if (nMod4 === 3 || inputLength - index === 1) {
-      for (let nMod3 = 0; nMod3 < 3 && nOutIdx < outputLength; nMod3++, nOutIdx++) {
-        bytes[nOutIdx] = nUint24 >>> (16 >>> nMod3 & 24) & 255;
-      }
-      nUint24 = 0;
+    const clearedBase64 = base64.replace(/[^A-Za-z0-9+/]/ug, '');
+    const inputLength = clearedBase64.length;
+    const outputLength = isDefined(blockSize) ? Math.ceil(((inputLength * 3) + 1 >> 2) / blockSize) * blockSize : (inputLength * 3) + 1 >> 2;
+    const bytes = new Uint8Array(outputLength);
+    let nUint24 = 0;
+    let nOutIdx = 0;
+    for (let index = 0; index < inputLength; index++) {
+        const nMod4 = index & 3;
+        nUint24 |= base64ToUint6(clearedBase64.charCodeAt(index)) << 6 * (3 - nMod4);
+        if (nMod4 === 3 || inputLength - index === 1) {
+            for (let nMod3 = 0; nMod3 < 3 && nOutIdx < outputLength; nMod3++, nOutIdx++) {
+                bytes[nOutIdx] = (nUint24 >>> ((16 >>> nMod3) & 24)) & 255;
+            }
+            nUint24 = 0;
+        }
     }
-  }
-  return bytes;
+    return bytes;
 }
-function utf8ArrayToString(bytes) {
-  let string = "";
-  for (let index = 0; index < bytes.length; index++) {
-    const byte = bytes[index];
-    const charCode = byte > 251 && byte < 254 && index + 5 < bytes.length ? (byte - 252) * 1073741824 + (bytes[++index] - 128 << 24) + (bytes[++index] - 128 << 18) + (bytes[++index] - 128 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128 : byte > 247 && byte < 252 && index + 4 < bytes.length ? (byte - 248 << 24) + (bytes[++index] - 128 << 18) + (bytes[++index] - 128 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128 : byte > 239 && byte < 248 && index + 3 < bytes.length ? (byte - 240 << 18) + (bytes[++index] - 128 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128 : byte > 223 && byte < 240 && index + 2 < bytes.length ? (byte - 224 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128 : byte > 191 && byte < 224 && index + 1 < bytes.length ? (byte - 192 << 6) + bytes[++index] - 128 : byte;
-    string += String.fromCharCode(charCode);
-  }
-  return string;
+export function utf8ArrayToString(bytes) {
+    let string = '';
+    for (let index = 0; index < bytes.length; index++) {
+        const byte = bytes[index];
+        const charCode = byte > 251 && byte < 254 && index + 5 < bytes.length
+            ? ((byte - 252) * 1073741824) + (bytes[++index] - 128 << 24) + (bytes[++index] - 128 << 18) + (bytes[++index] - 128 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128
+            : byte > 247 && byte < 252 && index + 4 < bytes.length
+                ? (byte - 248 << 24) + (bytes[++index] - 128 << 18) + (bytes[++index] - 128 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128
+                : byte > 239 && byte < 248 && index + 3 < bytes.length
+                    ? (byte - 240 << 18) + (bytes[++index] - 128 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128
+                    : byte > 223 && byte < 240 && index + 2 < bytes.length
+                        ? (byte - 224 << 12) + (bytes[++index] - 128 << 6) + bytes[++index] - 128
+                        : byte > 191 && byte < 224 && index + 1 < bytes.length
+                            ? (byte - 192 << 6) + bytes[++index] - 128
+                            : byte;
+        string += String.fromCharCode(charCode);
+    }
+    return string;
 }
-function stringToUtf8Array(string) {
-  let bytesLength = 0;
-  for (let i = 0; i < string.length; i++) {
-    const char = string.charCodeAt(i);
-    bytesLength += char < 128 ? 1 : char < 2048 ? 2 : char < 65536 ? 3 : char < 2097152 ? 4 : char < 67108864 ? 5 : 6;
-  }
-  const bytes = new Uint8Array(bytesLength);
-  for (let byteIndex = 0, charIndex = 0; byteIndex < bytesLength; charIndex++) {
-    const char = string.charCodeAt(charIndex);
-    if (char < 128) {
-      bytes[byteIndex++] = char;
-    } else if (char < 2048) {
-      bytes[byteIndex++] = 192 + (char >>> 6);
-      bytes[byteIndex++] = 128 + (char & 63);
-    } else if (char < 65536) {
-      bytes[byteIndex++] = 224 + (char >>> 12);
-      bytes[byteIndex++] = 128 + (char >>> 6 & 63);
-      bytes[byteIndex++] = 128 + (char & 63);
-    } else if (char < 2097152) {
-      bytes[byteIndex++] = 240 + (char >>> 18);
-      bytes[byteIndex++] = 128 + (char >>> 12 & 63);
-      bytes[byteIndex++] = 128 + (char >>> 6 & 63);
-      bytes[byteIndex++] = 128 + (char & 63);
-    } else if (char < 67108864) {
-      bytes[byteIndex++] = 248 + (char >>> 24);
-      bytes[byteIndex++] = 128 + (char >>> 18 & 63);
-      bytes[byteIndex++] = 128 + (char >>> 12 & 63);
-      bytes[byteIndex++] = 128 + (char >>> 6 & 63);
-      bytes[byteIndex++] = 128 + (char & 63);
-    } else {
-      bytes[byteIndex++] = 252 + (char >>> 30);
-      bytes[byteIndex++] = 128 + (char >>> 24 & 63);
-      bytes[byteIndex++] = 128 + (char >>> 18 & 63);
-      bytes[byteIndex++] = 128 + (char >>> 12 & 63);
-      bytes[byteIndex++] = 128 + (char >>> 6 & 63);
-      bytes[byteIndex++] = 128 + (char & 63);
+// eslint-disable-next-line max-lines-per-function, max-statements
+export function stringToUtf8Array(string) {
+    let bytesLength = 0;
+    for (let i = 0; i < string.length; i++) {
+        const char = string.charCodeAt(i);
+        bytesLength += char < 0x80 ? 1 : char < 0x800 ? 2 : char < 0x10000 ? 3 : char < 0x200000 ? 4 : char < 0x4000000 ? 5 : 6;
+    }
+    const bytes = new Uint8Array(bytesLength);
+    for (let byteIndex = 0, charIndex = 0; byteIndex < bytesLength; charIndex++) {
+        const char = string.charCodeAt(charIndex);
+        if (char < 128) {
+            bytes[byteIndex++] = char;
+        }
+        else if (char < 0x800) {
+            bytes[byteIndex++] = 192 + (char >>> 6);
+            bytes[byteIndex++] = 128 + (char & 63);
+        }
+        else if (char < 0x10000) {
+            bytes[byteIndex++] = 224 + (char >>> 12);
+            bytes[byteIndex++] = 128 + ((char >>> 6) & 63);
+            bytes[byteIndex++] = 128 + (char & 63);
+        }
+        else if (char < 0x200000) {
+            bytes[byteIndex++] = 240 + (char >>> 18);
+            bytes[byteIndex++] = 128 + ((char >>> 12) & 63);
+            bytes[byteIndex++] = 128 + ((char >>> 6) & 63);
+            bytes[byteIndex++] = 128 + (char & 63);
+        }
+        else if (char < 0x4000000) {
+            bytes[byteIndex++] = 248 + (char >>> 24);
+            bytes[byteIndex++] = 128 + ((char >>> 18) & 63);
+            bytes[byteIndex++] = 128 + ((char >>> 12) & 63);
+            bytes[byteIndex++] = 128 + ((char >>> 6) & 63);
+            bytes[byteIndex++] = 128 + (char & 63);
+        }
+        else {
+            bytes[byteIndex++] = 252 + (char >>> 30);
+            bytes[byteIndex++] = 128 + ((char >>> 24) & 63);
+            bytes[byteIndex++] = 128 + ((char >>> 18) & 63);
+            bytes[byteIndex++] = 128 + ((char >>> 12) & 63);
+            bytes[byteIndex++] = 128 + ((char >>> 6) & 63);
+            bytes[byteIndex++] = 128 + (char & 63);
+        }
     }
-  }
-  return bytes;
+    return bytes;
 }
 function uint6ToBase64(nUint6) {
-  return nUint6 < 26 ? nUint6 + 65 : nUint6 < 52 ? nUint6 + 71 : nUint6 < 62 ? nUint6 - 4 : nUint6 === 62 ? 43 : nUint6 === 63 ? 47 : 65;
+    return nUint6 < 26
+        ? nUint6 + 65
+        : nUint6 < 52
+            ? nUint6 + 71
+            : nUint6 < 62
+                ? nUint6 - 4
+                : nUint6 === 62
+                    ? 43
+                    : nUint6 === 63
+                        ? 47
+                        : 65;
 }
 function base64ToUint6(char) {
-  return char > 64 && char < 91 ? char - 65 : char > 96 && char < 123 ? char - 71 : char > 47 && char < 58 ? char + 4 : char === 43 ? 62 : char === 47 ? 63 : 0;
+    return char > 64 && char < 91
+        ? char - 65
+        : char > 96 && char < 123
+            ? char - 71
+            : char > 47 && char < 58
+                ? char + 4
+                : char === 43
+                    ? 62
+                    : char === 47
+                        ? 63
+                        : 0;
 }

package/utils/benchmark.js

@@ -1,121 +1,128 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var benchmark_exports = {};
-__export(benchmark_exports, {
-  benchmark: () => benchmark,
-  benchmarkAsync: () => benchmarkAsync,
-  measureBenchmarkOverhead: () => measureBenchmarkOverhead,
-  timedBenchmark: () => timedBenchmark,
-  timedBenchmarkAsync: () => timedBenchmarkAsync
-});
-module.exports = __toCommonJS(benchmark_exports);
-var import_math = require("./math.js");
-var import_noop = require("./noop.js");
-var import_timer = require("./timer.js");
+import { clamp } from './math.js';
+import { noop } from './noop.js';
+import { Timer } from './timer.js';
 let microsecondsPerTimerRead = 0;
-function measureBenchmarkOverhead(duration = 250) {
-  const timer = new import_timer.Timer(true);
-  const warmupDuration = (0, import_math.clamp)(duration / 2, 50, 500);
-  const testDuration = Math.max(duration - warmupDuration, 50);
-  let operations = 0;
-  let warmupPhase = true;
-  let warmupFunction = () => {
-    if (warmupPhase && timer.milliseconds >= warmupDuration) {
-      warmupPhase = false;
-      operations = 0;
-      warmupFunction = import_noop.noop;
-      timer.restart();
-    }
-  };
-  timer.start();
-  do {
-    warmupFunction();
-    operations++;
-  } while (timer.milliseconds < testDuration || warmupPhase);
-  timer.stop();
-  microsecondsPerTimerRead = timer.microseconds / operations;
+/**
+ * measure the timer overhead for more precise benchmarks
+ *
+ * only relevant for benchmarked functions with a execution time in the range of microseconds
+ * @param duration fow how long to measure the overhead in milliseconds (default 250)
+ */
+export function measureBenchmarkOverhead(duration = 250) {
+    const timer = new Timer(true);
+    const warmupDuration = clamp(duration / 2, 50, 500);
+    const testDuration = Math.max(duration - warmupDuration, 50);
+    let operations = 0;
+    let warmupPhase = true;
+    let warmupFunction = () => {
+        if (warmupPhase && timer.milliseconds >= warmupDuration) {
+            warmupPhase = false;
+            operations = 0;
+            warmupFunction = noop;
+            timer.restart();
+        }
+    };
+    timer.start();
+    do {
+        warmupFunction();
+        operations++;
+    } while (timer.milliseconds < testDuration || warmupPhase);
+    timer.stop();
+    microsecondsPerTimerRead = timer.microseconds / operations;
 }
-function benchmark(runs, fn, warmupDuration = 500) {
-  warmup(fn, warmupDuration);
-  const timer = new import_timer.Timer(true);
-  for (let run = 1; run <= runs; run++) {
-    fn(run);
-  }
-  return calculateResult(runs, timer.milliseconds);
+/**
+ * benchmarks a function for a number of times
+ * @param runs how often to run the benchmarked function
+ * @param fn the function to benchmark
+ * @param warmupDuration run the function for specified duration in milliseconds to warm it up
+ */
+export function benchmark(runs, fn, warmupDuration = 500) {
+    warmup(fn, warmupDuration);
+    const timer = new Timer(true);
+    for (let run = 1; run <= runs; run++) {
+        fn(run);
+    }
+    return calculateResult(runs, timer.milliseconds);
 }
-function timedBenchmark(milliseconds, fn, warmupDuration = 500) {
-  warmup(fn, warmupDuration);
-  const timer = new import_timer.Timer(true);
-  let runs = 0;
-  do {
-    runs++;
-    fn(runs);
-  } while (timer.milliseconds < milliseconds);
-  return calculateTimedResult(runs, timer.milliseconds);
+/**
+ * benchmarks a function for a duration
+ *
+ * hint: run measureTimerOverhead before benchmark for more precise results
+ * @param milliseconds for how long to benchmark the function
+ * @param fn the function to benchmark
+ * @param warmupDuration run the function for specified duration in milliseconds to warm it up
+ */
+export function timedBenchmark(milliseconds, fn, warmupDuration = 500) {
+    warmup(fn, warmupDuration);
+    const timer = new Timer(true);
+    let runs = 0;
+    do {
+        runs++;
+        fn(runs);
+    } while (timer.milliseconds < milliseconds);
+    return calculateTimedResult(runs, timer.milliseconds);
 }
-async function benchmarkAsync(runs, fn, warmupDuration = 500) {
-  await warmupAsync(fn, warmupDuration);
-  const timer = new import_timer.Timer(true);
-  for (let run = 1; run <= runs; run++) {
-    await fn(run);
-  }
-  return calculateResult(runs, timer.milliseconds);
+/**
+ * benchmarks an async function for a number of times
+ * @param runs how often to run the benchmarked function
+ * @param fn the function to benchmark
+ * @param warmupDuration run the function for specified duration in milliseconds to warm it up
+ */
+export async function benchmarkAsync(runs, fn, warmupDuration = 500) {
+    await warmupAsync(fn, warmupDuration);
+    const timer = new Timer(true);
+    for (let run = 1; run <= runs; run++) {
+        await fn(run);
+    }
+    return calculateResult(runs, timer.milliseconds);
 }
-async function timedBenchmarkAsync(milliseconds, fn, warmupDuration = 500) {
-  await warmupAsync(fn, warmupDuration);
-  const timer = new import_timer.Timer(true);
-  let runs = 0;
-  do {
-    runs++;
-    await fn(runs);
-  } while (timer.milliseconds < milliseconds);
-  return calculateTimedResult(runs, timer.milliseconds);
+/**
+ * benchmarks an async function for a duration
+ *
+ * hint: run measureTimerOverhead before benchmark for more precise results
+ * @param milliseconds for how long to benchmark the function
+ * @param fn the function to benchmark
+ * @param warmupDuration run the function for specified duration in milliseconds to warm it up
+ */
+export async function timedBenchmarkAsync(milliseconds, fn, warmupDuration = 500) {
+    await warmupAsync(fn, warmupDuration);
+    const timer = new Timer(true);
+    let runs = 0;
+    do {
+        runs++;
+        await fn(runs);
+    } while (timer.milliseconds < milliseconds);
+    return calculateTimedResult(runs, timer.milliseconds);
 }
 function calculateTimedResult(runs, time) {
-  const correctedTime = time - microsecondsPerTimerRead * runs / 1e3;
-  return calculateResult(runs, correctedTime);
+    const correctedTime = time - (microsecondsPerTimerRead * runs / 1000);
+    return calculateResult(runs, correctedTime);
 }
 function calculateResult(runs, time) {
-  const operationsPerMillisecond = runs / time;
-  const millisecondsPerOperation = time / runs;
-  return {
-    operationsPerMillisecond,
-    millisecondsPerOperation
-  };
+    const operationsPerMillisecond = runs / time;
+    const millisecondsPerOperation = time / runs;
+    return {
+        operationsPerMillisecond,
+        millisecondsPerOperation
+    };
 }
 function warmup(fn, duration) {
-  if (duration <= 0) {
-    return;
-  }
-  const timer = new import_timer.Timer(true);
-  let runs = 0;
-  while (timer.milliseconds < duration) {
-    fn(++runs);
-  }
+    if (duration <= 0) {
+        return;
+    }
+    const timer = new Timer(true);
+    let runs = 0;
+    while (timer.milliseconds < duration) {
+        fn(++runs);
+    }
 }
 async function warmupAsync(fn, duration) {
-  if (duration <= 0) {
-    return;
-  }
-  const timer = new import_timer.Timer(true);
-  let runs = 0;
-  while (timer.milliseconds < duration) {
-    await fn(++runs);
-  }
+    if (duration <= 0) {
+        return;
+    }
+    const timer = new Timer(true);
+    let runs = 0;
+    while (timer.milliseconds < duration) {
+        await fn(++runs);
+    }
 }