@jaypie/fabricator 0.1.0

package/dist/Fabricator.d.ts

@@ -0,0 +1,79 @@
+import { Faker } from '@faker-js/faker';
+import { RandomFunction } from './random.js';
+/**
+ * Fabricator class for generating test data with faker.js
+ * Manages an internal faker instance with optional seeding for deterministic output
+ */
+export declare class Fabricator {
+    private _faker;
+    private _random;
+    /**
+     * Creates a new Fabricator instance
+     * @param seed - Optional seed (string or number) for deterministic data generation
+     */
+    constructor(seed?: string | number);
+    /**
+     * Gets the internal faker instance
+     */
+    get faker(): Faker;
+    /**
+     * Gets the internal random function
+     */
+    random: RandomFunction;
+    /**
+     * Generates a random word combination using one of three patterns:
+     * - adjective noun
+     * - adjective verb
+     * - noun verb
+     * @returns A string with two words following one of the patterns
+     */
+    words(): string;
+    /**
+     * Generate namespace for complex data generation methods
+     */
+    generate: {
+        /**
+         * Generates a person with firstName, middleName, lastName, and fullName
+         * Uses probabilistic logic for variations:
+         * - firstName: 0.021 (rare) chance to be a lastName instead
+         * - middleName: 0.146 (uncommon) chance to be missing, 0.021 (rare) chance to be lastName, 0.00307 (epic) chance to have two
+         * - lastName: 0.021 (rare) chance to have two hyphenated
+         * - fullName: always "first last", 0.146 (uncommon) chance to include middle
+         *
+         * @param id - Optional UUID to seed the subfaker. If not provided, generates a new UUID
+         * @returns Person object with firstName, middleName, lastName, and fullName
+         */
+        person: (id?: string) => {
+            id: string;
+            firstName: string;
+            middleName: string | undefined;
+            lastName: string;
+            fullName: string;
+        };
+    };
+    get airline(): import('@faker-js/faker').AirlineModule;
+    get animal(): import('@faker-js/faker').AnimalModule;
+    get color(): import('@faker-js/faker').ColorModule;
+    get commerce(): import('@faker-js/faker').CommerceModule;
+    get company(): import('@faker-js/faker').CompanyModule;
+    get database(): import('@faker-js/faker').DatabaseModule;
+    get datatype(): import('@faker-js/faker').DatatypeModule;
+    get date(): import('@faker-js/faker').DateModule;
+    get finance(): import('@faker-js/faker').FinanceModule;
+    get git(): import('@faker-js/faker').GitModule;
+    get hacker(): import('@faker-js/faker').HackerModule;
+    get helpers(): import('@faker-js/faker').HelpersModule;
+    get image(): import('@faker-js/faker').ImageModule;
+    get internet(): import('@faker-js/faker').InternetModule;
+    get location(): import('@faker-js/faker').LocationModule;
+    get lorem(): import('@faker-js/faker').LoremModule;
+    get music(): import('@faker-js/faker').MusicModule;
+    get number(): import('@faker-js/faker').NumberModule;
+    get person(): import('@faker-js/faker').PersonModule;
+    get phone(): import('@faker-js/faker').PhoneModule;
+    get science(): import('@faker-js/faker').ScienceModule;
+    get string(): import('@faker-js/faker').StringModule;
+    get system(): import('@faker-js/faker').SystemModule;
+    get vehicle(): import('@faker-js/faker').VehicleModule;
+    get word(): import('@faker-js/faker').WordModule;
+}

package/dist/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const CHANCE: {
+    UNCOMMON: number;
+    RARE: number;
+    EPIC: number;
+    LEGENDARY: number;
+};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { Fabricator } from './Fabricator.js';
+export { Fabricator } from './Fabricator.js';
+/**
+ * Creates and returns a new Fabricator instance with optional seeding
+ * @param seed - Optional seed (string or number) for deterministic data generation
+ * @returns A new Fabricator instance
+ */
+export declare function fabricator(seed?: string | number): Fabricator;
+export { DEFAULT_MIN, DEFAULT_MAX, random } from './random.js';
+export type { RandomOptions, RandomFunction } from './random.js';
+export * from './util';
+export * from './constants.js';

package/dist/index.js

