@tempots/std 0.9.7 → 0.10.4

package/string.js

@@ -0,0 +1,396 @@
+import { any as c, all as b, range as A, fill as O } from "./array.js";
+import { map as p } from "./regexp.js";
+function a(n, t, r) {
+  return n.split(t).join(r);
+}
+function J(n, t) {
+  const r = n.indexOf(t);
+  return r < 0 ? "" : n.substring(r + t.length);
+}
+function Q(n, t) {
+  const r = n.lastIndexOf(t);
+  return r < 0 ? "" : n.substring(r + t.length);
+}
+function V(n, t) {
+  const r = n.indexOf(t);
+  return r < 0 ? "" : n.substring(0, r);
+}
+function X(n, t) {
+  const r = n.lastIndexOf(t);
+  return r < 0 ? "" : n.substring(0, r);
+}
+function h(n) {
+  return n.substring(0, 1).toUpperCase() + n.substring(1);
+}
+const d = (n) => n.toUpperCase();
+function Y(n, t = !1) {
+  return t ? p(h(n), R, d) : p(h(n), P, d);
+}
+function v(n) {
+  return n.replace(q, `
+`);
+}
+function nn(n, t) {
+  return n == null && t == null ? 0 : n == null ? -1 : t == null ? 1 : y(n.toLowerCase(), t.toLowerCase());
+}
+function L(n, t) {
+  return n.substring(0, n.length - t.length) === t;
+}
+function tn(n, t) {
+  return n.substring(0, n.length - t.length).toLowerCase() === t.toLowerCase();
+}
+function W(n, t) {
+  return n.substring(0, t.length) === t;
+}
+function rn(n, t) {
+  return n.substring(0, t.length).toLowerCase() === t.toLowerCase();
+}
+function en(n, t) {
+  return E(
+    n.toLowerCase(),
+    t.map((r) => r.toLowerCase())
+  );
+}
+function on(n, t) {
+  return _(
+    n.toLowerCase(),
+    t.map((r) => r.toLowerCase())
+  );
+}
+function sn(n) {
+  return n.trim().replace(m, " ");
+}
+function y(n, t) {
+  return n < t ? -1 : n > t ? 1 : 0;
+}
+function w(n, t) {
+  return n.toLowerCase().includes(t.toLowerCase());
+}
+function l(n, t) {
+  return n.includes(t);
+}
+function un(n, t) {
+  return n.split(t).length - 1;
+}
+function fn(n, t) {
+  return c(t, (r) => w(n, r));
+}
+function cn(n, t) {
+  return c(t, (r) => l(n, r));
+}
+function ln(n, t) {
+  return b(t, (r) => w(n, r));
+}
+function an(n, t) {
+  return b(t, (r) => l(n, r));
+}
+function gn(n) {
+  return n.replace("_", "-");
+}
+function pn(n, t) {
+  const r = Math.min(n.length, t.length);
+  for (let e = 0; e < r; e++)
+    if (n.substring(e, e + 1) !== t.substring(e, e + 1)) return e;
+  return r;
+}
+function z(n, t = 20, r = "…") {
+  const e = n.length, i = r.length;
+  return e > t ? t < i ? r.substr(i - t, t) : n.substr(0, t - i) + r : n;
+}
+function hn(n, t = 20, r = "…") {
+  const e = n.length, i = r.length;
+  if (e > t) {
+    if (t <= i)
+      return z(n, t, r);
+    const u = Math.ceil((t - i) / 2), f = Math.floor((t - i) / 2);
+    return n.substr(0, u) + r + n.substr(e - f, f);
+  } else return n;
+}
+function E(n, t) {
+  return c(t, (r) => L(n, r));
+}
+function dn(n, t) {
+  return g(n).filter(t).join("");
+}
+function Cn(n, t) {
+  return $(n).filter(t).map((e) => String.fromCharCode(e)).join("");
+}
+function bn(n, t) {
+  const r = n.indexOf(t);
+  return r < 0 ? "" : n.substring(r);
+}
+function An(n, t = 2166136261) {
+  let r = t;
+  for (let e = 0, i = n.length; e < i; e++)
+    r ^= n.charCodeAt(e), r += (r << 1) + (r << 4) + (r << 7) + (r << 8) + (r << 24);
+  return r >>> 0;
+}
+function Ln(n) {
+  return n != null && n.length > 0;
+}
+function wn(n) {
+  return a(T(n), "_", " ");
+}
+function In(n) {
+  return n.length > 0 && !x.test(n);
+}
+function mn(n) {
+  return D.test(n);
+}
+function Sn(n) {
+  return !Z.test(n);
+}
+function On(n) {
+  return n.toLowerCase() === n;
+}
+function Wn(n) {
+  return n.toUpperCase() === n;
+}
+function yn(n, t) {
+  return n != null && n !== "" ? n : t;
+}
+function zn(n) {
+  return G.test(n);
+}
+function En(n) {
+  return n == null || n === "";
+}
+function Bn(n) {
+  return n.substring(0, 1).toLowerCase() + n.substring(1);
+}
+function B(n, t = 1) {
+  return n.substring(
+    Math.floor((n.length - t + 1) * Math.random()),
+    t
+  );
+}
+function j(n, t) {
+  return A(t, () => B(n)).join("");
+}
+function jn(n) {
+  return j(k, n);
+}
+function _n(n, t) {
+  return g(t).map(n);
+}
+function $n(n, t) {
+  return a(n, t, "");
+}
+function Mn(n, t) {
+  return L(n, t) ? n.substring(0, n.length - t.length) : n;
+}
+function Nn(n, t, r) {
+  return n.substring(0, t) + n.substring(t + r);
+}
+function Tn(n, t) {
+  return W(n, t) ? n.substring(t.length) : n;
+}
+function Un(n, t) {
+  const r = n.indexOf(t);
+  return r < 0 ? n : n.substring(0, r) + n.substring(r + t.length);
+}
+function I(n, t) {
+  return O(t, n).join("");
+}
+function kn(n) {
+  const t = g(n);
+  return t.reverse(), t.join("");
+}
+function Pn(n) {
+  return n.includes('"') ? n.includes("'") ? '"' + a(n, '"', '\\"') + '"' : "'" + n + "'" : '"' + n + '"';
+}
+function Zn(n, t) {
+  const r = n.indexOf(t);
+  return r < 0 ? [n] : [n.substring(0, r), n.substring(r + t.length)];
+}
+function _(n, t) {
+  return c(t, (r) => n.startsWith(r));
+}
+function xn(n) {
+  return n.replace(H, "");
+}
+function Rn(n, t, r = t) {
+  return `${t}${n}${r}`;
+}
+function g(n) {
+  return n.split("");
+}
+function $(n) {
+  return A(n.length, (t) => n.charCodeAt(t));
+}
+function Dn(n, t) {
+  const r = [];
+  for (; n.length > 0; )
+    r.push(n.substring(0, t)), n = n.substr(t, n.length - t);
+  return r;
+}
+function Gn(n) {
+  return n.split(S);
+}
+function Hn(n, t) {
+  return N(M(n, t), t);
+}
+function M(n, t) {
+  let r = 0;
+  for (let e = 0; e < n.length && l(t, n.charAt(e)); e++)
+    r++;
+  return n.substring(r);
+}
+function N(n, t) {
+  const r = n.length;
+  let e = r, i;
+  for (let u = 0; u < r && (i = r - u - 1, l(t, n.charAt(i))); u++)
+    e = i;
+  return n.substring(0, e);
+}
+function T(n) {
+  return n = n.replace(/::/g, "/"), n = n.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2"), n = n.replace(/([a-z\d])([A-Z])/g, "$1_$2"), n = n.replace(/-/g, "_"), n.toLowerCase();
+}
+function qn(n) {
+  return n.substring(0, 1).toUpperCase() + n.substring(1);
+}
+function Fn(n, t) {
+  const r = n.indexOf(t);
+  return r < 0 ? n : n.substring(0, r);
+}
+function Kn(n, t = 78, r = "", e = `
+`) {
+  return n.split(S).map(
+    (i) => U(i.replace(m, " ").trim(), t, r, e)
+  ).join(e);
+}
+function C(n, t) {
+  if (t < 0 || t >= n.length) return !1;
+  const r = n.charCodeAt(t);
+  return r === 9 || r === 10 || r === 11 || r === 12 || r === 13 || r === 32;
+}
+function Jn(n) {
+  if (typeof Buffer < "u")
+    return Buffer.from(n).toString("base64");
+  if (typeof btoa < "u")
+    return btoa(n);
+  throw new Error("no implementation provided for base64 encoding");
+}
+function Qn(n) {
+  if (typeof Buffer < "u")
+    return Buffer.from(n, "base64").toString("utf8");
+  if (typeof atob < "u")
+    return atob(n);
+  throw new Error("no implementation provided for base64 decoding");
+}
+function U(n, t, r, e) {
+  const i = [], u = n.length, f = r.length;
+  let s = 0;
+  for (t -= f; ; ) {
+    if (s + t >= u - f) {
+      i.push(n.substring(s));
+      break;
+    }
+    let o = 0;
+    for (; !C(n, s + t - o) && o < t; ) o++;
+    if (o === t) {
+      for (o = 0; !C(n, s + t + o) && s + t + o < u; ) o++;
+      i.push(n.substring(s, s + t + o)), s += t + o + 1;
+    } else
+      i.push(n.substring(s, s + t - o)), s += t - o + 1;
+  }
+  return r + i.join(e + r);
+}
+function Vn(n, t, r) {
+  const e = r - n.length;
+  return e > 0 ? I(t, e) + n : n;
+}
+function Xn(n, t, r) {
+  const e = r - n.length;
+  return e > 0 ? n + I(t, e) : n;
+}
+function Yn(n, t) {
+  const r = n.lastIndexOf(t);
+  return r >= 0 ? [n.substring(0, r), n.substring(r + t.length)] : [n];
+}
+function vn(n, t) {
+  const r = n.indexOf(t);
+  return r >= 0 ? [n.substring(0, r), n.substring(r + t.length)] : [n];
+}
+const k = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", P = /[^a-zA-Z]([a-z])/g, Z = /[^\t\n\r ]/, x = /[^a-zA-Z]/, R = /[ \t\r\n][a-z]/g, D = /^[a-z0-9]+$/i, G = /^[0-9]+$/, H = /<\/?[a-z]+[^>]*>/gi, m = /[ \t\r\n]+/g, S = /\r\n|\n\r|\n|\r/g, q = /\r\n|\n\r|\r/g;
+export {
+  J as after,
+  Q as afterLast,
+  V as before,
+  X as beforeLast,
+  v as canonicalizeNewlines,
+  h as capitalize,
+  Y as capitalizeWords,
+  sn as collapse,
+  y as compare,
+  nn as compareCaseInsensitive,
+  l as contains,
+  an as containsAll,
+  ln as containsAllCaseInsensitive,
+  cn as containsAny,
+  fn as containsAnyCaseInsensitive,
+  w as containsCaseInsensitive,
+  un as count,
+  gn as dasherize,
+  Qn as decodeBase64,
+  pn as diffIndex,
+  z as ellipsis,
+  hn as ellipsisMiddle,
+  Jn as encodeBase64,
+  L as endsWith,
+  E as endsWithAny,
+  en as endsWithAnyCaseInsensitive,
+  tn as endsWithCaseInsensitive,
+  dn as filter,
+  Cn as filterCharcode,
+  bn as from,
+  Ln as hasContent,
+  An as hashCode,
+  wn as humanize,
+  yn as ifEmpty,
+  In as isAlpha,
+  mn as isAlphaNum,
+  Sn as isBreakingWhitespace,
+  zn as isDigitsOnly,
+  En as isEmpty,
+  On as isLowerCase,
+  C as isSpaceAt,
+  Wn as isUpperCase,
+  Bn as lowerCaseFirst,
+  Vn as lpad,
+  _n as map,
+  Pn as quote,
+  B as random,
+  j as randomSequence,
+  jn as randomSequence64,
+  $n as remove,
+  Mn as removeAfter,
+  Nn as removeAt,
+  Tn as removeBefore,
+  Un as removeOne,
+  I as repeat,
+  a as replace,
+  kn as reverse,
+  Xn as rpad,
+  vn as splitOnFirst,
+  Yn as splitOnLast,
+  Zn as splitOnce,
+  W as startsWith,
+  _ as startsWithAny,
+  on as startsWithAnyCaseInsensitive,
+  rn as startsWithCaseInsensitive,
+  xn as stripTags,
+  Rn as surround,
+  g as toArray,
+  $ as toCharcodes,
+  Dn as toChunks,
+  Gn as toLines,
+  Hn as trimChars,
+  M as trimCharsLeft,
+  N as trimCharsRight,
+  T as underscore,
+  Fn as upTo,
+  qn as upperCaseFirst,
+  Kn as wrapColumns,
+  U as wrapLine
+};

