@design-edito/tools 0.4.5 → 0.4.11

package/agnostic/misc/data-size/index.js

@@ -1,295 +1,183 @@
-// src/agnostic/misc/data-size/index.ts
-var DataSize = class {
-  value;
-  unit;
-  constructor(value, unit) {
-    this.value = value;
-    if (unit === "b" || unit === "bit") {
-      this.unit = "bit";
-    } else if (unit === "B" || unit === "byte") {
-      this.unit = "byte";
-    } else if (unit === "KB" || unit === "kilobyte") {
-      this.unit = "kilobyte";
-    } else if (unit === "MB" || unit === "megabyte") {
-      this.unit = "megabyte";
-    } else if (unit === "GB" || unit === "gigabyte") {
-      this.unit = "gigabyte";
-    } else if (unit === "TB" || unit === "terabyte") {
-      this.unit = "terabyte";
-    } else if (unit === "PB" || unit === "petabyte") {
-      this.unit = "petabyte";
-    } else if (unit === "EB" || unit === "exabyte") {
-      this.unit = "exabyte";
-    } else if (unit === "KiB" || unit === "kibibyte") {
-      this.unit = "kibibyte";
-    } else if (unit === "MiB" || unit === "mebibyte") {
-      this.unit = "mebibyte";
-    } else if (unit === "GiB" || unit === "gibibyte") {
-      this.unit = "gibibyte";
-    } else if (unit === "TiB" || unit === "tebibyte") {
-      this.unit = "tebibyte";
-    } else if (unit === "PiB" || unit === "pebibyte") {
-      this.unit = "pebibyte";
-    } else if (unit === "EiB" || unit === "exbibyte") {
-      this.unit = "exbibyte";
-    } else {
-      this.unit = "byte";
+export class DataSize {
+    value;
+    unit;
+    constructor(value, unit) {
+        this.value = value;
+        if (unit === 'b' || unit === 'bit') {
+            this.unit = 'bit';
+        }
+        else if (unit === 'B' || unit === 'byte') {
+            this.unit = 'byte';
+        }
+        else if (unit === 'KB' || unit === 'kilobyte') {
+            this.unit = 'kilobyte';
+        }
+        else if (unit === 'MB' || unit === 'megabyte') {
+            this.unit = 'megabyte';
+        }
+        else if (unit === 'GB' || unit === 'gigabyte') {
+            this.unit = 'gigabyte';
+        }
+        else if (unit === 'TB' || unit === 'terabyte') {
+            this.unit = 'terabyte';
+        }
+        else if (unit === 'PB' || unit === 'petabyte') {
+            this.unit = 'petabyte';
+        }
+        else if (unit === 'EB' || unit === 'exabyte') {
+            this.unit = 'exabyte';
+        }
+        else if (unit === 'KiB' || unit === 'kibibyte') {
+            this.unit = 'kibibyte';
+        }
+        else if (unit === 'MiB' || unit === 'mebibyte') {
+            this.unit = 'mebibyte';
+        }
+        else if (unit === 'GiB' || unit === 'gibibyte') {
+            this.unit = 'gibibyte';
+        }
+        else if (unit === 'TiB' || unit === 'tebibyte') {
+            this.unit = 'tebibyte';
+        }
+        else if (unit === 'PiB' || unit === 'pebibyte') {
+            this.unit = 'pebibyte';
+        }
+        else if (unit === 'EiB' || unit === 'exbibyte') {
+            this.unit = 'exbibyte';
+        }
+        else {
+            this.unit = 'byte';
+        } // defaults to byte
+        this.toBits = this.toBits.bind(this);
+        this.toBytes = this.toBytes.bind(this);
+        this.toKilobytes = this.toKilobytes.bind(this);
+        this.toMegabytes = this.toMegabytes.bind(this);
+        this.toGigabytes = this.toGigabytes.bind(this);
+        this.toTerabytes = this.toTerabytes.bind(this);
+        this.toPetabytes = this.toPetabytes.bind(this);
+        this.toExabytes = this.toExabytes.bind(this);
+        this.toKibibytes = this.toKibibytes.bind(this);
+        this.toMebibytes = this.toMebibytes.bind(this);
+        this.toGibibytes = this.toGibibytes.bind(this);
+        this.toTebibytes = this.toTebibytes.bind(this);
+        this.toPebibytes = this.toPebibytes.bind(this);
+        this.toExbibytes = this.toExbibytes.bind(this);
     }
-    this.toBits = this.toBits.bind(this);
-    this.toBytes = this.toBytes.bind(this);
-    this.toKilobytes = this.toKilobytes.bind(this);
-    this.toMegabytes = this.toMegabytes.bind(this);
-    this.toGigabytes = this.toGigabytes.bind(this);
-    this.toTerabytes = this.toTerabytes.bind(this);
-    this.toPetabytes = this.toPetabytes.bind(this);
-    this.toExabytes = this.toExabytes.bind(this);
-    this.toKibibytes = this.toKibibytes.bind(this);
-    this.toMebibytes = this.toMebibytes.bind(this);
-    this.toGibibytes = this.toGibibytes.bind(this);
-    this.toTebibytes = this.toTebibytes.bind(this);
-    this.toPebibytes = this.toPebibytes.bind(this);
-    this.toExbibytes = this.toExbibytes.bind(this);
-  }
-  toBits() {
-    if (this.unit === "bit") return this.value;
-    if (this.unit === "byte") return this.value * 8;
-    if (this.unit === "kilobyte") return this.value * 8 * 1e3;
-    if (this.unit === "megabyte") return this.value * 8 * 1e6;
-    if (this.unit === "gigabyte") return this.value * 8 * 1e9;
-    if (this.unit === "terabyte") return this.value * 8 * 1e12;
-    if (this.unit === "petabyte") return this.value * 8 * 1e15;
-    if (this.unit === "exabyte") return this.value * 8 * 1e18;
-    if (this.unit === "kibibyte") return this.value * 8 * 1024;
-    if (this.unit === "mebibyte") return this.value * 8 * Math.pow(1024, 2);
-    if (this.unit === "gibibyte") return this.value * 8 * Math.pow(1024, 3);
-    if (this.unit === "tebibyte") return this.value * 8 * Math.pow(1024, 4);
-    if (this.unit === "pebibyte") return this.value * 8 * Math.pow(1024, 5);
-    if (this.unit === "exbibyte") return this.value * 8 * Math.pow(1024, 6);
-    return this.value;
-  }
-  /* * * * * * * * * * * * * * * * * *
-   * Decimal unit converters
-   * * * * * * * * * * * * * * * * * */
-  toBytes() {
-    return this.toBits() / 8;
-  }
-  toB = this.toBytes.bind(this);
-  toKilobytes() {
-    return this.toBytes() / 1e3;
-  }
-  toKB = this.toKilobytes.bind(this);
-  toMegabytes() {
-    return this.toBytes() / 1e6;
-  }
-  toMB = this.toMegabytes.bind(this);
-  toGigabytes() {
-    return this.toBytes() / 1e9;
-  }
-  toGB = this.toGigabytes.bind(this);
-  toTerabytes() {
-    return this.toBytes() / 1e12;
-  }
-  toTB = this.toTerabytes.bind(this);
-  toPetabytes() {
-    return this.toBytes() / 1e15;
-  }
-  toPB = this.toPetabytes.bind(this);
-  toExabytes() {
-    return this.toBytes() / 1e18;
-  }
-  toEB = this.toExabytes.bind(this);
-  /* * * * * * * * * * * * * * * * * *
-   * Binary unit converters
-   * * * * * * * * * * * * * * * * * */
-  toKibibytes() {
-    return this.toBytes() / 1024;
-  }
-  toKiB = this.toKibibytes.bind(this);
-  toMebibytes() {
-    return this.toBytes() / Math.pow(1024, 2);
-  }
-  toMiB = this.toMebibytes.bind(this);
-  toGibibytes() {
-    return this.toBytes() / Math.pow(1024, 3);
-  }
-  toGiB = this.toGibibytes.bind(this);
-  toTebibytes() {
-    return this.toBytes() / Math.pow(1024, 4);
-  }
-  toTiB = this.toTebibytes.bind(this);
-  toPebibytes() {
-    return this.toBytes() / Math.pow(1024, 5);
-  }
-  toPiB = this.toPebibytes.bind(this);
-  toExbibytes() {
-    return this.toBytes() / Math.pow(1024, 6);
-  }
-  toEiB = this.toExbibytes.bind(this);
-};
-function bits(value) {
-  return new DataSize(value, "bit");
-}
-function bytes(value) {
-  return new DataSize(value, "byte");
-}
-function kilobytes(value) {
-  return new DataSize(value, "kilobyte");
-}
-function megabytes(value) {
-  return new DataSize(value, "megabyte");
-}
-function gigabytes(value) {
-  return new DataSize(value, "gigabyte");
-}
-function terabytes(value) {
-  return new DataSize(value, "terabyte");
-}
-function petabytes(value) {
-  return new DataSize(value, "petabyte");
-}
-function exabytes(value) {
-  return new DataSize(value, "exabyte");
-}
-function kibibytes(value) {
-  return new DataSize(value, "kibibyte");
-}
-function mebibytes(value) {
-  return new DataSize(value, "mebibyte");
-}
-function gibibytes(value) {
-  return new DataSize(value, "gibibyte");
-}
-function tebibytes(value) {
-  return new DataSize(value, "tebibyte");
-}
-function pebibytes(value) {
-  return new DataSize(value, "pebibyte");
-}
-function exbibytes(value) {
-  return new DataSize(value, "exbibyte");
-}
-var B = bytes;
-var KB = kilobytes;
-var MB = megabytes;
-var GB = gigabytes;
-var TB = terabytes;
-var PB = petabytes;
-var EB = exabytes;
-var KiB = kibibytes;
-var MiB = mebibytes;
-var GiB = gibibytes;
-var TiB = tebibytes;
-var PiB = pebibytes;
-var EiB = exbibytes;
-function toBits(value, unit) {
-  return new DataSize(value, unit).toBits();
-}
-function toBytes(value, unit) {
-  return new DataSize(value, unit).toBytes();
-}
-function toKilobytes(value, unit) {
-  return new DataSize(value, unit).toKilobytes();
-}
-function toMegabytes(value, unit) {
-  return new DataSize(value, unit).toMegabytes();
-}
-function toGigabytes(value, unit) {
-  return new DataSize(value, unit).toGigabytes();
-}
-function toTerabytes(value, unit) {
-  return new DataSize(value, unit).toTerabytes();
-}
-function toPetabytes(value, unit) {
-  return new DataSize(value, unit).toPetabytes();
-}
-function toExabytes(value, unit) {
-  return new DataSize(value, unit).toExabytes();
-}
-function toKibibytes(value, unit) {
-  return new DataSize(value, unit).toKibibytes();
-}
-function toMebibytes(value, unit) {
-  return new DataSize(value, unit).toMebibytes();
-}
-function toGibibytes(value, unit) {
-  return new DataSize(value, unit).toGibibytes();
-}
-function toTebibytes(value, unit) {
-  return new DataSize(value, unit).toTebibytes();
-}
-function toPebibytes(value, unit) {
-  return new DataSize(value, unit).toPebibytes();
-}
-function toExbibytes(value, unit) {
-  return new DataSize(value, unit).toExbibytes();
-}
-var toB = toBytes;
-var toKB = toKilobytes;
-var toMB = toMegabytes;
-var toGB = toGigabytes;
-var toTB = toTerabytes;
-var toPB = toPetabytes;
-var toEB = toExabytes;
-var toKiB = toKibibytes;
-var toMiB = toMebibytes;
-var toGiB = toGibibytes;
-var toTiB = toTebibytes;
-var toPiB = toPebibytes;
-var toEiB = toExbibytes;
-export {
-  B,
-  DataSize,
-  EB,
-  EiB,
-  GB,
-  GiB,
-  KB,
-  KiB,
-  MB,
-  MiB,
-  PB,
-  PiB,
-  TB,
-  TiB,
-  bits,
-  bytes,
-  exabytes,
-  exbibytes,
-  gibibytes,
-  gigabytes,
-  kibibytes,
-  kilobytes,
-  mebibytes,
-  megabytes,
-  pebibytes,
-  petabytes,
-  tebibytes,
-  terabytes,
-  toB,
-  toBits,
-  toBytes,
-  toEB,
-  toEiB,
-  toExabytes,
-  toExbibytes,
-  toGB,
-  toGiB,
-  toGibibytes,
-  toGigabytes,
-  toKB,
-  toKiB,
-  toKibibytes,
-  toKilobytes,
-  toMB,
-  toMebibytes,
-  toMegabytes,
-  toMiB,
-  toPB,
-  toPebibytes,
-  toPetabytes,
-  toPiB,
-  toTB,
-  toTebibytes,
-  toTerabytes,
-  toTiB
-};
+    toBits() {
+        if (this.unit === 'bit')
+            return this.value;
+        if (this.unit === 'byte')
+            return this.value * 8;
+        if (this.unit === 'kilobyte')
+            return this.value * 8 * 1e3;
+        if (this.unit === 'megabyte')
+            return this.value * 8 * 1e6;
+        if (this.unit === 'gigabyte')
+            return this.value * 8 * 1e9;
+        if (this.unit === 'terabyte')
+            return this.value * 8 * 1e12;
+        if (this.unit === 'petabyte')
+            return this.value * 8 * 1e15;
+        if (this.unit === 'exabyte')
+            return this.value * 8 * 1e18;
+        if (this.unit === 'kibibyte')
+            return this.value * 8 * 1024;
+        if (this.unit === 'mebibyte')
+            return this.value * 8 * Math.pow(1024, 2);
+        if (this.unit === 'gibibyte')
+            return this.value * 8 * Math.pow(1024, 3);
+        if (this.unit === 'tebibyte')
+            return this.value * 8 * Math.pow(1024, 4);
+        if (this.unit === 'pebibyte')
+            return this.value * 8 * Math.pow(1024, 5);
+        if (this.unit === 'exbibyte')
+            return this.value * 8 * Math.pow(1024, 6);
+        return this.value; // defaults to bits
+    }
+    /* * * * * * * * * * * * * * * * * *
+     * Decimal unit converters
+     * * * * * * * * * * * * * * * * * */
+    toBytes() { return this.toBits() / 8; }
+    toB = this.toBytes.bind(this);
+    toKilobytes() { return this.toBytes() / 1e3; }
+    toKB = this.toKilobytes.bind(this);
+    toMegabytes() { return this.toBytes() / 1e6; }
+    toMB = this.toMegabytes.bind(this);
+    toGigabytes() { return this.toBytes() / 1e9; }
+    toGB = this.toGigabytes.bind(this);
+    toTerabytes() { return this.toBytes() / 1e12; }
+    toTB = this.toTerabytes.bind(this);
+    toPetabytes() { return this.toBytes() / 1e15; }
+    toPB = this.toPetabytes.bind(this);
+    toExabytes() { return this.toBytes() / 1e18; }
+    toEB = this.toExabytes.bind(this);
+    /* * * * * * * * * * * * * * * * * *
+     * Binary unit converters
+     * * * * * * * * * * * * * * * * * */
+    toKibibytes() { return this.toBytes() / 1024; }
+    toKiB = this.toKibibytes.bind(this);
+    toMebibytes() { return this.toBytes() / Math.pow(1024, 2); }
+    toMiB = this.toMebibytes.bind(this);
+    toGibibytes() { return this.toBytes() / Math.pow(1024, 3); }
+    toGiB = this.toGibibytes.bind(this);
+    toTebibytes() { return this.toBytes() / Math.pow(1024, 4); }
+    toTiB = this.toTebibytes.bind(this);
+    toPebibytes() { return this.toBytes() / Math.pow(1024, 5); }
+    toPiB = this.toPebibytes.bind(this);
+    toExbibytes() { return this.toBytes() / Math.pow(1024, 6); }
+    toEiB = this.toExbibytes.bind(this);
+}
+export function bits(value) { return new DataSize(value, 'bit'); }
+export function bytes(value) { return new DataSize(value, 'byte'); }
+export function kilobytes(value) { return new DataSize(value, 'kilobyte'); }
+export function megabytes(value) { return new DataSize(value, 'megabyte'); }
+export function gigabytes(value) { return new DataSize(value, 'gigabyte'); }
+export function terabytes(value) { return new DataSize(value, 'terabyte'); }
+export function petabytes(value) { return new DataSize(value, 'petabyte'); }
+export function exabytes(value) { return new DataSize(value, 'exabyte'); }
+export function kibibytes(value) { return new DataSize(value, 'kibibyte'); }
+export function mebibytes(value) { return new DataSize(value, 'mebibyte'); }
+export function gibibytes(value) { return new DataSize(value, 'gibibyte'); }
+export function tebibytes(value) { return new DataSize(value, 'tebibyte'); }
+export function pebibytes(value) { return new DataSize(value, 'pebibyte'); }
+export function exbibytes(value) { return new DataSize(value, 'exbibyte'); }
+export const B = bytes;
+export const KB = kilobytes;
+export const MB = megabytes;
+export const GB = gigabytes;
+export const TB = terabytes;
+export const PB = petabytes;
+export const EB = exabytes;
+export const KiB = kibibytes;
+export const MiB = mebibytes;
+export const GiB = gibibytes;
+export const TiB = tebibytes;
+export const PiB = pebibytes;
+export const EiB = exbibytes;
+export function toBits(value, unit) { return new DataSize(value, unit).toBits(); }
+export function toBytes(value, unit) { return new DataSize(value, unit).toBytes(); }
+export function toKilobytes(value, unit) { return new DataSize(value, unit).toKilobytes(); }
+export function toMegabytes(value, unit) { return new DataSize(value, unit).toMegabytes(); }
+export function toGigabytes(value, unit) { return new DataSize(value, unit).toGigabytes(); }
+export function toTerabytes(value, unit) { return new DataSize(value, unit).toTerabytes(); }
+export function toPetabytes(value, unit) { return new DataSize(value, unit).toPetabytes(); }
+export function toExabytes(value, unit) { return new DataSize(value, unit).toExabytes(); }
+export function toKibibytes(value, unit) { return new DataSize(value, unit).toKibibytes(); }
+export function toMebibytes(value, unit) { return new DataSize(value, unit).toMebibytes(); }
+export function toGibibytes(value, unit) { return new DataSize(value, unit).toGibibytes(); }
+export function toTebibytes(value, unit) { return new DataSize(value, unit).toTebibytes(); }
+export function toPebibytes(value, unit) { return new DataSize(value, unit).toPebibytes(); }
+export function toExbibytes(value, unit) { return new DataSize(value, unit).toExbibytes(); }
+export const toB = toBytes;
+export const toKB = toKilobytes;
+export const toMB = toMegabytes;
+export const toGB = toGigabytes;
+export const toTB = toTerabytes;
+export const toPB = toPetabytes;
+export const toEB = toExabytes;
+export const toKiB = toKibibytes;
+export const toMiB = toMebibytes;
+export const toGiB = toGibibytes;
+export const toTiB = toTebibytes;
+export const toPiB = toPebibytes;
+export const toEiB = toExbibytes;

package/agnostic/misc/data-size/index.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { DataSize, bytes, kilobytes, megabytes, toBytes, toKilobytes, toMegabytes } from './index.js';
+describe('DataSize', () => {
+    it('creates instance with value and unit', () => {
+        const size = new DataSize(100, 'byte');
+        expect(size.value).toBe(100);
+        expect(size.unit).toBe('byte');
+    });
+    it('accepts short unit forms', () => {
+        expect(new DataSize(1, 'B').unit).toBe('byte');
+        expect(new DataSize(1, 'KB').unit).toBe('kilobyte');
+        expect(new DataSize(1, 'KiB').unit).toBe('kibibyte');
+    });
+    it('defaults to byte for unknown units', () => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const size = new DataSize(100, 'unknown');
+        expect(size.unit).toBe('byte');
+    });
+});
+describe('toBits', () => {
+    it('converts bytes to bits', () => {
+        const size = new DataSize(1, 'byte');
+        expect(size.toBits()).toBe(8);
+    });
+    it('converts kilobytes to bits', () => {
+        const size = new DataSize(1, 'kilobyte');
+        expect(size.toBits()).toBe(8000);
+    });
+    it('returns bits as-is', () => {
+        const size = new DataSize(8, 'bit');
+        expect(size.toBits()).toBe(8);
+    });
+});
+describe('toBytes', () => {
+    it('converts bits to bytes', () => {
+        const size = new DataSize(8, 'bit');
+        expect(size.toBytes()).toBe(1);
+    });
+    it('converts kilobytes to bytes', () => {
+        const size = new DataSize(1, 'kilobyte');
+        expect(size.toBytes()).toBe(1000);
+    });
+    it('converts kibibytes to bytes', () => {
+        const size = new DataSize(1, 'kibibyte');
+        expect(size.toBytes()).toBe(1024);
+    });
+});
+describe('toKilobytes', () => {
+    it('converts bytes to kilobytes', () => {
+        const size = new DataSize(1000, 'byte');
+        expect(size.toKilobytes()).toBe(1);
+    });
+    it('converts megabytes to kilobytes', () => {
+        const size = new DataSize(1, 'megabyte');
+        expect(size.toKilobytes()).toBe(1000);
+    });
+});
+describe('toMegabytes', () => {
+    it('converts bytes to megabytes', () => {
+        const size = new DataSize(1000000, 'byte');
+        expect(size.toMegabytes()).toBe(1);
+    });
+});
+describe('bytes', () => {
+    it('creates DataSize with byte unit', () => {
+        const size = bytes(100);
+        expect(size.value).toBe(100);
+        expect(size.unit).toBe('byte');
+    });
+});
+describe('kilobytes', () => {
+    it('creates DataSize with kilobyte unit', () => {
+        const size = kilobytes(1);
+        expect(size.value).toBe(1);
+        expect(size.unit).toBe('kilobyte');
+    });
+});
+describe('megabytes', () => {
+    it('creates DataSize with megabyte unit', () => {
+        const size = megabytes(1);
+        expect(size.value).toBe(1);
+        expect(size.unit).toBe('megabyte');
+    });
+});
+describe('toBytes', () => {
+    it('converts value with unit to bytes', () => {
+        expect(toBytes(8, 'bit')).toBe(1);
+        expect(toBytes(1, 'kilobyte')).toBe(1000);
+    });
+});
+describe('toKilobytes', () => {
+    it('converts value with unit to kilobytes', () => {
+        expect(toKilobytes(1000, 'byte')).toBe(1);
+    });
+});
+describe('toMegabytes', () => {
+    it('converts value with unit to megabytes', () => {
+        expect(toMegabytes(1000000, 'byte')).toBe(1);
+    });
+});