@@ -0,0 +1,974 @@
+import { Faker as M, en as U } from "@faker-js/faker";
+const W = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+function Q(r) {
+  return typeof r == "string" && W.test(r);
+}
+function y(r) {
+  if (!Q(r))
+    throw TypeError("Invalid UUID");
+  let t;
+  return Uint8Array.of((t = parseInt(r.slice(0, 8), 16)) >>> 24, t >>> 16 & 255, t >>> 8 & 255, t & 255, (t = parseInt(r.slice(9, 13), 16)) >>> 8, t & 255, (t = parseInt(r.slice(14, 18), 16)) >>> 8, t & 255, (t = parseInt(r.slice(19, 23), 16)) >>> 8, t & 255, (t = parseInt(r.slice(24, 36), 16)) / 1099511627776 & 255, t / 4294967296 & 255, t >>> 24 & 255, t >>> 16 & 255, t >>> 8 & 255, t & 255);
+}
+function P(r) {
+  if (!r)
+    return 0;
+  const t = y(r), e = Array.from(t.slice(-6)).map((n) => n.toString(16).padStart(2, "0")).join("");
+  return parseInt(e, 16);
+}
+const j = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function w(r) {
+  return typeof r == "number" ? Math.abs(r) : j.test(r) ? P(r) : Math.abs(
+    r.split("").reduce((t, e) => {
+      const n = e.charCodeAt(0);
+      return (t << 5) - t + n | 0;
+    }, 0)
+  );
+}
+function V(r) {
+  if (!r)
+    return [0];
+  const t = y(r);
+  return Array.from(t);
+}
+const J = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function S(r) {
+  if (!J.test(r))
+    return [w(r)];
+  try {
+    return V(r);
+  } catch {
+    try {
+      return [P(r)];
+    } catch {
+      return [w(r)];
+    }
+  }
+}
+var Z = Object.defineProperty, z = (r, t, e) => t in r ? Z(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, T = (r, t, e) => z(r, typeof t != "symbol" ? t + "" : t, e), m = class {
+}, K = class v extends m {
+  constructor(t) {
+    var e;
+    super(), T(this, "_name"), T(this, "_rngFn"), this._name = (e = t.name) != null ? e : "function", this._rngFn = t;
+  }
+  get name() {
+    return this._name;
+  }
+  next() {
+    return this._rngFn();
+  }
+  clone() {
+    return new v(this._rngFn);
+  }
+};
+function b(r) {
+  switch (typeof r) {
+    case "object":
+      if (r instanceof m)
+        return r;
+      break;
+    case "function":
+      return new K(r);
+    default:
+      return new nt(r);
+  }
+  throw new Error(`invalid RNG seed or instance "${r}"`);
+}
+function X(r, t) {
+  var e;
+  const n = `${r}`;
+  let i = 0, s = 0;
+  for (; s < n.length; )
+    t[255 & s] = 255 & (i ^= ((e = t[255 & s]) != null ? e : 0) * 19) + n.charCodeAt(s++);
+  return t.length ? t : [0];
+}
+function G(r, t) {
+  for (let e = t.length - 1; e > 0; e -= 1) {
+    const n = Math.floor(r.next() * (e + 1)), i = t[e];
+    t[e] = t[n], t[n] = i;
+  }
+}
+function C(r, t, e) {
+  var n, i;
+  const s = /* @__PURE__ */ new Map(), a = t.length - 1, u = Array.from({ length: e });
+  for (let E = 0; E < e; E++) {
+    const h = a - E + 1, A = Math.floor(r.next() * h);
+    u[E] = t[(n = s.get(A)) != null ? n : A], s.set(A, (i = s.get(a - E)) != null ? i : a - E);
+  }
+  return u;
+}
+var tt = 281474976710656, et = 4503599627370496, rt = 9007199254740992, nt = class B extends m {
+  constructor(t = crypto.randomUUID()) {
+    super(), T(this, "_seed"), T(this, "i"), T(this, "j"), T(this, "S"), this._seed = t;
+    const e = X(t, []), n = [], i = e.length;
+    this.i = 0, this.j = 0, this.S = n;
+    let s = 0;
+    for (; s <= 255; )
+      n[s] = s++;
+    for (let a = 0, u = 0; a <= 255; a++) {
+      const E = n[a];
+      u = 255 & u + e[a % i] + E, n[a] = n[u], n[u] = E;
+    }
+    this.g(256);
+  }
+  get name() {
+    return "arc4";
+  }
+  next() {
+    let t = this.g(6), e = tt, n = 0;
+    for (; t < et; )
+      t = (t + n) * 256, e *= 256, n = this.g(1);
+    for (; t >= rt; )
+      t /= 2, e /= 2, n >>>= 1;
+    return (t + n) / e;
+  }
+  g(t) {
+    const { S: e } = this;
+    let { i: n, j: i } = this, s = 0;
+    for (; t--; ) {
+      n = 255 & n + 1;
+      const a = e[n];
+      e[i] = a, i = 255 & i + a, e[n] = e[i], s = s * 256 + e[255 & e[n] + a];
+    }
+    return this.i = n, this.j = i, s;
+  }
+  clone() {
+    return new B(this._seed);
+  }
+}, ot = class Y extends m {
+  get name() {
+    return "Math.random";
+  }
+  next() {
+    return Math.random();
+  }
+  clone() {
+    return new Y();
+  }
+};
+function R(r) {
+  return new it(r);
+}
+var it = class {
+  constructor(r) {
+    T(this, "n"), T(this, "isInt", () => {
+      if (Number.isInteger(this.n))
+        return this;
+      throw new Error(`Expected number to be an integer, got ${this.n}`);
+    }), T(this, "isPositive", () => {
+      if (this.n > 0)
+        return this;
+      throw new Error(`Expected number to be positive, got ${this.n}`);
+    }), T(this, "lessThan", (t) => {
+      if (this.n < t)
+        return this;
+      throw new Error(`Expected number to be less than ${t}, got ${this.n}`);
+    }), T(this, "lessThanOrEqual", (t) => {
+      if (this.n <= t)
+        return this;
+      throw new Error(
+        `Expected number to be less than or equal to ${t}, got ${this.n}`
+      );
+    }), T(this, "greaterThanOrEqual", (t) => {
+      if (this.n >= t)
+        return this;
+      throw new Error(
+        `Expected number to be greater than or equal to ${t}, got ${this.n}`
+      );
+    }), T(this, "greaterThan", (t) => {
+      if (this.n > t)
+        return this;
+      throw new Error(`Expected number to be greater than ${t}, got ${this.n}`);
+    }), this.n = r;
+  }
+};
+function st(r, t = 1) {
+  R(t).isInt().isPositive();
+  const e = r.irwinHall(t);
+  return () => e() / t;
+}
+function at(r, t = 0.5) {
+  return R(t).greaterThanOrEqual(0).lessThanOrEqual(1), () => Math.min(1, Math.floor(r.next() + t));
+}
+function Et(r, t = 1, e = 0.5) {
+  return R(t).isInt().isPositive(), R(e).greaterThanOrEqual(0).lessThan(1), () => {
+    let n = 0, i = 0;
+    for (; n++ < t; )
+      r.next() < e && i++;
+    return i;
+  };
+}
+function ut(r, t = 1) {
+  return R(t).isPositive(), () => -Math.log(1 - r.next()) / t;
+}
+function ht(r, t = 0.5) {
+  R(t).greaterThan(0).lessThan(1);
+  const e = 1 / Math.log(1 - t);
+  return () => Math.floor(1 + Math.log(r.next()) * e);
+}
+function ct(r, t = 1) {
+  return R(t).isInt().greaterThanOrEqual(0), () => {
+    let e = 0;
+    for (let n = 0; n < t; ++n)
+      e += r.next();
+    return e;
+  };
+}
+function ft(r, t = 0, e = 1) {
+  const n = r.normal(t, e);
+  return () => Math.exp(n());
+}
+function lt(r, t = 0, e = 1) {
+  return () => {
+    let n, i, s;
+    do
+      n = r.next() * 2 - 1, i = r.next() * 2 - 1, s = n * n + i * i;
+    while (!s || s > 1);
+    return t + e * i * Math.sqrt(-2 * Math.log(s) / s);
+  };
+}
+function Tt(r, t = 1) {
+  R(t).greaterThanOrEqual(0);
+  const e = 1 / t;
+  return () => 1 / Math.pow(1 - r.next(), e);
+}
+var At = [
+  0,
+  0,
+  0.6931471805599453,
+  1.791759469228055,
+  3.1780538303479458,
+  4.787491742782046,
+  6.579251212010101,
+  8.525161361065415,
+  10.60460290274525,
+  12.801827480081469
+], Rt = (r) => At[r], Ot = 0.9189385332046727;
+function _t(r, t = 1) {
+  if (R(t).isPositive(), t < 10) {
+    const e = Math.exp(-t);
+    return () => {
+      let n = e, i = 0, s = r.next();
+      for (; s > n; )
+        s = s - n, n = t * n / ++i;
+      return i;
+    };
+  } else {
+    const e = Math.sqrt(t), n = 0.931 + 2.53 * e, i = -0.059 + 0.02483 * n, s = 1.1239 + 1.1328 / (n - 3.4), a = 0.9277 - 3.6224 / (n - 2);
+    return () => {
+      for (var u; ; ) {
+        let E, h = r.next();
+        if (h <= 0.86 * a)
+          return E = h / a - 0.43, Math.floor(
+            (2 * i / (0.5 - Math.abs(E)) + n) * E + t + 0.445
+          );
+        h >= a ? E = r.next() - 0.5 : (E = h / a - 0.93, E = (E < 0 ? -0.5 : 0.5) - E, h = r.next() * a);
+        const A = 0.5 - Math.abs(E);
+        if (A < 0.013 && h > A)
+          continue;
+        const c = Math.floor((2 * i / A + n) * E + t + 0.445);
+        if (h = h * s / (i / (A * A) + n), c >= 10) {
+          const _ = (c + 0.5) * Math.log(t / c) - t - Ot + c - (0.08333333333333333 - (0.002777777777777778 - 1 / (1260 * c * c)) / (c * c)) / c;
+          if (Math.log(h * e) <= _)
+            return c;
+        } else if (c >= 0) {
+          const _ = (u = Rt(c)) != null ? u : 0;
+          if (Math.log(h) <= c * Math.log(t) - t - _)
+            return c;
+        }
+      }
+    };
+  }
+}
+function Nt(r, t = 0, e = 1) {
+  return () => r.next() * (e - t) + t;
+}
+function pt(r) {
+  return () => r.next() >= 0.5;
+}
+function gt(r, t = 0, e = 1) {
+  return e === void 0 && (e = t === void 0 ? 1 : t, t = 0), R(t).isInt(), R(e).isInt(), () => Math.floor(r.next() * (e - t + 1) + t);
+}
+function It(r, t, e) {
+  return R(t).greaterThan(0), R(e).greaterThan(0), () => {
+    const n = 1 - r.next();
+    return t * Math.pow(-Math.log(n), 1 / e);
+  };
+}
+var mt = class F {
+  constructor(t = new ot()) {
+    T(this, "_rng"), T(this, "_cache", {}), this._rng = b(t);
+  }
+  /**
+   * @member {RNG} rng - Underlying pseudo-random number generator.
+   */
+  get rng() {
+    return this._rng;
+  }
+  /**
+   * Creates a new `Random` instance, optionally specifying parameters to
+   * set a new seed.
+   */
+  clone(t = this.rng.clone()) {
+    return new F(t);
+  }
+  /**
+   * Sets the underlying pseudorandom number generator.
+   *
+   * @example
+   * ```ts
+   * import random from 'random'
+   *
+   * random.use('example-seed')
+   * // or
+   * random.use(Math.random)
+   * ```
+   */
+  use(t) {
+    this._rng = b(t), this._cache = {};
+  }
+  // --------------------------------------------------------------------------
+  // Uniform utility functions
+  // --------------------------------------------------------------------------
+  /**
+   * Convenience wrapper around `this.rng.next()`
+   *
+   * Returns a floating point number in [0, 1).
+   *
+   * @return {number}
+   */
+  next() {
+    return this._rng.next();
+  }
+  /**
+   * Samples a uniform random floating point number, optionally specifying
+   * lower and upper bounds.
+   *
+   * Convenience wrapper around `random.uniform()`
+   *
+   * @param {number} [min=0] - Lower bound (float, inclusive)
+   * @param {number} [max=1] - Upper bound (float, exclusive)
+   */
+  float(t, e) {
+    return this.uniform(t, e)();
+  }
+  /**
+   * Samples a uniform random integer, optionally specifying lower and upper
+   * bounds.
+   *
+   * Convenience wrapper around `random.uniformInt()`
+   *
+   * @param {number} [min=0] - Lower bound (integer, inclusive)
+   * @param {number} [max=1] - Upper bound (integer, inclusive)
+   */
+  int(t, e) {
+    return this.uniformInt(t, e)();
+  }
+  /**
+   * Samples a uniform random integer, optionally specifying lower and upper
+   * bounds.
+   *
+   * Convenience wrapper around `random.uniformInt()`
+   *
+   * @alias `random.int`
+   *
+   * @param {number} [min=0] - Lower bound (integer, inclusive)
+   * @param {number} [max=1] - Upper bound (integer, inclusive)
+   */
+  integer(t, e) {
+    return this.uniformInt(t, e)();
+  }
+  /**
+   * Samples a uniform random boolean value.
+   *
+   * Convenience wrapper around `random.uniformBoolean()`
+   *
+   * @alias `random.boolean`
+   */
+  bool() {
+    return this.uniformBoolean()();
+  }
+  /**
+   * Samples a uniform random boolean value.
+   *
+   * Convenience wrapper around `random.uniformBoolean()`
+   */
+  boolean() {
+    return this.uniformBoolean()();
+  }
+  /**
+   * Returns an item chosen uniformly at random from the given array.
+   *
+   * Convenience wrapper around `random.uniformInt()`
+   *
+   * @param {Array<T>} [array] - Input array
+   */
+  choice(t) {
+    if (!Array.isArray(t))
+      throw new TypeError(
+        `Random.choice expected input to be an array, got ${typeof t}`
+      );
+    const e = t.length;
+    if (e > 0) {
+      const n = this.uniformInt(0, e - 1)();
+      return t[n];
+    } else
+      return;
+  }
+  /**
+   * Returns a random subset of k items from the given array (without replacement).
+   *
+   * @param {Array<T>} [array] - Input array
+   */
+  sample(t, e) {
+    if (!Array.isArray(t))
+      throw new TypeError(
+        `Random.sample expected input to be an array, got ${typeof t}`
+      );
+    if (e < 0 || e > t.length)
+      throw new Error(
+        `Random.sample: k must be between 0 and array.length (${t.length}), got ${e}`
+      );
+    return C(this.rng, t, e);
+  }
+  /**
+   * Generates a thunk which returns samples of size k from the given array.
+   *
+   * This is for convenience only; there is no gain in efficiency.
+   *
+   * @param {Array<T>} [array] - Input array
+   */
+  sampler(t, e) {
+    if (!Array.isArray(t))
+      throw new TypeError(
+        `Random.sampler expected input to be an array, got ${typeof t}`
+      );
+    if (e < 0 || e > t.length)
+      throw new Error(
+        `Random.sampler: k must be between 0 and array.length (${t.length}), got ${e}`
+      );
+    const n = this.rng;
+    return () => C(n, t, e);
+  }
+  /**
+   * Returns a shuffled copy of the given array.
+   *
+   * @param {Array<T>} [array] - Input array
+   */
+  shuffle(t) {
+    if (!Array.isArray(t))
+      throw new TypeError(
+        `Random.shuffle expected input to be an array, got ${typeof t}`
+      );
+    const e = [...t];
+    return G(this.rng, e), e;
+  }
+  /**
+   * Generates a thunk which returns shuffled copies of the given array.
+   *
+   * @param {Array<T>} [array] - Input array
+   */
+  shuffler(t) {
+    if (!Array.isArray(t))
+      throw new TypeError(
+        `Random.shuffler expected input to be an array, got ${typeof t}`
+      );
+    const e = this.rng, n = [...t];
+    return () => (G(e, n), [...n]);
+  }
+  // --------------------------------------------------------------------------
+  // Uniform distributions
+  // --------------------------------------------------------------------------
+  /**
+   * Generates a [Continuous uniform distribution](https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)).
+   *
+   * @param {number} [min=0] - Lower bound (float, inclusive)
+   * @param {number} [max=1] - Upper bound (float, exclusive)
+   */
+  uniform(t, e) {
+    return this._memoize("uniform", Nt, t, e);
+  }
+  /**
+   * Generates a [Discrete uniform distribution](https://en.wikipedia.org/wiki/Discrete_uniform_distribution).
+   *
+   * @param {number} [min=0] - Lower bound (integer, inclusive)
+   * @param {number} [max=1] - Upper bound (integer, inclusive)
+   */
+  uniformInt(t, e) {
+    return this._memoize("uniformInt", gt, t, e);
+  }
+  /**
+   * Generates a [Discrete uniform distribution](https://en.wikipedia.org/wiki/Discrete_uniform_distribution),
+   * with two possible outcomes, `true` or `false.
+   *
+   * This method is analogous to flipping a coin.
+   */
+  uniformBoolean() {
+    return this._memoize("uniformBoolean", pt);
+  }
+  // --------------------------------------------------------------------------
+  // Normal distributions
+  // --------------------------------------------------------------------------
+  /**
+   * Generates a [Normal distribution](https://en.wikipedia.org/wiki/Normal_distribution).
+   *
+   * @param {number} [mu=0] - Mean
+   * @param {number} [sigma=1] - Standard deviation
+   */
+  normal(t, e) {
+    return lt(this, t, e);
+  }
+  /**
+   * Generates a [Log-normal distribution](https://en.wikipedia.org/wiki/Log-normal_distribution).
+   *
+   * @param {number} [mu=0] - Mean of underlying normal distribution
+   * @param {number} [sigma=1] - Standard deviation of underlying normal distribution
+   */
+  logNormal(t, e) {
+    return ft(this, t, e);
+  }
+  // --------------------------------------------------------------------------
+  // Bernoulli distributions
+  // --------------------------------------------------------------------------
+  /**
+   * Generates a [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution).
+   *
+   * @param {number} [p=0.5] - Success probability of each trial.
+   */
+  bernoulli(t) {
+    return at(this, t);
+  }
+  /**
+   * Generates a [Binomial distribution](https://en.wikipedia.org/wiki/Binomial_distribution).
+   *
+   * @param {number} [n=1] - Number of trials.
+   * @param {number} [p=0.5] - Success probability of each trial.
+   */
+  binomial(t, e) {
+    return Et(this, t, e);
+  }
+  /**
+   * Generates a [Geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution).
+   *
+   * @param {number} [p=0.5] - Success probability of each trial.
+   */
+  geometric(t) {
+    return ht(this, t);
+  }
+  // --------------------------------------------------------------------------
+  // Poisson distributions
+  // --------------------------------------------------------------------------
+  /**
+   * Generates a [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution).
+   *
+   * @param {number} [lambda=1] - Mean (lambda > 0)
+   */
+  poisson(t) {
+    return _t(this, t);
+  }
+  /**
+   * Generates an [Exponential distribution](https://en.wikipedia.org/wiki/Exponential_distribution).
+   *
+   * @param {number} [lambda=1] - Inverse mean (lambda > 0)
+   */
+  exponential(t) {
+    return ut(this, t);
+  }
+  // --------------------------------------------------------------------------
+  // Misc distributions
+  // --------------------------------------------------------------------------
+  /**
+   * Generates an [Irwin Hall distribution](https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution).
+   *
+   * @param {number} [n=1] - Number of uniform samples to sum (n >= 0)
+   */
+  irwinHall(t) {
+    return ct(this, t);
+  }
+  /**
+   * Generates a [Bates distribution](https://en.wikipedia.org/wiki/Bates_distribution).
+   *
+   * @param {number} [n=1] - Number of uniform samples to average (n >= 1)
+   */
+  bates(t) {
+    return st(this, t);
+  }
+  /**
+   * Generates a [Pareto distribution](https://en.wikipedia.org/wiki/Pareto_distribution).
+   *
+   * @param {number} [alpha=1] - Alpha
+   */
+  pareto(t) {
+    return Tt(this, t);
+  }
+  /**
+   * Generates a [Weibull distribution](https://en.wikipedia.org/wiki/Weibull_distribution).
+   *
+   * @param {number} [lambda] - Lambda, the scale parameter
+   * @param {number} [k] - k, the shape parameter
+   */
+  weibull(t, e) {
+    return It(this, t, e);
+  }
+  // --------------------------------------------------------------------------
+  // Internal
+  // --------------------------------------------------------------------------
+  /**
+   * Memoizes distributions to ensure they're only created when necessary.
+   *
+   * Returns a thunk which that returns independent, identically distributed
+   * samples from the specified distribution.
+   *
+   * @internal
+   *
+   * @param {string} label - Name of distribution
+   * @param {function} getter - Function which generates a new distribution
+   * @param {...*} args - Distribution-specific arguments
+   */
+  _memoize(t, e, ...n) {
+    const i = `${n.join(";")}`;
+    let s = this._cache[t];
+    return (s === void 0 || s.key !== i) && (s = {
+      key: i,
+      distribution: e(this, ...n)
+    }, this._cache[t] = s), s.distribution;
+  }
+}, x = new mt();
+const f = {
+  CODE: {
+    BAD_GATEWAY: 502,
+    BAD_REQUEST: 400,
+    FORBIDDEN: 403,
+    GATEWAY_TIMEOUT: 504,
+    GONE: 410,
+    INTERNAL_ERROR: 500,
+    METHOD_NOT_ALLOWED: 405,
+    NOT_FOUND: 404,
+    TEAPOT: 418,
+    TOO_MANY_REQUESTS: 429,
+    UNAUTHORIZED: 401,
+    UNAVAILABLE: 503
+  }
+}, o = {
+  MESSAGE: {
+    BAD_GATEWAY: "An unexpected error occurred on an upstream resource",
+    BAD_REQUEST: "The request was not properly formatted",
+    CONFIGURATION_ERROR: "The application responding to the request encountered a configuration error",
+    CORS_ERROR: "The requesting origin is not authorized to this resource",
+    FORBIDDEN: "Access to this resource is not authorized",
+    GATEWAY_TIMEOUT: "The connection timed out waiting for an upstream resource",
+    GONE: "The requested resource is no longer available",
+    ILLOGICAL: "The application encountered an illogical condition while processing the request",
+    INTERNAL_ERROR: "An unexpected error occurred and the request was unable to complete",
+    METHOD_NOT_ALLOWED: "The requested method is not allowed",
+    NOT_FOUND: "The requested resource was not found",
+    NOT_IMPLEMENTED: "The request was understood but the resource is not implemented",
+    REJECTED: "The request was rejected prior to processing",
+    TEAPOT: "This resource is a teapot incapable of processing the request",
+    TOO_MANY_REQUESTS: "The requesting origin exceeded the request limit",
+    UNAUTHORIZED: "The request did not include valid authentication credentials",
+    UNAVAILABLE: "The requested resource is temporarily unavailable",
+    UNHANDLED: "An unhandled error occurred and the request was unable to complete",
+    UNREACHABLE_CODE: "The application encountered an unreachable condition while processing the request"
+  },
+  TITLE: {
+    BAD_GATEWAY: "Bad Gateway",
+    BAD_REQUEST: "Bad Request",
+    CONFIGURATION_ERROR: "Internal Configuration Error",
+    CORS_ERROR: "Unauthorized Origin",
+    FORBIDDEN: "Forbidden",
+    GATEWAY_TIMEOUT: "Gateway Timeout",
+    GONE: "Gone",
+    INTERNAL_ERROR: "Internal Application Error",
+    METHOD_NOT_ALLOWED: "Method Not Allowed",
+    NOT_FOUND: "Not Found",
+    NOT_IMPLEMENTED: "Not Implemented",
+    REJECTED: "Request Rejected",
+    TEAPOT: "Teapot",
+    TOO_MANY_REQUESTS: "Too Many Requests",
+    UNAUTHORIZED: "Service Unauthorized",
+    UNAVAILABLE: "Service Unavailable"
+  },
+  TYPE: {
+    BAD_GATEWAY: "BAD_GATEWAY",
+    BAD_REQUEST: "BAD_REQUEST",
+    CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
+    CORS_ERROR: "CORS_ERROR",
+    FORBIDDEN: "FORBIDDEN",
+    GATEWAY_TIMEOUT: "GATEWAY_TIMEOUT",
+    GONE: "GONE",
+    ILLOGICAL: "ILLOGICAL",
+    INTERNAL_ERROR: "INTERNAL_ERROR",
+    METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED",
+    NOT_FOUND: "NOT_FOUND",
+    NOT_IMPLEMENTED: "NOT_IMPLEMENTED",
+    REJECTED: "REJECTED",
+    TEAPOT: "TEAPOT",
+    TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+    UNAUTHORIZED: "UNAUTHORIZED",
+    UNAVAILABLE: "UNAVAILABLE",
+    UNHANDLED: "UNHANDLED",
+    UNKNOWN_TYPE: "UNKNOWN_TYPE",
+    UNREACHABLE_CODE: "UNREACHABLE_CODE"
+  }
+}, Dt = "JaypieError";
+class dt extends Error {
+  constructor(t = o.MESSAGE.INTERNAL_ERROR, { status: e = f.CODE.INTERNAL_ERROR, title: n = o.TITLE.INTERNAL_ERROR } = {}, { _type: i = o.TYPE.UNKNOWN_TYPE } = {}) {
+    super(t), this.title = n, this.detail = t, this.status = e, this.name = Dt, this.isProjectError = !0, this.isJaypieError = !0, this._type = i, this.body = () => ({
+      errors: [
+        {
+          status: this.status,
+          title: this.title,
+          detail: this.detail
+        }
+      ]
+    }), this.json = () => ({
+      status: this.status,
+      title: this.title,
+      detail: this.detail
+    });
+  }
+}
+const Lt = {
+  apply: (r, t, e) => new r(...e)
+};
+function l(r, t, e, n) {
+  return new Proxy(class extends dt {
+    constructor(i = r) {
+      super(i, { status: t, title: e }, { _type: n });
+    }
+  }, Lt);
+}
+l(o.MESSAGE.BAD_GATEWAY, f.CODE.BAD_GATEWAY, o.TITLE.BAD_GATEWAY, o.TYPE.BAD_GATEWAY);
+l(o.MESSAGE.BAD_REQUEST, f.CODE.BAD_REQUEST, o.TITLE.BAD_REQUEST, o.TYPE.BAD_REQUEST);
+l(o.MESSAGE.FORBIDDEN, f.CODE.FORBIDDEN, o.TITLE.FORBIDDEN, o.TYPE.FORBIDDEN);
+l(o.MESSAGE.GATEWAY_TIMEOUT, f.CODE.GATEWAY_TIMEOUT, o.TITLE.GATEWAY_TIMEOUT, o.TYPE.GATEWAY_TIMEOUT);
+l(o.MESSAGE.GONE, f.CODE.GONE, o.TITLE.GONE, o.TYPE.GONE);
+l(o.MESSAGE.INTERNAL_ERROR, f.CODE.INTERNAL_ERROR, o.TITLE.INTERNAL_ERROR, o.TYPE.INTERNAL_ERROR);
+l(o.MESSAGE.METHOD_NOT_ALLOWED, f.CODE.METHOD_NOT_ALLOWED, o.TITLE.METHOD_NOT_ALLOWED, o.TYPE.METHOD_NOT_ALLOWED);
+l(o.MESSAGE.NOT_FOUND, f.CODE.NOT_FOUND, o.TITLE.NOT_FOUND, o.TYPE.NOT_FOUND);
+l(o.MESSAGE.TEAPOT, f.CODE.TEAPOT, o.TITLE.TEAPOT, o.TYPE.TEAPOT);
+l(o.MESSAGE.TOO_MANY_REQUESTS, f.CODE.TOO_MANY_REQUESTS, o.TITLE.TOO_MANY_REQUESTS, o.TYPE.TOO_MANY_REQUESTS);
+l(o.MESSAGE.UNAUTHORIZED, f.CODE.UNAUTHORIZED, o.TITLE.UNAUTHORIZED, o.TYPE.UNAUTHORIZED);
+l(o.MESSAGE.UNAVAILABLE, f.CODE.UNAVAILABLE, o.TITLE.UNAVAILABLE, o.TYPE.UNAVAILABLE);
+const Mt = l(o.MESSAGE.CONFIGURATION_ERROR, f.CODE.INTERNAL_ERROR, o.TITLE.CONFIGURATION_ERROR, o.TYPE.CONFIGURATION_ERROR);
+l(o.MESSAGE.CORS_ERROR, f.CODE.UNAUTHORIZED, o.TITLE.CORS_ERROR, o.TYPE.CORS_ERROR);
+l(o.MESSAGE.ILLOGICAL, f.CODE.INTERNAL_ERROR, o.TITLE.INTERNAL_ERROR, o.TYPE.ILLOGICAL);
+l(o.MESSAGE.NOT_IMPLEMENTED, f.CODE.BAD_REQUEST, o.TITLE.NOT_IMPLEMENTED, o.TYPE.NOT_IMPLEMENTED);
+l(o.MESSAGE.REJECTED, f.CODE.FORBIDDEN, o.TITLE.REJECTED, o.TYPE.REJECTED);
+l(o.MESSAGE.UNHANDLED, f.CODE.INTERNAL_ERROR, o.TITLE.INTERNAL_ERROR, o.TYPE.UNHANDLED);
+l(o.MESSAGE.UNREACHABLE_CODE, f.CODE.INTERNAL_ERROR, o.TITLE.INTERNAL_ERROR, o.TYPE.UNREACHABLE_CODE);
+const Ut = 0, wt = 1, St = (r, t, e) => {
+  let n = r;
+  return typeof t == "number" && (n = Math.max(n, t)), typeof e == "number" && (n = Math.min(n, e)), n;
+}, bt = (r, t) => {
+  if (typeof r == "number" && typeof t == "number" && r > t)
+    throw new Mt(
+      `Invalid bounds: min (${r}) cannot be greater than max (${t})`
+    );
+};
+function Gt(r) {
+  const t = r !== void 0 ? String(r) : void 0, e = x.clone(t), n = /* @__PURE__ */ new Map();
+  return ({
+    min: s,
+    max: a,
+    mean: u,
+    stddev: E,
+    integer: h = !1,
+    start: A = 0,
+    seed: c,
+    precision: _,
+    currency: $ = !1
+  } = {}) => {
+    const g = c ? n.get(c) || (() => {
+      const O = x.clone(c);
+      return n.set(c, O), O;
+    })() : e;
+    let N = a;
+    typeof s == "number" && typeof N != "number" && (N = s * 2), bt(s, N);
+    const H = () => {
+      if (h) return 0;
+      const O = [];
+      return typeof _ == "number" && _ >= 0 && O.push(_), $ && O.push(2), O.length > 0 ? Math.min(...O) : void 0;
+    }, D = (O) => {
+      const I = H();
+      if (typeof I == "number") {
+        const p = Math.pow(10, I);
+        return Math.round(O * p) / p;
+      }
+      return O;
+    };
+    if (typeof u == "number" && typeof E == "number") {
+      const I = g.normal(u, E)(), p = St(I, s, a);
+      if (typeof s == "number" && typeof a == "number" && p !== I) {
+        const q = h ? g.int(s, N) : g.float(s, N);
+        return D(A + q);
+      }
+      return D(
+        A + (h ? Math.round(p) : p)
+      );
+    }
+    const d = typeof s == "number" ? s : Ut, L = typeof N == "number" ? N : wt, k = h ? g.int(d, L) : g.float(d, L);
+    return D(A + k);
+  };
+}
+class Ct {
+  /**
+   * Creates a new Fabricator instance
+   * @param seed - Optional seed (string or number) for deterministic data generation
+   */
+  constructor(t) {
+    if (this.random = (e) => this._random(e), this.generate = {
+      /**
+       * Generates a person with firstName, middleName, lastName, and fullName
+       * Uses probabilistic logic for variations:
+       * - firstName: 0.021 (rare) chance to be a lastName instead
+       * - middleName: 0.146 (uncommon) chance to be missing, 0.021 (rare) chance to be lastName, 0.00307 (epic) chance to have two
+       * - lastName: 0.021 (rare) chance to have two hyphenated
+       * - fullName: always "first last", 0.146 (uncommon) chance to include middle
+       *
+       * @param id - Optional UUID to seed the subfaker. If not provided, generates a new UUID
+       * @returns Person object with firstName, middleName, lastName, and fullName
+       */
+      person: (e) => {
+        const n = e ?? this._faker.string.uuid(), i = new M({ locale: U }), s = S(n);
+        i.seed(s);
+        const a = i.number.float() < 0.021 ? i.person.lastName() : i.person.firstName();
+        let u;
+        const E = i.number.float();
+        E < 307e-5 ? u = `${i.person.firstName()} ${i.person.firstName()}` : E < 307e-5 + 0.021 ? u = i.person.lastName() : E < 307e-5 + 0.021 + 0.146 ? u = void 0 : u = i.person.firstName();
+        const h = i.number.float() < 0.021 ? `${i.person.lastName()}-${i.person.lastName()}` : i.person.lastName(), c = i.number.float() < 0.146 && u ? `${a} ${u} ${h}` : `${a} ${h}`;
+        return {
+          id: n,
+          firstName: a,
+          middleName: u,
+          lastName: h,
+          fullName: c
+        };
+      }
+    }, this._faker = new M({ locale: U }), this._random = Gt(t), t !== void 0) {
+      const e = S(String(t));
+      this._faker.seed(e);
+    }
+  }
+  /**
+   * Gets the internal faker instance
+   */
+  get faker() {
+    return this._faker;
+  }
+  /**
+   * Generates a random word combination using one of three patterns:
+   * - adjective noun
+   * - adjective verb
+   * - noun verb
+   * @returns A string with two words following one of the patterns
+   */
+  words() {
+    const t = [
+      () => `${this._faker.word.adjective()} ${this._faker.word.noun()}`,
+      // adjective noun
+      () => `${this._faker.word.adjective()} ${this._faker.word.verb()}`,
+      // adjective verb
+      () => `${this._faker.word.noun()} ${this._faker.word.verb()}`
+      // noun verb
+    ], e = t[this._faker.number.int({ min: 0, max: t.length - 1 })];
+    return e();
+  }
+  // Proxy all faker fields for direct access
+  get airline() {
+    return this._faker.airline;
+  }
+  get animal() {
+    return this._faker.animal;
+  }
+  get color() {
+    return this._faker.color;
+  }
+  get commerce() {
+    return this._faker.commerce;
+  }
+  get company() {
+    return this._faker.company;
+  }
+  get database() {
+    return this._faker.database;
+  }
+  get datatype() {
+    return this._faker.datatype;
+  }
+  get date() {
+    return this._faker.date;
+  }
+  get finance() {
+    return this._faker.finance;
+  }
+  get git() {
+    return this._faker.git;
+  }
+  get hacker() {
+    return this._faker.hacker;
+  }
+  get helpers() {
+    return this._faker.helpers;
+  }
+  get image() {
+    return this._faker.image;
+  }
+  get internet() {
+    return this._faker.internet;
+  }
+  get location() {
+    return this._faker.location;
+  }
+  get lorem() {
+    return this._faker.lorem;
+  }
+  get music() {
+    return this._faker.music;
+  }
+  get number() {
+    return this._faker.number;
+  }
+  get person() {
+    return this._faker.person;
+  }
+  get phone() {
+    return this._faker.phone;
+  }
+  get science() {
+    return this._faker.science;
+  }
+  get string() {
+    return this._faker.string;
+  }
+  get system() {
+    return this._faker.system;
+  }
+  get vehicle() {
+    return this._faker.vehicle;
+  }
+  get word() {
+    return this._faker.word;
+  }
+}
+const yt = {
+  UNCOMMON: 0.146,
+  RARE: 0.021,
+  EPIC: 307e-5,
+  LEGENDARY: 441e-6
+};
+function Pt(r) {
+  return new Ct(r);
+}
+export {
+  yt as CHANCE,
+  wt as DEFAULT_MAX,
+  Ut as DEFAULT_MIN,
+  Ct as Fabricator,
+  Pt as fabricator,
+  w as numericSeed,
+  S as numericSeedArray,
+  Gt as random,
+  V as uuidToBytes,
+  P as uuidToNumber
+};

package/dist/random.d.ts

@@ -0,0 +1,38 @@
+export interface RandomOptions {
+    min?: number;
+    max?: number;
+    mean?: number;
+    stddev?: number;
+    integer?: boolean;
+    start?: number;
+    seed?: string;
+    precision?: number;
+    currency?: boolean;
+}
+export type RandomFunction = {
+    (options?: RandomOptions): number;
+};
+export declare const DEFAULT_MIN = 0;
+export declare const DEFAULT_MAX = 1;
+/**
+ * Creates a random number generator with optional seeding
+ *
+ * @param defaultSeed - Seed (string, number, or undefined) for the default RNG
+ * @returns A function that generates random numbers based on provided options
+ *
+ * @example
+ * const rng = random("default-seed");
+ *
+ * // Generate a random float between 0 and 1
+ * const basic = rng();
+ *
+ * // Generate an integer between 1 and 10
+ * const integer = rng({ min: 1, max: 10, integer: true });
+ *
+ * // Generate from normal distribution
+ * const normal = rng({ mean: 50, stddev: 10 });
+ *
+ * // Use consistent seeding
+ * const seeded = rng({ seed: "my-seed" });
+ */
+export declare function random(defaultSeed?: string | number): RandomFunction;

package/dist/util/index.d.ts

@@ -0,0 +1,4 @@
+export { default as numericSeed } from './numericSeed.js';
+export { default as numericSeedArray } from './numericSeedArray.js';
+export { default as uuidToBytes } from './uuidToBytes.js';
+export { default as uuidToNumber } from './uuidToNumber.js';

package/dist/util/numericSeed.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a string or number seed into a deterministic numeric value.
+ * If the input is a number, returns it directly.
+ * If the string is a UUID, uses uuidToNumber for conversion.
+ * @param seed - String or number to convert into a numeric seed
+ * @returns Absolute numeric value derived from the input
+ */
+export default function numericSeed(seed: string | number): number;

package/dist/util/numericSeedArray.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Converts a string into an array of numeric values.
+ * If the string is a UUID, attempts to convert using uuidToBytes.
+ * Falls back to uuidToNumber if uuidToBytes fails.
+ * Finally falls back to numericSeed for non-UUID strings.
+ * @param seed - String to convert into numeric array
+ * @returns Array of numeric values derived from the input
+ */
+export default function numericSeedArray(seed: string): number[];

package/dist/util/uuidToBytes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a UUID string into a numeric value by using the last 6 bytes
+ * to ensure better uniqueness between different UUIDs
+ * @param uuid - UUID string to convert
+ * @returns Numeric value derived from the UUID
+ */
+export default function uuidToBytes(uuid: string): number[];

package/dist/util/uuidToNumber.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a UUID string into a numeric value by using the last 6 bytes
+ * to ensure better uniqueness between different UUIDs
+ * @param uuid - UUID string to convert
+ * @returns Numeric value derived from the UUID
+ */
+export default function uuidToNumber(uuid: string): number;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@jaypie/fabricator",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./constants": {
+      "import": "./dist/constants.js",
+      "types": "./dist/constants.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "clean": "rimraf coverage dist node_modules package-lock.json",
+    "dev": "vite",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@faker-js/faker": "^9.3.0",
+    "@jaypie/errors": "^1.1.7",
+    "random": "^5.4.1",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.2.1",
+    "@types/uuid": "^10.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}