lacspace-fake 0.1.0

package/dist/lib.cjs

@@ -0,0 +1,753 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib.ts
+var lib_exports = {};
+__export(lib_exports, {
+  GEN_ORDER: () => GEN_ORDER,
+  LOCALES: () => LOCALES,
+  RNG: () => RNG,
+  callGen: () => callGen,
+  columnsOf: () => columnsOf,
+  formatRows: () => formatRows,
+  formatValues: () => formatValues,
+  generateRows: () => generateRows,
+  generateValues: () => generateValues,
+  generators: () => generators,
+  hasGen: () => hasGen,
+  hashSeed: () => hashSeed,
+  isFormat: () => isFormat,
+  isLocale: () => isLocale,
+  normalizeSeed: () => normalizeSeed,
+  parseArgString: () => parseArgString,
+  parseFields: () => parseFields,
+  parseJsonSchema: () => parseJsonSchema,
+  slugify: () => slugify,
+  specFromJson: () => specFromJson,
+  specFromString: () => specFromString,
+  sqlIdent: () => sqlIdent,
+  sqlValue: () => sqlValue,
+  toCsv: () => toCsv,
+  toSql: () => toSql
+});
+module.exports = __toCommonJS(lib_exports);
+
+// src/prng.ts
+function hashSeed(input) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function normalizeSeed(seed) {
+  if (typeof seed === "number") return Math.floor(seed) >>> 0;
+  const trimmed = seed.trim();
+  if (/^-?\d+$/.test(trimmed)) return Math.abs(Number(trimmed)) >>> 0;
+  return hashSeed(trimmed);
+}
+function mulberry32(a) {
+  let state = a >>> 0;
+  return function next() {
+    state = state + 1831565813 | 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var RNG = class {
+  _next;
+  seed;
+  constructor(seed) {
+    this.seed = normalizeSeed(seed);
+    this._next = mulberry32(this.seed);
+  }
+  /** Uniform float in [0, 1). */
+  next() {
+    return this._next();
+  }
+  /** Inclusive integer in [min, max]. */
+  int(min, max) {
+    if (max < min) [min, max] = [max, min];
+    return min + Math.floor(this.next() * (max - min + 1));
+  }
+  /** Float in [min, max) rounded to `decimals` places (default 2). */
+  float(min, max, decimals = 2) {
+    if (max < min) [min, max] = [max, min];
+    const v = min + this.next() * (max - min);
+    const f = 10 ** decimals;
+    return Math.round(v * f) / f;
+  }
+  /** `true` with probability `prob` (default 0.5). */
+  bool(prob = 0.5) {
+    return this.next() < prob;
+  }
+  /** Pick one element uniformly. Throws on an empty array. */
+  pick(items) {
+    if (items.length === 0) throw new Error("pick() called on an empty array");
+    return items[Math.floor(this.next() * items.length)];
+  }
+  /** Pick `n` distinct elements (Fisher–Yates partial shuffle). */
+  sample(items, n) {
+    const arr = items.slice();
+    const k = Math.min(n, arr.length);
+    for (let i = 0; i < k; i++) {
+      const j = i + Math.floor(this.next() * (arr.length - i));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr.slice(0, k);
+  }
+  /** Return a shuffled copy. */
+  shuffle(items) {
+    return this.sample(items, items.length);
+  }
+  /** Weighted pick. Entries are `[value, weight]`; weights need not sum to 1. */
+  weighted(entries) {
+    const total = entries.reduce((s, [, w]) => s + (w > 0 ? w : 0), 0);
+    if (total <= 0) throw new Error("weighted() needs at least one positive weight");
+    let r = this.next() * total;
+    for (const [value, w] of entries) {
+      if (w <= 0) continue;
+      r -= w;
+      if (r < 0) return value;
+    }
+    return entries[entries.length - 1][0];
+  }
+  /** A string of `len` random hex characters. */
+  hex(len) {
+    let out = "";
+    for (let i = 0; i < len; i++) out += "0123456789abcdef"[this.int(0, 15)];
+    return out;
+  }
+  /** A string of `len` random decimal digits. */
+  digits(len) {
+    let out = "";
+    for (let i = 0; i < len; i++) out += String(this.int(0, 9));
+    return out;
+  }
+  /** Pick `len` characters from an alphabet. */
+  chars(alphabet, len) {
+    let out = "";
+    for (let i = 0; i < len; i++) out += alphabet[this.int(0, alphabet.length - 1)];
+    return out;
+  }
+  /** An RFC-4122 version-4 UUID, drawn deterministically from this RNG. */
+  uuid() {
+    const h = this.hex(32).split("");
+    h[12] = "4";
+    h[16] = "89ab"[this.int(0, 3)];
+    const s = h.join("");
+    return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20, 32)}`;
+  }
+};
+
+// src/data.ts
+var LOREM = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua enim ad minim veniam quis nostrud exercitation ullamco laboris nisi aliquip ex ea commodo consequat duis aute irure in reprehenderit voluptate velit esse cillum eu fugiat nulla pariatur excepteur sint occaecat cupidatat non proident sunt culpa qui officia deserunt mollit anim id est laborum".split(" ");
+var LOREM_WORDS = LOREM;
+var EMAIL_DOMAINS = ["gmail.com", "yahoo.com", "outlook.com", "hotmail.com", "proton.me", "icloud.com"];
+var URL_TLDS = ["com", "net", "org", "io", "dev", "co", "app", "xyz"];
+var COMPANY_SUFFIXES = ["Inc", "LLC", "Ltd", "Group", "Labs", "Technologies", "Systems", "Solutions", "Holdings", "Partners"];
+var COMPANY_PREFIXES = ["Blue", "Green", "Bright", "Silver", "North", "Peak", "Core", "Nova", "Prime", "Vertex", "Quantum", "Apex", "Cloud", "Iron", "Golden"];
+var COMPANY_ROOTS = ["wave", "byte", "forge", "sphere", "logic", "sync", "grid", "flux", "scale", "stack", "pulse", "bloom", "shift", "orbit", "loop"];
+var BUZZ_ADJ = ["synergistic", "scalable", "frictionless", "customer-centric", "cutting-edge", "cloud-native", "next-generation", "end-to-end", "data-driven", "seamless", "robust", "agile"];
+var BUZZ_NOUN = ["solutions", "paradigms", "platforms", "architectures", "ecosystems", "workflows", "insights", "experiences", "pipelines", "frameworks", "channels", "networks"];
+var BUZZ_VERB = ["engineer", "empower", "streamline", "orchestrate", "harness", "leverage", "optimize", "accelerate", "transform", "unlock", "scale", "deliver"];
+var JOB_LEVELS = ["Junior", "Senior", "Lead", "Principal", "Staff", "Chief", "Head of", "Associate"];
+var JOB_ROLES = ["Engineer", "Developer", "Designer", "Manager", "Analyst", "Consultant", "Architect", "Specialist", "Officer", "Strategist", "Scientist", "Administrator"];
+var DEPARTMENTS = ["Engineering", "Sales", "Marketing", "Finance", "Human Resources", "Operations", "Support", "Product", "Design", "Legal", "Research", "IT"];
+var PRODUCT_ADJ = ["Ergonomic", "Rustic", "Handcrafted", "Sleek", "Refined", "Intelligent", "Modern", "Premium", "Compact", "Elegant", "Durable", "Lightweight"];
+var PRODUCT_MATERIAL = ["Steel", "Wooden", "Cotton", "Leather", "Bamboo", "Ceramic", "Plastic", "Concrete", "Glass", "Copper"];
+var PRODUCT_NOUN = ["Chair", "Table", "Keyboard", "Bottle", "Backpack", "Lamp", "Shoes", "Watch", "Headphones", "Jacket", "Mug", "Gloves", "Wallet", "Speaker"];
+var PRODUCT_CATEGORIES = ["Electronics", "Books", "Clothing", "Home", "Toys", "Sports", "Beauty", "Grocery", "Automotive", "Garden", "Health", "Office"];
+var COLORS = ["red", "green", "blue", "yellow", "orange", "purple", "teal", "black", "white", "gray", "pink", "brown"];
+var EN = {
+  firstNamesMale: ["James", "John", "Michael", "David", "Robert", "William", "Daniel", "Thomas", "Joseph", "Ethan", "Liam", "Noah", "Lucas", "Henry", "Alexander"],
+  firstNamesFemale: ["Mary", "Emma", "Olivia", "Sophia", "Isabella", "Ava", "Charlotte", "Amelia", "Emily", "Grace", "Chloe", "Zoe", "Hannah", "Lily", "Nora"],
+  lastNames: ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez", "Wilson", "Anderson", "Taylor", "Thomas", "Moore"],
+  cities: ["New York", "London", "San Francisco", "Berlin", "Toronto", "Sydney", "Singapore", "Tokyo", "Paris", "Amsterdam", "Austin", "Seattle", "Boston", "Chicago", "Denver"],
+  states: ["California", "Texas", "New York", "Florida", "Washington", "Illinois", "Ohio", "Georgia", "Colorado", "Oregon", "Arizona", "Nevada"],
+  country: "United States",
+  countryCode: "US",
+  streetNames: ["Maple", "Oak", "Pine", "Cedar", "Elm", "Washington", "Lake", "Hill", "Sunset", "River", "Park", "Main", "Highland", "Franklin", "Union"],
+  streetSuffixes: ["Street", "Avenue", "Boulevard", "Lane", "Road", "Drive", "Court", "Way", "Terrace", "Place"],
+  zip: (r) => r.digits(5),
+  currency: { code: "USD", symbol: "$" },
+  phone: (r) => {
+    const area = r.digits(3);
+    const rest = `${r.digits(3)}${r.digits(4)}`;
+    return { e164: `+1${area}${rest}`, local: `(${area}) ${rest.slice(0, 3)}-${rest.slice(3)}` };
+  }
+};
+var NE = {
+  firstNamesMale: ["Aarav", "Aayush", "Anish", "Bibek", "Prakash", "Rajesh", "Sujan", "Kiran", "Nabin", "Suman", "Dipesh", "Hari", "Krishna", "Bishal", "Rohit", "Manish", "Saroj", "Sandesh"],
+  firstNamesFemale: ["Anjali", "Sita", "Gita", "Puja", "Sunita", "Rita", "Sarita", "Nisha", "Priya", "Laxmi", "Sabina", "Muna", "Rekha", "Asha", "Deepa", "Sushmita", "Manisha", "Pratima"],
+  lastNames: ["Sharma", "Shrestha", "Adhikari", "Karki", "Thapa", "Gurung", "Magar", "Rai", "Limbu", "Tamang", "Bhattarai", "Poudel", "Koirala", "Acharya", "Dahal", "Bhandari", "Pandey", "Khadka", "Basnet", "Maharjan"],
+  cities: ["Kathmandu", "Lalitpur", "Bhaktapur", "Pokhara", "Biratnagar", "Birgunj", "Dharan", "Butwal", "Hetauda", "Nepalgunj", "Dhangadhi", "Janakpur", "Itahari", "Bharatpur", "Damak"],
+  states: ["Koshi", "Madhesh", "Bagmati", "Gandaki", "Lumbini", "Karnali", "Sudurpashchim"],
+  country: "Nepal",
+  countryCode: "NP",
+  streetNames: ["New Road", "Durbar Marg", "Lakeside", "Putalisadak", "Baneshwor", "Thamel", "Kupondole", "Jawalakhel", "Maitighar", "Baluwatar", "Sanepa", "Boudha"],
+  streetSuffixes: ["Marg", "Chowk", "Tole", "Path", "Road", "Sadak"],
+  zip: (r) => r.digits(5),
+  currency: { code: "NPR", symbol: "Rs." },
+  phone: (r) => {
+    const prefix = r.pick(["98", "97"]);
+    const carrier = r.pick(["4", "5", "6", "0", "1", "8"]);
+    const rest = r.digits(7);
+    const local = `${prefix}${carrier}${rest}`;
+    return { e164: `+977${local}`, local: `${local.slice(0, 3)}-${local.slice(3)}` };
+  }
+};
+var LOCALES = { en: EN, ne: NE };
+function isLocale(v) {
+  return v === "en" || v === "ne";
+}
+
+// src/generators.ts
+function data(ctx) {
+  return LOCALES[ctx.locale];
+}
+function num(a, fallback) {
+  if (a === void 0) return fallback;
+  const n = typeof a === "number" ? a : Number(a);
+  return Number.isFinite(n) ? n : fallback;
+}
+function str(a, fallback = "") {
+  return a === void 0 ? fallback : String(a);
+}
+function slugify(input) {
+  return input.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function capitalize(s) {
+  return s.length ? s[0].toUpperCase() + s.slice(1) : s;
+}
+function pickFirstName(ctx, gender) {
+  const d = data(ctx);
+  const g = gender ?? (ctx.rng.bool() ? "male" : "female");
+  return ctx.rng.pick(g === "male" ? d.firstNamesMale : d.firstNamesFemale);
+}
+function nameParts(ctx) {
+  const d = data(ctx);
+  const rowFirst = ctx.row["firstName"];
+  const rowLast = ctx.row["lastName"];
+  const first = typeof rowFirst === "string" && rowFirst ? rowFirst : pickFirstName(ctx);
+  const last = typeof rowLast === "string" && rowLast ? rowLast : ctx.rng.pick(d.lastNames);
+  return { first, last };
+}
+function makeWords(ctx, count) {
+  const out = [];
+  for (let i = 0; i < count; i++) out.push(ctx.rng.pick(LOREM_WORDS));
+  return out.join(" ");
+}
+function makeSentence(ctx, words) {
+  const n = words ?? ctx.rng.int(6, 14);
+  return capitalize(makeWords(ctx, n)) + ".";
+}
+function makeParagraph(ctx, sentences) {
+  const n = sentences ?? ctx.rng.int(3, 6);
+  const out = [];
+  for (let i = 0; i < n; i++) out.push(makeSentence(ctx));
+  return out.join(" ");
+}
+var DAY_MS = 864e5;
+function isoOf(ms) {
+  return new Date(ms).toISOString();
+}
+var generators = {
+  // person
+  firstName: (ctx, a) => pickFirstName(ctx, a[0] === "male" || a[0] === "female" ? a[0] : void 0),
+  lastName: (ctx) => ctx.rng.pick(data(ctx).lastNames),
+  fullName: (ctx) => {
+    const { first, last } = nameParts(ctx);
+    return `${first} ${last}`;
+  },
+  name: (ctx) => generators["fullName"](ctx, []),
+  gender: (ctx) => ctx.rng.pick(["male", "female"]),
+  age: (ctx, a) => ctx.rng.int(num(a[0], 18), num(a[1], 80)),
+  dateOfBirth: (ctx, a) => {
+    const minAge = num(a[0], 18);
+    const maxAge = num(a[1], 80);
+    const years = ctx.rng.int(minAge, maxAge);
+    const ms = Date.now() - years * 365.25 * DAY_MS - ctx.rng.int(0, 364) * DAY_MS;
+    return isoOf(ms).slice(0, 10);
+  },
+  dob: (ctx, a) => generators["dateOfBirth"](ctx, a),
+  // internet
+  username: (ctx) => {
+    const { first, last } = nameParts(ctx);
+    const sep = ctx.rng.pick(["", ".", "_"]);
+    const tail = ctx.rng.bool(0.6) ? String(ctx.rng.int(1, 999)) : "";
+    return `${first.toLowerCase()}${sep}${last.toLowerCase()}${tail}`;
+  },
+  email: (ctx, a) => {
+    const { first, last } = nameParts(ctx);
+    const rowUser = ctx.row["username"];
+    const localBase = typeof rowUser === "string" && rowUser ? rowUser : `${first.toLowerCase()}${ctx.rng.pick([".", "_", ""])}${last.toLowerCase()}`;
+    const suffix = ctx.rng.bool(0.5) ? String(ctx.rng.int(1, 99)) : "";
+    const domain = a[0] !== void 0 ? str(a[0]) : ctx.rng.pick(EMAIL_DOMAINS);
+    return `${slugify(localBase).replace(/-/g, ".")}${suffix}@${domain}`;
+  },
+  domain: (ctx) => `${ctx.rng.pick(COMPANY_ROOTS)}${ctx.rng.pick(COMPANY_ROOTS)}.${ctx.rng.pick(URL_TLDS)}`,
+  url: (ctx) => `https://${ctx.rng.pick(COMPANY_ROOTS)}${ctx.rng.pick(COMPANY_ROOTS)}.${ctx.rng.pick(URL_TLDS)}`,
+  slug: (ctx, a) => {
+    const words = num(a[0], ctx.rng.int(2, 4));
+    return slugify(makeWords(ctx, words));
+  },
+  ipv4: (ctx) => `${ctx.rng.int(1, 255)}.${ctx.rng.int(0, 255)}.${ctx.rng.int(0, 255)}.${ctx.rng.int(1, 254)}`,
+  ipv6: (ctx) => Array.from({ length: 8 }, () => ctx.rng.hex(4)).join(":"),
+  mac: (ctx) => Array.from({ length: 6 }, () => ctx.rng.hex(2)).join(":"),
+  password: (ctx, a) => {
+    const len = num(a[0], 12);
+    return ctx.rng.chars("abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789!@#$%&*", len);
+  },
+  uuid: (ctx) => ctx.rng.uuid(),
+  // phone
+  phone: (ctx) => data(ctx).phone(ctx.rng).e164,
+  phoneLocal: (ctx) => data(ctx).phone(ctx.rng).local,
+  // address
+  street: (ctx) => {
+    const d = data(ctx);
+    return `${ctx.rng.int(1, 9999)} ${ctx.rng.pick(d.streetNames)} ${ctx.rng.pick(d.streetSuffixes)}`;
+  },
+  city: (ctx) => ctx.rng.pick(data(ctx).cities),
+  state: (ctx) => ctx.rng.pick(data(ctx).states),
+  province: (ctx) => ctx.rng.pick(data(ctx).states),
+  country: (ctx) => data(ctx).country,
+  countryCode: (ctx) => data(ctx).countryCode,
+  zip: (ctx) => data(ctx).zip(ctx.rng),
+  postalCode: (ctx) => data(ctx).zip(ctx.rng),
+  address: (ctx) => {
+    const d = data(ctx);
+    const street = `${ctx.rng.int(1, 9999)} ${ctx.rng.pick(d.streetNames)} ${ctx.rng.pick(d.streetSuffixes)}`;
+    return `${street}, ${ctx.rng.pick(d.cities)}, ${ctx.rng.pick(d.states)} ${d.zip(ctx.rng)}`;
+  },
+  latitude: (ctx) => ctx.rng.float(-90, 90, 6),
+  longitude: (ctx) => ctx.rng.float(-180, 180, 6),
+  latlng: (ctx) => `${ctx.rng.float(-90, 90, 6)},${ctx.rng.float(-180, 180, 6)}`,
+  // company
+  company: (ctx) => `${ctx.rng.pick(COMPANY_PREFIXES)}${ctx.rng.pick(COMPANY_ROOTS)} ${ctx.rng.pick(COMPANY_SUFFIXES)}`,
+  catchphrase: (ctx) => capitalize(`${ctx.rng.pick(BUZZ_VERB)} ${ctx.rng.pick(BUZZ_ADJ)} ${ctx.rng.pick(BUZZ_NOUN)}`),
+  jobTitle: (ctx) => `${ctx.rng.pick(JOB_LEVELS)} ${ctx.rng.pick(JOB_ROLES)}`,
+  department: (ctx) => ctx.rng.pick(DEPARTMENTS),
+  // commerce
+  productName: (ctx) => `${ctx.rng.pick(PRODUCT_ADJ)} ${ctx.rng.pick(PRODUCT_MATERIAL)} ${ctx.rng.pick(PRODUCT_NOUN)}`,
+  price: (ctx, a) => ctx.rng.float(num(a[0], 1), num(a[1], 999), 2),
+  sku: (ctx) => `${ctx.rng.chars("ABCDEFGHJKLMNPQRSTUVWXYZ", 3)}-${ctx.rng.digits(6)}`,
+  currency: (ctx) => data(ctx).currency.code,
+  category: (ctx) => ctx.rng.pick(PRODUCT_CATEGORIES),
+  color: (ctx) => ctx.rng.pick(COLORS),
+  // text
+  word: (ctx) => ctx.rng.pick(LOREM_WORDS),
+  words: (ctx, a) => makeWords(ctx, num(a[0], 3)),
+  sentence: (ctx, a) => makeSentence(ctx, a[0] !== void 0 ? num(a[0], 8) : void 0),
+  paragraph: (ctx, a) => makeParagraph(ctx, a[0] !== void 0 ? num(a[0], 4) : void 0),
+  lorem: (ctx, a) => makeParagraph(ctx, num(a[0], 3)),
+  // datetime
+  past: (ctx, a) => {
+    const days = num(a[0], 365);
+    return isoOf(Date.now() - ctx.rng.int(1, Math.max(1, days)) * DAY_MS - ctx.rng.int(0, DAY_MS));
+  },
+  future: (ctx, a) => {
+    const days = num(a[0], 365);
+    return isoOf(Date.now() + ctx.rng.int(1, Math.max(1, days)) * DAY_MS + ctx.rng.int(0, DAY_MS));
+  },
+  recent: (ctx, a) => {
+    const days = num(a[0], 7);
+    return isoOf(Date.now() - ctx.rng.int(0, Math.max(1, days) * DAY_MS));
+  },
+  soon: (ctx, a) => {
+    const days = num(a[0], 7);
+    return isoOf(Date.now() + ctx.rng.int(0, Math.max(1, days) * DAY_MS));
+  },
+  between: (ctx, a) => {
+    const from = Date.parse(str(a[0]));
+    const to = Date.parse(str(a[1]));
+    if (Number.isNaN(from) || Number.isNaN(to)) throw new Error("between(from..to) needs two ISO dates");
+    const lo = Math.min(from, to);
+    const hi = Math.max(from, to);
+    return isoOf(lo + Math.floor(ctx.rng.next() * (hi - lo)));
+  },
+  timestamp: (ctx, a) => {
+    const days = num(a[0], 365);
+    return isoOf(Date.now() - ctx.rng.int(0, Math.max(1, days)) * DAY_MS);
+  },
+  date: (ctx, a) => String(generators["timestamp"](ctx, a)).slice(0, 10),
+  time: (ctx) => `${String(ctx.rng.int(0, 23)).padStart(2, "0")}:${String(ctx.rng.int(0, 59)).padStart(2, "0")}`,
+  // numbers / booleans / enums
+  int: (ctx, a) => ctx.rng.int(num(a[0], 0), num(a[1], 100)),
+  number: (ctx, a) => ctx.rng.int(num(a[0], 0), num(a[1], 100)),
+  float: (ctx, a) => ctx.rng.float(num(a[0], 0), num(a[1], 1), num(a[2], 2)),
+  digit: (ctx) => ctx.rng.int(0, 9),
+  bool: (ctx, a) => ctx.rng.bool(a[0] !== void 0 ? num(a[0], 0.5) : 0.5),
+  boolean: (ctx, a) => ctx.rng.bool(a[0] !== void 0 ? num(a[0], 0.5) : 0.5),
+  oneOf: (ctx, a) => {
+    if (a.length === 0) throw new Error("oneOf(...) needs at least one option");
+    return ctx.rng.pick(a);
+  },
+  enum: (ctx, a) => generators["oneOf"](ctx, a),
+  weighted: (ctx, a) => {
+    const entries = a.map((raw) => {
+      const s = String(raw);
+      const idx = s.lastIndexOf(":");
+      if (idx < 0) return [s, 1];
+      return [s.slice(0, idx), Number(s.slice(idx + 1)) || 0];
+    });
+    if (entries.length === 0) throw new Error("weighted(...) needs at least one value:weight");
+    return ctx.rng.weighted(entries);
+  },
+  // ids
+  autoincrement: (ctx, a) => num(a[0], 1) + ctx.index,
+  autoInc: (ctx, a) => generators["autoincrement"](ctx, a),
+  id: (ctx, a) => generators["autoincrement"](ctx, a),
+  nanoid: (ctx, a) => ctx.rng.chars("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-", num(a[0], 21)),
+  objectId: (ctx) => ctx.rng.hex(24),
+  // Nepal-flavoured ids (locale-aware amount/tax numbers)
+  pan: (ctx) => ctx.rng.digits(9),
+  vat: (ctx) => ctx.rng.digits(9)
+};
+var GEN_ORDER = [
+  "firstName",
+  "lastName",
+  "fullName",
+  "gender",
+  "age",
+  "dateOfBirth",
+  "email",
+  "username",
+  "url",
+  "domain",
+  "ipv4",
+  "ipv6",
+  "mac",
+  "password",
+  "uuid",
+  "slug",
+  "phone",
+  "phoneLocal",
+  "street",
+  "city",
+  "state",
+  "country",
+  "countryCode",
+  "zip",
+  "address",
+  "latitude",
+  "longitude",
+  "latlng",
+  "company",
+  "catchphrase",
+  "jobTitle",
+  "department",
+  "productName",
+  "price",
+  "sku",
+  "currency",
+  "category",
+  "color",
+  "word",
+  "words",
+  "sentence",
+  "paragraph",
+  "lorem",
+  "past",
+  "future",
+  "recent",
+  "soon",
+  "between",
+  "timestamp",
+  "date",
+  "time",
+  "int",
+  "float",
+  "bool",
+  "oneOf",
+  "weighted",
+  "digit",
+  "autoincrement",
+  "nanoid",
+  "objectId",
+  "pan",
+  "vat"
+];
+function callGen(name, ctx, args) {
+  const gen = generators[name];
+  if (!gen) throw new Error(`Unknown generator: "${name}". Run \`lacspace-fake list\` to see all generators.`);
+  return gen(ctx, args);
+}
+function hasGen(name) {
+  return Object.prototype.hasOwnProperty.call(generators, name);
+}
+
+// src/schema.ts
+function splitTopLevel(input, sep) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of input) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    if (ch === sep && depth === 0) {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur.trim() !== "" || out.length) out.push(cur);
+  return out.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function coerceArg(token) {
+  const t = token.trim();
+  if (/^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+  return t;
+}
+function parseArgString(inner) {
+  const trimmed = inner.trim();
+  if (trimmed === "") return [];
+  let parts;
+  if (trimmed.includes("|")) parts = trimmed.split("|");
+  else if (trimmed.includes("..")) parts = trimmed.split("..");
+  else parts = splitTopLevel(trimmed, ",");
+  return parts.map((p) => coerceArg(p));
+}
+function specFromString(raw) {
+  const s = raw.trim();
+  const m = /^([A-Za-z_][A-Za-z0-9_]*)\s*(?:\((.*)\))?$/.exec(s);
+  if (!m) throw new Error(`Invalid generator spec: "${raw}"`);
+  const name = m[1];
+  const args = m[2] !== void 0 ? parseArgString(m[2]) : [];
+  callGen(name, probeCtx(), args);
+  return (ctx) => callGen(name, ctx, args);
+}
+function probeCtx() {
+  return { rng: new RNG(1), locale: "en", index: 0, row: {} };
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function specFromJson(value) {
+  if (typeof value === "string") return specFromString(value);
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return () => value;
+  }
+  if (Array.isArray(value)) {
+    const specs = value.map((v) => specFromJson(v));
+    return (ctx) => specs[ctx.rng.int(0, specs.length - 1)](ctx);
+  }
+  if (isRecord(value)) {
+    const type = value["type"];
+    if (type === "array") {
+      const a = value;
+      if (a.of === void 0) throw new Error('array spec needs an "of" field');
+      const itemSpec = specFromJson(a.of);
+      return (ctx) => {
+        const n = typeof a.count === "number" ? a.count : ctx.rng.int(typeof a.min === "number" ? a.min : 1, typeof a.max === "number" ? a.max : 3);
+        const out = [];
+        for (let i = 0; i < n; i++) out.push(itemSpec(ctx));
+        return out;
+      };
+    }
+    if (type === "object") {
+      const o = value;
+      if (!isRecord(o.properties)) throw new Error('object spec needs a "properties" map');
+      const fields2 = fieldsFromRecord(o.properties);
+      return (ctx) => buildObject(fields2, ctx);
+    }
+    if (typeof type === "string") {
+      const args = argsFromJsonObject(value);
+      return (ctx) => callGen(type, ctx, args);
+    }
+    const fields = fieldsFromRecord(value);
+    return (ctx) => buildObject(fields, ctx);
+  }
+  throw new Error(`Unsupported schema value: ${JSON.stringify(value)}`);
+}
+function argsFromJsonObject(obj) {
+  if (Array.isArray(obj["args"])) return obj["args"].map((v) => typeof v === "number" ? v : String(v));
+  if (Array.isArray(obj["values"])) return obj["values"].map((v) => typeof v === "number" ? v : String(v));
+  const out = [];
+  if (typeof obj["min"] === "number") out.push(obj["min"]);
+  if (typeof obj["max"] === "number") out.push(obj["max"]);
+  if (typeof obj["decimals"] === "number") out.push(obj["decimals"]);
+  if (out.length === 0 && typeof obj["prob"] === "number") out.push(obj["prob"]);
+  if (out.length === 0 && typeof obj["count"] === "number") out.push(obj["count"]);
+  return out;
+}
+function fieldsFromRecord(rec) {
+  return Object.keys(rec).map((key) => ({ key, spec: specFromJson(rec[key]) }));
+}
+function buildObject(fields, parent) {
+  const row = {};
+  const ctx = { rng: parent.rng, locale: parent.locale, index: parent.index, row };
+  for (const f of fields) row[f.key] = f.spec(ctx);
+  return row;
+}
+function parseFields(input) {
+  const specs = splitTopLevel(input, ",");
+  if (specs.length === 0) throw new Error("--fields is empty");
+  return specs.map((chunk) => {
+    const idx = chunk.indexOf(":");
+    if (idx < 0) throw new Error(`Field "${chunk}" must be in the form key:generator`);
+    const key = chunk.slice(0, idx).trim();
+    const specStr = chunk.slice(idx + 1).trim();
+    if (!key) throw new Error(`Field "${chunk}" has an empty key`);
+    return { key, spec: specFromString(specStr) };
+  });
+}
+function parseJsonSchema(schema) {
+  if (!isRecord(schema)) throw new Error("A JSON schema must be an object mapping field \u2192 spec");
+  const body = isRecord(schema["fields"]) ? schema["fields"] : isRecord(schema["properties"]) && schema["type"] === "object" ? schema["properties"] : schema;
+  const fields = fieldsFromRecord(body);
+  if (fields.length === 0) throw new Error("The JSON schema has no fields");
+  return fields;
+}
+function generateRows(fields, opts = {}) {
+  const count = Math.max(0, opts.count ?? 10);
+  const seed = opts.seed ?? Math.floor(Math.random() * 4294967295);
+  const locale = opts.locale ?? "en";
+  const rng = new RNG(seed);
+  const rows = [];
+  for (let i = 0; i < count; i++) {
+    const row = {};
+    const ctx = { rng, locale, index: i, row };
+    for (const f of fields) row[f.key] = f.spec(ctx);
+    rows.push(row);
+  }
+  return rows;
+}
+function generateValues(specStr, opts = {}) {
+  const spec = specFromString(specStr);
+  const count = Math.max(0, opts.count ?? 10);
+  const seed = opts.seed ?? Math.floor(Math.random() * 4294967295);
+  const locale = opts.locale ?? "en";
+  const rng = new RNG(seed);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    out.push(spec({ rng, locale, index: i, row: {} }));
+  }
+  return out;
+}
+
+// src/format.ts
+function isFormat(v) {
+  return v === "json" || v === "ndjson" || v === "csv" || v === "sql";
+}
+function columnsOf(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const cols = [];
+  for (const r of rows) {
+    for (const k of Object.keys(r)) {
+      if (!seen.has(k)) {
+        seen.add(k);
+        cols.push(k);
+      }
+    }
+  }
+  return cols;
+}
+function cellString(v) {
+  if (v === null || v === void 0) return "";
+  if (typeof v === "object") return JSON.stringify(v);
+  return String(v);
+}
+function csvEscape(v) {
+  if (v === null || v === void 0) return "";
+  const s = cellString(v);
+  if (/[",\n\r]/.test(s)) return `"${s.replace(/"/g, '""')}"`;
+  return s;
+}
+function toCsv(rows) {
+  const cols = columnsOf(rows);
+  const lines = [cols.map(csvEscape).join(",")];
+  for (const r of rows) lines.push(cols.map((c) => csvEscape(r[c])).join(","));
+  return lines.join("\n");
+}
+function sqlValue(v) {
+  if (v === null || v === void 0) return "NULL";
+  if (typeof v === "number") return Number.isFinite(v) ? String(v) : "NULL";
+  if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
+  const s = typeof v === "object" ? JSON.stringify(v) : String(v);
+  return `'${s.replace(/'/g, "''")}'`;
+}
+function sqlIdent(name) {
+  return `"${String(name).replace(/"/g, '""')}"`;
+}
+function toSql(rows, table) {
+  if (!table) throw new Error("SQL output needs a --table name");
+  const cols = columnsOf(rows);
+  if (rows.length === 0) return `-- no rows for ${sqlIdent(table)}`;
+  const colList = cols.map(sqlIdent).join(", ");
+  const valueRows = rows.map((r) => `  (${cols.map((c) => sqlValue(r[c])).join(", ")})`);
+  return `INSERT INTO ${sqlIdent(table)} (${colList}) VALUES
+${valueRows.join(",\n")};`;
+}
+function formatRows(rows, opts) {
+  switch (opts.format) {
+    case "json":
+      return JSON.stringify(rows, null, opts.pretty ? 2 : 0);
+    case "ndjson":
+      return rows.map((r) => JSON.stringify(r)).join("\n");
+    case "csv":
+      return toCsv(rows);
+    case "sql":
+      return toSql(rows, opts.table ?? "");
+  }
+}
+function formatValues(values, column, opts) {
+  switch (opts.format) {
+    case "json":
+      return JSON.stringify(values, null, opts.pretty ? 2 : 0);
+    case "ndjson":
+      return values.map((v) => JSON.stringify(v)).join("\n");
+    case "csv":
+      return toCsv(values.map((v) => ({ [column]: v })));
+    case "sql":
+      return toSql(values.map((v) => ({ [column]: v })), opts.table ?? column);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GEN_ORDER,
+  LOCALES,
+  RNG,
+  callGen,
+  columnsOf,
+  formatRows,
+  formatValues,
+  generateRows,
+  generateValues,
+  generators,
+  hasGen,
+  hashSeed,
+  isFormat,
+  isLocale,
+  normalizeSeed,
+  parseArgString,
+  parseFields,
+  parseJsonSchema,
+  slugify,
+  specFromJson,
+  specFromString,
+  sqlIdent,
+  sqlValue,
+  toCsv,
+  toSql
+});