@thi.ng/bench 3.4.12 → 3.4.14

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1,2 +1,6 @@
-export const FLOAT = (x) => x.toFixed(2);
-export const EMPTY = () => "";
+const FLOAT = (x) => x.toFixed(2);
+const EMPTY = () => "";
+export {
+  EMPTY,
+  FLOAT
+};

package/bench.js

@@ -1,34 +1,23 @@
 import { timed, timedResult } from "./timed.js";
-/**
- * Executes given function `n` times, prints elapsed time to console and
- * returns last result from fn. The optional `prefix` will be displayed
- * with the output, allowing to label different measurements.
- *
- * @param fn - function to time
- * @param n - number of iterations
- */
-export const bench = (fn, n = 1e6, prefix = "") => {
-    let res;
-    return timed(() => {
-        while (n-- > 0) {
-            res = fn();
-        }
-        return res;
-    }, prefix);
+const bench = (fn, n = 1e6, prefix = "") => {
+  let res;
+  return timed(() => {
+    while (n-- > 0) {
+      res = fn();
+    }
+    return res;
+  }, prefix);
 };
-/**
- * Similar to {@link bench}, but produces no output and instead returns
- * tuple of `fn`'s last result and the grand total time measurement.
- *
- * @param fn - function to time
- * @param n - number of iterations
- */
-export const benchResult = (fn, n = 1e6) => {
-    let res;
-    return timedResult(() => {
-        while (n-- > 0) {
-            res = fn();
-        }
-        return res;
-    });
+const benchResult = (fn, n = 1e6) => {
+  let res;
+  return timedResult(() => {
+    while (n-- > 0) {
+      res = fn();
+    }
+    return res;
+  });
+};
+export {
+  bench,
+  benchResult
 };

package/benchmark.js

@@ -1,55 +1,53 @@
 import { benchResult } from "./bench.js";
 import { FORMAT_DEFAULT } from "./format/default.js";
-export const DEFAULT_OPTS = {
-    title: "benchmark",
-    iter: 1e3,
-    size: 1,
-    warmup: 10,
-    output: true,
-    format: FORMAT_DEFAULT,
+const DEFAULT_OPTS = {
+  title: "benchmark",
+  iter: 1e3,
+  size: 1,
+  warmup: 10,
+  output: true,
+  format: FORMAT_DEFAULT
 };
-export const benchmark = (fn, opts) => {
-    const _opts = { ...DEFAULT_OPTS, ...opts };
-    const { iter, size, warmup, output, format } = _opts;
-    output && outputString(format.start(_opts));
-    const t = benchResult(fn, warmup * size)[1];
-    output && outputString(format.warmup(t, _opts));
-    const samples = [];
-    for (let i = iter; i-- > 0;) {
-        samples.push(benchResult(fn, size)[1]);
-    }
-    samples.sort((a, b) => a - b);
-    const total = samples.reduce((acc, x) => acc + x, 0);
-    const mean = total / iter;
-    const median = samples[iter >> 1];
-    const min = samples[0];
-    const max = samples[iter - 1];
-    const q1 = samples[Math.ceil(iter * 0.25)];
-    const q3 = samples[Math.ceil(iter * 0.75)];
-    const sd = (Math.sqrt(samples.reduce((acc, x) => acc + (mean - x) ** 2, 0) / iter) /
-        mean) *
-        100;
-    const res = {
-        title: _opts.title,
-        iter,
-        size,
-        total,
-        mean,
-        median,
-        min,
-        max,
-        q1,
-        q3,
-        sd,
-    };
-    output && outputString(format.result(res));
-    return res;
+const benchmark = (fn, opts) => {
+  const _opts = { ...DEFAULT_OPTS, ...opts };
+  const { iter, size, warmup, output, format } = _opts;
+  output && outputString(format.start(_opts));
+  const t = benchResult(fn, warmup * size)[1];
+  output && outputString(format.warmup(t, _opts));
+  const samples = [];
+  for (let i = iter; i-- > 0; ) {
+    samples.push(benchResult(fn, size)[1]);
+  }
+  samples.sort((a, b) => a - b);
+  const total = samples.reduce((acc, x) => acc + x, 0);
+  const mean = total / iter;
+  const median = samples[iter >> 1];
+  const min = samples[0];
+  const max = samples[iter - 1];
+  const q1 = samples[Math.ceil(iter * 0.25)];
+  const q3 = samples[Math.ceil(iter * 0.75)];
+  const sd = Math.sqrt(
+    samples.reduce((acc, x) => acc + (mean - x) ** 2, 0) / iter
+  ) / mean * 100;
+  const res = {
+    title: _opts.title,
+    iter,
+    size,
+    total,
+    mean,
+    median,
+    min,
+    max,
+    q1,
+    q3,
+    sd
+  };
+  output && outputString(format.result(res));
+  return res;
+};
+const outputString = (str) => str !== "" && console.log(str);
+export {
+  DEFAULT_OPTS,
+  benchmark,
+  outputString
 };
-/**
- * Only outputs non-empty strings to console.
- *
- * @param str
- *
- * @internal
- */
-export const outputString = (str) => str !== "" && console.log(str);

package/format/csv.js

@@ -1,20 +1,21 @@
 import { EMPTY, FLOAT } from "../api.js";
-export const FORMAT_CSV = {
-    prefix: () => `Title,Iterations,Size,Total,Mean,Median,Min,Max,Q1,Q3,SD%`,
-    start: EMPTY,
-    warmup: EMPTY,
-    result: (res) => `"${res.title}",${res.iter},${res.size},${[
-        res.total,
-        res.mean,
-        res.median,
-        res.min,
-        res.max,
-        res.q1,
-        res.q3,
-        res.sd,
-    ]
-        .map(FLOAT)
-        .join(",")}`,
-    total: EMPTY,
-    suffix: EMPTY,
+const FORMAT_CSV = {
+  prefix: () => `Title,Iterations,Size,Total,Mean,Median,Min,Max,Q1,Q3,SD%`,
+  start: EMPTY,
+  warmup: EMPTY,
+  result: (res) => `"${res.title}",${res.iter},${res.size},${[
+    res.total,
+    res.mean,
+    res.median,
+    res.min,
+    res.max,
+    res.q1,
+    res.q3,
+    res.sd
+  ].map(FLOAT).join(",")}`,
+  total: EMPTY,
+  suffix: EMPTY
+};
+export {
+  FORMAT_CSV
 };

package/format/default.js

@@ -1,17 +1,21 @@
 import { EMPTY, FLOAT } from "../api.js";
-export const FORMAT_DEFAULT = {
-    prefix: EMPTY,
-    start: ({ title }) => `benchmarking: ${title}`,
-    warmup: (t, { warmup }) => `\twarmup... ${FLOAT(t)}ms (${warmup} runs)`,
-    result: ({ iter, size, total, mean, median, min, max, q1, q3, sd }) => 
+const FORMAT_DEFAULT = {
+  prefix: EMPTY,
+  start: ({ title }) => `benchmarking: ${title}`,
+  warmup: (t, { warmup }) => `	warmup... ${FLOAT(t)}ms (${warmup} runs)`,
+  result: ({ iter, size, total, mean, median, min, max, q1, q3, sd }) => (
     // prettier-ignore
-    `\ttotal: ${FLOAT(total)}ms, runs: ${iter} (@ ${size} calls/iter)
-\tmean: ${FLOAT(mean)}ms, median: ${FLOAT(median)}ms, range: [${FLOAT(min)}..${FLOAT(max)}]
-\tq1: ${FLOAT(q1)}ms, q3: ${FLOAT(q3)}ms
-\tsd: ${FLOAT(sd)}%`,
-    total: (res) => {
-        const fastest = res.slice().sort((a, b) => a.mean - b.mean)[0];
-        return `Fastest: "${fastest.title}"`;
-    },
-    suffix: () => `---`,
+    `	total: ${FLOAT(total)}ms, runs: ${iter} (@ ${size} calls/iter)
+	mean: ${FLOAT(mean)}ms, median: ${FLOAT(median)}ms, range: [${FLOAT(min)}..${FLOAT(max)}]
+	q1: ${FLOAT(q1)}ms, q3: ${FLOAT(q3)}ms
+	sd: ${FLOAT(sd)}%`
+  ),
+  total: (res) => {
+    const fastest = res.slice().sort((a, b) => a.mean - b.mean)[0];
+    return `Fastest: "${fastest.title}"`;
+  },
+  suffix: () => `---`
+};
+export {
+  FORMAT_DEFAULT
 };

package/format/markdown.js

@@ -1,13 +1,11 @@
 import { EMPTY, FLOAT } from "../api.js";
 const $n = (n, char = "-") => new Array(n).fill(char).join("");
 const pad = (w) => {
-    const column = $n(w, " ");
-    return (x) => {
-        const s = typeof x === "number" ? FLOAT(x) : x;
-        return s.length < w
-            ? column.substr(0, w - s.length) + s
-            : s.substr(0, w);
-    };
+  const column = $n(w, " ");
+  return (x) => {
+    const s = typeof x === "number" ? FLOAT(x) : x;
+    return s.length < w ? column.substr(0, w - s.length) + s : s.substr(0, w);
+  };
 };
 const c24 = pad(24);
 const c12 = pad(12);
@@ -18,35 +16,39 @@ const d8 = $n(7) + ":";
 const COLUMNS = [c24, c8, c8, c12, c8, c8, c8, c8, c8, c8, c8];
 const DASHES = [d24, d8, d8, d12, d8, d8, d8, d8, d8, d8, d8];
 const row = (cols) => `|${cols.map((x, i) => COLUMNS[i](x)).join("|")}|`;
-export const FORMAT_MD = {
-    prefix: () => row([
-        "Title",
-        "Iter",
-        "Size",
-        "Total",
-        "Mean",
-        "Median",
-        "Min",
-        "Max",
-        "Q1",
-        "Q3",
-        "SD%",
-    ]) + `\n|${DASHES.join("|")}|`,
-    start: EMPTY,
-    warmup: EMPTY,
-    result: (res) => row([
-        res.title,
-        "" + res.iter,
-        "" + res.size,
-        res.total,
-        res.mean,
-        res.median,
-        res.min,
-        res.max,
-        res.q1,
-        res.q3,
-        res.sd,
-    ]),
-    total: EMPTY,
-    suffix: EMPTY,
+const FORMAT_MD = {
+  prefix: () => row([
+    "Title",
+    "Iter",
+    "Size",
+    "Total",
+    "Mean",
+    "Median",
+    "Min",
+    "Max",
+    "Q1",
+    "Q3",
+    "SD%"
+  ]) + `
+|${DASHES.join("|")}|`,
+  start: EMPTY,
+  warmup: EMPTY,
+  result: (res) => row([
+    res.title,
+    "" + res.iter,
+    "" + res.size,
+    res.total,
+    res.mean,
+    res.median,
+    res.min,
+    res.max,
+    res.q1,
+    res.q3,
+    res.sd
+  ]),
+  total: EMPTY,
+  suffix: EMPTY
+};
+export {
+  FORMAT_MD
 };

package/now.js

@@ -1,33 +1,8 @@
-/**
- * If available, returns wrapper for `process.hrtime.bigint()` else falls back
- * to `performance.now()` or lacking that to `Date.now()`. In all cases, returns
- * a nanosec-scale timestamp, either as `bigint` or `number`.
- */
-export const now = typeof BigInt !== "undefined"
-    ? typeof process !== "undefined" &&
-        typeof process.hrtime !== "undefined" &&
-        typeof process.hrtime.bigint === "function"
-        ? () => process.hrtime.bigint()
-        : typeof performance !== "undefined"
-            ? () => BigInt(Math.floor(performance.now() * 1e6))
-            : () => BigInt(Date.now() * 1e6)
-    : typeof performance !== "undefined"
-        ? () => performance.now() * 1e6
-        : () => Date.now() * 1e6;
-/**
- * Returns the difference in milliseconds between 2 given {@link Timestamp}s.
- * `b` defaults to result of {@link now}.
- *
- * @param a
- * @param b
- */
-export const timeDiff = (a, b = now()) => (typeof BigInt !== "undefined"
-    ? Number(b - a)
-    : b - a) * 1e-6;
-/**
- * Takes a duration (either a number or bigint) in nanosec-scale (see
- * {@link now}) and converts it to a JS number in milliseconds.
- *
- * @param t
- */
-export const asMillis = (t) => (typeof t === "bigint" ? Number(t) : t) * 1e-6;
+const now = typeof BigInt !== "undefined" ? typeof process !== "undefined" && typeof process.hrtime !== "undefined" && typeof process.hrtime.bigint === "function" ? () => process.hrtime.bigint() : typeof performance !== "undefined" ? () => BigInt(Math.floor(performance.now() * 1e6)) : () => BigInt(Date.now() * 1e6) : typeof performance !== "undefined" ? () => performance.now() * 1e6 : () => Date.now() * 1e6;
+const timeDiff = (a, b = now()) => (typeof BigInt !== "undefined" ? Number(b - a) : b - a) * 1e-6;
+const asMillis = (t) => (typeof t === "bigint" ? Number(t) : t) * 1e-6;
+export {
+  asMillis,
+  now,
+  timeDiff
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/bench",
-  "version": "3.4.12",
+  "version": "3.4.14",
   "description": "Benchmarking & profiling utilities w/ various statistics & formatters (CSV, JSON, Markdown etc.)",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt <k+npm@thi.ng>",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc format",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,12 +35,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10"
+    "@thi.ng/api": "^8.9.12"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "@thi.ng/testament": "^0.4.5",
     "@types/node": "^20.10.2",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -116,5 +119,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/profiler.js

@@ -1,300 +1,308 @@
 import { benchResult } from "./bench.js";
 import { asMillis, now } from "./now.js";
-export class Profiler {
-    _session;
-    _profiles;
-    _enabled;
-    _overhead = 0;
-    constructor(opts) {
-        const { warmup, enabled } = {
-            warmup: 1e6,
-            enabled: true,
-            ...opts,
-        };
-        this.enable();
-        if (warmup > 0)
-            this.warmup(warmup);
-        enabled ? this.reset() : this.disable();
+class Profiler {
+  _session;
+  _profiles;
+  _enabled;
+  _overhead = 0;
+  constructor(opts) {
+    const { warmup, enabled } = {
+      warmup: 1e6,
+      enabled: true,
+      ...opts
+    };
+    this.enable();
+    if (warmup > 0)
+      this.warmup(warmup);
+    enabled ? this.reset() : this.disable();
+  }
+  isEnabled() {
+    return this._enabled;
+  }
+  /**
+   * Disables profiler and clears all existing profiles.
+   *
+   * @remarks
+   * Calls to {@link Profiler.start} and {@link Profiler.end} only are no-ops
+   * if the profiler is currently disabled.
+   */
+  disable() {
+    if (this._enabled) {
+      this._enabled = false;
+      this.reset();
     }
-    isEnabled() {
-        return this._enabled;
+  }
+  /**
+   * Enables profiler and clears all existing profiles.
+   *
+   * @remarks
+   * Calls to {@link Profiler.start} and {@link Profiler.end} only are no-ops
+   * if the profiler is currently disabled.
+   */
+  enable() {
+    if (!this._enabled) {
+      this._enabled = true;
+      this.reset();
     }
-    /**
-     * Disables profiler and clears all existing profiles.
-     *
-     * @remarks
-     * Calls to {@link Profiler.start} and {@link Profiler.end} only are no-ops
-     * if the profiler is currently disabled.
-     */
-    disable() {
-        if (this._enabled) {
-            this._enabled = false;
-            this.reset();
-        }
+  }
+  /**
+   * Resets profiler state and clears all recorded profiles.
+   */
+  reset() {
+    this._profiles = {};
+    this._session = void 0;
+    return this;
+  }
+  /**
+   * Prepare and return all recorded profiles as object of
+   * {@link ProfileResult}s.
+   *
+   * @remarks
+   * Automatically computes and subtracts internal overhead from each
+   * profile's total (Overhead is computed during profiler ctor and/or
+   * {@link Profiler.warmup}).
+   *
+   * Also see {@link Profiler.asCSV} to obtain results in CSV format.
+   */
+  deref() {
+    const { _profiles, _session, _overhead } = this;
+    if (!_session)
+      return {};
+    const res = {};
+    const sessionTotal = asMillis(_session.total) - _session.calls * _overhead;
+    for (let id in _profiles) {
+      const profile = _profiles[id];
+      const total = asMillis(profile.total) - profile.calls * _overhead;
+      const totalPercent = total / sessionTotal * 100;
+      const callsPercent = profile.calls / _session.calls * 100;
+      res[id] = {
+        id,
+        total,
+        timePerCall: total / profile.calls,
+        totalPercent,
+        calls: profile.calls,
+        callsPercent,
+        maxDepth: profile.maxDepth
+      };
     }
-    /**
-     * Enables profiler and clears all existing profiles.
-     *
-     * @remarks
-     * Calls to {@link Profiler.start} and {@link Profiler.end} only are no-ops
-     * if the profiler is currently disabled.
-     */
-    enable() {
-        if (!this._enabled) {
-            this._enabled = true;
-            this.reset();
-        }
+    return res;
+  }
+  /**
+   * Start a new profile (or add to an existing ID) by recording current
+   * timestamp (via {@link now}), number of calls (to this method and for this
+   * ID), as well as max. recursion depth. Use {@link Profiler.end} to
+   * stop/update measurements.
+   *
+   * @remarks
+   * Profiling only happens if the profiler is currently enabled, else a
+   * no-op.
+   *
+   * * @example
+   * ```ts
+   * const profiler = new Profiler();
+   *
+   * // recursive function
+   * const countdown = (n, acc = []) => {
+   *   profiler.start("countdown");
+   *   if (n > 0) countdown(n - 1, (acc.push(n),acc));
+   *   profiler.end("countdown");
+   *   return acc;
+   * }
+   *
+   * countdown(10);
+   * // [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
+   *
+   * countdown(5);
+   * // [ 5, 4, 3, 2, 1 ]
+   *
+   * profiler.deref()
+   * // {
+   * //   countdown: {
+   * //     id: 'countdown',
+   * //     total: 0.029665688286,
+   * //     timePerCall: 0.0017450404874117648,
+   * //     totalPercent: 96.0872831622525,
+   * //     calls: 17,
+   * //     callsPercent: 100,
+   * //     maxDepth: 11
+   * //   }
+   * // }
+   * ```
+   *
+   * @param id
+   */
+  start(id) {
+    if (!this._enabled)
+      return;
+    let profile = this._profiles[id];
+    const t0 = now();
+    if (!profile) {
+      this._profiles[id] = this.newProfile(t0);
+    } else {
+      profile.maxDepth = Math.max(profile.t0.push(t0), profile.maxDepth);
+      profile.calls++;
     }
-    /**
-     * Resets profiler state and clears all recorded profiles.
-     */
-    reset() {
-        this._profiles = {};
-        this._session = undefined;
-        return this;
+    if (!this._session) {
+      this._session = this.newProfile(t0);
+    } else {
+      this._session.calls++;
     }
-    /**
-     * Prepare and return all recorded profiles as object of
-     * {@link ProfileResult}s.
-     *
-     * @remarks
-     * Automatically computes and subtracts internal overhead from each
-     * profile's total (Overhead is computed during profiler ctor and/or
-     * {@link Profiler.warmup}).
-     *
-     * Also see {@link Profiler.asCSV} to obtain results in CSV format.
-     */
-    deref() {
-        const { _profiles, _session, _overhead } = this;
-        if (!_session)
-            return {};
-        const res = {};
-        const sessionTotal = asMillis(_session.total) - _session.calls * _overhead;
-        for (let id in _profiles) {
-            const profile = _profiles[id];
-            const total = asMillis(profile.total) - profile.calls * _overhead;
-            const totalPercent = (total / sessionTotal) * 100;
-            const callsPercent = (profile.calls / _session.calls) * 100;
-            res[id] = {
-                id,
-                total: total,
-                timePerCall: total / profile.calls,
-                totalPercent,
-                calls: profile.calls,
-                callsPercent,
-                maxDepth: profile.maxDepth,
-            };
-        }
-        return res;
+  }
+  /**
+   * Ends/updates measurements for given profile ID. Throws error if `id` is
+   * invalid or if no active profiling iteration exists for this ID (e.g. if
+   * this method is called more often than a corresponding
+   * {@link Profiler.start}).
+   *
+   * @remarks
+   * Profiling only happens if the profiler is currently enabled, else a
+   * no-op.
+   *
+   * @param id
+   */
+  end(id) {
+    if (!this._enabled)
+      return;
+    const t = now();
+    const profile = this._profiles[id];
+    if (!profile)
+      throw new Error(`invalid profile ID: ${id}`);
+    const t1 = profile.t0.pop();
+    if (t1 === void 0)
+      throw new Error(`no active profile for ID: ${id}`);
+    if (!profile.t0.length) {
+      profile.total += t - t1;
+      this._session.total += t - t1;
     }
-    /**
-     * Start a new profile (or add to an existing ID) by recording current
-     * timestamp (via {@link now}), number of calls (to this method and for this
-     * ID), as well as max. recursion depth. Use {@link Profiler.end} to
-     * stop/update measurements.
-     *
-     * @remarks
-     * Profiling only happens if the profiler is currently enabled, else a
-     * no-op.
-     *
-     * * @example
-     * ```ts
-     * const profiler = new Profiler();
-     *
-     * // recursive function
-     * const countdown = (n, acc = []) => {
-     *   profiler.start("countdown");
-     *   if (n > 0) countdown(n - 1, (acc.push(n),acc));
-     *   profiler.end("countdown");
-     *   return acc;
-     * }
-     *
-     * countdown(10);
-     * // [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
-     *
-     * countdown(5);
-     * // [ 5, 4, 3, 2, 1 ]
-     *
-     * profiler.deref()
-     * // {
-     * //   countdown: {
-     * //     id: 'countdown',
-     * //     total: 0.029665688286,
-     * //     timePerCall: 0.0017450404874117648,
-     * //     totalPercent: 96.0872831622525,
-     * //     calls: 17,
-     * //     callsPercent: 100,
-     * //     maxDepth: 11
-     * //   }
-     * // }
-     * ```
-     *
-     * @param id
-     */
-    start(id) {
-        if (!this._enabled)
-            return;
-        let profile = this._profiles[id];
-        const t0 = now();
-        if (!profile) {
-            this._profiles[id] = this.newProfile(t0);
-        }
-        else {
-            profile.maxDepth = Math.max(profile.t0.push(t0), profile.maxDepth);
-            profile.calls++;
-        }
-        if (!this._session) {
-            this._session = this.newProfile(t0);
-        }
-        else {
-            this._session.calls++;
-        }
-    }
-    /**
-     * Ends/updates measurements for given profile ID. Throws error if `id` is
-     * invalid or if no active profiling iteration exists for this ID (e.g. if
-     * this method is called more often than a corresponding
-     * {@link Profiler.start}).
-     *
-     * @remarks
-     * Profiling only happens if the profiler is currently enabled, else a
-     * no-op.
-     *
-     * @param id
-     */
-    end(id) {
-        if (!this._enabled)
-            return;
-        const t = now();
-        const profile = this._profiles[id];
-        if (!profile)
-            throw new Error(`invalid profile ID: ${id}`);
-        const t1 = profile.t0.pop();
-        if (t1 === undefined)
-            throw new Error(`no active profile for ID: ${id}`);
-        if (!profile.t0.length) {
-            // @ts-ignore num/bigint
-            profile.total += t - t1;
-            // @ts-ignore num/bigint
-            this._session.total += t - t1;
-        }
-    }
-    /**
-     * Takes a profile `id`, function `fn` and any (optional) arguments. Calls
-     * `fn` with given args and profiles it using provided ID. Returns result
-     * of `fn`.
-     *
-     * @remarks
-     * Also see {@link Profiler.wrap}
-     *
-     * @param id
-     * @param fn
-     */
-    profile(id, fn, ...args) {
+  }
+  /**
+   * Takes a profile `id`, function `fn` and any (optional) arguments. Calls
+   * `fn` with given args and profiles it using provided ID. Returns result
+   * of `fn`.
+   *
+   * @remarks
+   * Also see {@link Profiler.wrap}
+   *
+   * @param id
+   * @param fn
+   */
+  profile(id, fn, ...args) {
+    this.start(id);
+    const res = fn.apply(null, args);
+    this.end(id);
+    return res;
+  }
+  /**
+   * Higher-order version of {@link Profiler.profile}. Takes a profile `id`
+   * and vararg function `fn`. Returns new function which when called, calls
+   * given `fn` and profiles it using provided `id`, then returns result of
+   * `fn`.
+   *
+   * @example
+   * ```ts
+   * const sum = profiler.wrap(
+   *   "sum",
+   *   (vec: number[]) => vec.reduce((acc, x) => acc + x, 0)
+   * );
+   *
+   * sum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+   * // 55
+   *
+   * profiler.deref()
+   * // {
+   * //   sum: {
+   * //     id: 'sum',
+   * //     total: 0.015644915291,
+   * //     timePerCall: 0.015644915291,
+   * //     totalPercent: 100,
+   * //     calls: 1,
+   * //     callsPercent: 100,
+   * //     maxDepth: 1
+   * //   }
+   * // }
+   * ```
+   *
+   * @param id
+   * @param fn
+   */
+  wrap(id, fn) {
+    return (...args) => {
+      this.start(id);
+      const res = fn.apply(null, args);
+      this.end(id);
+      return res;
+    };
+  }
+  /**
+   * Estimates the internal overhead of the {@link Profiler.start} and
+   * {@link Profiler.end} methods by performing given number of `iter`ations
+   * (distributed over 10 runs) and taking the mean duration of those runs.
+   *
+   * @remarks
+   * The computed overhead (per iteration) will be subtracted from the all
+   * recorded profiles (see {@link Profiler.deref} and
+   * {@link Profiler.asCSV}).
+   *
+   * @param iter
+   */
+  warmup(iter) {
+    let total = 0;
+    for (let i = 0; i < 10; i++) {
+      const id = `prof-${i}`;
+      const [_, taken] = benchResult(() => {
         this.start(id);
-        const res = fn.apply(null, args);
         this.end(id);
-        return res;
-    }
-    /**
-     * Higher-order version of {@link Profiler.profile}. Takes a profile `id`
-     * and vararg function `fn`. Returns new function which when called, calls
-     * given `fn` and profiles it using provided `id`, then returns result of
-     * `fn`.
-     *
-     * @example
-     * ```ts
-     * const sum = profiler.wrap(
-     *   "sum",
-     *   (vec: number[]) => vec.reduce((acc, x) => acc + x, 0)
-     * );
-     *
-     * sum([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-     * // 55
-     *
-     * profiler.deref()
-     * // {
-     * //   sum: {
-     * //     id: 'sum',
-     * //     total: 0.015644915291,
-     * //     timePerCall: 0.015644915291,
-     * //     totalPercent: 100,
-     * //     calls: 1,
-     * //     callsPercent: 100,
-     * //     maxDepth: 1
-     * //   }
-     * // }
-     * ```
-     *
-     * @param id
-     * @param fn
-     */
-    wrap(id, fn) {
-        return (...args) => {
-            this.start(id);
-            const res = fn.apply(null, args);
-            this.end(id);
-            return res;
-        };
-    }
-    /**
-     * Estimates the internal overhead of the {@link Profiler.start} and
-     * {@link Profiler.end} methods by performing given number of `iter`ations
-     * (distributed over 10 runs) and taking the mean duration of those runs.
-     *
-     * @remarks
-     * The computed overhead (per iteration) will be subtracted from the all
-     * recorded profiles (see {@link Profiler.deref} and
-     * {@link Profiler.asCSV}).
-     *
-     * @param iter
-     */
-    warmup(iter) {
-        let total = 0;
-        for (let i = 0; i < 10; i++) {
-            const id = `prof-${i}`;
-            const [_, taken] = benchResult(() => {
-                this.start(id);
-                this.end(id);
-            }, ~~(iter / 10));
-            total += taken;
-        }
-        this._overhead = total / iter;
-    }
-    /**
-     * Same as {@link Profiler.deref}.
-     */
-    toJSON() {
-        return this.deref();
-    }
-    /**
-     * Returns {@link Profiler.deref} formatted as CSV string.
-     */
-    asCSV() {
-        const res = [
-            `"id","total (ms)","time/call (ms)","total (%)","calls","calls (%)","max depth"`,
-        ];
-        const stats = this.deref();
-        for (let id of Object.keys(stats).sort()) {
-            const { total, timePerCall, totalPercent, calls, callsPercent, maxDepth, } = stats[id];
-            res.push([
-                `"${id}"`,
-                total.toFixed(5),
-                timePerCall.toFixed(5),
-                totalPercent.toFixed(2),
-                calls,
-                callsPercent.toFixed(2),
-                maxDepth,
-            ].join(","));
-        }
-        return res.join("\n");
+      }, ~~(iter / 10));
+      total += taken;
     }
-    newProfile(t0) {
-        return {
-            t0: [t0],
-            total: typeof t0 === "bigint" ? BigInt(0) : 0,
-            calls: 1,
-            maxDepth: 1,
-        };
+    this._overhead = total / iter;
+  }
+  /**
+   * Same as {@link Profiler.deref}.
+   */
+  toJSON() {
+    return this.deref();
+  }
+  /**
+   * Returns {@link Profiler.deref} formatted as CSV string.
+   */
+  asCSV() {
+    const res = [
+      `"id","total (ms)","time/call (ms)","total (%)","calls","calls (%)","max depth"`
+    ];
+    const stats = this.deref();
+    for (let id of Object.keys(stats).sort()) {
+      const {
+        total,
+        timePerCall,
+        totalPercent,
+        calls,
+        callsPercent,
+        maxDepth
+      } = stats[id];
+      res.push(
+        [
+          `"${id}"`,
+          total.toFixed(5),
+          timePerCall.toFixed(5),
+          totalPercent.toFixed(2),
+          calls,
+          callsPercent.toFixed(2),
+          maxDepth
+        ].join(",")
+      );
     }
+    return res.join("\n");
+  }
+  newProfile(t0) {
+    return {
+      t0: [t0],
+      total: typeof t0 === "bigint" ? BigInt(0) : 0,
+      calls: 1,
+      maxDepth: 1
+    };
+  }
 }
+export {
+  Profiler
+};

package/suite.js

@@ -1,15 +1,18 @@
 import { benchmark, DEFAULT_OPTS, outputString } from "./benchmark.js";
-export const suite = (cases, opts) => {
-    const _opts = {
-        ...DEFAULT_OPTS,
-        ...opts,
-    };
-    _opts.output && outputString(_opts.format.prefix());
-    const results = [];
-    for (let c of cases) {
-        results.push(benchmark(c.fn, { ..._opts, ...c.opts, title: c.title }));
-    }
-    _opts.output && outputString(_opts.format.total(results));
-    _opts.output && outputString(_opts.format.suffix());
-    return results;
+const suite = (cases, opts) => {
+  const _opts = {
+    ...DEFAULT_OPTS,
+    ...opts
+  };
+  _opts.output && outputString(_opts.format.prefix());
+  const results = [];
+  for (let c of cases) {
+    results.push(benchmark(c.fn, { ..._opts, ...c.opts, title: c.title }));
+  }
+  _opts.output && outputString(_opts.format.total(results));
+  _opts.output && outputString(_opts.format.suffix());
+  return results;
+};
+export {
+  suite
 };

package/timed.js

@@ -1,26 +1,16 @@
 import { now, timeDiff } from "./now.js";
-/**
- * Calls function `fn` without args, prints elapsed time and returns
- * fn's result. The optional `prefix` will be displayed with the output,
- * allowing to label different measurements.
- *
- * @param fn - function to time
- * @param prefix - log prefix
- */
-export const timed = (fn, prefix = "") => {
-    const [res, t] = timedResult(fn);
-    console.log(`${prefix} ${t.toFixed(2)}ms`);
-    return res;
+const timed = (fn, prefix = "") => {
+  const [res, t] = timedResult(fn);
+  console.log(`${prefix} ${t.toFixed(2)}ms`);
+  return res;
 };
-/**
- * Similar to {@link timed}, but produces no output and instead returns
- * tuple of `fn`'s result and the time measurement (in milliseconds).
- *
- * @param fn - function to time
- */
-export const timedResult = (fn) => {
-    const t0 = now();
-    const res = fn();
-    const t1 = now();
-    return [res, timeDiff(t0, t1)];
+const timedResult = (fn) => {
+  const t0 = now();
+  const res = fn();
+  const t1 = now();
+  return [res, timeDiff(t0, t1)];
+};
+export {
+  timed,
+  timedResult
 };