lacspace-fake 0.1.0

package/dist/cli.js

@@ -0,0 +1,895 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { stdout, stderr, argv, exit, env } from "process";
+import { readFileSync, writeFileSync } from "fs";
+
+// 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);
+}
+
+// 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((c2) => csvEscape(r[c2])).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((c2) => sqlValue(r[c2])).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);
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var NO_COLOR = Boolean(env["NO_COLOR"]) || !stdout.isTTY;
+var RAW = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m"
+};
+var c = (k, s) => NO_COLOR ? s : `${RAW[k]}${s}${RAW.reset}`;
+var log = (s = "") => void stderr.write(s + "\n");
+function parseArgs(list) {
+  const a = {
+    positional: [],
+    locale: "en",
+    count: 10,
+    format: "json",
+    pretty: false,
+    help: false,
+    version: false
+  };
+  for (let i = 0; i < list.length; i++) {
+    const arg = list[i];
+    const nextVal = () => list[++i] ?? "";
+    if (arg === "--seed" || arg === "-s") a.seed = nextVal();
+    else if (arg === "--locale" || arg === "-l") {
+      const l = nextVal();
+      if (!isLocale(l)) fail(`Unknown locale "${l}". Use "en" or "ne".`, false);
+      a.locale = l;
+    } else if (arg === "--count" || arg === "-n") a.count = Math.max(0, Math.floor(Number(nextVal())) || 0);
+    else if (arg === "--format" || arg === "-f") {
+      const f = nextVal();
+      if (!isFormat(f)) fail(`Unknown format "${f}". Use json | ndjson | csv | sql.`, false);
+      a.format = f;
+    } else if (arg === "--table" || arg === "-t") a.table = nextVal();
+    else if (arg === "--pretty") a.pretty = true;
+    else if (arg === "--out" || arg === "-o") a.out = nextVal();
+    else if (arg === "--fields") a.fields = nextVal();
+    else if (arg === "--schema") a.schema = nextVal();
+    else if (arg === "-h" || arg === "--help") a.help = true;
+    else if (arg === "-v" || arg === "--version") a.version = true;
+    else if (!arg.startsWith("-")) a.positional.push(arg);
+    else fail(`Unknown flag "${arg}". Run --help for usage.`, false);
+  }
+  return a;
+}
+var HELP = `
+${c("bold", c("magenta", "\u25C6 lacspace-fake"))} ${c("dim", "\u2014 keyless, deterministic fake / seed data generator")}
+
+${c("bold", "Usage")}
+  npx lacspace-fake --fields "<spec>" [options]     ${c("dim", "# schema rows")}
+  npx lacspace-fake --schema <file.json> [options]  ${c("dim", "# JSON schema rows")}
+  npx lacspace-fake <generator> [options]           ${c("dim", "# N values of one generator")}
+  npx lacspace-fake list                            ${c("dim", "# every generator + a sample")}
+
+${c("bold", "Options")}
+  -n, --count <n>      How many rows/values to generate (default 10)
+  -f, --format <fmt>   json | ndjson | csv | sql (default json)
+  -t, --table <name>   Table name for -f sql (INSERT INTO <name> ...)
+      --fields <spec>  Inline schema: "key:gen,key:gen(args),..."
+      --schema <file>  JSON schema file (nested objects + arrays supported)
+  -s, --seed <str>     Seed for reproducible output (number or any string)
+  -l, --locale <loc>   en (default) or ne (Nepal-aware)
+      --pretty         Pretty-print JSON
+  -o, --out <file>     Write to a file instead of stdout
+  -h, --help           Show this help
+  -v, --version        Print the version
+
+${c("bold", "Inline field syntax")}
+  ${c("dim", "key:generator            e.g.  name:fullName")}
+  ${c("dim", "key:generator(args)      e.g.  age:int(18..65)  role:oneOf(admin|user)")}
+  ${c("dim", "ranges use ..            lists use |            weighted uses value:weight")}
+
+${c("bold", "Examples")}
+  npx lacspace-fake --fields "id:autoincrement,name:fullName,email:email,age:int(18..65)" -n 5
+  npx lacspace-fake --fields "id:autoincrement,name:fullName,role:oneOf(admin|user)" -f sql --table users
+  npx lacspace-fake --fields "user:fullName,phone:phone" --locale ne -n 3
+  npx lacspace-fake --schema users.json -n 50 -f csv -o users.csv
+  npx lacspace-fake email -n 5 --seed 42
+  npx lacspace-fake list
+
+${c("dim", "Free \xB7 keyless \xB7 zero-dependency \xB7 runs fully offline \xB7 no telemetry")}
+`;
+function fail(msg, isJsonUnused) {
+  log(c("red", `
+\u2717 ${msg}
+`));
+  exit(1);
+}
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function runList(a) {
+  const seed = a.seed ?? "sample";
+  const lines = [];
+  lines.push(`
+${c("bold", c("magenta", "\u25C6 lacspace-fake generators"))} ${c("dim", `\xB7 locale ${a.locale}`)}`);
+  for (const name of GEN_ORDER) {
+    const rng = new RNG(`${seed}:${name}`);
+    const ctx = { rng, locale: a.locale, index: 0, row: {} };
+    let sample;
+    try {
+      sample = callGen(name, ctx, sampleArgs(name));
+    } catch {
+      sample = "(needs args)";
+    }
+    lines.push(`  ${c("cyan", name.padEnd(16))} ${c("dim", String(sample))}`);
+  }
+  lines.push(`
+${c("dim", `${GEN_ORDER.length} generators \xB7 use as key:${c("dim", "generator")} in --fields, or directly: lacspace-fake <generator>`)}
+`);
+  stdout.write(lines.join("\n") + "\n");
+}
+function sampleArgs(name) {
+  switch (name) {
+    case "int":
+      return [1, 100];
+    case "float":
+      return [0, 1, 2];
+    case "oneOf":
+      return ["red", "green", "blue"];
+    case "weighted":
+      return ["admin:1", "user:5"];
+    case "between":
+      return ["2020-01-01", "2024-12-31"];
+    default:
+      return [];
+  }
+}
+function output(text, a) {
+  if (a.out) {
+    writeFileSync(a.out, text.endsWith("\n") ? text : text + "\n");
+    log(`${c("green", "\u2713")} wrote ${c("bold", a.out)} ${c("dim", `(${a.format})`)}`);
+  } else {
+    stdout.write(text + "\n");
+  }
+}
+function main() {
+  const a = parseArgs(argv.slice(2));
+  if (a.version) {
+    stdout.write(VERSION + "\n");
+    return;
+  }
+  const cmd = a.positional[0];
+  if (a.help || a.positional.length === 0 && !a.fields && !a.schema) {
+    stdout.write(HELP + "\n");
+    return;
+  }
+  if (cmd === "list") {
+    runList(a);
+    return;
+  }
+  if (a.schema) {
+    let raw;
+    try {
+      raw = a.schema === "-" ? readStdin() : readFileSync(a.schema, "utf8");
+    } catch (err) {
+      fail(`Could not read schema file "${a.schema}": ${err.message}`, false);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      fail(`Schema file is not valid JSON: ${err.message}`, false);
+    }
+    let text2;
+    try {
+      const fields = parseJsonSchema(parsed);
+      const rows = generateRows(fields, { count: a.count, seed: a.seed, locale: a.locale });
+      text2 = formatRows(rows, { format: a.format, pretty: a.pretty, table: a.table });
+    } catch (err) {
+      fail(err.message, false);
+    }
+    output(text2, a);
+    return;
+  }
+  if (a.fields) {
+    let text2;
+    try {
+      const fields = parseFields(a.fields);
+      const rows = generateRows(fields, { count: a.count, seed: a.seed, locale: a.locale });
+      text2 = formatRows(rows, { format: a.format, pretty: a.pretty, table: a.table });
+    } catch (err) {
+      fail(err.message, false);
+    }
+    output(text2, a);
+    return;
+  }
+  const specStr = cmd;
+  const column = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(specStr)?.[1] ?? "value";
+  let text;
+  try {
+    specFromString(specStr);
+    const values = generateValues(specStr, { count: a.count, seed: a.seed, locale: a.locale });
+    text = formatValues(values, column, { format: a.format, pretty: a.pretty, table: a.table });
+  } catch (err) {
+    fail(err.message, false);
+  }
+  output(text, a);
+}
+try {
+  main();
+} catch (err) {
+  log(c("red", `
+\u2717 ${err instanceof Error ? err.message : String(err)}
+`));
+  exit(1);
+}