@thi.ng/strings 3.7.1 → 3.7.3

package/units.js

@@ -1,81 +1,114 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
-export const units = memoizeJ((exp, base, prec = 2) => {
-    const groups = exp
-        .map((x) => [
-        x[0],
-        x[2] != null ? x[2] : prec,
-        x[1],
-    ])
-        .sort((a, b) => a[0] - b[0]);
-    return (x) => {
-        if (x === 0) {
-            return `0${base}`;
-        }
-        const absX = Math.abs(x);
-        for (let i = groups.length; i-- > 0;) {
-            const g = groups[i];
-            if (absX >= g[0] || i === 0) {
-                return (x / g[0]).toFixed(g[1]) + g[2];
-            }
-        }
-        return "";
-    };
+const units = memoizeJ((exp, base, prec = 2) => {
+  const groups = exp.map(
+    (x) => [
+      x[0],
+      x[2] != null ? x[2] : prec,
+      x[1]
+    ]
+  ).sort((a, b) => a[0] - b[0]);
+  return (x) => {
+    if (x === 0) {
+      return `0${base}`;
+    }
+    const absX = Math.abs(x);
+    for (let i = groups.length; i-- > 0; ) {
+      const g = groups[i];
+      if (absX >= g[0] || i === 0) {
+        return (x / g[0]).toFixed(g[1]) + g[2];
+      }
+    }
+    return "";
+  };
 });
 const KB = 1024;
-export const bits = units([
+const bits = units(
+  [
     [1, " bits", 0],
     [KB, " Kb"],
     [KB ** 2, " Mb"],
-    [KB ** 3, " Gb"],
-], " bits", 2);
-export const bytes = units([
+    [KB ** 3, " Gb"]
+  ],
+  " bits",
+  2
+);
+const bytes = units(
+  [
     [1, " bytes", 0],
     [KB, " KB"],
     [KB ** 2, " MB"],
     [KB ** 3, " GB"],
     [KB ** 4, " TB"],
-    [KB ** 5, " PB"],
-], " bytes", 2);
-export const seconds = units([
+    [KB ** 5, " PB"]
+  ],
+  " bytes",
+  2
+);
+const seconds = units(
+  [
     [1e-12, " ps"],
     [1e-9, " ns"],
-    [1e-6, " µs"],
+    [1e-6, " \xB5s"],
     [1e-3, " ms"],
     [1, " secs"],
     [60, " mins"],
     [60 * 60, " hours"],
-    [24 * 60 * 60, " days"],
-], " secs", 3);
-export const meters = units([
+    [24 * 60 * 60, " days"]
+  ],
+  " secs",
+  3
+);
+const meters = units(
+  [
     [1e-12, " pm"],
     [1e-9, " nm"],
-    [1e-6, " µm"],
+    [1e-6, " \xB5m"],
     [1e-3, " mm"],
-    [1e-2, " cm"],
+    [0.01, " cm"],
     [1, " m"],
-    [1e3, " km"],
-], " m", 2);
-export const grams = units([
+    [1e3, " km"]
+  ],
+  " m",
+  2
+);
+const grams = units(
+  [
     [1e-12, " pg"],
     [1e-9, " ng"],
-    [1e-6, " µg"],
+    [1e-6, " \xB5g"],
     [1e-3, " mg"],
     [1, " g"],
     [1e3, " kg"],
     [1e6, " t"],
     [1e9, " kt"],
-    [1e12, " Mt"],
-], " g", 2);
-export const unitless = units([
+    [1e12, " Mt"]
+  ],
+  " g",
+  2
+);
+const unitless = units(
+  [
     [1e-15, "f", 1],
     [1e-12, "p", 1],
     [1e-9, "n", 1],
-    [1e-6, "µ", 1],
+    [1e-6, "\xB5", 1],
     [1e-3, "m", 1],
     [1, ""],
     [1e3, "k", 1],
     [1e6, "M", 1],
     [1e9, "G", 1],
     [1e12, "T", 1],
-    [1e15, "P", 1],
-], "", 0);
+    [1e15, "P", 1]
+  ],
+  "",
+  0
+);
+export {
+  bits,
+  bytes,
+  grams,
+  meters,
+  seconds,
+  unitless,
+  units
+};

package/utf8.js

@@ -1,140 +1,82 @@
 import { defError } from "@thi.ng/errors/deferror";
-/**
- * Returns the number of bytes required to encode the given string as UTF-8.
- *
- * @param str
- */
-export const utf8Length = (str) => {
-    const n = str.length;
-    let len = 0;
-    for (let i = 0; i < n; ++i) {
-        let u = str.charCodeAt(i);
-        if (u >= 0xd800 && u < 0xe0000) {
-            u = (0x10000 + ((u & 0x3ff) << 10)) | (str.charCodeAt(++i) & 0x3ff);
-        }
-        len +=
-            u < 0x80
-                ? 1
-                : u < 0x800
-                    ? 2
-                    : u < 0x10000
-                        ? 3
-                        : u < 0x200000
-                            ? 4
-                            : u < 0x4000000
-                                ? 5
-                                : 6;
+const utf8Length = (str) => {
+  const n = str.length;
+  let len = 0;
+  for (let i = 0; i < n; ++i) {
+    let u = str.charCodeAt(i);
+    if (u >= 55296 && u < 917504) {
+      u = 65536 + ((u & 1023) << 10) | str.charCodeAt(++i) & 1023;
     }
-    return len;
+    len += u < 128 ? 1 : u < 2048 ? 2 : u < 65536 ? 3 : u < 2097152 ? 4 : u < 67108864 ? 5 : 6;
+  }
+  return len;
 };
-/**
- * Non-transducer version of
- * [`utf8Decode()`](https://docs.thi.ng/umbrella/transducers-binary/functions/utf8Decode.html).
- * Decodes `num` bytes from `start` index in given byte buffer. In Firefox this
- * is much faster than using the `TextDecoder` API.
- *
- * @param buf
- * @param start
- * @param num
- */
-export const utf8Decode = (buf, start, num) => {
-    const end = start + num;
-    let i = start;
-    let result = "";
-    let c;
-    while (i < end) {
-        c = buf[i++];
-        if (c < 0x80) {
-            result += String.fromCharCode(c);
-        }
-        else {
-            if (c >= 0xc0 && c < 0xe0) {
-                c = ((c & 0x1f) << 6) | (buf[i++] & 0x3f);
-            }
-            else if (c >= 0xe0 && c < 0xf0) {
-                c =
-                    ((c & 0x0f) << 12) |
-                        ((buf[i++] & 0x3f) << 6) |
-                        (buf[i++] & 0x3f);
-            }
-            else if (c >= 0xf0 && c < 0xf8) {
-                c =
-                    ((c & 7) << 18) |
-                        ((buf[i++] & 0x3f) << 12) |
-                        ((buf[i++] & 0x3f) << 6) |
-                        (buf[i++] & 0x3f);
-            }
-            else
-                utf8Error();
-            result += fromUtf8CodePoint(c);
-        }
+const utf8Decode = (buf, start, num) => {
+  const end = start + num;
+  let i = start;
+  let result = "";
+  let c;
+  while (i < end) {
+    c = buf[i++];
+    if (c < 128) {
+      result += String.fromCharCode(c);
+    } else {
+      if (c >= 192 && c < 224) {
+        c = (c & 31) << 6 | buf[i++] & 63;
+      } else if (c >= 224 && c < 240) {
+        c = (c & 15) << 12 | (buf[i++] & 63) << 6 | buf[i++] & 63;
+      } else if (c >= 240 && c < 248) {
+        c = (c & 7) << 18 | (buf[i++] & 63) << 12 | (buf[i++] & 63) << 6 | buf[i++] & 63;
+      } else
+        utf8Error();
+      result += fromUtf8CodePoint(c);
     }
-    return result;
+  }
+  return result;
 };
-/**
- * Non-transducer version of
- * [`utf8Encode()`](https://docs.thi.ng/umbrella/transducers-binary/functions/utf8Encode.html).
- *
- * @remarks
- * If `capacity` is given, initializes the byte array to that size (and assumes
- * that it is sufficient to store the entire string, e.g. by using
- * {@link utf8Length} to pre-determine the number of bytes required for a given
- * string). If `capacity` is _not_ provided, the buffer will be initialized to
- * `4 * src.length`.
- *
- * Based on:
- * - https://github.com/thi-ng/umbrella/blob/main/packages/transducers-binary/src/utf8.ts
- * - https://gist.github.com/pascaldekloe/62546103a1576803dade9269ccf76330
- *
- * @param buf
- */
-export const utf8Encode = (src, capacity) => {
-    const n = src.length;
-    const buf = new Uint8Array(capacity || n << 2);
-    let pos = 0;
-    let c;
-    for (let i = 0; i < n; i++) {
-        c = src.charCodeAt(i);
-        if (c < 0x80) {
-            buf[pos++] = c;
-        }
-        else {
-            if (c < 0x800) {
-                buf[pos++] = 0xc0 | (c >> 6);
-            }
-            else {
-                if (c >= 0xd800 && c < 0xdc00) {
-                    c =
-                        0x10000 +
-                            ((c & 0x03ff) << 10) +
-                            (src.charCodeAt(++i) & 0x3ff);
-                    buf[pos++] = 0xf0 | (c >> 18);
-                    buf[pos++] = 0x80 | ((c >> 12) & 0x3f);
-                }
-                else
-                    buf[pos++] = 0xe0 | (c >> 12);
-                buf[pos++] = 0x80 | ((c >> 6) & 0x3f);
-            }
-            buf[pos++] = 0x80 | (c & 0x3f);
-        }
+const utf8Encode = (src, capacity) => {
+  const n = src.length;
+  const buf = new Uint8Array(capacity || n << 2);
+  let pos = 0;
+  let c;
+  for (let i = 0; i < n; i++) {
+    c = src.charCodeAt(i);
+    if (c < 128) {
+      buf[pos++] = c;
+    } else {
+      if (c < 2048) {
+        buf[pos++] = 192 | c >> 6;
+      } else {
+        if (c >= 55296 && c < 56320) {
+          c = 65536 + ((c & 1023) << 10) + (src.charCodeAt(++i) & 1023);
+          buf[pos++] = 240 | c >> 18;
+          buf[pos++] = 128 | c >> 12 & 63;
+        } else
+          buf[pos++] = 224 | c >> 12;
+        buf[pos++] = 128 | c >> 6 & 63;
+      }
+      buf[pos++] = 128 | c & 63;
     }
-    return buf.subarray(0, pos);
+  }
+  return buf.subarray(0, pos);
 };
-/**
- * Returns character string for given UTF-8 codepoint.
- *
- * @param x
- */
-export const fromUtf8CodePoint = (x) => {
-    if (x < 0x10000)
-        return String.fromCharCode(x);
-    if (x < 0x110000) {
-        x -= 0x10000;
-        return String.fromCharCode(0xd800 | (x >>> 10), 0xdc00 | (x & 0x3ff));
-    }
-    return utf8Error(`invalid codepoint 0x${x.toString(16)}`);
+const fromUtf8CodePoint = (x) => {
+  if (x < 65536)
+    return String.fromCharCode(x);
+  if (x < 1114112) {
+    x -= 65536;
+    return String.fromCharCode(55296 | x >>> 10, 56320 | x & 1023);
+  }
+  return utf8Error(`invalid codepoint 0x${x.toString(16)}`);
 };
-export const UTF8Error = defError(() => "UTF-8 error");
+const UTF8Error = defError(() => "UTF-8 error");
 const utf8Error = (msg) => {
-    throw new UTF8Error(msg);
+  throw new UTF8Error(msg);
+};
+export {
+  UTF8Error,
+  fromUtf8CodePoint,
+  utf8Decode,
+  utf8Encode,
+  utf8Length
 };

package/uuid.js

@@ -1,15 +1,5 @@
 import { uuid as $uuid } from "@thi.ng/hex";
-/**
- * Same as [`uuid()`](https://docs.thi.ng/umbrella/hex/functions/uuid.html).
- * Returns UUID formatted string of given byte array from optional start index
- * `i` (default: 0). Array must have min. length
- * 16.
- *
- * @remarks
- * Use [`uuid()`](https://docs.thi.ng/umbrella/random/functions/uuid.html) to
- * also generate an UUID from scratch (rather than just format one).
- *
- * @param id -
- * @param i -
- */
-export const uuid = $uuid;
+const uuid = $uuid;
+export {
+  uuid
+};

package/vector.js

@@ -1,33 +1,30 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
 import { float } from "./float.js";
-/**
- * Higher order formatter for n-D vectors, with each element formatted using
- * `prec` and using optional delimiter and pre/postfixes.
- *
- * @size - vector size (optimized for size 1-4)
- * @prec - precision (see {@link float}) or existing number formatter
- * @delim - delimiter (default: `,`)
- * @pre - prefix (default: `[`)
- * @post - prefix (default: `]`)
- */
-export const vector = memoizeJ((size, prec = 3, d = ",", pre = "[", post = "]") => {
+const vector = memoizeJ(
+  (size, prec = 3, d = ",", pre = "[", post = "]") => {
     const f = typeof prec === "number" ? float(prec) : prec;
     switch (size) {
-        case 1:
-            return (v) => `${pre}${f(v[0])}${post}`;
-        case 2:
-            return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${post}`;
-        case 3:
-            return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${d}${f(v[2])}${post}`;
-        case 4:
-            return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${d}${f(v[2])}${d}${f(v[3])}${post}`;
-        default:
-            return (v) => {
-                const res = [];
-                for (let i = 0; i < v.length; i++) {
-                    res.push(f(v[i]));
-                }
-                return `${pre}${res.join(d)}${post}`;
-            };
+      case 1:
+        return (v) => `${pre}${f(v[0])}${post}`;
+      case 2:
+        return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${post}`;
+      case 3:
+        return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${d}${f(v[2])}${post}`;
+      case 4:
+        return (v) => `${pre}${f(v[0])}${d}${f(v[1])}${d}${f(v[2])}${d}${f(
+          v[3]
+        )}${post}`;
+      default:
+        return (v) => {
+          const res = [];
+          for (let i = 0; i < v.length; i++) {
+            res.push(f(v[i]));
+          }
+          return `${pre}${res.join(d)}${post}`;
+        };
     }
-});
+  }
+);
+export {
+  vector
+};