@thi.ng/strings 3.7.2 → 3.7.4

package/radix.js

@@ -1,59 +1,37 @@
-import { U16 as $16, U24 as $24, U32 as $32, U64HL, U8 as $8, } from "@thi.ng/hex";
+import {
+  U16 as $16,
+  U24 as $24,
+  U32 as $32,
+  U64HL,
+  U8 as $8
+} from "@thi.ng/hex";
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
 import { repeat } from "./repeat.js";
-/**
- * Returns a {@link Stringer} which formats given numbers to `radix`, `len` and
- * with optional prefix (not included in `len`).
- *
- * @remarks
- * Only bases 2 - 36 are supported, due to native `Number.toString()`
- * limitations.
- *
- * @param radix -
- * @param len -
- * @param prefix -
- */
-export const radix = memoizeJ((radix, n, prefix = "") => {
+const radix = memoizeJ(
+  (radix2, n, prefix = "") => {
     const buf = repeat("0", n);
     return (x) => {
-        x = (x >>> 0).toString(radix);
-        return prefix + (x.length < n ? buf.substring(x.length) + x : x);
+      x = (x >>> 0).toString(radix2);
+      return prefix + (x.length < n ? buf.substring(x.length) + x : x);
     };
-});
-/**
- * 8bit binary conversion preset.
- */
-export const B8 = radix(2, 8);
-/**
- * 16bit binary conversion preset.
- */
-export const B16 = radix(2, 16);
-/**
- * 32bit binary conversion preset.
- */
-export const B32 = radix(2, 32);
-/**
- * 8bit hex conversion preset.
- * Assumes unsigned inputs.
- */
-export const U8 = $8;
-/**
- * 16bit hex conversion preset.
- * Assumes unsigned inputs.
- */
-export const U16 = $16;
-/**
- * 24bit hex conversion preset.
- * Assumes unsigned inputs.
- */
-export const U24 = $24;
-/**
- * 32bit hex conversion preset.
- * Assumes unsigned inputs.
- */
-export const U32 = $32;
-/**
- * 64bit hex conversion preset (2x 32bit ints)
- * Assumes unsigned inputs.
- */
-export const U64 = U64HL;
+  }
+);
+const B8 = radix(2, 8);
+const B16 = radix(2, 16);
+const B32 = radix(2, 32);
+const U8 = $8;
+const U16 = $16;
+const U24 = $24;
+const U32 = $32;
+const U64 = U64HL;
+export {
+  B16,
+  B32,
+  B8,
+  U16,
+  U24,
+  U32,
+  U64,
+  U8,
+  radix
+};

package/range.js