package/agnostic/misc/data-size/types.js

@@ -0,0 +1 @@
+export {};

package/agnostic/misc/index.d.ts

@@ -1,12 +1,12 @@
-export * as cast from './cast/index.js'
 export * as assert from './assert/index.js'
-export * as crawler from './crawler/index.js'
 export * as connection from './connection/index.js'
+export * as cast from './cast/index.js'
+export * as crawler from './crawler/index.js'
 export * as crossenv from './crossenv/index.js'
-export * as isConstructorFunction from './is-constructor-function/index.js'
 export * as dataSize from './data-size/index.js'
+export * as isNullish from './is-nullish/index.js'
 export * as logs from './logs/index.js'
+export * as isConstructorFunction from './is-constructor-function/index.js'
 export * as normalizeExtension from './normalize-extension/index.js'
-export * as loremIpsum from './lorem-ipsum/index.js'
-export * as isNullish from './is-nullish/index.js'
 export * as outcome from './outcome/index.js'
+export * as loremIpsum from './lorem-ipsum/index.js'

package/agnostic/misc/index.js

@@ -1,12 +1,12 @@
-export * as cast from './cast/index.js'
 export * as assert from './assert/index.js'
-export * as crawler from './crawler/index.js'
 export * as connection from './connection/index.js'
