@zinaid/str 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abraham Arango
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/base64.d.ts

@@ -0,0 +1,7 @@
+export declare function toBase64(value: string): string;
+/**
+ * Convert raw bytes to a Base64 string using the same fallbacks as toBase64.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function fromBase64(value: string, strict?: boolean): string | false;
+//# sourceMappingURL=base64.d.ts.map

package/dist/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../src/base64.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA+B9C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAsBvD;AAED,wBAAgB,UAAU,CACtB,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,OAAe,GACxB,MAAM,GAAG,KAAK,CAqEhB"}

package/dist/base64.js

@@ -0,0 +1,123 @@
+function m(n) {
+  const o = l();
+  if (o.Buffer && typeof o.Buffer.from == "function")
+    return o.Buffer.from(n, "utf8").toString("base64");
+  if (typeof o.btoa == "function")
+    try {
+      const t = g(n);
+      return o.btoa(t);
+    } catch {
+      return o.btoa(n);
+    }
+  const e = g(n);
+  return d(e);
+}
+function B(n) {
+  const o = l();
+  if (o.Buffer && typeof o.Buffer.from == "function")
+    return o.Buffer.from(n).toString("base64");
+  let e = "";
+  for (let t = 0; t < n.length; t++)
+    e += String.fromCharCode(n[t]);
+  return typeof o.btoa == "function" ? o.btoa(e) : d(e);
+}
+function y(n, o = !1) {
+  const e = l();
+  let t = String(n);
+  if (o) {
+    const c = t.replace(/\s+/g, "");
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(c))
+      return !1;
+    t = c;
+  } else
+    t = t.replace(/[^A-Za-z0-9+/=]/g, "");
+  if (e.Buffer && typeof e.Buffer.from == "function")
+    try {
+      return e.Buffer.from(t, "base64").toString("utf8");
+    } catch {
+      return !1;
+    }
+  if (typeof e.atob == "function")
+    try {
+      const c = e.atob(t);
+      if (typeof e.TextDecoder == "function") {
+        const f = new Uint8Array(c.length);
+        for (let a = 0; a < c.length; a++)
+          f[a] = c.charCodeAt(a);
+        return new e.TextDecoder("utf-8").decode(f);
+      }
+      let r = "";
+      for (let f = 0; f < c.length; f++)
+        r += "%" + c.charCodeAt(f).toString(16).padStart(2, "0");
+      return decodeURIComponent(r);
+    } catch {
+      return !1;
+    }
+  try {
+    const c = A(t);
+    return C(c);
+  } catch {
+    return !1;
+  }
+}
+function l() {
+  return globalThis;
+}
+function g(n) {
+  return encodeURIComponent(n).replace(
+    /%([0-9A-F]{2})/g,
+    (o, e) => String.fromCharCode(parseInt(e, 16))
+  );
+}
+function d(n) {
+  const o = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  let e = "";
+  for (let t = 0; t < n.length; t += 3) {
+    const c = n.charCodeAt(t), r = n.charCodeAt(t + 1), f = n.charCodeAt(t + 2), a = (c ?? 0) << 16 | (r ?? 0) << 8 | (f ?? 0), i = a >> 18 & 63, s = a >> 12 & 63, u = a >> 6 & 63, h = a & 63;
+    isNaN(r) ? e += o.charAt(i) + o.charAt(s) + "==" : isNaN(f) ? e += o.charAt(i) + o.charAt(s) + o.charAt(u) + "=" : e += o.charAt(i) + o.charAt(s) + o.charAt(u) + o.charAt(h);
+  }
+  return e;
+}
+function A(n) {
+  const o = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", e = /* @__PURE__ */ new Map();
+  for (let r = 0; r < o.length; r++)
+    e.set(o[r], r);
+  const t = n.replace(/=+$/g, ""), c = [];
+  for (let r = 0; r < t.length; r += 4) {
+    const f = e.has(t[r]) ? e.get(t[r]) : 64, a = e.has(t[r + 1]) ? e.get(t[r + 1]) : 64, i = e.has(t[r + 2]) ? e.get(t[r + 2]) : 64, s = e.has(t[r + 3]) ? e.get(t[r + 3]) : 64, u = f << 18 | a << 12 | (i & 63) << 6 | s & 63, h = u >> 16 & 255, p = u >> 8 & 255, b = u & 255;
+    c.push(h), i !== 64 && c.push(p), s !== 64 && c.push(b);
+  }
+  return c;
+}
+function C(n) {
+  const o = l();
+  if (typeof o.TextDecoder == "function")
+    return new o.TextDecoder("utf-8").decode(new Uint8Array(n));
+  let e = "";
+  for (let t = 0; t < n.length; ) {
+    const c = n[t++];
+    if (c < 128)
+      e += String.fromCharCode(c);
+    else if (c < 224) {
+      const r = n[t++];
+      e += String.fromCharCode((c & 31) << 6 | r & 63);
+    } else if (c < 240) {
+      const r = n[t++], f = n[t++];
+      e += String.fromCharCode(
+        (c & 15) << 12 | (r & 63) << 6 | f & 63
+      );
+    } else {
+      const r = n[t++], f = n[t++], a = n[t++], s = ((c & 7) << 18 | (r & 63) << 12 | (f & 63) << 6 | a & 63) - 65536;
+      e += String.fromCharCode(
+        55296 + (s >> 10 & 1023),
+        56320 + (s & 1023)
+      );
+    }
+  }
+  return e;
+}
+export {
+  B as bytesToBase64,
+  y as fromBase64,
+  m as toBase64
+};