package/arrays.js

@@ -1,249 +0,0 @@
-/*
-Copyright 2019 Google LLC
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-    https://www.apache.org/licenses/LICENSE-2.0
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-/**
- * Utility functions to manipulate `Array` values.
- */
-import { Maybe } from './maybe';
-import { keys } from './objects';
-export function map(arr, f) {
-    return Array.from({ length: arr.length }, (_, i) => f(arr[i], i));
-}
-export function mapNotNull(arr, f) {
-    const buff = [];
-    for (let i = 0; i < arr.length; i++) {
-        const v = f(arr[i], i);
-        if (v != null) {
-            buff.push(v);
-        }
-    }
-    return buff;
-}
-export function flatMap(arr, f) {
-    const buff = [];
-    for (const el of arr) {
-        buff.push(...f(el));
-    }
-    return buff;
-}
-export function head(arr) {
-    return arr.length > 0 ? arr[0] : Maybe.nothing;
-}
-export function tail(arr) {
-    return arr.slice(1);
-}
-export function equals(a, b, equality) {
-    if (a.length !== b.length)
-        return false;
-    else {
-        for (let i = 0; i < a.length; i++) {
-            if (!equality(a[i], b[i]))
-                return false;
-        }
-        return true;
-    }
-}
-export function makeEquals(equality) {
-    return function (a, b) {
-        return equals(a, b, equality);
-    };
-}
-export function isEmpty(arr) {
-    return arr.length === 0;
-}
-export function hasValues(arr) {
-    return arr.length > 0;
-}
-export function filter(arr, predicate) {
-    const buff = [];
-    for (const a of arr)
-        if (predicate(a))
-            buff.push(a);
-    return buff;
-}
-export function filterNulls(arr) {
-    return filter(arr, v => v != null);
-}
-export function flatten(arr) {
-    return [].concat(...arr);
-}
-export function foldLeft(arr, f, b) {
-    for (const a of arr) {
-        b = f(b, a);
-    }
-    return b;
-}
-export function all(arr, predicate) {
-    for (const a of arr) {
-        if (!predicate(a)) {
-            return false;
-        }
-    }
-    return true;
-}
-export function any(arr, predicate) {
-    for (const a of arr) {
-        if (predicate(a)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function each(arr, f) {
-    for (const a of arr)
-        f(a);
-}
-export function concat(...arrs) {
-    return [].concat(...arrs);
-}
-export function makeCompare(comparef, shorterFirst = true) {
-    return function (a, b) {
-        if (a.length < b.length) {
-            return -1 * (shorterFirst ? 1 : -1);
-        }
-        else if (a.length > b.length) {
-            return 1 * (shorterFirst ? 1 : -1);
-        }
-        for (let i = 0; i < a.length; i++) {
-            const ord = comparef(a[i], b[i]);
-            if (ord !== 0)
-                return ord;
-        }
-        return 0;
-    };
-}
-export function sort(compare, arr) {
-    return arr.slice().sort(compare);
-}
-export function range(length, f) {
-    return Array.from({ length }, (_, i) => f(i));
-}
-export function numbersRange(length, startAt = 0) {
-    return range(length, i => startAt + i);
-}
-export function fill(length, value) {
-    return range(length, () => value);
-}
-export function distinctPrimitive(values) {
-    return Array.from(new Set(values));
-}
-export function distinctByPredicate(values, predicate) {
-    const map = {};
-    values.forEach(v => {
-        map[predicate(v)] = v;
-    });
-    return keys(map).map(k => map[k]);
-}
-export function remove(arr, item, predicate) {
-    let index;
-    if (predicate !== undefined) {
-        index = arr.findIndex(predicate);
-    }
-    else {
-        index = arr.indexOf(item);
-    }
-    if (index < 0) {
-        return false;
-    }
-    else {
-        arr.splice(index, 1);
-        return true;
-    }
-}
-export function ofIterableIterator(it) {
-    const buff = [];
-    for (let r = it.next(); !(r.done ?? false); r = it.next()) {
-        buff.push(r.value);
-    }
-    return buff;
-}
-export function diffOperations(from, to, getKey) {
-    const ops = {
-        removals: [],
-        swaps: [],
-        inserts: []
-    };
-    const { removals, inserts, swaps } = ops;
-    const mapB = new Map();
-    to.forEach((v, i) => mapB.set(getKey(v), i));
-    const indexesOfAThatDoNotExistInB = from
-        .map((v, i) => [v, i])
-        .filter(([v]) => !mapB.has(getKey(v)))
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .map(([_, i]) => i);
-    for (let i = indexesOfAThatDoNotExistInB.length - 1; i >= 0; i--) {
-        const p = indexesOfAThatDoNotExistInB[i];
-        const last = removals.length > 0 ? removals[removals.length - 1] : undefined;
-        if ((last != null) && last.at === p + 1) {
-            last.at--;
-            last.qt++;
-        }
-        else {
-            removals.push({ at: p, qt: 1 });
-        }
-    }
-    const mapA = new Map();
-    from.forEach((v, i) => mapA.set(getKey(v), i));
-    const indexesOfBThatDoNotExistInA = to
-        .map((v, i) => [v, i])
-        .filter(([v]) => !mapA.has(getKey(v)))
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        .map(([_, i]) => i);
-    for (const p of indexesOfBThatDoNotExistInA) {
-        const last = inserts.length > 0 ? inserts[inserts.length - 1] : undefined;
-        if ((last != null) && last.at + last.values.length === p) {
-            last.values.push(to[p]);
-        }
-        else {
-            inserts.push({ at: p, values: [to[p]] });
-        }
-    }
-    const ra = from.filter((_, i) => !indexesOfAThatDoNotExistInB.includes(i));
-    const mapRA = new Map();
-    for (let i = 0; i < ra.length; i++) {
-        mapRA.set(getKey(ra[i]), i);
-    }
-    const rb = to.filter((_, i) => !indexesOfBThatDoNotExistInA.includes(i));
-    for (let i = 0; i < rb.length; i++) {
-        const bk = getKey(rb[i]);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const ai = mapRA.get(bk);
-        if (ai == null || i === ai)
-            continue;
-        const ak = getKey(ra[i]);
-        mapRA.delete(ak);
-        swaps.push({ from: i, to: ai });
-    }
-    return ops;
-}
-export function applyOperations(operations, start) {
-    const buff = [...start];
-    for (const { at, qt } of operations.removals) {
-        buff.splice(at, qt);
-    }
-    for (const { from, to } of operations.swaps) {
-        const t = buff[to];
-        buff[to] = buff[from];
-        buff[from] = t;
-    }
-    for (const op of operations.inserts) {
-        buff.splice(op.at, 0, ...op.values);
-    }
-    return buff;
-}
-export function joinWithConjunction(arr, conjunction = ' and ', separator = ', ') {
-    if (arr.length === 0)
-        return '';
-    if (arr.length === 1)
-        return String(arr[0]);
-    return `${arr.slice(0, -1).join(separator)}${conjunction}${String(arr[arr.length - 1])}`;
-}

package/async-result.d.ts

@@ -1,37 +0,0 @@
-export interface Idle {
-    type: 'idle';
-}
-export interface Loading {
-    type: 'loading';
-}
-export interface Success<V> {
-    type: 'success';
-    value: V;
-}
-export interface Failure<E> {
-    type: 'failure';
-    error: E;
-}
-export type AsyncResult<V, E> = Idle | Loading | Success<V> | Failure<E>;
-export declare const AsyncResult: {
-    idle: {
-        type: "idle";
-    };
-    loading: {
-        type: "loading";
-    };
-    success<V>(value: V): AsyncResult<V, never>;
-    failure<E>(error: E): AsyncResult<never, E>;
-    isSuccess<V_1, E_1>(r: AsyncResult<V_1, E_1>): r is Success<V_1>;
-    isFailure<V_2, E_2>(r: AsyncResult<V_2, E_2>): r is Failure<E_2>;
-    isIdle<V_3, E_3>(r: AsyncResult<V_3, E_3>): r is Idle;
-    isLoading<V_4, E_4>(r: AsyncResult<V_4, E_4>): r is Loading;
-    getOrElse<V_5, E_5>(r: AsyncResult<V_5, E_5>, alt: V_5): V_5;
-    getOrElseLazy<V_6, E_6>(r: AsyncResult<V_6, E_6>, altf: () => V_6): V_6;
-    getOrNull<V_7, E_7>(r: AsyncResult<V_7, E_7>): V_7 | null;
-    getOrUndefined<V_8, E_8>(r: AsyncResult<V_8, E_8>): V_8 | undefined;
-    cmatch: <V1, V2, E_9>(success: (value: V1) => V2, failure: (error: E_9) => V2, loading: () => V2, idle?: () => V2) => (r: AsyncResult<V1, E_9>) => V2;
-    match: <V1_1, V2_1, E_10>(r: AsyncResult<V1_1, E_10>, success: (value: V1_1) => V2_1, failure: (error: E_10) => V2_1, loading: () => V2_1, idle?: () => V2_1) => V2_1;
-    whenSuccess: <V_9, E_11>(apply: (v: V_9) => void) => (r: AsyncResult<V_9, E_11>) => AsyncResult<V_9, E_11>;
-    whenFailure: <V_10, E_12>(apply: (e: E_12) => void) => (r: AsyncResult<V_10, E_12>) => AsyncResult<V_10, E_12>;
-};