+export * as cast from './cast/index.js'
+export * as crawler from './crawler/index.js'
 export * as crossenv from './crossenv/index.js'
-export * as isConstructorFunction from './is-constructor-function/index.js'
 export * as dataSize from './data-size/index.js'
+export * as isNullish from './is-nullish/index.js'
 export * as logs from './logs/index.js'
+export * as isConstructorFunction from './is-constructor-function/index.js'
 export * as normalizeExtension from './normalize-extension/index.js'
-export * as loremIpsum from './lorem-ipsum/index.js'
-export * as isNullish from './is-nullish/index.js'
 export * as outcome from './outcome/index.js'
+export * as loremIpsum from './lorem-ipsum/index.js'

package/agnostic/misc/is-constructor-function/index.js

@@ -1,7 +1,13 @@
-// src/agnostic/misc/is-constructor-function/index.ts
-function isConstructorFunction(input) {
-  return typeof input === "function" && "prototype" in input && typeof input.prototype === "object" && "constructor" in input.prototype && input.prototype.constructor === input;
+/**
+ * Checks whether a given value is a constructor function (i.e., a class or function with a prototype).
+ *
+ * @param {unknown} input - The value to check.
+ * @returns {input is ConstructorFunction} `true` if the input is a constructor function, otherwise `false`.
+ */
+export function isConstructorFunction(input) {
+    return typeof input === 'function'
+        && 'prototype' in input
+        && typeof input.prototype === 'object'
+        && 'constructor' in input.prototype
+        && input.prototype.constructor === input;
 }
-export {
-  isConstructorFunction
-};