@thi.ng/strings 3.7.2 → 3.7.4

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:04Z
+- **Last updated**: 2023-12-18T13:41:19Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,13 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+### [3.7.4](https://github.com/thi-ng/umbrella/tree/@thi.ng/strings@3.7.4) (2023-12-18)
+
+#### 🩹 Bug fixes
+
+- improve split() regexp handling ([65fe14b](https://github.com/thi-ng/umbrella/commit/65fe14b))
+  - ensure given regexp has global flag enabled
+
 ## [3.7.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/strings@3.7.0) (2023-11-24)
 
 #### 🚀 Features

package/README.md

@@ -141,7 +141,7 @@ For Node.js REPL:
 const strings = await import("@thi.ng/strings");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 5.41 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 5.43 KB
 
 ## Dependencies
 

package/ansi.js

@@ -1,38 +1,13 @@
 const RE = /\x1b\[[0-9;]+m/g;
-/**
- * Removes all ANSI control sequences from given string.
- *
- * @example
- * ```ts
- * stripAnsi("\x1B[32mhello\x1B[0m \x1B[91mworld\x1B[0m!"");
- * // 'hello world!'
- * ```
- *
- * @param x -
- */
-export const stripAnsi = (x) => x.replace(RE, "");
-/**
- * Returns true iff `x` contains ANSI control sequences.
- *
- * @param x -
- */
-export const isAnsi = (x) => /\x1b\[[0-9;]+m/i.test(x);
-/**
- * Returns true iff `x` starts w/ an ANSI control sequence.
- *
- * @param x -
- */
-export const isAnsiStart = (x) => /^\x1b\[[0-9;]+m/i.test(x);
-/**
- * Returns true iff `x` ends w/ an ANSI control sequence.
- *
- * @param x -
- */
-export const isAnsiEnd = (x) => /\x1b\[[0-9;]+m$/i.test(x);
-/**
- * Returns length of `x` excluding any ANSI control sequences (via
- * {@link stripAnsi}).
- *
- * @param x -
- */
-export const lengthAnsi = (x) => stripAnsi(x).length;
+const stripAnsi = (x) => x.replace(RE, "");
+const isAnsi = (x) => /\x1b\[[0-9;]+m/i.test(x);
+const isAnsiStart = (x) => /^\x1b\[[0-9;]+m/i.test(x);
+const isAnsiEnd = (x) => /\x1b\[[0-9;]+m$/i.test(x);
+const lengthAnsi = (x) => stripAnsi(x).length;
+export {
+  isAnsi,
+  isAnsiEnd,
+  isAnsiStart,
+  lengthAnsi,
+  stripAnsi
+};

package/api.js

@@ -1,5 +1,4 @@
-/**
- * UTF-8 Byte Order Mark character
- * https://en.wikipedia.org/wiki/Byte_order_mark
- */
-export const BOM = "\ufeff";
+const BOM = "\uFEFF";
+export {
+  BOM
+};

package/case.js

@@ -1,56 +1,24 @@
-/**
- * Uppercase string formatter.
- *
- * @param x - string to transform
- */
-export const upper = (x) => x.toUpperCase();
-/**
- * Lowercase string formatter.
- *
- * @param x - string to transform
- */
-export const lower = (x) => x.toLowerCase();
-/**
- * String formatter which capitalizes first character.
- *
- * @param x - string to transform
- */
-export const capitalize = (x) => x.length ? x[0].toUpperCase() + x.substring(1) : x;
-/**
- * Converts a CamelCase string into kebab case, with optional custom
- * delimiter (`-` by default).
- *
- * @example
- * ```ts
- * kebab("FooBar23Baz");
- * // "foo-bar23-baz"
- * ```
- *
- * @param x -
- * @param delim -
- */
-export const kebab = (x, delim = "-") => lower(x.replace(
-// TC39
-// /(?<=[a-z0-9\u00e0-\u00fd])(?=[A-Z\u00c0-\u00dd])/g,
-// (_, i) => (i ? delim : "")
-/([a-z0-9\u00e0-\u00fd])([A-Z\u00c0-\u00dd])/g, (_, a, b) => a + delim + b));
-/**
- * Short for {@link kebab} using `_` as delimiter.
- *
- * @param x -
- */
-export const snake = (x) => kebab(x, "_");
-/**
- * Uppercase version of {@link snake}.
- *
- * @param x -
- */
-export const upperSnake = (x) => snake(x).toUpperCase();
-/**
- * Converts a kebab-case or snake_case string into CamelCase. Uses `-`
- * as default delimiter.
- *
- * @param x -
- * @param delim -
- */
-export const camel = (x, delim = "-") => lower(x).replace(new RegExp(`\\${delim}+(\\w)`, "g"), (_, c) => upper(c));
+const upper = (x) => x.toUpperCase();
+const lower = (x) => x.toLowerCase();
+const capitalize = (x) => x.length ? x[0].toUpperCase() + x.substring(1) : x;
+const kebab = (x, delim = "-") => lower(
+  x.replace(
+    // TC39
+    // /(?<=[a-z0-9\u00e0-\u00fd])(?=[A-Z\u00c0-\u00dd])/g,
+    // (_, i) => (i ? delim : "")
+    /([a-z0-9\u00e0-\u00fd])([A-Z\u00c0-\u00dd])/g,
+    (_, a, b) => a + delim + b
+  )
+);
+const snake = (x) => kebab(x, "_");
+const upperSnake = (x) => snake(x).toUpperCase();
+const camel = (x, delim = "-") => lower(x).replace(new RegExp(`\\${delim}+(\\w)`, "g"), (_, c) => upper(c));
+export {
+  camel,
+  capitalize,
+  kebab,
+  lower,
+  snake,
+  upper,
+  upperSnake
+};

package/center.js

@@ -1,36 +1,16 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
 import { repeat } from "./repeat.js";
 import { truncate } from "./truncate.js";
-/**
- * Returns stringer which pads given input with `ch` (default: space) on
- * both sides and returns fixed width string of given `lineWidth`.
- * Returns string of only pad characters for any `null` or `undefined`
- * values. If the string version of an input is > `lineWidth`, no
- * centering is performed, but the string will be truncated to
- * `lineWidth`.
- *
- * Note: The padding string can contain multiple characters.
- *
- * @example
- * ```ts
- * center(20, "<>")(wrap(" ")("thi.ng"))
- * // "<><><> thi.ng <><><>"
- * ```
- *
- * @param lineWidth - target length
- * @param pad - pad character(s)
- */
-export const center = memoizeJ((n, pad = " ") => {
-    const buf = repeat(String(pad), n);
-    return (x) => {
-        if (x == null)
-            return buf;
-        x = x.toString();
-        const r = (n - x.length) / 2;
-        return x.length < n
-            ? buf.substring(0, r) +
-                x +
-                buf.substring(0, r + ((n & 1) === (x.length & 1) ? 0 : 1))
-            : truncate(n)(x);
-    };
+const center = memoizeJ((n, pad = " ") => {
+  const buf = repeat(String(pad), n);
+  return (x) => {
+    if (x == null)
+      return buf;
+    x = x.toString();
+    const r = (n - x.length) / 2;
+    return x.length < n ? buf.substring(0, r) + x + buf.substring(0, r + ((n & 1) === (x.length & 1) ? 0 : 1)) : truncate(n)(x);
+  };
 });
+export {
+  center
+};

package/currency.js

@@ -1,10 +1,18 @@
 import { memoizeJ } from "@thi.ng/memoize/memoizej";
-export const currency = memoizeJ((sym, pre = true, prec = 2) => {
-    const ff = (x) => x.toFixed(prec);
-    return pre ? (x) => sym + ff(x) : (x) => ff(x) + sym;
+const currency = memoizeJ((sym, pre = true, prec = 2) => {
+  const ff = (x) => x.toFixed(prec);
+  return pre ? (x) => sym + ff(x) : (x) => ff(x) + sym;
 });
-export const chf = currency("CHF ");
-export const eur = currency("€");
-export const gbp = currency("£");
-export const usd = currency("$");
-export const yen = currency("¥");
+const chf = currency("CHF ");
+const eur = currency("\u20AC");
+const gbp = currency("\xA3");
+const usd = currency("$");
+const yen = currency("\xA5");
+export {
+  chf,
+  currency,
+  eur,
+  gbp,
+  usd,
+  yen
+};

package/cursor.js

@@ -1,38 +1,17 @@
-/**
- * Takes a string, linear index position and optional line split delimiter (or
- * regexp, default: "\n"). Computes and returns position of index as cursor
- * coords tuple: `[line, column]`
- *
- * @remarks
- * By default the returned coords are 1-based, but can be configured via
- * optional `offset` arg (also in `[line,column]` order).
- *
- * @example
- * ```ts
- * computeCursorPos("thi.ng\numbrella", 10);
- * // [ 2, 4 ]
- *
- * // w/ custom offset
- * computeCursorPos("thi.ng\numbrella", 10, "\n", [11, 1]);
- * // [ 12, 4 ]
- * ```
- *
- * @param str -
- * @param pos -
- * @param delim -
- * @param offset -
- */
-export const computeCursorPos = (str, pos, delim = "\n", offset = [1, 1]) => {
-    if (!str.length)
-        return [1, 1];
-    pos = Math.min(Math.max(0, pos), str.length);
-    const lines = str.split(delim);
-    const n = lines.length;
-    for (let i = 0; i < n; i++) {
-        const l = lines[i];
-        if (pos <= l.length)
-            return [i + offset[0], pos + offset[1]];
-        pos -= l.length + 1;
-    }
-    return [n + offset[0] - 1, offset[1]];
+const computeCursorPos = (str, pos, delim = "\n", offset = [1, 1]) => {
+  if (!str.length)
+    return [1, 1];
+  pos = Math.min(Math.max(0, pos), str.length);
+  const lines = str.split(delim);
+  const n = lines.length;
+  for (let i = 0; i < n; i++) {
+    const l = lines[i];
+    if (pos <= l.length)
+      return [i + offset[0], pos + offset[1]];
+    pos -= l.length + 1;
+  }
+  return [n + offset[0] - 1, offset[1]];
+};
+export {
+  computeCursorPos
 };

package/entities.js

@@ -1,151 +1,138 @@
-/**
- * @remarks
- * References:
- * - https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
- * - https://www.w3.org/TR/xml-entity-names/byalpha.html
- */
-export const ENTITIES = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    "≤": "&le;",
-    "≥": "&ge;",
-    '"': "&quot;",
-    "'": "&apos;",
-    "—": "&mdash;",
-    "–": "&ndash;",
-    "…": "&hellip;",
-    "⋮": "&vellip;",
-    "⋯": "&ctdot;",
-    "¢": "&cent;",
-    "€": "&euro;",
-    "£": "&pound;",
-    "¥": "&yen;",
-    "₹": "&#8377;",
-    元: "&#20803;",
-    "§": "&sect;",
-    "¶": "&para;",
-    "©": "&copy;",
-    "®": "&reg;",
-    "™": "&trade;",
-    "℃": "&#8451;",
-    "℉": "&#8457;",
-    K: "&#8490;",
-    "◂": "&ltrif;",
-    "▸": "&rtrif;",
-    "▴": "&utrif;",
-    "▾": "&dtrif;",
-    "←": "&larr;",
-    "→": "&rarr;",
-    "↑": "&uarr;",
-    "↓": "&darr;",
-    "↵": "&crarr;",
-    "↩": "&larrhk;",
-    "⇐": "&lArr;",
-    "⇒": "&rArr;",
-    "↺": "&olarr;",
-    "↻": "&orarr;",
-    "¹": "&sup1;",
-    "²": "&sup2;",
-    "³": "&sup3;",
-    "½": "&frac12;",
-    "⅓": "&frac13;",
-    "⅔": "&frac23;",
-    "¼": "&frac14;",
-    "¾": "&frac34;",
-    "⅕": "&frac15;",
-    "⅙": "&frac16;",
-    "⅛": "&frac18;",
-    Ä: "&Auml;",
-    Ë: "&Euml;",
-    Ï: "&Iuml;",
-    Ö: "&Ouml;",
-    Ü: "&Uuml;",
-    ä: "&auml;",
-    ë: "&euml;",
-    ï: "&iuml;",
-    ö: "&ouml;",
-    ü: "&uuml;",
-    ß: "&szlig;",
-    α: "&alpha;",
-    β: "&beta;",
-    γ: "&gamma;",
-    δ: "&delta;",
-    ε: "&epsi;",
-    θ: "&theta;",
-    λ: "&lambda;",
-    μ: "&mu;",
-    π: "&pi;",
-    σ: "&sigma;",
-    τ: "&tau;",
-    φ: "&phi;",
-    ω: "&omega;",
-    Δ: "&Delta;",
-    Ω: "&Omega;",
-    "∞": "&infin;",
-    "±": "&plusmn;",
-    "⨯": "&Cross;",
-    "°": "&deg;",
-    "∑": "&sum;",
-    "∏": "&prod;",
-    "∫": "&int;",
-    "√": "&radic;",
-    "∠": "&angle;",
-    "∧": "&and;",
-    "∨": "&or;",
-    "∩": "&cap;",
-    "∪": "&cup;",
-    "⊂": "&sub;",
-    "⊃": "&sup;",
-    "∈": "&isin;",
-    "∉": "&notin;",
-    "∅": "&empty;",
-    "⊕": "&oplus;",
-    "⊖": "&ominus;",
-    "⊗": "&otimes;",
-    "⌖": "&target;",
-    "☆": "&star;",
-    "★": "&starf;",
-    "✓": "&check;",
-    "✗": "&cross;",
-    "\xa0": "&nbsp;",
+const ENTITIES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  "\u2264": "&le;",
+  "\u2265": "&ge;",
+  '"': "&quot;",
+  "'": "&apos;",
+  "\u2014": "&mdash;",
+  "\u2013": "&ndash;",
+  "\u2026": "&hellip;",
+  "\u22EE": "&vellip;",
+  "\u22EF": "&ctdot;",
+  "\xA2": "&cent;",
+  "\u20AC": "&euro;",
+  "\xA3": "&pound;",
+  "\xA5": "&yen;",
+  "\u20B9": "&#8377;",
+  \u5143: "&#20803;",
+  "\xA7": "&sect;",
+  "\xB6": "&para;",
+  "\xA9": "&copy;",
+  "\xAE": "&reg;",
+  "\u2122": "&trade;",
+  "\u2103": "&#8451;",
+  "\u2109": "&#8457;",
+  K: "&#8490;",
+  "\u25C2": "&ltrif;",
+  "\u25B8": "&rtrif;",
+  "\u25B4": "&utrif;",
+  "\u25BE": "&dtrif;",
+  "\u2190": "&larr;",
+  "\u2192": "&rarr;",
+  "\u2191": "&uarr;",
+  "\u2193": "&darr;",
+  "\u21B5": "&crarr;",
+  "\u21A9": "&larrhk;",
+  "\u21D0": "&lArr;",
+  "\u21D2": "&rArr;",
+  "\u21BA": "&olarr;",
+  "\u21BB": "&orarr;",
+  "\xB9": "&sup1;",
+  "\xB2": "&sup2;",
+  "\xB3": "&sup3;",
+  "\xBD": "&frac12;",
+  "\u2153": "&frac13;",
+  "\u2154": "&frac23;",
+  "\xBC": "&frac14;",
+  "\xBE": "&frac34;",
+  "\u2155": "&frac15;",
+  "\u2159": "&frac16;",
+  "\u215B": "&frac18;",
+  \u00C4: "&Auml;",
+  \u00CB: "&Euml;",
+  \u00CF: "&Iuml;",
+  \u00D6: "&Ouml;",
+  \u00DC: "&Uuml;",
+  \u00E4: "&auml;",
+  \u00EB: "&euml;",
+  \u00EF: "&iuml;",
+  \u00F6: "&ouml;",
+  \u00FC: "&uuml;",
+  \u00DF: "&szlig;",
+  \u03B1: "&alpha;",
+  \u03B2: "&beta;",
+  \u03B3: "&gamma;",
+  \u03B4: "&delta;",
+  \u03B5: "&epsi;",
+  \u03B8: "&theta;",
+  \u03BB: "&lambda;",
+  \u03BC: "&mu;",
+  \u03C0: "&pi;",
+  \u03C3: "&sigma;",
+  \u03C4: "&tau;",
+  \u03C6: "&phi;",
+  \u03C9: "&omega;",
+  \u0394: "&Delta;",
+  \u03A9: "&Omega;",
+  "\u221E": "&infin;",
+  "\xB1": "&plusmn;",
+  "\u2A2F": "&Cross;",
+  "\xB0": "&deg;",
+  "\u2211": "&sum;",
+  "\u220F": "&prod;",
+  "\u222B": "&int;",
+  "\u221A": "&radic;",
+  "\u2220": "&angle;",
+  "\u2227": "&and;",
+  "\u2228": "&or;",
+  "\u2229": "&cap;",
+  "\u222A": "&cup;",
+  "\u2282": "&sub;",
+  "\u2283": "&sup;",
+  "\u2208": "&isin;",
+  "\u2209": "&notin;",
+  "\u2205": "&empty;",
+  "\u2295": "&oplus;",
+  "\u2296": "&ominus;",
+  "\u2297": "&otimes;",
+  "\u2316": "&target;",
+  "\u2606": "&star;",
+  "\u2605": "&starf;",
+  "\u2713": "&check;",
+  "\u2717": "&cross;",
+  "\xA0": "&nbsp;"
 };
-export const RE_ENTITIES = new RegExp(`[${Object.keys(ENTITIES).join("")}]`, "gu");
-export const ENTITIES_REV = Object.entries(ENTITIES).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});
-export const RE_ENTITIES_REV = new RegExp(`(${Object.keys(ENTITIES_REV).join("|")})`, "g");
-export const RE_ENTITIES_NUM = /&#(x?)([0-9a-f]+);/gi;
-/**
- * Replaces all occurrences of character keys in {@link ENTITIES} with their
- * named HTML entities.
- *
- * @remarks
- * Only use this function when targetting HTML output. For XML/SVG etc. use
- * {@link escapeEntitiesNum}.
- *
- * @param src
- */
-export const escapeEntities = (src) => src.replace(RE_ENTITIES, (x) => ENTITIES[x]);
-/**
- * Similar to {@link escapeEntities}, but only uses _named_ entities for `&`,
- * `<`, `>`, `'`, `"` and numeric entities for all others.
- *
- * @remarks
- * This function is used as default by thi.ng/hiccup `serialize()` to escape
- * characters and ensure compatibility with XML (which by default only supports
- * named entities for the above 5 characters).
- *
- * @param src
- */
-export const escapeEntitiesNum = (src) => src.replace(RE_ENTITIES, (x) => {
-    const code = x.charCodeAt(0);
-    return code < 128 ? ENTITIES[x] : `&#x${code.toString(16)};`;
+const RE_ENTITIES = new RegExp(
+  `[${Object.keys(ENTITIES).join("")}]`,
+  "gu"
+);
+const ENTITIES_REV = Object.entries(ENTITIES).reduce(
+  (acc, [k, v]) => (acc[v] = k, acc),
+  {}
+);
+const RE_ENTITIES_REV = new RegExp(
+  `(${Object.keys(ENTITIES_REV).join("|")})`,
+  "g"
+);
+const RE_ENTITIES_NUM = /&#(x?)([0-9a-f]+);/gi;
+const escapeEntities = (src) => src.replace(RE_ENTITIES, (x) => ENTITIES[x]);
+const escapeEntitiesNum = (src) => src.replace(RE_ENTITIES, (x) => {
+  const code = x.charCodeAt(0);
+  return code < 128 ? ENTITIES[x] : `&#x${code.toString(16)};`;
 });
-/**
- * Replace all known named and numeric entities with their original characters.
- * Opposite op of {@link escapeEntities} and {@link escapeEntitiesNum}.
- *
- * @param src
- */
-export const unescapeEntities = (src) => src
-    .replace(RE_ENTITIES_REV, (x) => ENTITIES_REV[x])
-    .replace(RE_ENTITIES_NUM, (_, hex, x) => String.fromCharCode(parseInt(x, hex ? 16 : 10)));
+const unescapeEntities = (src) => src.replace(RE_ENTITIES_REV, (x) => ENTITIES_REV[x]).replace(
+  RE_ENTITIES_NUM,
+  (_, hex, x) => String.fromCharCode(parseInt(x, hex ? 16 : 10))
+);
+export {
+  ENTITIES,
+  ENTITIES_REV,
+  RE_ENTITIES,
+  RE_ENTITIES_NUM,
+  RE_ENTITIES_REV,
+  escapeEntities,
+  escapeEntitiesNum,
+  unescapeEntities
+};