@@ -1,21 +1,16 @@
-/**
- * Yields iterator of characters [`from`..`to`] (inclusive). Uses
- * reverse ordering if `to` < `from`.
- *
- * @param from -
- * @param to -
- */
-export function* charRange(from, to) {
-    let i = typeof from === "string" ? from.charCodeAt(0) : from;
-    const end = typeof to === "string" ? to.charCodeAt(0) : to;
-    if (i <= end) {
-        for (; i <= end; i++) {
-            yield String.fromCharCode(i);
-        }
+function* charRange(from, to) {
+  let i = typeof from === "string" ? from.charCodeAt(0) : from;
+  const end = typeof to === "string" ? to.charCodeAt(0) : to;
+  if (i <= end) {
+    for (; i <= end; i++) {
+      yield String.fromCharCode(i);
     }
-    else {
-        for (; i >= end; i--) {
-            yield String.fromCharCode(i);
-        }
+  } else {
+    for (; i >= end; i--) {
+      yield String.fromCharCode(i);
     }
+  }
 }
+export {
+  charRange
+};

package/repeat.js

@@ -1,6 +1,7 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
-/**
- * @param ch - character
- * @param n - repeat count
- */
-export const repeat = memoizeJ((ch, n) => ch.repeat(n));
+const repeat = memoizeJ(
+  (ch, n) => ch.repeat(n)
+);
+export {
+  repeat
+};

package/ruler.js

@@ -1,65 +1,14 @@
 import { repeat } from "./repeat.js";
-/**
- * Returns a ruler-like string of given `width`, using `a` character for major
- * ticks and `b` for minor ticks.
- *
- * @example
- * ```ts
- * console.log(ruler(40))
- * // |''''|''''|''''|''''|''''|''''|''''|''''
- *
- * console.log(ruler(40, 8, "!", "."))
- * // !.......!.......!.......!.......!.......
- * ```
- *
- * @param width -
- * @param major -
- * @param a -
- * @param b -
- */
-export const ruler = (width, major = 5, a = "|", b = "'") => repeat(a + repeat(b, major - 1), Math.ceil(width / major)).substring(0, width);
-/**
- * Returns a grid of given `cols` x `rows` as string, each cell of size `w` x
- * `h`. The optional `chars` can be used to customize the grid.
- *
- * @example
- * ```ts
- * console.log(grid(3, 3, 4, 2));
- * // +---+---+---+
- * // |   |   |   |
- * // +---+---+---+
- * // |   |   |   |
- * // +---+---+---+
- * // |   |   |   |
- * // +---+---+---+
- *
- * console.log(grid(3, 3, 4, 2, "*_/"));
- * // *___*___*___*
- * // /   /   /   /
- * // *___*___*___*
- * // /   /   /   /
- * // *___*___*___*
- * // /   /   /   /
- * // *___*___*___*
- *
- * console.log(grid(3, 2, 3, 3, "+  #"));
- * // +  +  +
- * //  ## ##
- * //  ## ##
- * // +  +  +
- * //  ## ##
- * //  ## ##
- * // +  +  +
- * ```
- *
- * @param cols -
- * @param rows -
- * @param w -
- * @param h -
- * @param chars -
- */
-export const grid = (cols, rows, w, h, [a, b, c, d] = "+-| ") => {
-    const major = ruler(cols * w, w, a, b) + a + "\n";
-    const minor = ruler(cols * w, w, c, d) + c + "\n";
-    return repeat(major + repeat(minor, h - 1), rows) + major;
+const ruler = (width, major = 5, a = "|", b = "'") => repeat(a + repeat(b, major - 1), Math.ceil(width / major)).substring(
+  0,
+  width
+);
+const grid = (cols, rows, w, h, [a, b, c, d] = "+-| ") => {
+  const major = ruler(cols * w, w, a, b) + a + "\n";
+  const minor = ruler(cols * w, w, c, d) + c + "\n";
+  return repeat(major + repeat(minor, h - 1), rows) + major;
+};
+export {
+  grid,
+  ruler
 };

package/slugify.js

@@ -1,52 +1,16 @@
-const src = "àáäâãåèéëêìíïîòóöôùúüûñçßÿœæŕśńṕẃǵǹḿǘẍźḧ·/_,:;";
+const src = "\xE0\xE1\xE4\xE2\xE3\xE5\xE8\xE9\xEB\xEA\xEC\xED\xEF\xEE\xF2\xF3\xF6\xF4\xF9\xFA\xFC\xFB\xF1\xE7\xDF\xFF\u0153\xE6\u0155\u015B\u0144\u1E55\u1E83\u01F5\u01F9\u1E3F\u01D8\u1E8D\u017A\u1E27\xB7/_,:;";
 const dest = "aaaaaaeeeeiiiioooouuuuncsyoarsnpwgnmuxzh------";
 const re = new RegExp(src.split("").join("|"), "g");
-/**
- * Based on:
- * https://medium.com/@matthagemann/the-ultimate-way-to-slugify-a-url-string-in-javascript-b8e4a0d849e1
- *
- * @example
- * ```ts
- * slugify("Me, myself (& ëye) 😀!")
- * // "me-myself-and-eye"
- * ```
- *
- * @param str -
- */
-export const slugify = (str) => {
-    return (str
-        .toLowerCase()
-        .replace(/\s+/g, "-")
-        .replace(re, (c) => dest[src.indexOf(c)])
-        .replace(/&+/g, "-and-")
-        .replace(/[^\w\-]+/g, "")
-        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
-        .replace(/\p{Emoji_Presentation}/gu, "")
-        .replace(/\-{2,}/g, "-")
-        .replace(/(^-+)|(-+$)/g, ""));
+const slugify = (str) => {
+  return str.toLowerCase().replace(/\s+/g, "-").replace(re, (c) => dest[src.indexOf(c)]).replace(/&+/g, "-and-").replace(/[^\w\-]+/g, "").replace(/\p{Emoji_Presentation}/gu, "").replace(/\-{2,}/g, "-").replace(/(^-+)|(-+$)/g, "");
 };
-/**
- * Similar to {@link slugify}, however uses GitHub's anchor naming rules
- * for headings in markdown files (AFAICT).
- *
- * @example
- * ```ts
- * slugifyGH("Me, myself (& ëye) 😀!")
- * // "me-myself--ëye-"
- * ```
- *
- * @param str -
- */
-export const slugifyGH = (str) => {
-    return (str
-        .toLowerCase()
-        // remove all punctuations:
-        // - ascii
-        // - https://www.unicode.org/charts/PDF/U2000.pdf (general)
-        // - https://www.unicode.org/charts/PDF/U2700.pdf (dingbats)
-        // - https://www.unicode.org/charts/PDF/U2E00.pdf (supplemental)
-        .replace(/[!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~\u0000-\u001f\u2000-\u206f\u2700-\u27bf\u2e00-\u2e7f]/g, "")
-        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Unicode_Property_Escapes
-        .replace(/\p{Emoji_Presentation}/gu, "")
-        .replace(/\s/g, "-"));
+const slugifyGH = (str) => {
+  return str.toLowerCase().replace(
+    /[!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~\u0000-\u001f\u2000-\u206f\u2700-\u27bf\u2e00-\u2e7f]/g,
+    ""
+  ).replace(/\p{Emoji_Presentation}/gu, "").replace(/\s/g, "-");
+};
+export {
+  slugify,
+  slugifyGH
 };

package/splice.js

@@ -1,31 +1,17 @@
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
-/**
- * Forms a new strings which inserts given `insert` string into `src`
- * string at `from` position and appends remaining `src` chars from
- * original `to` position. If `from` and `to` are equal (`to` by default
- * is), the operation is a pure insertion. If not, then some chars from
- * `src` will be removed in the new string. If either position is
- * negative, it'll be considered relative to the end of the `src`.
- *
- * @param src -
- * @param insert -
- * @param from -
- * @param to -
- */
-export const splice = (src, insert, from, to = from) => {
-    if (from < 0) {
-        from += src.length;
-    }
-    if (to < 0) {
-        to += src.length;
-    }
-    if (from > to) {
-        illegalArgs("'from' index must be <= 'to'");
-    }
-    to = Math.max(to, 0);
-    return from <= 0
-        ? insert + src.substring(to)
-        : from >= src.length
-            ? src + insert
-            : src.substring(0, from) + insert + src.substring(to);
+const splice = (src, insert, from, to = from) => {
+  if (from < 0) {
+    from += src.length;
+  }
+  if (to < 0) {
+    to += src.length;
+  }
+  if (from > to) {
+    illegalArgs("'from' index must be <= 'to'");
+  }
+  to = Math.max(to, 0);
+  return from <= 0 ? insert + src.substring(to) : from >= src.length ? src + insert : src.substring(0, from) + insert + src.substring(to);
+};
+export {
+  splice
 };

package/split.d.ts

@@ -8,6 +8,9 @@
  * This function is ~2x faster for large strings (benchmarked with 8MB & 16MB
  * inputs), with dramatically lower memory consumption.
  *
+ * If given an regexp as `delim`, the function ensures the regexp has its global
+ * flag enabled.
+ *
  * @param src -
  * @param delim -
  * @param includeDelim -

package/split.js

@@ -1,30 +1,26 @@
-/**
- * Iterator version of `String.prototype.split()`. Yields iterable of substrings
- * of `src`, delimited by given regexp (default: unix & windows linebreaks).
- *
- * @remarks
- * Use this function to avoid creating an entire full copy of the original
- * source string, e.g. when only single-token or line-based accesses are needed.
- * This function is ~2x faster for large strings (benchmarked with 8MB & 16MB
- * inputs), with dramatically lower memory consumption.
- *
- * @param src -
- * @param delim -
- * @param includeDelim -
- */
-export function* split(src, delim = /\r?\n/g, includeDelim = false) {
-    let i = 0;
-    const n = src.length;
-    const include = ~~includeDelim;
-    const re = typeof delim === "string" ? new RegExp(delim, "g") : delim;
-    for (; i < n;) {
-        const m = re.exec(src);
-        if (!m) {
-            yield src.substring(i);
-            return;
-        }
-        const len = m[0].length;
-        yield src.substring(i, m.index + include * len);
-        i = m.index + len;
+function* split(src, delim = /\r?\n/g, includeDelim = false) {
+  let i = 0;
+  const n = src.length;
+  const include = ~~includeDelim;
+  let re;
+  if (typeof delim === "string") {
+    re = new RegExp(delim, "g");
+  } else if (!delim.flags.includes("g")) {
+    re = new RegExp(delim, delim.flags + "g");
+  } else {
+    re = delim;
+  }
+  for (; i < n; ) {
+    const m = re.exec(src);
+    if (!m) {
+      yield src.substring(i);
+      return;
     }
+    const len = m[0].length;
+    yield src.substring(i, m.index + include * len);
+    i = m.index + len;
+  }
 }
+export {
+  split
+};

package/stringify.js

@@ -1,12 +1,4 @@
-/**
- * Higher order version of `JSON.stringify()` with the option to treat strings
- * and numbers differently. If `all` is `false` (default), strings and numbers
- * are simply converted using `String(x)`. If `indent` is given, it will be used
- * for `JSON.stringify(x, null, indent)`
- *
- * @param all -
- * @param indent -
- */
-export const stringify = (all = false, indent) => (x) => all || (typeof x !== "string" && typeof x !== "number")
-    ? JSON.stringify(x, null, indent)
-    : String(x);
+const stringify = (all = false, indent) => (x) => all || typeof x !== "string" && typeof x !== "number" ? JSON.stringify(x, null, indent) : String(x);
+export {
+  stringify
+};

package/tabs.js

@@ -1,87 +1,46 @@
 import { repeat } from "./repeat.js";
 const nextTab = (x, tabSize) => Math.floor((x + tabSize) / tabSize) * tabSize;
-/**
- * Multi-line version of {@link tabsToSpacesLine}.
- *
- * @example
- * ```ts
- * console.log(
- *   tabsToSpaces("0\t1\t2", 10)
- *   + "\n" +
- *   tabsToSpaces("0\t45\t890\t\t6\t0")
- *   + "\n" +
- *   tabsToSpaces("^\t^\t^\t^\t^\t^")
- * );
- * // 0         1         2
- * // 0   45  890     6   0
- * // ^   ^   ^   ^   ^   ^
- * ```
- *
- * @param src -
- * @param tabSize -
- */
-export const tabsToSpaces = (src, tabSize = 4) => src
-    .split(/\r?\n/g)
-    .map((line) => tabsToSpacesLine(line, tabSize))
-    .join("\n");
-/**
- * Takes a single line string and converts all tab characters to spaces, using
- * given `tabSize`.
- *
- * @param line -
- * @param tabSize -
- */
-export const tabsToSpacesLine = (line, tabSize = 4) => {
-    let res = "";
-    let words = line.split(/\t/g);
-    let n = words.length - 1;
-    for (let i = 0; i < n; i++) {
-        const w = words[i];
-        res += w;
-        res += repeat(" ", nextTab(res.length, tabSize) - res.length);
-    }
-    res += words[n];
-    return res;
+const tabsToSpaces = (src, tabSize = 4) => src.split(/\r?\n/g).map((line) => tabsToSpacesLine(line, tabSize)).join("\n");
+const tabsToSpacesLine = (line, tabSize = 4) => {
+  let res = "";
+  let words = line.split(/\t/g);
+  let n = words.length - 1;
+  for (let i = 0; i < n; i++) {
+    const w = words[i];
+    res += w;
+    res += repeat(" ", nextTab(res.length, tabSize) - res.length);
+  }
+  res += words[n];
+  return res;
 };
-/**
- * Multi-line version of {@link spacesToTabsLine}.
- *
- * @param src -
- * @param tabSize -
- */
-export const spacesToTabs = (src, tabSize = 4) => src
-    .split(/\r?\n/g)
-    .map((line) => spacesToTabsLine(line, tabSize))
-    .join("\n");
-/**
- * Takes a single line string and converts all tab characters to spaces, using
- * given `tabSize`. Inverse op of {@link tabsToSpacesLine}.
- *
- * @param line -
- * @param tabSize -
- */
-export const spacesToTabsLine = (line, tabSize = 4) => {
-    const re = /\s{2,}/g;
-    let i = 0;
-    let res = "";
-    let m;
-    while ((m = re.exec(line))) {
-        const numSpaces = m[0].length;
-        res += line.substring(i, m.index);
-        i = m.index;
-        const end = m.index + numSpaces;
-        while (i < end) {
-            const j = nextTab(i, tabSize);
-            if (j <= end) {
-                res += "\t";
-                i = j;
-            }
-            else {
-                res += repeat(" ", end - i);
-                i = end;
-            }
-        }
+const spacesToTabs = (src, tabSize = 4) => src.split(/\r?\n/g).map((line) => spacesToTabsLine(line, tabSize)).join("\n");
+const spacesToTabsLine = (line, tabSize = 4) => {
+  const re = /\s{2,}/g;
+  let i = 0;
+  let res = "";
+  let m;
+  while (m = re.exec(line)) {
+    const numSpaces = m[0].length;
+    res += line.substring(i, m.index);
+    i = m.index;
+    const end = m.index + numSpaces;
+    while (i < end) {
+      const j = nextTab(i, tabSize);
+      if (j <= end) {
+        res += "	";
+        i = j;
+      } else {
+        res += repeat(" ", end - i);
         i = end;
+      }
     }
-    return res + line.substring(i);
+    i = end;
+  }
+  return res + line.substring(i);
+};
+export {
+  spacesToTabs,
+  spacesToTabsLine,
+  tabsToSpaces,
+  tabsToSpacesLine
 };

package/trim.js

@@ -1,24 +1,9 @@
 import { memoize1 } from "@thi.ng/memoize/memoize1";
-/**
- * Higher order trim function (both sides) with support for user defined
- * trimmable characters (default: whitespace only).
- *
- * @example
- * ```ts
- * trim()("  Hello   ")
- * // "Hello"
- *
- * trim(" -+")("-+-+- Hello -+-+-")
- * // "Hello"
- * ```
- *
- * @param chars -
- */
-export const trim = memoize1((chars = " \t\n\r") => {
-    chars = `(${chars
-        .split("")
-        .map((x) => `\\${x}`)
-        .join("|")})`;
-    const re = new RegExp(`(^${chars}+)|(${chars}+$)`, "g");
-    return (x) => x.replace(re, "");
+const trim = memoize1((chars = " 	\n\r") => {
+  chars = `(${chars.split("").map((x) => `\\${x}`).join("|")})`;
+  const re = new RegExp(`(^${chars}+)|(${chars}+$)`, "g");
+  return (x) => x.replace(re, "");
 });
+export {
+  trim
+};

package/truncate-left.js

@@ -1,4 +1,7 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
-export const truncateLeft = memoizeJ((n, prefix = "") => (x) => x.length > n
-    ? prefix + x.substring(x.length - n + prefix.length)
-    : x);
+const truncateLeft = memoizeJ(
+  (n, prefix = "") => (x) => x.length > n ? prefix + x.substring(x.length - n + prefix.length) : x
+);
+export {
+  truncateLeft
+};

package/truncate.js

@@ -1,6 +1,9 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
-export const truncate = memoizeJ((n, suffix = "") => (x) => x.length > n ? x.substring(0, n - suffix.length) + suffix : x);
-/**
- * Alias for {@link truncate}
- */
-export const truncateRight = truncate;
+const truncate = memoizeJ(
+  (n, suffix = "") => (x) => x.length > n ? x.substring(0, n - suffix.length) + suffix : x
+);
+const truncateRight = truncate;
+export {
+  truncate,
+  truncateRight
+};