bit-byte-bit 0.0.0-stage → 2.1.2

package/assets/site/site.js

@@ -0,0 +1,188 @@
+/* bit-byte-bit site bundle — docs demo with bundled helpers */
+(function () {
+  "use strict";
+
+  var DEC_UNITS = ["B", "KB", "MB", "GB", "TB", "PB"];
+  var BIN_UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
+
+  function formatBytes(bytes, opts) {
+    opts = opts || {};
+    var decimals = opts.decimals === undefined ? 1 : opts.decimals;
+    var binary = !!opts.binary;
+    var base = opts.base || (binary ? 1024 : 1000);
+    var units = binary ? BIN_UNITS : DEC_UNITS;
+    var n = Number(bytes);
+    if (!isFinite(n) || n < 0) return "0 B";
+    if (n === 0) return "0 B";
+    var i = Math.min(Math.floor(Math.log(n) / Math.log(base)), units.length - 1);
+    if (n < base) i = 0;
+    var v = n / Math.pow(base, i);
+    var s = v >= 100 || i === 0 ? String(Math.round(v)) : v.toFixed(decimals).replace(/\.0+$/, "");
+    return s + " " + units[i];
+  }
+
+  function parseBytes(input) {
+    if (typeof input === "number") return input;
+    if (typeof input !== "string") return NaN;
+    var m = input.trim().match(/^([\d.]+)\s*(b|bytes?|bit|bits?|kb|kib|mb|mib|gb|gib|tb|tib|pb|pib)$/i);
+    if (!m) return NaN;
+    var n = parseFloat(m[1]);
+    if (!isFinite(n) || n < 0) return NaN;
+    var u = m[2].toLowerCase();
+    var table = {
+      b: 1, byte: 1, bytes: 1, bit: 0.125, bits: 0.125,
+      kb: 1e3, kib: 1024, mb: 1e6, mib: 1048576,
+      gb: 1e9, gib: 1073741824, tb: 1e12, tib: 1099511627776,
+      pb: 1e15, pib: 1125899906842624,
+    };
+    return n * (table[u] || 1);
+  }
+
+  function bitsToBytes(bits) { return Number(bits) / 8; }
+  function bytesToBits(bytes) { return Math.round(Number(bytes) * 8); }
+  function formatBits(bits, opts) { return formatBytes(bitsToBytes(bits), opts); }
+
+  function bytesToHex(bytes) {
+    var arr = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    var out = "";
+    for (var i = 0; i < arr.length; i++) out += arr[i].toString(16).padStart(2, "0");
+    return out;
+  }
+
+  function hexToBytes(hex) {
+    var h = String(hex).replace(/^0x/i, "");
+    if (h.length % 2 || /[^0-9a-f]/i.test(h)) return new Uint8Array(0);
+    var out = new Uint8Array(h.length / 2);
+    for (var i = 0; i < out.length; i++) out[i] = parseInt(h.substr(i * 2, 2), 16);
+    return out;
+  }
+
+  function crc32(buf) {
+    var bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+    var crc = 0xffffffff;
+    for (var i = 0; i < bytes.length; i++) {
+      crc ^= bytes[i];
+      for (var j = 0; j < 8; j++) crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+  }
+
+  function randomBytes(len) {
+    var out = new Uint8Array(len);
+    crypto.getRandomValues(out);
+    return out;
+  }
+
+  var API = [
+    ["formatBytes", "formatBytes(n, opts?)", "Human-readable sizes: 1.5 KB.", "sizes"],
+    ["formatBits", "formatBits(n, opts?)", "Same, for bit counts.", "sizes"],
+    ["parseBytes", "parseBytes(str)", "\"2 MiB\" / \"512 kb\" to a number.", "sizes"],
+    ["bytesToBits", "bytesToBits(n)", "Bytes to bits.", "convert"],
+    ["bitsToBytes", "bitsToBytes(n)", "Bits to bytes.", "convert"],
+    ["bytesToHex", "bytesToHex(buf)", "Bytes to lowercase hex.", "hex"],
+    ["hexToBytes", "hexToBytes(str)", "Hex string to Uint8Array.", "hex"],
+    ["crc32", "crc32(buf)", "CRC-32 checksum.", "checksums"],
+    ["randomBytes", "randomBytes(len)", "Crypto-random Uint8Array.", "generate"],
+  ];
+
+  var GROUP_LABEL = { sizes: "sizes", convert: "conversion", hex: "hex", checksums: "checksums", generate: "generate" };
+
+  function esc(s) {
+    return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+
+  function mount() {
+    var tbody = document.getElementById("api-rows");
+    if (tbody) {
+      var lastGroup = null;
+      API.forEach(function (row) {
+        if (GROUP_LABEL[row[3]] !== lastGroup) {
+          lastGroup = GROUP_LABEL[row[3]];
+          var h = document.createElement("tr");
+          var hc = document.createElement("td");
+          hc.colSpan = 3;
+          hc.className = "group";
+          hc.textContent = lastGroup;
+          h.appendChild(hc);
+          tbody.appendChild(h);
+        }
+        var tr = document.createElement("tr");
+        tr.innerHTML =
+          '<td class="name">' + esc(row[0]) + "</td>" +
+          '<td class="sig">' + esc(row[1]) + "</td>" +
+          '<td class="what">' + esc(row[2]) + "</td>";
+        tbody.appendChild(tr);
+      });
+    }
+
+    var set = function (id, text) {
+      var el = document.getElementById(id);
+      if (el) el.textContent = text;
+    };
+
+    set(
+      "demo-cn",
+      "formatBytes(1536)                 => " + formatBytes(1536) + "\n" +
+        "formatBytes(1536, { binary: true }) => " + formatBytes(1536, { binary: true }) + "\n" +
+        "formatBytes(248291048)            => " + formatBytes(248291048)
+    );
+
+    set(
+      "demo-fmt",
+      'parseBytes("2 MiB")  => ' + parseBytes("2 MiB") + "\n" +
+        'parseBytes("512 kb") => ' + parseBytes("512 kb") + "\n" +
+        'parseBytes("1.5 GB") => ' + parseBytes("1.5 GB")
+    );
+
+    set(
+      "demo-time",
+      "bytesToBits(256)  => " + bytesToBits(256) + " bits\n" +
+        "bitsToBytes(1024) => " + bitsToBytes(1024) + " bytes\n" +
+        "formatBits(1e9)   => " + formatBits(1e9)
+    );
+
+    set(
+      "demo-deb",
+      "bytesToHex([255, 0, 171, 16]) => " + bytesToHex([255, 0, 171, 16]) + "\n" +
+        "crc32(\"hello\") => " + crc32(new TextEncoder().encode("hello")) + "\n" +
+        "randomBytes(8).length => " + randomBytes(8).length
+    );
+
+    var btn = document.getElementById("copy-install");
+    if (btn) {
+      btn.addEventListener("click", function () {
+        var text = "npm install bit-byte-bit";
+        var done = function () {
+          btn.textContent = "copied";
+          btn.classList.add("done");
+          setTimeout(function () {
+            btn.textContent = "copy";
+            btn.classList.remove("done");
+          }, 1400);
+        };
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+          navigator.clipboard.writeText(text).then(done, fallback);
+        } else {
+          fallback();
+        }
+        function fallback() {
+          var ta = document.createElement("textarea");
+          ta.value = text;
+          ta.style.position = "fixed";
+          ta.style.opacity = "0";
+          document.body.appendChild(ta);
+          ta.select();
+          try { document.execCommand("copy"); } catch (e) {}
+          document.body.removeChild(ta);
+          done();
+        }
+      });
+    }
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", mount);
+  } else {
+    mount();
+  }
+})();

package/index.cjs

@@ -0,0 +1,83 @@
+"use strict";
+
+const DEC_UNITS = ["B", "KB", "MB", "GB", "TB", "PB"];
+const BIN_UNITS = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
+
+function formatBytes(bytes, opts = {}) {
+  const { decimals = 1, binary = false, base = binary ? 1024 : 1000 } = opts;
+  const units = binary ? BIN_UNITS : DEC_UNITS;
+  const n = Number(bytes);
+  if (!isFinite(n) || n < 0) return "0 B";
+  if (n === 0) return "0 B";
+  let i = Math.min(Math.floor(Math.log(n) / Math.log(base)), units.length - 1);
+  if (n < base) i = 0;
+  const v = n / Math.pow(base, i);
+  const s = v >= 100 || i === 0 ? String(Math.round(v)) : v.toFixed(decimals).replace(/\.0+$/, "");
+  return `${s} ${units[i]}`;
+}
+
+function parseBytes(input) {
+  if (typeof input === "number") return input;
+  if (typeof input !== "string") return NaN;
+  const m = input.trim().match(/^([\d.]+)\s*(b|bytes?|bit|bits?|kb|kib|mb|mib|gb|gib|tb|tib|pb|pib)$/i);
+  if (!m) return NaN;
+  const n = parseFloat(m[1]);
+  if (!isFinite(n) || n < 0) return NaN;
+  const u = m[2].toLowerCase();
+  const table = {
+    b: 1, byte: 1, bytes: 1, bit: 0.125, bits: 0.125,
+    kb: 1e3, kib: 1024, mb: 1e6, mib: 1048576,
+    gb: 1e9, gib: 1073741824, tb: 1e12, tib: 1099511627776, pb: 1e15, pib: 1125899906842624,
+  };
+  return n * (table[u] || 1);
+}
+
+function bytesToBits(bytes) {
+  return Math.round(Number(bytes) * 8);
+}
+
+function bitsToBytes(bits) {
+  return Number(bits) / 8;
+}
+
+function formatBits(bits, opts = {}) {
+  return formatBytes(bitsToBytes(bits), opts);
+}
+
+function bytesToHex(bytes) {
+  const arr = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let out = "";
+  for (let i = 0; i < arr.length; i++) out += arr[i].toString(16).padStart(2, "0");
+  return out;
+}
+
+function hexToBytes(hex) {
+  const h = String(hex).replace(/^0x/i, "");
+  if (h.length % 2 || /[^0-9a-f]/i.test(h)) return new Uint8Array(0);
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.substr(i * 2, 2), 16);
+  return out;
+}
+
+function crc32(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  let crc = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) {
+    crc ^= bytes[i];
+    for (let j = 0; j < 8; j++) crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function randomBytes(len) {
+  const out = new Uint8Array(len);
+  const c = globalThis.crypto || require("crypto").webcrypto;
+  c.getRandomValues(out);
+  return out;
+}
+
+module.exports = {
+  formatBytes, parseBytes, formatBits,
+  bytesToBits, bitsToBytes, bytesToHex, hexToBytes,
+  crc32, randomBytes,
+};

package/index.d.ts

@@ -0,0 +1,14 @@
+export interface FormatBytesOptions {
+  decimals?: number;
+  binary?: boolean;
+  base?: number;
+}
+export declare function formatBytes(bytes: number, opts?: FormatBytesOptions): string;
+export declare function parseBytes(input: string | number): number;
+export declare function formatBits(bits: number, opts?: FormatBytesOptions): string;
+export declare function bytesToBits(bytes: number): number;
+export declare function bitsToBytes(bits: number): number;
+export declare function bytesToHex(bytes: Uint8Array | ArrayBuffer | number[]): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function crc32(buf: Uint8Array | ArrayBuffer): number;
+export declare function randomBytes(len: number): Uint8Array;

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "bit-byte-bit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.1.2",
+  "description": "Small, dependency-free utilities for bytes, bits, hex, and data sizes.",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.cjs",
+      "require": "./index.cjs"
+    }
+  },
+  "files": [
+    "index.cjs",
+    "index.d.ts",
+    "README.md",
+    "assets"
+  ],
+  "keywords": [
+    "bytes",
+    "bits",
+    "hex",
+    "formatBytes",
+    "crc32",
+    "zero-dependency"
+  ],
+  "license": "MIT",
+  "engines": { "node": ">=14" },
+  "sideEffects": false
+}