package/dist/convertcase.d.ts

@@ -0,0 +1,38 @@
+export declare const CaseTypes: {
+    readonly upper: "upper";
+    readonly lower: "lower";
+    readonly title: "title";
+    readonly fold: "fold";
+    readonly simple: "simple";
+    readonly lower_simple: "lower_simple";
+    readonly title_simple: "title_simple";
+    readonly fold_simple: "fold_simple";
+};
+export type ConvertCaseMode = (typeof CaseTypes)[keyof typeof CaseTypes];
+/**
+ * Convert the case of a string.
+ *
+ * @example
+ *
+ * convertCase('hello', CaseTypes.upper); -> 'HELLO'
+ */
+export declare function convertCase(value: string, mode?: ConvertCaseMode): string;
+/**
+ * Convert the given string to upper-case.
+ *
+ * @example
+ *
+ * upper("foo bar baz"); -> "FOO BAR BAZ"
+ * upper("foO bAr BaZ"); -> "FOO BAR BAZ"
+ */
+export declare function upper(value: string): string;
+/**
+ * Convert the given string to proper case.
+ *
+ * @example
+ *
+ * title("foo bar baz"); -> "Foo Bar Baz"
+ * title("foO bAr BaZ"); -> "Foo Bar Baz"
+ */
+export declare function title(value: string): string;
+//# sourceMappingURL=convertcase.d.ts.map

package/dist/convertcase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertcase.d.ts","sourceRoot":"","sources":["../src/convertcase.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;CASZ,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEzE;;;;;;GAMG;AACH,wBAAgB,WAAW,CACvB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,eAAgC,GACvC,MAAM,CAER;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3C"}

package/dist/convertcase.js

