@anil-labs/factory 0.1.0

package/dist/chunks/faker-BlEhpR26.mjs

@@ -0,0 +1,1287 @@
+import { en } from "../locales/en.mjs";
+//#region src/prng/mulberry32.ts
+/**
+* Mulberry32 — 32-bit, ~4 billion period, very fast, deterministic.
+*
+* Good enough for test data and snapshots. NOT cryptographically secure.
+*
+* @see https://gist.github.com/tommyettinger/46a3b8f97c8e3a59e1e0c7f8e85bcde6
+*/
+var Mulberry32 = class {
+	state;
+	constructor(seed) {
+		this.state = normalizeSeed(seed);
+	}
+	get currentSeed() {
+		return this.state >>> 0;
+	}
+	seed(seed) {
+		this.state = normalizeSeed(seed);
+	}
+	next() {
+		this.state = this.state + 1831565813 >>> 0;
+		let t = this.state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	}
+	int(min, max) {
+		if (max < min) [min, max] = [max, min];
+		return Math.floor(this.next() * (max - min + 1)) + min;
+	}
+	float(min, max, decimals = 2) {
+		const v = this.next() * (max - min) + min;
+		const factor = 10 ** decimals;
+		return Math.round(v * factor) / factor;
+	}
+	bool(chance = .5) {
+		return this.next() < chance;
+	}
+	pick(items) {
+		if (items.length === 0) throw new Error("[Prng] pick(): array is empty.");
+		const picked = items[this.int(0, items.length - 1)];
+		if (picked === void 0) throw new Error("[Prng] pick(): unreachable index");
+		return picked;
+	}
+};
+/**
+* Coerce any input into a non-zero 32-bit unsigned integer. We map `0` to the
+* golden-ratio constant so callers passing `0` get a deterministic-but-non-zero
+* starting state (zero would emit a long initial run of small numbers).
+*/
+function normalizeSeed(seed) {
+	if (typeof seed !== "number" || Number.isNaN(seed)) return (Date.now() ^ Math.floor(Math.random() * 4294967295)) >>> 0;
+	const truncated = Math.trunc(seed) >>> 0;
+	return truncated === 0 ? 2654435769 : truncated;
+}
+//#endregion
+//#region src/prng/index.ts
+/** Construct a default PRNG (currently Mulberry32). */
+function createPrng(seed) {
+	return new Mulberry32(seed);
+}
+//#endregion
+//#region src/faker/locale.ts
+/**
+* Live reference to the active locale data. A single instance is shared by
+* every faker namespace, so swapping the locale at the `Faker` level
+* propagates instantly without rebuilding modules.
+*/
+var LocaleRef = class {
+	currentName;
+	currentData;
+	constructor(initial = "en") {
+		this.currentName = initial;
+		const data = registry.get(initial);
+		if (!data) throw new Error(`[Locale] Unknown locale "${initial}". Registered: ${[...registry.keys()].join(", ")}`);
+		this.currentData = data;
+	}
+	/** Read the currently-active locale data. */
+	get data() {
+		return this.currentData;
+	}
+	/** Read the active locale's identifier (e.g. `"en"`). */
+	get name() {
+		return this.currentName;
+	}
+	/** Swap to a different registered locale. Throws if unknown. */
+	set(name) {
+		const data = registry.get(name);
+		if (!data) throw new Error(`[Locale] Unknown locale "${name}". Registered: ${[...registry.keys()].join(", ")}`);
+		this.currentName = name;
+		this.currentData = data;
+	}
+};
+var registry = /* @__PURE__ */ new Map();
+registry.set("en", en);
+/** Register a new locale. Overwrites if `name` already exists. */
+function registerLocale(name, data) {
+	registry.set(name, data);
+}
+/** Read a locale's raw data without making it active. */
+function getLocale(name) {
+	return registry.get(name);
+}
+/** List every registered locale identifier. */
+function listLocales() {
+	return [...registry.keys()];
+}
+//#endregion
+//#region src/faker/person.ts
+/**
+* Personal-name namespace.
+*
+* @example
+* ```ts
+* faker.person.firstName()       // "Sarah"
+* faker.person.firstName('male') // "James"
+* faker.person.fullName()        // "Olivia Patel"
+* faker.person.jobTitle()        // → from `company.jobTitle()`
+* ```
+*/
+var Person = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	firstName(sex) {
+		const d = this.locale.data;
+		if (sex === "male" && d.firstNamesMale?.length) return this.rng.pick(d.firstNamesMale);
+		if (sex === "female" && d.firstNamesFemale?.length) return this.rng.pick(d.firstNamesFemale);
+		return this.rng.pick(d.firstNames);
+	}
+	lastName() {
+		return this.rng.pick(this.locale.data.lastNames);
+	}
+	fullName(opts = {}) {
+		const parts = [];
+		if (opts.withPrefix) parts.push(this.prefix());
+		parts.push(this.firstName(opts.sex), this.lastName());
+		if (opts.withSuffix) parts.push(this.suffix());
+		return parts.join(" ");
+	}
+	prefix() {
+		return this.rng.pick(this.locale.data.prefixes);
+	}
+	suffix() {
+		return this.rng.pick(this.locale.data.suffixes);
+	}
+	/** Returns `"male"` or `"female"`. */
+	sex() {
+		return this.rng.bool() ? "male" : "female";
+	}
+};
+//#endregion
+//#region src/faker/internet.ts
+/**
+* Internet / network namespace.
+*
+* @example
+* ```ts
+* faker.internet.email()         // "olivia.patel91@example.com"
+* faker.internet.email({ firstName: 'Alice', lastName: 'Wu' })  // "alice.wu41@…"
+* faker.internet.userName()      // "alex_anderson"
+* faker.internet.url()           // "https://app.gupta.io"
+* faker.internet.ipv4()          // "172.16.42.7"
+* faker.internet.password(12)    // "K8m$pQrt2Wz!"
+* ```
+*/
+var Internet = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	email(opts = {}) {
+		const first = (opts.firstName ?? this.rng.pick(this.locale.data.firstNames)).toLowerCase();
+		const last = (opts.lastName ?? this.rng.pick(this.locale.data.lastNames)).toLowerCase();
+		const suffix = this.rng.int(1, 99).toString();
+		return `${this.rng.pick([
+			`${first}.${last}`,
+			`${first}${last}`,
+			`${first}_${last}`
+		])}${suffix}@${this.rng.pick(this.locale.data.emailDomains)}`;
+	}
+	userName() {
+		const first = this.rng.pick(this.locale.data.firstNames).toLowerCase();
+		const last = this.rng.pick(this.locale.data.lastNames).toLowerCase();
+		const numeric = this.rng.int(1, 999).toString();
+		return this.rng.pick([
+			`${first}.${last}`,
+			`${first}_${last}`,
+			`${first}${numeric}`
+		]);
+	}
+	/** Bare domain (e.g. `acme.io`). */
+	domainName() {
+		return `${this.rng.pick(this.locale.data.firstNames).toLowerCase()}.${this.rng.pick(this.locale.data.tlds)}`;
+	}
+	url() {
+		return `https://${this.rng.pick([
+			"www",
+			"app",
+			"api",
+			"blog",
+			"docs"
+		])}.${this.domainName()}`;
+	}
+	ipv4() {
+		return [
+			this.rng.int(1, 255),
+			this.rng.int(0, 255),
+			this.rng.int(0, 255),
+			this.rng.int(1, 254)
+		].join(".");
+	}
+	ipv6() {
+		return Array.from({ length: 8 }, () => this.rng.int(0, 65535).toString(16).padStart(4, "0")).join(":");
+	}
+	/** Random MAC address (colon-separated). */
+	mac() {
+		return Array.from({ length: 6 }, () => this.rng.int(0, 255).toString(16).padStart(2, "0")).join(":");
+	}
+	password(length = 12) {
+		const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=";
+		let out = "";
+		for (let i = 0; i < length; i++) {
+			const ch = chars[this.rng.int(0, 75)];
+			if (ch !== void 0) out += ch;
+		}
+		return out;
+	}
+};
+//#endregion
+//#region src/faker/location.ts
+/**
+* Postal-address namespace.
+*
+* @example
+* ```ts
+* faker.location.streetAddress()    // "742 Oak Ave"
+* faker.location.city()             // "Seattle"
+* faker.location.country()          // "United States"
+* faker.location.latitude()         // 47.6062
+* ```
+*/
+var Location = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	streetAddress() {
+		return `${this.rng.int(100, 9999).toString()} ${this.rng.pick(this.locale.data.streetNames)} ${this.rng.pick(this.locale.data.streetSuffixes)}`;
+	}
+	city() {
+		return this.rng.pick(this.locale.data.cities);
+	}
+	state() {
+		return this.rng.pick(this.locale.data.states);
+	}
+	zipCode() {
+		return String(this.rng.int(1e4, 99999));
+	}
+	/** Locale's primary country (e.g. `"United States"` for `en`). */
+	country() {
+		return this.locale.data.country;
+	}
+	/** Random country from the locale's broader country list. */
+	countryName() {
+		return this.rng.pick(this.locale.data.countries);
+	}
+	/** Full single-line address. */
+	fullAddress() {
+		return `${this.streetAddress()}, ${this.city()}, ${this.state()} ${this.zipCode()}`;
+	}
+	latitude(min = -90, max = 90) {
+		return this.rng.float(min, max, 4);
+	}
+	longitude(min = -180, max = 180) {
+		return this.rng.float(min, max, 4);
+	}
+};
+//#endregion
+//#region src/faker/lorem.ts
+/** Capitalise the first character of a string. */
+function capitalize(s) {
+	const first = s[0];
+	return first === void 0 ? s : first.toUpperCase() + s.slice(1);
+}
+/**
+* Lorem-ipsum text generator.
+*
+* @example
+* ```ts
+* faker.lorem.word()              // "consectetur"
+* faker.lorem.words(3)            // "dolor sit amet"
+* faker.lorem.sentence()          // "Ut labore et dolore magna aliqua."
+* faker.lorem.paragraph()
+* faker.lorem.paragraphs(3)
+* ```
+*/
+var Lorem = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	word() {
+		return this.rng.pick(this.locale.data.loremWords);
+	}
+	words(count = 3) {
+		return Array.from({ length: count }, () => this.word()).join(" ");
+	}
+	sentence(wordCount) {
+		const count = wordCount ?? this.rng.int(4, 12);
+		return capitalize(this.words(count)) + ".";
+	}
+	paragraph(sentenceCount) {
+		const count = sentenceCount ?? this.rng.int(3, 6);
+		return Array.from({ length: count }, () => this.sentence()).join(" ");
+	}
+	paragraphs(count = 3) {
+		return Array.from({ length: count }, () => this.paragraph()).join("\n\n");
+	}
+	/** Alias of `paragraph()` — matches faker.js. */
+	text() {
+		return this.paragraph();
+	}
+};
+//#endregion
+//#region src/faker/date.ts
+var DAY_MS = 864e5;
+/**
+* Date / time generators.
+*
+* @example
+* ```ts
+* faker.date.past()            // a Date in the last 365 days
+* faker.date.recent(30)        // last 30 days
+* faker.date.future(60)        // next 60 days
+* faker.date.between(a, b)
+* faker.date.birthdate({ min: 18, max: 65 })
+* ```
+*/
+var DateGen = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	past(days = 365) {
+		const now = Date.now();
+		return new Date(this.rng.int(now - days * DAY_MS, now - 1));
+	}
+	recent(days = 30) {
+		return this.past(days);
+	}
+	future(days = 30) {
+		const now = Date.now();
+		return new Date(this.rng.int(now + 1, now + days * DAY_MS));
+	}
+	soon(days = 7) {
+		return this.future(days);
+	}
+	between(from, to) {
+		const a = from.getTime();
+		const b = to.getTime();
+		return new Date(this.rng.int(Math.min(a, b), Math.max(a, b)));
+	}
+	/** ISO-8601 string of a random recent date. */
+	iso(days = 365) {
+		return this.past(days).toISOString();
+	}
+	/** A plausible birthdate for someone in `[min, max]` years old. */
+	birthdate(opts = {}) {
+		const min = opts.min ?? 18;
+		const max = opts.max ?? 80;
+		const now = Date.now();
+		const minTime = now - max * 365 * DAY_MS;
+		const maxTime = now - min * 365 * DAY_MS;
+		return new Date(this.rng.int(minTime, maxTime));
+	}
+};
+//#endregion
+//#region src/faker/number.ts
+/**
+* Number generators.
+*
+* @example
+* ```ts
+* faker.number.int({ min: 1, max: 100 })
+* faker.number.float({ min: 0, max: 1, decimals: 3 })
+* faker.number.bigInt({ min: 0n, max: 1000n })
+* faker.number.between(1, 5)
+* ```
+*/
+var NumberGen = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	int(opts = {}) {
+		return this.rng.int(opts.min ?? 0, opts.max ?? Number.MAX_SAFE_INTEGER);
+	}
+	float(opts = {}) {
+		return this.rng.float(opts.min ?? 0, opts.max ?? 1, opts.decimals ?? 2);
+	}
+	bigInt(opts = {}) {
+		const min = opts.min ?? 0n;
+		const max = opts.max ?? 1000000000n;
+		if (max < min) throw new Error("[Number] bigInt: max < min");
+		const range = max - min + 1n;
+		const lo = BigInt(this.rng.int(0, 4294967295));
+		return min + (BigInt(this.rng.int(0, 4294967295)) << 32n | lo) % range;
+	}
+	/** Convenience: integer in `[min, max]`. */
+	between(min, max) {
+		return this.rng.int(min, max);
+	}
+};
+//#endregion
+//#region src/faker/string.ts
+var ALPHA = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var NUMERIC = "0123456789";
+var ALPHANUMERIC = ALPHA + NUMERIC;
+var HEX = "0123456789abcdef";
+var NANOID = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+/**
+* String / identifier generators.
+*
+* @example
+* ```ts
+* faker.string.uuid()              // "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+* faker.string.nanoid()
+* faker.string.alphanumeric(8)
+* faker.string.hexadecimal(16)
+* faker.string.sample(20)          // any printable char
+* faker.string.slug()              // "dolor-sit-amet"
+* ```
+*/
+var StringGen = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	/** RFC-4122 v4 UUID. */
+	uuid() {
+		const bytes = Array.from({ length: 16 }, () => this.rng.int(0, 255));
+		bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+		bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+		const hex = bytes.map((b) => b.toString(16).padStart(2, "0")).join("");
+		return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+	}
+	/** URL-safe random ID — same alphabet as nanoid. */
+	nanoid(length = 21) {
+		return this.pickFrom(NANOID, length);
+	}
+	alpha(length = 10) {
+		return this.pickFrom(ALPHA, length);
+	}
+	numeric(length = 10) {
+		return this.pickFrom(NUMERIC, length);
+	}
+	alphanumeric(length = 10) {
+		return this.pickFrom(ALPHANUMERIC, length);
+	}
+	hexadecimal(length = 8, opts = {}) {
+		return (opts.prefix ?? "") + this.pickFrom(HEX, length);
+	}
+	/** Random printable ASCII (32–126), any character. */
+	sample(length = 10) {
+		let out = "";
+		for (let i = 0; i < length; i++) out += String.fromCharCode(this.rng.int(33, 126));
+		return out;
+	}
+	/** Lowercase, hyphen-joined word sequence. */
+	slug(words = 3, dictionary) {
+		const pool = dictionary ?? DEFAULT_SLUG_WORDS;
+		return Array.from({ length: words }, () => this.rng.pick(pool)).join("-");
+	}
+	pickFrom(pool, length) {
+		let out = "";
+		for (let i = 0; i < length; i++) {
+			const ch = pool[this.rng.int(0, pool.length - 1)];
+			if (ch !== void 0) out += ch;
+		}
+		return out;
+	}
+};
+var DEFAULT_SLUG_WORDS = [
+	"amber",
+	"azure",
+	"cedar",
+	"cobalt",
+	"coral",
+	"dawn",
+	"ember",
+	"fern",
+	"frost",
+	"glass",
+	"haven",
+	"iris",
+	"jade",
+	"lake",
+	"maple",
+	"meadow",
+	"nova",
+	"opal",
+	"pine",
+	"quartz",
+	"river",
+	"sage",
+	"silk",
+	"stone",
+	"tide",
+	"umber",
+	"velvet",
+	"wave",
+	"xeno",
+	"yarn",
+	"zenith"
+];
+//#endregion
+//#region src/faker/color.ts
+/**
+* Color generators.
+*
+* @example
+* ```ts
+* faker.color.name()    // "amber"
+* faker.color.hex()     // "#3f8ad5"
+* faker.color.rgb()     // "rgb(63, 138, 213)"
+* faker.color.hsl()     // "hsl(217, 64%, 54%)"
+* ```
+*/
+var Color = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	name() {
+		return this.rng.pick(this.locale.data.colors);
+	}
+	hex() {
+		return "#" + this.rng.int(0, 16777215).toString(16).padStart(6, "0");
+	}
+	rgb() {
+		return `rgb(${this.rng.int(0, 255).toString()}, ${this.rng.int(0, 255).toString()}, ${this.rng.int(0, 255).toString()})`;
+	}
+	hsl() {
+		return `hsl(${this.rng.int(0, 360).toString()}, ${this.rng.int(40, 90).toString()}%, ${this.rng.int(30, 70).toString()}%)`;
+	}
+};
+//#endregion
+//#region src/faker/company.ts
+/**
+* Company / employment generators.
+*
+* @example
+* ```ts
+* faker.company.name()        // "Stark Industries"
+* faker.company.jobTitle()    // "Frontend Developer"
+* faker.company.buzzPhrase()  // "leverage cross-platform synergies"
+* ```
+*/
+var Company = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	name() {
+		return this.rng.pick(this.locale.data.companies);
+	}
+	jobTitle() {
+		return this.rng.pick(this.locale.data.jobTitles);
+	}
+	buzzPhrase() {
+		return this.rng.pick(this.locale.data.buzzPhrases);
+	}
+};
+//#endregion
+//#region src/faker/commerce.ts
+/**
+* Commerce generators.
+*
+* @example
+* ```ts
+* faker.commerce.productName()   // "Bamboo Notebook"
+* faker.commerce.price()         // 24.99
+* faker.commerce.department()    // "Electronics"
+* ```
+*/
+var Commerce = class {
+	rng;
+	locale;
+	constructor(rng, locale) {
+		this.rng = rng;
+		this.locale = locale;
+	}
+	productName() {
+		return this.rng.pick(this.locale.data.productNames);
+	}
+	department() {
+		return this.rng.pick(this.locale.data.departments);
+	}
+	price(min = 1, max = 1e3, decimals = 2) {
+		return this.rng.float(min, max, decimals);
+	}
+	productDescription() {
+		return `${this.rng.pick([
+			"Premium",
+			"Eco-friendly",
+			"Hand-crafted",
+			"Vintage",
+			"Modern"
+		])} ${this.productName().toLowerCase()} designed for everyday use.`;
+	}
+};
+//#endregion
+//#region src/faker/finance.ts
+/**
+* Finance generators.
+*
+* @example
+* ```ts
+* faker.finance.amount()              // "327.41"
+* faker.finance.amount(0, 10, 2, '$') // "$4.27"
+* faker.finance.accountNumber()
+* faker.finance.creditCardNumber()    // 16-digit Luhn-valid number
+* faker.finance.currencyCode()
+* faker.finance.iban()
+* ```
+*/
+var Finance = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	amount(min = 0, max = 1e3, decimals = 2, symbol = "") {
+		return symbol + this.rng.float(min, max, decimals).toFixed(decimals);
+	}
+	accountNumber(digits = 10) {
+		let out = "";
+		for (let i = 0; i < digits; i++) out += this.rng.int(0, 9).toString();
+		return out;
+	}
+	/** Generates a Luhn-valid 16-digit credit-card number. */
+	creditCardNumber() {
+		const digits = [];
+		for (let i = 0; i < 15; i++) digits.push(this.rng.int(0, 9));
+		let sum = 0;
+		for (let i = digits.length - 1; i >= 0; i--) {
+			const raw = digits[i];
+			if (raw === void 0) continue;
+			let d = raw;
+			if ((digits.length - i) % 2 === 1) {
+				d *= 2;
+				if (d > 9) d -= 9;
+			}
+			sum += d;
+		}
+		digits.push((10 - sum % 10) % 10);
+		return digits.join("");
+	}
+	currencyCode() {
+		return this.rng.pick(CURRENCY_CODES);
+	}
+	iban(countryCode = "GB", length = 22) {
+		let body = "";
+		for (let i = 0; i < length - 4; i++) body += this.rng.int(0, 9).toString();
+		return `${countryCode}${this.rng.int(10, 99).toString()}${body}`;
+	}
+	bitcoinAddress() {
+		const chars = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz123456789";
+		let out = this.rng.pick(["1", "3"]);
+		const length = this.rng.int(25, 33);
+		for (let i = 1; i < length; i++) {
+			const ch = chars[this.rng.int(0, 57)];
+			if (ch !== void 0) out += ch;
+		}
+		return out;
+	}
+};
+var CURRENCY_CODES = [
+	"USD",
+	"EUR",
+	"GBP",
+	"JPY",
+	"CHF",
+	"CAD",
+	"AUD",
+	"CNY",
+	"INR",
+	"NPR",
+	"BRL",
+	"MXN",
+	"SGD",
+	"HKD",
+	"KRW"
+];
+//#endregion
+//#region src/faker/image.ts
+/**
+* Image-URL generators. No bytes are produced — just predictable URLs that
+* resolve to real images from public providers.
+*
+* @example
+* ```ts
+* faker.image.url()                 // picsum.photos URL
+* faker.image.avatar()              // ui-avatars URL
+* faker.image.dataUri(64, 64)       // tiny embeddable PNG
+* ```
+*/
+var Image = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	/** Picsum-photos placeholder URL. */
+	url(width = 640, height = 480) {
+		const random = this.rng.int(1, 1e4).toString();
+		return `https://picsum.photos/${width.toString()}/${height.toString()}?random=${random}`;
+	}
+	/** ui-avatars.com avatar URL — needs a name to render initials. */
+	avatar(name = "User") {
+		return `https://ui-avatars.com/api/?${new URLSearchParams({
+			name,
+			size: String(this.rng.pick([
+				64,
+				96,
+				128,
+				256
+			])),
+			background: this.rng.int(0, 16777215).toString(16).padStart(6, "0"),
+			color: "fff"
+		}).toString()}`;
+	}
+	/** Tiny single-color PNG data-uri — useful for testing inline-image flows. */
+	dataUri(width = 1, height = 1) {
+		return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+	}
+};
+//#endregion
+//#region src/faker/system.ts
+/**
+* Filesystem / operating-system generators.
+*
+* @example
+* ```ts
+* faker.system.fileName()       // "amber-cedar-pine.json"
+* faker.system.commonFileExt()  // "pdf"
+* faker.system.mimeType()       // "image/png"
+* faker.system.filePath()       // "/var/log/glass-stone.txt"
+* ```
+*/
+var System = class {
+	rng;
+	locale;
+	strings;
+	constructor(rng, locale, strings) {
+		this.rng = rng;
+		this.locale = locale;
+		this.strings = strings;
+	}
+	commonFileExt() {
+		return this.rng.pick(this.locale.data.fileExtensions);
+	}
+	fileExt() {
+		return this.rng.pick(this.locale.data.fileExtensions);
+	}
+	fileName(opts = {}) {
+		const base = this.strings.slug(this.rng.int(2, 4));
+		return opts.withExt === false ? base : `${base}.${this.commonFileExt()}`;
+	}
+	directoryPath() {
+		const depth = this.rng.int(1, 4);
+		return "/" + Array.from({ length: depth }, () => this.strings.slug(1)).join("/");
+	}
+	filePath() {
+		return `${this.directoryPath()}/${this.fileName()}`;
+	}
+	mimeType() {
+		return this.rng.pick(this.locale.data.mimeTypes);
+	}
+	semver() {
+		return [
+			this.rng.int(0, 10),
+			this.rng.int(0, 20),
+			this.rng.int(0, 100)
+		].join(".");
+	}
+};
+//#endregion
+//#region src/faker/datatype.ts
+/**
+* Primitive datatype generators.
+*
+* @example
+* ```ts
+* faker.datatype.boolean()        // true or false
+* faker.datatype.boolean(0.8)     // true with 80% probability
+* ```
+*/
+var Datatype = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	/** Boolean with probability `chance` of `true` (default 0.5). */
+	boolean(chance = .5) {
+		return this.rng.bool(chance);
+	}
+};
+//#endregion
+//#region src/faker/regex.ts
+/**
+* Generate a sample string that matches the given regular-expression pattern.
+*
+* Supports the regex subset commonly used in test data:
+*   - Literals, dot, escaped characters
+*   - Character classes `[a-z]`, `[^…]`, `\d`, `\D`, `\w`, `\W`, `\s`, `\S`
+*   - Groups `(...)`, non-capturing `(?:...)`, alternation `a|b|c`
+*   - Quantifiers `*`, `+`, `?`, `{n}`, `{n,m}` (lazy `?` is ignored)
+*
+* Unsupported regex features (lookbehind/lookahead, backreferences,
+* named groups) are silently treated as literals.
+*
+* @example
+* ```ts
+* generateFromRegex(/[A-Z]{3}-\d{4}/, prng) // "ZQX-4172"
+* ```
+*/
+function generateFromRegex(pattern, rng) {
+	return render(new RegexParser(pattern instanceof RegExp ? pattern.source : pattern).parse(), rng);
+}
+function charRange(startCode, endCode) {
+	const out = [];
+	for (let c = startCode; c <= endCode; c++) out.push(String.fromCharCode(c));
+	return out;
+}
+var D = charRange(48, 57);
+var L = charRange(97, 122);
+var U = charRange(65, 90);
+var W = [
+	...D,
+	...L,
+	...U,
+	"_"
+];
+var S = [" ", "	"];
+var NW = [
+	" ",
+	"!",
+	"@",
+	"#",
+	"$",
+	"%",
+	"&",
+	"*",
+	"-",
+	"+",
+	"=",
+	";",
+	":",
+	",",
+	".",
+	"/",
+	"?"
+];
+var ALL = [
+	...W,
+	...S,
+	"!",
+	"@",
+	"#",
+	"$",
+	"%",
+	"^",
+	"&",
+	"*",
+	"(",
+	")",
+	"-",
+	"+"
+];
+function expandEscape(ch) {
+	switch (ch) {
+		case "d": return [...D];
+		case "D": return [
+			...L,
+			...U,
+			"_",
+			" "
+		];
+		case "w": return [...W];
+		case "W": return [...NW];
+		case "s": return [...S];
+		case "S": return [...W, ...NW];
+		case "n": return ["\n"];
+		case "t": return ["	"];
+		case "r": return ["\r"];
+		default: return [ch];
+	}
+}
+var RegexParser = class {
+	src;
+	pos = 0;
+	constructor(src) {
+		this.src = src;
+	}
+	parse() {
+		return this.parseAlt();
+	}
+	peek() {
+		return this.src[this.pos];
+	}
+	parseAlt() {
+		const branches = [this.parseSeq()];
+		while (this.peek() === "|") {
+			this.pos++;
+			branches.push(this.parseSeq());
+		}
+		if (branches.length === 1) {
+			const only = branches[0];
+			if (only === void 0) throw new Error("[regex] unreachable: empty branches");
+			return only;
+		}
+		return {
+			kind: "alt",
+			branches
+		};
+	}
+	parseSeq() {
+		const items = [];
+		while (this.pos < this.src.length && this.peek() !== ")" && this.peek() !== "|") {
+			const node = this.parseAtom();
+			const q = this.parseQuant();
+			items.push({
+				node,
+				min: q.min,
+				max: q.max
+			});
+			if (this.peek() === "?") this.pos++;
+		}
+		return {
+			kind: "seq",
+			items
+		};
+	}
+	parseAtom() {
+		const ch = this.peek();
+		if (ch === "(") {
+			this.pos++;
+			if (this.peek() === "?") {
+				const colon = this.src.indexOf(":", this.pos);
+				if (colon !== -1) this.pos = colon + 1;
+			}
+			const inner = this.parseAlt();
+			if (this.peek() === ")") this.pos++;
+			return inner;
+		}
+		if (ch === "[") {
+			this.pos++;
+			return {
+				kind: "class",
+				pool: this.parseCharClass()
+			};
+		}
+		if (ch === ".") {
+			this.pos++;
+			return { kind: "dot" };
+		}
+		if (ch === "^" || ch === "$") {
+			this.pos++;
+			return {
+				kind: "lit",
+				value: ""
+			};
+		}
+		if (ch === "\\") {
+			this.pos++;
+			return {
+				kind: "class",
+				pool: expandEscape(this.src[this.pos++] ?? "")
+			};
+		}
+		this.pos++;
+		return {
+			kind: "lit",
+			value: ch ?? ""
+		};
+	}
+	parseCharClass() {
+		let negate = false;
+		if (this.peek() === "^") {
+			negate = true;
+			this.pos++;
+		}
+		const pool = [];
+		while (this.pos < this.src.length && this.peek() !== "]") if (this.peek() === "\\") {
+			this.pos++;
+			pool.push(...expandEscape(this.src[this.pos++] ?? ""));
+		} else if (this.src[this.pos + 1] === "-" && this.src[this.pos + 2] && this.src[this.pos + 2] !== "]") {
+			const fromCh = this.src[this.pos];
+			const toCh = this.src[this.pos + 2];
+			if (fromCh !== void 0 && toCh !== void 0) {
+				const from = fromCh.charCodeAt(0);
+				const to = toCh.charCodeAt(0);
+				for (let c = from; c <= to; c++) pool.push(String.fromCharCode(c));
+			}
+			this.pos += 3;
+		} else {
+			const ch = this.src[this.pos++];
+			if (ch !== void 0) pool.push(ch);
+		}
+		if (this.peek() === "]") this.pos++;
+		if (negate) {
+			const set = new Set(pool);
+			return ALL.filter((c) => !set.has(c));
+		}
+		return pool.length > 0 ? pool : ["a"];
+	}
+	parseQuant() {
+		const ch = this.peek();
+		if (ch === "*") {
+			this.pos++;
+			return {
+				min: 0,
+				max: 8
+			};
+		}
+		if (ch === "+") {
+			this.pos++;
+			return {
+				min: 1,
+				max: 8
+			};
+		}
+		if (ch === "?") {
+			this.pos++;
+			return {
+				min: 0,
+				max: 1
+			};
+		}
+		if (ch === "{") {
+			const end = this.src.indexOf("}", this.pos);
+			if (end !== -1) {
+				const inner = this.src.slice(this.pos + 1, end);
+				this.pos = end + 1;
+				if (this.peek() === "?") this.pos++;
+				const parts = inner.split(",");
+				const lo = parseInt(parts[0] ?? "1", 10);
+				const hi = parts.length > 1 ? parts[1] ? parseInt(parts[1], 10) : lo + 4 : lo;
+				return {
+					min: lo,
+					max: Math.min(hi, lo + 10)
+				};
+			}
+		}
+		return {
+			min: 1,
+			max: 1
+		};
+	}
+};
+function render(node, rng) {
+	switch (node.kind) {
+		case "lit": return node.value;
+		case "class": return node.pool.length > 0 ? rng.pick(node.pool) : "";
+		case "dot": return rng.pick([...W, " "]);
+		case "seq": {
+			let out = "";
+			for (const item of node.items) {
+				const count = rng.int(item.min, item.max);
+				for (let i = 0; i < count; i++) out += render(item.node, rng);
+			}
+			return out;
+		}
+		case "alt": return render(rng.pick(node.branches), rng);
+	}
+}
+//#endregion
+//#region src/faker/helpers.ts
+/**
+* General helpers — operate on arbitrary inputs, not tied to any locale or
+* faker namespace.
+*
+* @example
+* ```ts
+* faker.helpers.arrayElement([1, 2, 3])           // 2
+* faker.helpers.arrayElements([1, 2, 3, 4], 2)    // [3, 1]
+* faker.helpers.shuffle([1, 2, 3])                // [2, 3, 1]
+* faker.helpers.weightedArrayElement([
+*   { value: 'rare',   weight: 1 },
+*   { value: 'common', weight: 9 },
+* ])
+* faker.helpers.fromRegExp(/[A-Z]{3}\d{4}/)       // "PWB7401"
+* faker.helpers.unique(() => faker.internet.email(), 5)
+* ```
+*/
+var Helpers = class {
+	rng;
+	constructor(rng) {
+		this.rng = rng;
+	}
+	arrayElement(items) {
+		return this.rng.pick(items);
+	}
+	/** Pick `count` distinct elements from `items` (no replacement). */
+	arrayElements(items, count) {
+		const n = count ?? this.rng.int(1, items.length);
+		if (n > items.length) throw new Error(`[Helpers] arrayElements: requested ${n.toString()} from ${items.length.toString()} items.`);
+		return this.shuffle(items).slice(0, n);
+	}
+	shuffle(items) {
+		const copy = [...items];
+		for (let i = copy.length - 1; i > 0; i--) {
+			const j = this.rng.int(0, i);
+			const a = copy[i];
+			const b = copy[j];
+			if (a === void 0 || b === void 0) continue;
+			copy[i] = b;
+			copy[j] = a;
+		}
+		return copy;
+	}
+	weightedArrayElement(items) {
+		if (items.length === 0) throw new Error("[Helpers] weightedArrayElement: empty list.");
+		const total = items.reduce((acc, it) => acc + it.weight, 0);
+		if (total <= 0) throw new Error("[Helpers] weightedArrayElement: weights sum to <= 0.");
+		let target = this.rng.next() * total;
+		for (const it of items) {
+			target -= it.weight;
+			if (target <= 0) return it.value;
+		}
+		const last = items[items.length - 1];
+		if (last === void 0) throw new Error("[Helpers] weightedArrayElement: unreachable");
+		return last.value;
+	}
+	/** Build an array of length `length` by calling `fn(index)`. */
+	multiple(length, fn) {
+		return Array.from({ length }, (_, i) => fn(i));
+	}
+	/** Repeat a string `count` times. */
+	repeat(value, count) {
+		return value.repeat(count);
+	}
+	/** Sample-string matching a regex. */
+	fromRegExp(pattern) {
+		return generateFromRegex(pattern, this.rng);
+	}
+	/**
+	* Collect `count` unique results from `fn`. Throws if the retry budget is
+	* exhausted before reaching `count`.
+	*/
+	unique(fn, count, options = {}) {
+		const out = /* @__PURE__ */ new Set();
+		const budget = options.maxRetries ?? count * 10;
+		let attempts = 0;
+		while (out.size < count && attempts < budget) {
+			out.add(fn());
+			attempts++;
+		}
+		if (out.size < count) throw new Error(`[Helpers] unique: could not produce ${count.toString()} unique values after ${budget.toString()} attempts (got ${out.size.toString()}).`);
+		return [...out];
+	}
+	/** Pick a random `enum` value, handling numeric reverse-mappings. */
+	enumValue(enumObj) {
+		const numericKeys = Object.keys(enumObj).filter((k) => /^\d+$/.test(k));
+		const values = numericKeys.length > 0 ? numericKeys.map((k) => enumObj[k]) : Object.values(enumObj);
+		if (values.length === 0) throw new Error("[Helpers] enumValue: enum has no values.");
+		return this.rng.pick(values);
+	}
+	/** With probability `chance`, return `value`; otherwise `undefined`. */
+	maybe(value, chance = .5) {
+		return this.rng.bool(chance) ? value : void 0;
+	}
+};
+//#endregion
+//#region src/faker/faker.ts
+/**
+* Faceted, seedable, locale-aware random-data generator.
+*
+* Every namespace shares the same PRNG and locale reference — `seed()` and
+* `locale()` mutate that shared state in place, so changes propagate without
+* re-constructing modules.
+*
+* @example
+* ```ts
+* import { Faker } from '@anil-labs/factory'
+*
+* const f = new Faker({ seed: 42, locale: 'en' })
+* f.person.fullName()    // "Olivia Patel"
+* f.seed(42)
+* f.person.fullName()    // "Olivia Patel" — deterministic
+*
+* // Or use the package's default instance:
+* import { faker } from '@anil-labs/factory'
+* faker.seed(1)
+* faker.internet.email()
+* ```
+*/
+var Faker = class Faker {
+	rng;
+	localeRef;
+	person;
+	internet;
+	location;
+	lorem;
+	date;
+	number;
+	string;
+	color;
+	company;
+	commerce;
+	finance;
+	image;
+	system;
+	datatype;
+	helpers;
+	constructor(opts = {}) {
+		this.rng = createPrng(opts.seed);
+		this.localeRef = new LocaleRef(opts.locale ?? "en");
+		this.person = new Person(this.rng, this.localeRef);
+		this.internet = new Internet(this.rng, this.localeRef);
+		this.location = new Location(this.rng, this.localeRef);
+		this.lorem = new Lorem(this.rng, this.localeRef);
+		this.date = new DateGen(this.rng);
+		this.number = new NumberGen(this.rng);
+		this.string = new StringGen(this.rng);
+		this.color = new Color(this.rng, this.localeRef);
+		this.company = new Company(this.rng, this.localeRef);
+		this.commerce = new Commerce(this.rng, this.localeRef);
+		this.finance = new Finance(this.rng);
+		this.image = new Image(this.rng);
+		this.system = new System(this.rng, this.localeRef, this.string);
+		this.datatype = new Datatype(this.rng);
+		this.helpers = new Helpers(this.rng);
+	}
+	/** Reseed the underlying PRNG. Subsequent calls are deterministic from here. */
+	seed(seed) {
+		this.rng.seed(seed);
+		return this;
+	}
+	/** Switch the active locale. Throws if unknown. */
+	locale(name) {
+		this.localeRef.set(name);
+		return this;
+	}
+	/** Read the current locale identifier (e.g. `"en"`). */
+	currentLocale() {
+		return this.localeRef.name;
+	}
+	/** Read the current seed (useful for snapshot reproduction). */
+	currentSeed() {
+		return this.rng.currentSeed;
+	}
+	/**
+	* Build a fresh, independent `Faker` with its own PRNG seeded from this
+	* one's current state. Useful when you need to fork a deterministic stream.
+	*/
+	fork() {
+		return new Faker({
+			seed: this.rng.int(0, 4294967295),
+			locale: this.localeRef.name
+		});
+	}
+	/** Access the underlying PRNG. Advanced use only. */
+	rawPrng() {
+		return this.rng;
+	}
+};
+/** Default singleton — mutable via `faker.seed()` / `faker.locale()`. */
+var faker = new Faker();
+//#endregion
+export { createPrng as C, registerLocale as S, Internet as _, Datatype as a, getLocale as b, Finance as c, Color as d, StringGen as f, Location as g, Lorem as h, generateFromRegex as i, Commerce as l, DateGen as m, faker as n, System as o, NumberGen as p, Helpers as r, Image as s, Faker as t, Company as u, Person as v, Mulberry32 as w, listLocales as x, LocaleRef as y };
+
+//# sourceMappingURL=faker-BlEhpR26.mjs.map