@@ -0,0 +1,49 @@
+import { upperFirst as o, lowerFirst as l, toLower as s, toUpper as n } from "@zinaid/utils";
+const r = {
+  upper: "upper",
+  lower: "lower",
+  title: "title",
+  fold: "fold",
+  simple: "simple",
+  lower_simple: "lower_simple",
+  title_simple: "title_simple",
+  fold_simple: "fold_simple"
+};
+function a(e, p = r.fold) {
+  return i(e, p);
+}
+function m(e) {
+  return i(e, r.upper);
+}
+function u(e) {
+  return i(e, r.title);
+}
+function i(e, p) {
+  switch (p) {
+    case r.upper:
+      return n(e);
+    case r.lower:
+      return s(e);
+    case r.title:
+      return e.replace(
+        new RegExp("\\p{L}[\\p{L}\\p{M}\\p{N}]*", "gu"),
+        (t) => t.charAt(0).toUpperCase() + t.slice(1).toLowerCase()
+      );
+    case r.fold:
+      return e.normalize("NFKD").toLowerCase();
+    case r.simple:
+      return e.replace(/[^a-z0-9]+/g, " ").trim();
+    case r.lower_simple:
+      return l(e).replace(/[^a-z0-9]+/g, " ").trim();
+    case r.title_simple:
+      return e.split(/[^a-z0-9]+/g).map((t) => o(t)).join(" ");
+    case r.fold_simple:
+      return e.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  }
+}
+export {
+  r as CaseTypes,
+  a as convertCase,
+  u as title,
+  m as upper
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './base64';
+export * from './convertcase';
+export * from './markdown';
+export * from './pluralizer';
+export * from './random';
+export * from './replacer';
+export * from './str';
+export * from './stringable';
+export * from './trimmer';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,133 @@
+import { bytesToBase64 as a, fromBase64 as t, toBase64 as s } from "./base64.js";
+import { CaseTypes as n, convertCase as o, title as l, upper as c } from "./convertcase.js";
+import { inlineMarkdown as p, markDownRenderer as u, markdown as m } from "./markdown.js";
+import { inflector as h, isPlural as g, isSingular as S, matchCase as U, plural as w, singular as b, uncountable as x } from "./pluralizer.js";
+import { randomInt as k, randomString as y } from "./random.js";
+import { substr as z, substrCount as A, substrReplace as W } from "./replacer.js";
+import { after as B, afterLast as L, apa as v, ascii as E, before as M, beforeLast as N, between as P, betweenFirst as T, camel as F, camelCacheSize as D, charAt as I, chopEnd as J, chopStart as O, contains as j, containsAll as G, createRandomStringsNormally as H, createRandomStringsUsing as K, createRandomStringsUsingSequence as Q, createUlidsNormally as V, createUlidsUsing as X, createUlidsUsingSequence as Y, createUuidsNormally as Z, createUuidsUsing as _, createUuidsUsingSequence as $, deduplicate as ee, doesntContain as re, doesntEndWith as ae, doesntStartWith as te, endsWith as se, excerpt as ie, finish as ne, flushCache as oe, freezeUlids as le, freezeUuids as ce, headline as de, is as pe, isAscii as ue, isJson as me, isMatch as fe, isUlid as he, isUrl as ge, isUuid as Se, kebab as Ue, lcfirst as we, length as be, limit as xe, lower as Ce, makePad as ke, mask as ye, match as Re, matchAll as ze, numbers as Ae, padBoth as We, padLeft as qe, padRight as Be, pascal as Le, password as ve, pluralPascal as Ee, pluralStudly as Me, position as Ne, random as Pe, remove as Te, repeat as Fe, replace as De, replaceArray as Ie, replaceEnd as Je, replaceFirst as Oe, replaceLast as je, replaceMatches as Ge, replaceStart as He, reverse as Ke, slug as Qe, snake as Ve, snakeCacheSize as Xe, squish as Ye, start as Ze, startsWith as _e, stripTags as $e, studly as er, studlyCacheSize as rr, swap as ar, take as tr, toStringOr as sr, transliterate as ir, ucfirst as nr, ucsplit as or, ucwords as lr, ulid as cr, unwrap as dr, uuid as pr, uuid7 as ur, wordCount as mr, wordWrap as fr, words as hr, wrap as gr } from "./str.js";
+import { Stringable as Ur, of as wr } from "./stringable.js";
+import { ltrim as xr, rtrim as Cr, trim as kr } from "./trimmer.js";
+export {
+  n as CaseTypes,
+  Ur as Stringable,
+  B as after,
+  L as afterLast,
+  v as apa,
+  E as ascii,
+  M as before,
+  N as beforeLast,
+  P as between,
+  T as betweenFirst,
+  a as bytesToBase64,
+  F as camel,
+  D as camelCacheSize,
+  I as charAt,
+  J as chopEnd,
+  O as chopStart,
+  j as contains,
+  G as containsAll,
+  o as convertCase,
+  H as createRandomStringsNormally,
+  K as createRandomStringsUsing,
+  Q as createRandomStringsUsingSequence,
+  V as createUlidsNormally,
+  X as createUlidsUsing,
+  Y as createUlidsUsingSequence,
+  Z as createUuidsNormally,
+  _ as createUuidsUsing,
+  $ as createUuidsUsingSequence,
+  ee as deduplicate,
+  re as doesntContain,
+  ae as doesntEndWith,
+  te as doesntStartWith,
+  se as endsWith,
+  ie as excerpt,
+  ne as finish,
+  oe as flushCache,
+  le as freezeUlids,
+  ce as freezeUuids,
+  t as fromBase64,
+  de as headline,
+  h as inflector,
+  p as inlineMarkdown,
+  pe as is,
+  ue as isAscii,
+  me as isJson,
+  fe as isMatch,
+  g as isPlural,
+  S as isSingular,
+  he as isUlid,
+  ge as isUrl,
+  Se as isUuid,
+  Ue as kebab,
+  we as lcfirst,
+  be as length,
+  xe as limit,
+  Ce as lower,
+  xr as ltrim,
+  ke as makePad,
+  u as markDownRenderer,
+  m as markdown,
+  ye as mask,
+  Re as match,
+  ze as matchAll,
+  U as matchCase,
+  Ae as numbers,
+  wr as of,
+  We as padBoth,
+  qe as padLeft,
+  Be as padRight,
+  Le as pascal,
+  ve as password,
+  w as plural,
+  Ee as pluralPascal,
+  Me as pluralStudly,
+  Ne as position,
+  Pe as random,
+  k as randomInt,
+  y as randomString,
+  Te as remove,
+  Fe as repeat,
+  De as replace,
+  Ie as replaceArray,
+  Je as replaceEnd,
+  Oe as replaceFirst,
+  je as replaceLast,
+  Ge as replaceMatches,
+  He as replaceStart,
+  Ke as reverse,
+  Cr as rtrim,
+  b as singular,
+  Qe as slug,
+  Ve as snake,
+  Xe as snakeCacheSize,
+  Ye as squish,
+  Ze as start,
+  _e as startsWith,
+  $e as stripTags,
+  er as studly,
+  rr as studlyCacheSize,
+  z as substr,
+  A as substrCount,
+  W as substrReplace,
+  ar as swap,
+  tr as take,
+  l as title,
+  s as toBase64,
+  sr as toStringOr,
+  ir as transliterate,
+  kr as trim,
+  nr as ucfirst,
+  or as ucsplit,
+  lr as ucwords,
+  cr as ulid,
+  x as uncountable,
+  dr as unwrap,
+  c as upper,
+  pr as uuid,
+  ur as uuid7,
+  mr as wordCount,
+  fr as wordWrap,
+  hr as words,
+  gr as wrap
+};

package/dist/markdown.d.ts

@@ -0,0 +1,26 @@
+import { default as MarkdownIt, Options as MarkdownItOptions, PluginSimple, PluginWithOptions } from 'markdown-it';
+export interface MarkDownOptions extends MarkdownItOptions {
+    gfm?: boolean;
+    anchors?: object | boolean;
+    typographer?: boolean;
+}
+export type MarkDownExtension = PluginSimple | PluginWithOptions<unknown> | [PluginWithOptions<unknown>, unknown];
+export type MarkDownExtensions = MarkDownExtension[];
+/**
+ * Converts GitHub flavored Markdown into HTML.
+ *
+ * @example
+ *
+ * markdown('# Hello World'); -> '<h1>Hello World</h1>\n'
+ */
+export declare function markdown(value: string, options?: MarkDownOptions, extensions?: MarkDownExtensions): string;
+/**
+ * Converts inline Markdown into HTML.
+ *
+ * @example
+ *
+ * inlineMarkdown("Hello *World*"); -> "<p>Hello <em>World</em></p>"
+ */
+export declare function inlineMarkdown(value: string, options?: MarkDownOptions, extensions?: MarkDownExtensions): string;
+export declare function markDownRenderer(options?: MarkDownOptions, extensions?: MarkDownExtensions): MarkdownIt;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,EAAE,EACf,KAAK,OAAO,IAAI,iBAAiB,EACjC,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACzB,MAAM,aAAa,CAAC;AAIrB,MAAM,WAAW,eAAgB,SAAQ,iBAAiB;IACtD,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,MAAM,iBAAiB,GACvB,YAAY,GACZ,iBAAiB,CAAC,OAAO,CAAC,GAC1B,CAAC,iBAAiB,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;AAE5C,MAAM,MAAM,kBAAkB,GAAG,iBAAiB,EAAE,CAAC;AAErD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACpB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAA+C,EACxD,UAAU,GAAE,kBAAuB,GACpC,MAAM,CAER;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,eAA+B,EACxC,UAAU,GAAE,kBAAuB,GACpC,MAAM,CAER;AAED,wBAAgB,gBAAgB,CAC5B,OAAO,GAAE,eAA+C,EACxD,UAAU,GAAE,kBAAuB,cAgCtC"}

package/dist/markdown.js

@@ -0,0 +1,32 @@
+import { isArray as d } from "@zinaid/utils";
+import k from "markdown-it";
+import p from "markdown-it-anchor";
+import w from "markdown-it-task-lists";
+function y(r, e = { gfm: !0, anchors: !1 }, t = []) {
+  return s(e, t).render(r);
+}
+function A(r, e = { gfm: !0 }, t = []) {
+  return s(e, t).renderInline(r);
+}
+function s(r = { gfm: !0, anchors: !1 }, e = []) {
+  const {
+    html: t = !1,
+    linkify: i = !0,
+    breaks: u = !0,
+    gfm: a = !0,
+    anchors: f = !1,
+    ...m
+  } = r, n = new k({ html: t, linkify: i, breaks: u, ...m });
+  a && n.use(w, { label: !0, labelAfter: !0 }), f && n.use(p, typeof f == "object" ? f : {});
+  for (const o of e)
+    if (d(o)) {
+      const [l, c] = o;
+      n.use(l, c);
+    } else o && n.use(o);
+  return n;
+}
+export {
+  A as inlineMarkdown,
+  s as markDownRenderer,
+  y as markdown
+};

package/dist/pluralizer.d.ts

@@ -0,0 +1,39 @@
+import { default as pluralize } from 'pluralize';
+export interface PluralizerRules {
+    uncountable: string[];
+}
+/**
+ * Get the plural form of an English word.
+ *
+ * @example
+ *
+ * plural("child"); -> "children"
+ * plural("apple", 1); -> "apple"
+ * plural("apple", 2, true); -> "2 apples"
+ */
+export declare function plural(value: string, count?: number, prependCount?: boolean): string;
+/**
+ * Get the singular form of an English word.
+ */
+export declare function singular(value: string): string;
+/**
+ * Determine if the given value is uncountable.
+ */
+export declare function uncountable(value: string): boolean;
+/**
+ * Determine if the given value is plural.
+ */
+export declare function isPlural(value?: string): boolean;
+/**
+ * Determine if the given value is singular.
+ */
+export declare function isSingular(value?: string): boolean;
+/**
+ * Attempt to match the case on two strings
+ */
+export declare function matchCase(value: string, comparison: string): string;
+/**
+ * Get the pluralize instance
+ */
+export declare function inflector(): typeof pluralize;
+//# sourceMappingURL=pluralizer.d.ts.map

package/dist/pluralizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluralizer.d.ts","sourceRoot":"","sources":["../src/pluralizer.ts"],"names":[],"mappings":"AAEA,OAAO,SAAS,MAAM,WAAW,CAAC;AAElC,MAAM,WAAW,eAAe;IAC5B,WAAW,EAAE,MAAM,EAAE,CAAC;CACzB;AAoDD;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAClB,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAU,EACjB,YAAY,GAAE,OAAe,GAC9B,MAAM,CAKR;AAeD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI9C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAEtD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAiBnE;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,SAAS,CAU5C"}

package/dist/pluralizer.js

@@ -0,0 +1,90 @@
+import { format as a } from "@zinaid/num";
+import { isUndefined as s } from "@zinaid/utils";
+import l from "pluralize";
+let r;
+const o = {
+  uncountable: [
+    "audio",
+    "bison",
+    "cattle",
+    "chassis",
+    "compensation",
+    "coreopsis",
+    "data",
+    "deer",
+    "education",
+    "emoji",
+    "equipment",
+    "evidence",
+    "feedback",
+    "firmware",
+    "fish",
+    "furniture",
+    "gold",
+    "hardware",
+    "information",
+    "jedi",
+    "kin",
+    "knowledge",
+    "love",
+    "metadata",
+    "money",
+    "moose",
+    "news",
+    "nutrition",
+    "offspring",
+    "plankton",
+    "pokemon",
+    "police",
+    "rain",
+    "recommended",
+    "related",
+    "rice",
+    "series",
+    "sheep",
+    "software",
+    "species",
+    "swine",
+    "traffic",
+    "wheat"
+  ]
+};
+function w(e, n = 2, i = !1) {
+  return (i ? a(n) + " " : "") + f(e, n);
+}
+function f(e, n) {
+  if (Math.abs(n) === 1 || c(e))
+    return e;
+  const i = t().plural(e);
+  return u(i, e);
+}
+function b(e) {
+  const n = t().singular(e);
+  return u(n, e);
+}
+function c(e) {
+  return o.uncountable.includes(e.toLowerCase());
+}
+function g(e = "") {
+  return t().isPlural(e);
+}
+function h(e = "") {
+  return t().isSingular(e);
+}
+function u(e, n) {
+  return n.toLowerCase() === n ? e.toLowerCase() : n.toUpperCase() === n ? e.toUpperCase() : n[0] && n[0].toUpperCase() + n.slice(1) === n ? (e[0] ?? "").toUpperCase() + e.slice(1) : e;
+}
+function t() {
+  return s(r) && (r = l, o.uncountable.forEach(
+    (e) => r.addUncountableRule(e)
+  )), r;
+}
+export {
+  t as inflector,
+  g as isPlural,
+  h as isSingular,
+  u as matchCase,
+  w as plural,
+  b as singular,
+  c as uncountable
+};

package/dist/random.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Random utilities mirroring Laravel's Str::random and PHP's random_int.
+ *
+ * Uses a cryptographically secure RNG when available (Web Crypto / Node crypto).
+ */
+/**
+ * Generate a more truly "random" alpha-numeric string (Laravel compatible algorithm).
+ *
+ * @param length - The length of the random string to generate. Default is 16.
+ * @returns A random alpha-numeric string of the specified length.
+ *
+ * @example
+ * Random.string(); // 16 chars
+ * Random.string(40); // 40 chars
+ */
+export declare function randomString(length?: number): string;
+/**
+ * Cryptographically secure uniform random integer in [min, max] (inclusive).
+ * Mirrors PHP's random_int rejection sampling approach.
+ *
+ * @param min - The minimum value (inclusive).
+ * @param max - The maximum value (inclusive).
+ * @returns A cryptographically secure random integer between min and max (inclusive).
+ * @throws TypeError if bounds are not safe integers.
+ * @throws RangeError if min > max or bounds exceed MAX_SAFE_INTEGER.
+ */
+export declare function randomInt(min: number, max: number): number;
+//# sourceMappingURL=random.d.ts.map

package/dist/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../src/random.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAK,GAAG,MAAM,CAehD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CA4C1D"}

package/dist/random.js

@@ -0,0 +1,44 @@
+import { bytesToBase64 as c } from "@zinaid/str";
+function f(e = 16) {
+  if (!Number.isFinite(e) || e <= 0)
+    return "";
+  let t = "";
+  for (; t.length < e; ) {
+    const o = e - t.length, r = Math.ceil(o / 3) * 3, i = u(r), a = c(i).replace(/[/+=]/g, "");
+    t += a.slice(0, o);
+  }
+  return t;
+}
+function l(e, t) {
+  if (!Number.isInteger(e) || !Number.isInteger(t))
+    throw new TypeError("randomInt bounds must be safe integers");
+  if (e > t)
+    throw new RangeError("randomInt min must be <= max");
+  if (e === t)
+    return e;
+  if (Math.abs(e) > Number.MAX_SAFE_INTEGER || Math.abs(t) > Number.MAX_SAFE_INTEGER)
+    throw new RangeError("Bounds exceed MAX_SAFE_INTEGER");
+  const o = t - e, r = Math.floor(Math.log2(o)) + 1, i = Math.ceil(r / 8);
+  for (; ; ) {
+    const a = u(i);
+    let n = 0;
+    for (let s = 0; s < i; s++)
+      n = n << 8 | a[s];
+    if (r % 8 !== 0) {
+      const s = 8 - r % 8;
+      n = n >> s & (1 << r) - 1;
+    }
+    if (n <= o)
+      return e + n;
+  }
+}
+function u(e) {
+  if (e <= 0) return new Uint8Array();
+  if (typeof globalThis.crypto?.getRandomValues == "function")
+    return globalThis.crypto.getRandomValues(new Uint8Array(e));
+  throw new Error("Secure randomness not available in this environment");
+}
+export {
+  l as randomInt,
+  f as randomString
+};