@venn-lang/data 0.1.0

package/dist/index.js

@@ -0,0 +1,1941 @@
+import { arg, defineAction, definePlugin, optionalArg, restArg } from "@venn-lang/sdk";
+import { t } from "@venn-lang/types";
+//#region src/faker/data/business.ts
+const COMPANY_ROOTS = [
+	"Northwind",
+	"Acme",
+	"Globex",
+	"Initech",
+	"Umbrella",
+	"Vandelay",
+	"Stark",
+	"Wayne",
+	"Tyrell",
+	"Cyberdyne",
+	"Aperture",
+	"Soylent",
+	"Massive",
+	"Hooli"
+];
+const COMPANY_SUFFIXES = [
+	"Ltd",
+	"Inc",
+	"GmbH",
+	"S.A.",
+	"LLC",
+	"Group",
+	"Labs",
+	"Systems",
+	"Holdings"
+];
+const DEPARTMENTS = [
+	"Engineering",
+	"Design",
+	"Sales",
+	"Marketing",
+	"Support",
+	"Finance",
+	"Legal",
+	"People",
+	"Operations",
+	"Security",
+	"Data",
+	"Research"
+];
+const JOB_TITLES = [
+	"Software Engineer",
+	"Product Designer",
+	"Data Analyst",
+	"Engineering Manager",
+	"QA Engineer",
+	"Site Reliability Engineer",
+	"Technical Writer",
+	"Product Manager",
+	"Security Analyst",
+	"Solutions Architect",
+	"Support Specialist",
+	"Accountant"
+];
+const BUZZWORDS = [
+	"synergy",
+	"scalability",
+	"throughput",
+	"observability",
+	"resilience",
+	"alignment",
+	"velocity",
+	"leverage",
+	"bandwidth",
+	"runway"
+];
+const CATCH_VERBS = [
+	"streamline",
+	"orchestrate",
+	"unlock",
+	"accelerate",
+	"simplify",
+	"amplify"
+];
+//#endregion
+//#region src/faker/data/commerce.ts
+const PRODUCTS = [
+	"Chair",
+	"Keyboard",
+	"Lamp",
+	"Backpack",
+	"Mug",
+	"Notebook",
+	"Headphones",
+	"Monitor",
+	"Desk",
+	"Bottle",
+	"Jacket",
+	"Sneakers",
+	"Table",
+	"Shelf",
+	"Camera"
+];
+const MATERIALS = [
+	"cotton",
+	"steel",
+	"oak",
+	"leather",
+	"glass",
+	"aluminium",
+	"ceramic",
+	"linen"
+];
+const CATEGORIES = [
+	"Electronics",
+	"Home",
+	"Outdoors",
+	"Books",
+	"Clothing",
+	"Toys",
+	"Grocery",
+	"Sports",
+	"Beauty",
+	"Automotive"
+];
+const COLORS = [
+	["black", "#000000"],
+	["white", "#ffffff"],
+	["red", "#e53935"],
+	["blue", "#1e88e5"],
+	["green", "#43a047"],
+	["amber", "#ffb300"],
+	["violet", "#8e24aa"],
+	["teal", "#00897b"],
+	["slate", "#546e7a"],
+	["coral", "#ff7043"]
+];
+/** `[code, symbol, name]`. */
+const CURRENCIES = [
+	[
+		"BRL",
+		"R$",
+		"Brazilian Real"
+	],
+	[
+		"USD",
+		"$",
+		"US Dollar"
+	],
+	[
+		"EUR",
+		"€",
+		"Euro"
+	],
+	[
+		"GBP",
+		"£",
+		"Pound Sterling"
+	],
+	[
+		"JPY",
+		"¥",
+		"Japanese Yen"
+	],
+	[
+		"CAD",
+		"$",
+		"Canadian Dollar"
+	]
+];
+/** `[brand, prefix, length]`. The prefixes are the real issuer ranges. */
+const CARD_BRANDS = [
+	[
+		"Visa",
+		"4",
+		16
+	],
+	[
+		"Mastercard",
+		"51",
+		16
+	],
+	[
+		"Mastercard",
+		"55",
+		16
+	],
+	[
+		"Discover",
+		"6011",
+		16
+	],
+	[
+		"Elo",
+		"4011",
+		16
+	]
+];
+//#endregion
+//#region src/faker/data/names.ts
+/** Given names, mixing the computing pantheon with names common in Brazil. */
+const FIRST_NAMES = [
+	"Ada",
+	"Alan",
+	"Grace",
+	"Linus",
+	"Edsger",
+	"Barbara",
+	"Katherine",
+	"Dennis",
+	"Margaret",
+	"Donald",
+	"Anita",
+	"Tim",
+	"Radia",
+	"Ken",
+	"Frances",
+	"Vint",
+	"Ana",
+	"Bruno",
+	"Camila",
+	"Diego",
+	"Eduarda",
+	"Felipe",
+	"Gabriela",
+	"Heitor",
+	"Isabela",
+	"João",
+	"Larissa",
+	"Mateus",
+	"Natália",
+	"Otávio",
+	"Paula",
+	"Rafael",
+	"Sofia",
+	"Thiago",
+	"Valentina",
+	"Yuri",
+	"Beatriz",
+	"Caio",
+	"Débora",
+	"Enzo"
+];
+/** Family names, likewise mixed. */
+const LAST_NAMES = [
+	"Lovelace",
+	"Turing",
+	"Hopper",
+	"Torvalds",
+	"Dijkstra",
+	"Liskov",
+	"Johnson",
+	"Ritchie",
+	"Hamilton",
+	"Knuth",
+	"Borg",
+	"Berners-Lee",
+	"Perlman",
+	"Thompson",
+	"Allen",
+	"Cerf",
+	"Silva",
+	"Santos",
+	"Oliveira",
+	"Souza",
+	"Rodrigues",
+	"Ferreira",
+	"Almeida",
+	"Costa",
+	"Gomes",
+	"Martins",
+	"Araújo",
+	"Melo",
+	"Barbosa",
+	"Ribeiro",
+	"Carvalho",
+	"Pereira",
+	"Lima",
+	"Moreira",
+	"Cardoso",
+	"Teixeira",
+	"Correia"
+];
+/** Honorifics that precede a name. */
+const NAME_PREFIXES = [
+	"Dr.",
+	"Dra.",
+	"Sr.",
+	"Sra.",
+	"Prof.",
+	"Eng."
+];
+/** Generational suffixes that follow a name. */
+const NAME_SUFFIXES = [
+	"Jr.",
+	"Neto",
+	"Filho",
+	"II",
+	"III"
+];
+/** Gender values shaped the way most forms model them. */
+const GENDERS = [
+	"female",
+	"male",
+	"non-binary",
+	"prefer not to say"
+];
+//#endregion
+//#region src/faker/data/places.ts
+const CITIES = [
+	"Lisbon",
+	"Porto",
+	"Amsterdam",
+	"Berlin",
+	"Toronto",
+	"Austin",
+	"Dublin",
+	"Wellington",
+	"Reykjavík",
+	"Kyoto",
+	"Montréal",
+	"Helsinki",
+	"Tallinn",
+	"Bergen"
+];
+const COUNTRIES = [
+	["Brazil", "BR"],
+	["Portugal", "PT"],
+	["Netherlands", "NL"],
+	["Germany", "DE"],
+	["Canada", "CA"],
+	["United States", "US"],
+	["Ireland", "IE"],
+	["New Zealand", "NZ"],
+	["Japan", "JP"],
+	["Finland", "FI"],
+	["Estonia", "EE"],
+	["Norway", "NO"]
+];
+const STREET_TYPES = [
+	"Street",
+	"Avenue",
+	"Road",
+	"Lane",
+	"Way",
+	"Square"
+];
+const TIMEZONES = [
+	"America/Sao_Paulo",
+	"America/New_York",
+	"Europe/Lisbon",
+	"Europe/Berlin",
+	"Europe/Helsinki",
+	"Asia/Tokyo",
+	"Pacific/Auckland",
+	"UTC"
+];
+/** Brazilian federal units, as `[name, code]`. */
+const BR_STATES = [
+	["São Paulo", "SP"],
+	["Rio de Janeiro", "RJ"],
+	["Minas Gerais", "MG"],
+	["Bahia", "BA"],
+	["Paraná", "PR"],
+	["Rio Grande do Sul", "RS"],
+	["Pernambuco", "PE"],
+	["Ceará", "CE"],
+	["Santa Catarina", "SC"],
+	["Goiás", "GO"],
+	["Pará", "PA"],
+	["Espírito Santo", "ES"],
+	["Amazonas", "AM"],
+	["Distrito Federal", "DF"]
+];
+const BR_CITIES = [
+	"São Paulo",
+	"Rio de Janeiro",
+	"Belo Horizonte",
+	"Salvador",
+	"Curitiba",
+	"Porto Alegre",
+	"Recife",
+	"Fortaleza",
+	"Florianópolis",
+	"Goiânia",
+	"Belém",
+	"Vitória",
+	"Manaus",
+	"Brasília",
+	"Campinas",
+	"Uberlândia"
+];
+const BR_STREET_TYPES = [
+	"Rua",
+	"Avenida",
+	"Travessa",
+	"Alameda",
+	"Praça"
+];
+const BR_STREET_NAMES = [
+	"das Flores",
+	"Sete de Setembro",
+	"Getúlio Vargas",
+	"XV de Novembro",
+	"Santos Dumont",
+	"do Comércio",
+	"Paulista",
+	"Brasil",
+	"das Palmeiras",
+	"Tiradentes"
+];
+//#endregion
+//#region src/faker/data/web.ts
+/** Reserved by RFC 2606/6761, so a generated address never resolves to anyone real. */
+const SAFE_DOMAINS = [
+	"example.test",
+	"example.com",
+	"example.org",
+	"example.net",
+	"test.invalid"
+];
+const TLDS = [
+	"com",
+	"org",
+	"net",
+	"io",
+	"dev",
+	"app",
+	"com.br"
+];
+const HTTP_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS"
+];
+const HTTP_STATUSES = [
+	200,
+	201,
+	202,
+	204,
+	301,
+	302,
+	304,
+	400,
+	401,
+	403,
+	404,
+	409,
+	422,
+	429,
+	500,
+	502,
+	503
+];
+const MIME_TYPES = [
+	"application/json",
+	"text/html",
+	"text/plain",
+	"text/csv",
+	"application/pdf",
+	"image/png",
+	"image/jpeg",
+	"image/svg+xml",
+	"application/octet-stream"
+];
+const USER_AGENTS = [
+	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36",
+	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15",
+	"Mozilla/5.0 (X11; Linux x86_64; rv:127.0) Gecko/20100101 Firefox/127.0",
+	"Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+];
+const PROTOCOLS = ["https", "http"];
+//#endregion
+//#region src/faker/data/words.ts
+/** Classic lorem vocabulary: filler text that is obviously filler. */
+const 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",
+	"culpa",
+	"officia",
+	"deserunt",
+	"mollit",
+	"anim",
+	"id",
+	"est",
+	"laborum"
+];
+/** Adjectives, for product and project names. */
+const ADJECTIVES = [
+	"quiet",
+	"bright",
+	"rapid",
+	"solid",
+	"gentle",
+	"bold",
+	"clever",
+	"plain",
+	"sturdy",
+	"sleek",
+	"warm",
+	"crisp",
+	"amber",
+	"hollow",
+	"northern",
+	"silent"
+];
+/** Concrete nouns, for the same. */
+const NOUNS = [
+	"harbour",
+	"lantern",
+	"meadow",
+	"compass",
+	"anchor",
+	"ridge",
+	"beacon",
+	"quarry",
+	"willow",
+	"falcon",
+	"cascade",
+	"summit",
+	"orchard",
+	"canyon",
+	"delta",
+	"ember"
+];
+//#endregion
+//#region src/faker/primitives.ts
+const COMBINING = /[\u0300-\u036f]/g;
+const DIGITS = "0123456789";
+const HEX = "0123456789abcdef";
+const LOWER = "abcdefghijklmnopqrstuvwxyz";
+const ALNUM = `${LOWER}${LOWER.toUpperCase()}${DIGITS}`;
+/** Pick one item from a list. Drawing from an empty list is a programming error. */
+function pick(items, rng) {
+	const chosen = items[Math.floor(rng() * items.length)];
+	if (chosen === void 0) throw new Error("faker: cannot pick from an empty list");
+	return chosen;
+}
+/** An integer in the inclusive range [min, max]. */
+function intBetween(args) {
+	return args.min + Math.floor(args.rng() * (args.max - args.min + 1));
+}
+/** A number in [min, max), rounded to `decimals` places. */
+function floatBetween(args) {
+	const raw = args.min + args.rng() * (args.max - args.min);
+	return Number(raw.toFixed(args.decimals));
+}
+/** `count` characters drawn from `alphabet`. */
+function chars(args) {
+	let out = "";
+	for (let index = 0; index < args.count; index += 1) out += args.alphabet.charAt(Math.floor(args.rng() * args.alphabet.length));
+	return out;
+}
+/** `count` decimal digits, e.g. `"40721"`. */
+function digits(count, rng) {
+	return chars({
+		count,
+		alphabet: DIGITS,
+		rng
+	});
+}
+/** Upper-case the first character, leaving the rest alone. */
+function capitalize(word) {
+	return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/** Zero-pad a number to `width` digits. */
+function pad(value, width) {
+	return String(value).padStart(width, "0");
+}
+/** Strip diacritics so a name can become an email local part or a URL slug. */
+function ascii(text) {
+	return text.normalize("NFD").replace(COMBINING, "");
+}
+/** ASCII-safe lowercase slug: `"João Gonçalves"` → `"joao-goncalves"`. */
+function slug(text) {
+	return ascii(text).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/** Read a positional argument as a number, falling back when it is absent. */
+function numArg(args, index, fallback) {
+	const raw = Number(args[index]);
+	return args[index] === void 0 || Number.isNaN(raw) ? fallback : raw;
+}
+/** Build `count` values, each drawn independently. */
+function times(count, make) {
+	return Array.from({ length: count }, make);
+}
+//#endregion
+//#region src/faker/address.ts
+function street$1(rng) {
+	return `${capitalize(pick(NOUNS, rng))} ${pick(STREET_TYPES, rng)}`;
+}
+function streetAddress(rng) {
+	return `${intBetween({
+		min: 1,
+		max: 9999,
+		rng
+	})} ${street$1(rng)}`;
+}
+function country(rng) {
+	return pick(COUNTRIES, rng)[0];
+}
+function countryCode(rng) {
+	return pick(COUNTRIES, rng)[1];
+}
+/** A one-line postal address, the shape a shipping form expects. */
+function address$1(rng) {
+	return `${streetAddress(rng)}, ${pick(CITIES, rng)} ${digits(5, rng)}, ${country(rng)}`;
+}
+const addressSpecs = [
+	{
+		name: "street",
+		doc: "A street name.",
+		result: t.string,
+		make: street$1
+	},
+	{
+		name: "streetAddress",
+		doc: "A street name with a building number.",
+		result: t.string,
+		make: streetAddress
+	},
+	{
+		name: "address",
+		doc: "A full one-line postal address.",
+		result: t.string,
+		make: address$1
+	},
+	{
+		name: "buildingNumber",
+		doc: "A building number.",
+		result: t.number,
+		make: (rng) => intBetween({
+			min: 1,
+			max: 9999,
+			rng
+		})
+	},
+	{
+		name: "city",
+		doc: "A city name.",
+		result: t.string,
+		make: (rng) => pick(CITIES, rng)
+	},
+	{
+		name: "country",
+		doc: "A country name.",
+		result: t.string,
+		make: country
+	},
+	{
+		name: "countryCode",
+		doc: "An ISO 3166-1 alpha-2 code.",
+		result: t.string,
+		make: countryCode
+	},
+	{
+		name: "zip",
+		doc: "A five-digit postal code.",
+		result: t.string,
+		make: (rng) => digits(5, rng)
+	},
+	{
+		name: "latitude",
+		doc: "A latitude in degrees, between -90 and 90.",
+		result: t.number,
+		make: (rng) => floatBetween({
+			min: -90,
+			max: 90,
+			decimals: 6,
+			rng
+		})
+	},
+	{
+		name: "longitude",
+		doc: "A longitude in degrees, between -180 and 180.",
+		result: t.number,
+		make: (rng) => floatBetween({
+			min: -180,
+			max: 180,
+			decimals: 6,
+			rng
+		})
+	},
+	{
+		name: "timezone",
+		doc: "An IANA time zone name.",
+		result: t.string,
+		make: (rng) => pick(TIMEZONES, rng)
+	}
+];
+//#endregion
+//#region src/faker/brazil-documents.ts
+/**
+* The two CPF check digits.
+*
+* @param base The first nine digits, unformatted.
+* @returns Two digits to append.
+*/
+function cpfDigits(base) {
+	const first = cpfDigit(base, 10);
+	return `${first}${cpfDigit(`${base}${first}`, 11)}`;
+}
+function cpfDigit(base, weight) {
+	let sum = 0;
+	for (let index = 0; index < base.length; index += 1) sum += Number(base[index]) * (weight - index);
+	const rest = sum * 10 % 11;
+	return String(rest === 10 ? 0 : rest);
+}
+const CNPJ_WEIGHTS = [
+	6,
+	5,
+	4,
+	3,
+	2,
+	9,
+	8,
+	7,
+	6,
+	5,
+	4,
+	3,
+	2
+];
+/**
+* The two CNPJ check digits.
+*
+* @param base The first twelve digits, unformatted.
+* @returns Two digits to append.
+*/
+function cnpjDigits(base) {
+	const first = cnpjDigit(base);
+	return `${first}${cnpjDigit(`${base}${first}`)}`;
+}
+function cnpjDigit(base) {
+	const weights = CNPJ_WEIGHTS.slice(CNPJ_WEIGHTS.length - base.length);
+	let sum = 0;
+	for (let index = 0; index < base.length; index += 1) sum += Number(base[index]) * (weights[index] ?? 0);
+	const rest = sum % 11;
+	return String(rest < 2 ? 0 : 11 - rest);
+}
+//#endregion
+//#region src/faker/brazil.ts
+/** A CPF with correct check digits, formatted `000.000.000-00`. */
+function cpf(rng) {
+	const base = digits(9, rng);
+	const full = `${base}${cpfDigits(base)}`;
+	return `${full.slice(0, 3)}.${full.slice(3, 6)}.${full.slice(6, 9)}-${full.slice(9)}`;
+}
+/** A CNPJ with correct check digits, formatted `00.000.000/0001-00`. */
+function cnpj(rng) {
+	const base = `${digits(8, rng)}0001`;
+	const full = `${base}${cnpjDigits(base)}`;
+	return `${full.slice(0, 2)}.${full.slice(2, 5)}.${full.slice(5, 8)}/${full.slice(8, 12)}-${full.slice(12)}`;
+}
+function cep(rng) {
+	return `${digits(5, rng)}-${digits(3, rng)}`;
+}
+/** A mobile number, `(11) 9XXXX-XXXX`. */
+function phone$1(rng) {
+	return `(${intBetween({
+		min: 11,
+		max: 99,
+		rng
+	})}) 9${digits(4, rng)}-${digits(4, rng)}`;
+}
+/** A Mercosul plate, `ABC1D23`. */
+function plate(rng) {
+	const letters = (count) => chars({
+		count,
+		alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		rng
+	});
+	return `${letters(3)}${digits(1, rng)}${letters(1)}${digits(2, rng)}`;
+}
+function street(rng) {
+	return `${pick(BR_STREET_TYPES, rng)} ${pick(BR_STREET_NAMES, rng)}`;
+}
+function address(rng) {
+	const state = pick(BR_STATES, rng)[1];
+	const number = intBetween({
+		min: 1,
+		max: 4e3,
+		rng
+	});
+	return `${street(rng)}, ${number} — ${pick(BR_CITIES, rng)}/${state}, ${cep(rng)}`;
+}
+const brazilSpecs = [
+	{
+		name: "br.cpf",
+		doc: "A CPF with valid check digits.",
+		result: t.string,
+		make: cpf
+	},
+	{
+		name: "br.cnpj",
+		doc: "A CNPJ with valid check digits.",
+		result: t.string,
+		make: cnpj
+	},
+	{
+		name: "br.cep",
+		doc: "A postal code as `00000-000`.",
+		result: t.string,
+		make: cep
+	},
+	{
+		name: "br.phone",
+		doc: "A Brazilian mobile number.",
+		result: t.string,
+		make: phone$1
+	},
+	{
+		name: "br.plate",
+		doc: "A Mercosul licence plate.",
+		result: t.string,
+		make: plate
+	},
+	{
+		name: "br.street",
+		doc: "A Brazilian street name.",
+		result: t.string,
+		make: street
+	},
+	{
+		name: "br.address",
+		doc: "A full Brazilian address.",
+		result: t.string,
+		make: address
+	},
+	{
+		name: "br.city",
+		doc: "A Brazilian city.",
+		result: t.string,
+		make: (rng) => pick(BR_CITIES, rng)
+	},
+	{
+		name: "br.state",
+		doc: "A Brazilian federal unit, by name.",
+		result: t.string,
+		make: (rng) => pick(BR_STATES, rng)[0]
+	},
+	{
+		name: "br.stateCode",
+		doc: "A Brazilian federal unit, by two-letter code.",
+		result: t.string,
+		make: (rng) => pick(BR_STATES, rng)[1]
+	}
+];
+//#endregion
+//#region src/faker/check-digits.ts
+/**
+* The Luhn check digit for a card number.
+*
+* @param base The digits preceding the check digit.
+* @returns One digit. Appending it makes `base` pass the Luhn test.
+*/
+function luhnDigit(base) {
+	let sum = 0;
+	let double = true;
+	for (let index = base.length - 1; index >= 0; index -= 1) {
+		const scaled = Number(base[index]) * (double ? 2 : 1);
+		sum += scaled > 9 ? scaled - 9 : scaled;
+		double = !double;
+	}
+	return String((10 - sum % 10) % 10);
+}
+/**
+* The EAN-13 check digit for the leading 12 digits of a barcode.
+*
+* @param base Exactly 12 digits.
+* @returns The thirteenth digit.
+*/
+function eanDigit(base) {
+	let sum = 0;
+	for (let index = 0; index < base.length; index += 1) sum += Number(base[index]) * (index % 2 === 0 ? 1 : 3);
+	return String((10 - sum % 10) % 10);
+}
+/**
+* The two IBAN check digits: mod-97 over the rearranged, letter-expanded account.
+*
+* @param country The two-letter country code, upper case.
+* @param account The account part, without check digits.
+* @returns Two digits, zero-padded, to be inserted after the country code.
+*/
+function ibanCheck(country, account) {
+	return pad(98 - mod97(`${account}${country}00`.replace(/[A-Z]/g, (letter) => String(letter.charCodeAt(0) - 55))), 2);
+}
+/** Mod 97 digit by digit, because an expanded IBAN overflows `Number`. */
+function mod97(value) {
+	let rest = 0;
+	for (const char of value) rest = (rest * 10 + Number(char)) % 97;
+	return rest;
+}
+//#endregion
+//#region src/faker/commerce.ts
+function productName(rng) {
+	return `${capitalize(pick(ADJECTIVES, rng))} ${pick(MATERIALS, rng)} ${pick(PRODUCTS, rng)}`;
+}
+function sku(rng) {
+	return `${chars({
+		count: 3,
+		alphabet: "ABCDEFGHJKLMNPQRSTUVWXYZ",
+		rng
+	})}-${digits(5, rng)}`;
+}
+/** A 13-digit EAN with a real check digit, so barcode validators accept it. */
+function barcode(rng) {
+	const base = digits(12, rng);
+	return `${base}${eanDigit(base)}`;
+}
+const commerceSpecs = [
+	{
+		name: "product",
+		doc: "A product noun.",
+		result: t.string,
+		make: (rng) => pick(PRODUCTS, rng)
+	},
+	{
+		name: "productName",
+		doc: "A full product name.",
+		result: t.string,
+		make: productName
+	},
+	{
+		name: "sku",
+		doc: "A stock keeping unit.",
+		result: t.string,
+		make: sku
+	},
+	{
+		name: "barcode",
+		doc: "A valid EAN-13 barcode.",
+		result: t.string,
+		make: barcode
+	},
+	{
+		name: "category",
+		doc: "A product category.",
+		result: t.string,
+		make: (rng) => pick(CATEGORIES, rng)
+	},
+	{
+		name: "material",
+		doc: "A material, like `leather`.",
+		result: t.string,
+		make: (rng) => pick(MATERIALS, rng)
+	},
+	{
+		name: "color",
+		doc: "A colour name.",
+		result: t.string,
+		make: (rng) => pick(COLORS, rng)[0]
+	},
+	{
+		name: "hexColor",
+		doc: "A colour as a hex triplet, like `#1e88e5`.",
+		result: t.string,
+		make: (rng) => pick(COLORS, rng)[1]
+	},
+	{
+		name: "price",
+		doc: "A retail price with two decimal places.",
+		result: t.number,
+		make: (rng) => floatBetween({
+			min: 5,
+			max: 500,
+			decimals: 2,
+			rng
+		})
+	}
+];
+//#endregion
+//#region src/faker/company.ts
+function company(rng) {
+	return `${pick(COMPANY_ROOTS, rng)} ${pick(COMPANY_SUFFIXES, rng)}`;
+}
+function catchPhrase(rng) {
+	return `${capitalize(pick(CATCH_VERBS, rng))} your ${pick(BUZZWORDS, rng)}`;
+}
+const companySpecs = [
+	{
+		name: "company",
+		doc: "A company name.",
+		result: t.string,
+		make: company
+	},
+	{
+		name: "department",
+		doc: "A department name.",
+		result: t.string,
+		make: (rng) => pick(DEPARTMENTS, rng)
+	},
+	{
+		name: "catchPhrase",
+		doc: "A marketing catch phrase.",
+		result: t.string,
+		make: catchPhrase
+	},
+	{
+		name: "buzzword",
+		doc: "A single piece of business jargon.",
+		result: t.string,
+		make: (rng) => pick(BUZZWORDS, rng)
+	}
+];
+//#endregion
+//#region src/faker/datetime.ts
+/**
+* The instant every generated date is measured from.
+*
+* Dates hang off a fixed anchor rather than the wall clock: `Date.now()` would
+* give a different answer on every run and break the seeded replay guarantee.
+*/
+const ANCHOR = Date.UTC(2025, 0, 1);
+const DAY = 864e5;
+const YEAR = 365 * DAY;
+const WEEKDAYS = [
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday",
+	"Sunday"
+];
+const MONTHS = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+];
+function offsetFrom(args) {
+	return ANCHOR + intBetween({
+		min: args.min,
+		max: args.max,
+		rng: args.rng
+	});
+}
+/** `YYYY-MM-DD` within five years either side of the anchor. */
+function isoDate(rng) {
+	const at = offsetFrom({
+		rng,
+		min: -5 * YEAR,
+		max: 5 * YEAR
+	});
+	return new Date(at).toISOString().slice(0, 10);
+}
+function isoDateTime(rng) {
+	return new Date(offsetFrom({
+		rng,
+		min: -5 * YEAR,
+		max: 5 * YEAR
+	})).toISOString();
+}
+function pastDate(rng) {
+	return new Date(offsetFrom({
+		rng,
+		min: -5 * YEAR,
+		max: -864e5
+	})).toISOString();
+}
+function futureDate(rng) {
+	return new Date(offsetFrom({
+		rng,
+		min: DAY,
+		max: 5 * YEAR
+	})).toISOString();
+}
+/** `HH:MM:SS` on a 24-hour clock. */
+function time(rng) {
+	const part = (max) => pad(intBetween({
+		min: 0,
+		max,
+		rng
+	}), 2);
+	return `${part(23)}:${part(59)}:${part(59)}`;
+}
+/** Seconds since the epoch, the unit `exp` and `iat` claims use. */
+function timestamp(rng) {
+	return Math.floor(offsetFrom({
+		rng,
+		min: -5 * YEAR,
+		max: 5 * YEAR
+	}) / 1e3);
+}
+const datetimeSpecs = [
+	{
+		name: "date",
+		doc: "A date as `YYYY-MM-DD`.",
+		result: t.string,
+		make: isoDate
+	},
+	{
+		name: "dateTime",
+		doc: "An ISO 8601 instant.",
+		result: t.string,
+		make: isoDateTime
+	},
+	{
+		name: "pastDate",
+		doc: "An ISO 8601 instant before the anchor.",
+		result: t.string,
+		make: pastDate
+	},
+	{
+		name: "futureDate",
+		doc: "An ISO 8601 instant after the anchor.",
+		result: t.string,
+		make: futureDate
+	},
+	{
+		name: "time",
+		doc: "A time of day as `HH:MM:SS`.",
+		result: t.string,
+		make: time
+	},
+	{
+		name: "timestamp",
+		doc: "Seconds since the Unix epoch.",
+		result: t.number,
+		make: timestamp
+	},
+	{
+		name: "weekday",
+		doc: "A day of the week.",
+		result: t.string,
+		make: (rng) => pick(WEEKDAYS, rng)
+	},
+	{
+		name: "month",
+		doc: "A month name.",
+		result: t.string,
+		make: (rng) => pick(MONTHS, rng)
+	},
+	{
+		name: "year",
+		doc: "A year. `faker.year(2000, 2030)` bounds it.",
+		result: t.number,
+		args: [optionalArg("from", t.number, "The earliest year, included."), optionalArg("to", t.number, "The latest year, included.")],
+		make: (rng, args) => intBetween({
+			min: numArg(args, 0, 1980),
+			max: numArg(args, 1, 2030),
+			rng
+		})
+	}
+];
+//#endregion
+//#region src/faker/finance.ts
+/** A 16-digit card number that passes Luhn, grouped `#### #### #### ####`. */
+function creditCard(rng) {
+	const [, prefix, length] = pick(CARD_BRANDS, rng);
+	const base = `${prefix}${digits(length - prefix.length - 1, rng)}`;
+	return (`${base}${luhnDigit(base)}`.match(/.{1,4}/g) ?? []).join(" ");
+}
+function expiryDate(rng) {
+	return `${pad(intBetween({
+		min: 1,
+		max: 12,
+		rng
+	}), 2)}/${intBetween({
+		min: 26,
+		max: 34,
+		rng
+	})}`;
+}
+/** An IBAN with correct mod-97 check digits. */
+function iban(rng) {
+	const country = "DE";
+	const account = digits(18, rng);
+	return `${country}${ibanCheck(country, account)}${account}`;
+}
+function bic(rng) {
+	const letters = (count) => chars({
+		count,
+		alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+		rng
+	});
+	return `${letters(4)}${letters(2)}${letters(2)}`;
+}
+const financeSpecs = [
+	{
+		name: "creditCard",
+		doc: "A 16-digit card number that passes the Luhn check.",
+		result: t.string,
+		make: creditCard
+	},
+	{
+		name: "cardType",
+		doc: "A card brand, like `Visa`.",
+		result: t.string,
+		make: (rng) => pick(CARD_BRANDS, rng)[0]
+	},
+	{
+		name: "cvv",
+		doc: "A three-digit card security code.",
+		result: t.string,
+		make: (rng) => digits(3, rng)
+	},
+	{
+		name: "expiryDate",
+		doc: "A card expiry as `MM/YY`.",
+		result: t.string,
+		make: expiryDate
+	},
+	{
+		name: "iban",
+		doc: "An IBAN with valid check digits.",
+		result: t.string,
+		make: iban
+	},
+	{
+		name: "bic",
+		doc: "A SWIFT/BIC code.",
+		result: t.string,
+		make: bic
+	},
+	{
+		name: "accountNumber",
+		doc: "A bank account number.",
+		result: t.string,
+		make: (rng) => digits(10, rng)
+	},
+	{
+		name: "currencyCode",
+		doc: "An ISO 4217 currency code, like `BRL`.",
+		result: t.string,
+		make: (rng) => pick(CURRENCIES, rng)[0]
+	},
+	{
+		name: "currencySymbol",
+		doc: "A currency symbol, like `R$`.",
+		result: t.string,
+		make: (rng) => pick(CURRENCIES, rng)[1]
+	},
+	{
+		name: "currencyName",
+		doc: "A currency name, like `Brazilian Real`.",
+		result: t.string,
+		make: (rng) => pick(CURRENCIES, rng)[2]
+	},
+	{
+		name: "amount",
+		doc: "A monetary amount with two decimal places.",
+		result: t.number,
+		make: (rng) => floatBetween({
+			min: 1,
+			max: 1e4,
+			decimals: 2,
+			rng
+		})
+	}
+];
+//#endregion
+//#region src/faker/ids.ts
+/** An RFC 4122 v4 UUID. The version and variant bits are stamped, not drawn. */
+function uuid(rng) {
+	const hex = (count) => chars({
+		count,
+		alphabet: HEX,
+		rng
+	});
+	const variant = "89ab".charAt(Math.floor(rng() * 4));
+	return `${hex(8)}-${hex(4)}-4${hex(3)}-${variant}${hex(3)}-${hex(12)}`;
+}
+const NANO_ALPHABET = `${ALNUM}_-`;
+const idSpecs = [
+	{
+		name: "uuid",
+		doc: "A v4 UUID.",
+		result: t.string,
+		make: uuid
+	},
+	{
+		name: "nanoid",
+		doc: "A 21-character NanoID. `faker.nanoid(10)` sets the length.",
+		result: t.string,
+		args: [optionalArg("length", t.number, "How many characters. 21 by default.")],
+		make: (rng, args) => chars({
+			count: numArg(args, 0, 21),
+			alphabet: NANO_ALPHABET,
+			rng
+		})
+	},
+	{
+		name: "objectId",
+		doc: "A 24-character MongoDB ObjectId.",
+		result: t.string,
+		make: (rng) => chars({
+			count: 24,
+			alphabet: HEX,
+			rng
+		})
+	},
+	{
+		name: "hex",
+		doc: "Hex characters. `faker.hex(32)` sets how many.",
+		result: t.string,
+		args: [optionalArg("length", t.number, "How many characters.")],
+		make: (rng, args) => chars({
+			count: numArg(args, 0, 16),
+			alphabet: HEX,
+			rng
+		})
+	},
+	{
+		name: "token",
+		doc: "A 32-character opaque token.",
+		result: t.string,
+		make: (rng) => chars({
+			count: 32,
+			alphabet: ALNUM,
+			rng
+		})
+	},
+	{
+		name: "alphanumeric",
+		doc: "Letters and digits. `faker.alphanumeric(8)` sets how many.",
+		result: t.string,
+		args: [optionalArg("length", t.number, "How many characters.")],
+		make: (rng, args) => chars({
+			count: numArg(args, 0, 8),
+			alphabet: ALNUM,
+			rng
+		})
+	},
+	{
+		name: "digits",
+		doc: "Decimal digits. `faker.digits(6)` sets how many.",
+		result: t.string,
+		args: [optionalArg("length", t.number, "How many digits.")],
+		make: (rng, args) => digits(numArg(args, 0, 6), rng)
+	},
+	{
+		name: "int",
+		doc: "An integer. `faker.int(1, 10)` bounds it, inclusive.",
+		result: t.number,
+		args: [optionalArg("min", t.number, "The lowest it may be, included."), optionalArg("max", t.number, "The highest it may be, included.")],
+		make: (rng, args) => intBetween({
+			min: numArg(args, 0, 0),
+			max: numArg(args, 1, 100),
+			rng
+		})
+	},
+	{
+		name: "float",
+		doc: "A number with two decimals. `faker.float(0, 1)` bounds it.",
+		result: t.number,
+		args: [optionalArg("min", t.number, "The lowest it may be."), optionalArg("max", t.number, "The highest it may be.")],
+		make: (rng, args) => floatBetween({
+			min: numArg(args, 0, 0),
+			max: numArg(args, 1, 1),
+			decimals: 2,
+			rng
+		})
+	},
+	{
+		name: "boolean",
+		doc: "`true` or `false`.",
+		result: t.bool,
+		make: (rng) => rng() < .5
+	}
+];
+//#endregion
+//#region src/faker/person.ts
+/** A given name, e.g. `"Grace"`. */
+function firstName(rng) {
+	return pick(FIRST_NAMES, rng);
+}
+/** A family name, e.g. `"Hopper"`. */
+function lastName(rng) {
+	return pick(LAST_NAMES, rng);
+}
+/** A full name, e.g. `"Grace Hopper"`. */
+function fullName(rng) {
+	return `${firstName(rng)} ${lastName(rng)}`;
+}
+function birthDate(rng) {
+	const year = intBetween({
+		min: 1950,
+		max: 2006,
+		rng
+	});
+	const month = intBetween({
+		min: 1,
+		max: 12,
+		rng
+	});
+	const day = intBetween({
+		min: 1,
+		max: 28,
+		rng
+	});
+	return `${year}-${pad(month, 2)}-${pad(day, 2)}`;
+}
+/** `+1 555 01xx`, the range reserved for fiction, so it can never reach anyone. */
+function phone(rng) {
+	return `+1 555 01${digits(2, rng)}`;
+}
+const personSpecs = [
+	{
+		name: "firstName",
+		doc: "A given name.",
+		result: t.string,
+		make: firstName
+	},
+	{
+		name: "lastName",
+		doc: "A family name.",
+		result: t.string,
+		make: lastName
+	},
+	{
+		name: "name",
+		doc: "A full name.",
+		result: t.string,
+		make: fullName
+	},
+	{
+		name: "fullName",
+		doc: "A full name.",
+		result: t.string,
+		make: fullName
+	},
+	{
+		name: "prefix",
+		doc: "An honorific that precedes a name, like `Dra.`.",
+		result: t.string,
+		make: (rng) => pick(NAME_PREFIXES, rng)
+	},
+	{
+		name: "suffix",
+		doc: "A generational suffix that follows a name, like `Neto`.",
+		result: t.string,
+		make: (rng) => pick(NAME_SUFFIXES, rng)
+	},
+	{
+		name: "gender",
+		doc: "A gender value shaped the way most forms model them.",
+		result: t.string,
+		make: (rng) => pick(GENDERS, rng)
+	},
+	{
+		name: "jobTitle",
+		doc: "A job title, like `Site Reliability Engineer`.",
+		result: t.string,
+		make: (rng) => pick(JOB_TITLES, rng)
+	},
+	{
+		name: "age",
+		doc: "An adult age, between 18 and 80.",
+		result: t.number,
+		make: (rng) => intBetween({
+			min: 18,
+			max: 80,
+			rng
+		})
+	},
+	{
+		name: "birthDate",
+		doc: "A birth date as `YYYY-MM-DD`.",
+		result: t.string,
+		make: birthDate
+	},
+	{
+		name: "phone",
+		doc: "An international phone number in the range reserved for fiction.",
+		result: t.string,
+		make: phone
+	}
+];
+//#endregion
+//#region src/faker/internet.ts
+/** An email on a reserved domain, e.g. `"grace.hopper@example.test"`. It reaches nobody. */
+function email(rng) {
+	return `${`${slug(firstName(rng))}.${slug(lastName(rng))}`}@${pick(SAFE_DOMAINS, rng)}`;
+}
+function username(rng) {
+	return `${slug(firstName(rng))}${intBetween({
+		min: 1,
+		max: 99,
+		rng
+	})}`;
+}
+function password(rng) {
+	return chars({
+		count: 14,
+		alphabet: `${ALNUM}!@#$%&*?`,
+		rng
+	});
+}
+function domain(rng) {
+	return `${pick(ADJECTIVES, rng)}${pick(NOUNS, rng)}.${pick(TLDS, rng)}`;
+}
+function url(rng) {
+	return `${pick(PROTOCOLS, rng)}://${domain(rng)}/${pick(NOUNS, rng)}`;
+}
+function ipv4(rng) {
+	const octet = () => intBetween({
+		min: 1,
+		max: 254,
+		rng
+	});
+	return `${octet()}.${octet()}.${octet()}.${octet()}`;
+}
+function ipv6(rng) {
+	const group = () => chars({
+		count: 4,
+		alphabet: HEX,
+		rng
+	});
+	return Array.from({ length: 8 }, group).join(":");
+}
+function mac(rng) {
+	const pair = () => chars({
+		count: 2,
+		alphabet: HEX,
+		rng
+	}).toUpperCase();
+	return Array.from({ length: 6 }, pair).join(":");
+}
+const internetSpecs = [
+	{
+		name: "email",
+		doc: "An email address on a reserved domain.",
+		result: t.string,
+		make: email
+	},
+	{
+		name: "username",
+		doc: "A login name.",
+		result: t.string,
+		make: username
+	},
+	{
+		name: "password",
+		doc: "A 14-character password.",
+		result: t.string,
+		make: password
+	},
+	{
+		name: "domain",
+		doc: "A domain name.",
+		result: t.string,
+		make: domain
+	},
+	{
+		name: "url",
+		doc: "An absolute URL.",
+		result: t.string,
+		make: url
+	},
+	{
+		name: "ipv4",
+		doc: "An IPv4 address.",
+		result: t.string,
+		make: ipv4
+	},
+	{
+		name: "ipv6",
+		doc: "An IPv6 address.",
+		result: t.string,
+		make: ipv6
+	},
+	{
+		name: "mac",
+		doc: "A MAC address.",
+		result: t.string,
+		make: mac
+	},
+	{
+		name: "port",
+		doc: "An unprivileged TCP port.",
+		result: t.number,
+		make: (rng) => intBetween({
+			min: 1024,
+			max: 65535,
+			rng
+		})
+	},
+	{
+		name: "userAgent",
+		doc: "A browser User-Agent string.",
+		result: t.string,
+		make: (rng) => pick(USER_AGENTS, rng)
+	},
+	{
+		name: "slug",
+		doc: "A URL slug, like `bright-harbour-417`.",
+		result: t.string,
+		make: (rng) => `${pick(ADJECTIVES, rng)}-${pick(NOUNS, rng)}-${digits(3, rng)}`
+	},
+	{
+		name: "httpMethod",
+		doc: "An HTTP verb.",
+		result: t.string,
+		make: (rng) => pick(HTTP_METHODS, rng)
+	},
+	{
+		name: "httpStatus",
+		doc: "An HTTP status code that servers really return.",
+		result: t.number,
+		make: (rng) => pick(HTTP_STATUSES, rng)
+	},
+	{
+		name: "mimeType",
+		doc: "A MIME type.",
+		result: t.string,
+		make: (rng) => pick(MIME_TYPES, rng)
+	}
+];
+//#endregion
+//#region src/faker/text.ts
+function words(rng, count) {
+	return times(count, () => pick(LOREM, rng)).join(" ");
+}
+/** A capitalised sentence of 6 to 14 words, ending in a full stop. */
+function sentence(rng) {
+	return `${capitalize(words(rng, intBetween({
+		min: 6,
+		max: 14,
+		rng
+	})))}.`;
+}
+function sentences(rng, count) {
+	return times(count, () => sentence(rng)).join(" ");
+}
+function paragraph(rng) {
+	return sentences(rng, intBetween({
+		min: 3,
+		max: 6,
+		rng
+	}));
+}
+/** A headline in title case, e.g. `"Bright Harbour"`. */
+function title(rng) {
+	return `${capitalize(pick(ADJECTIVES, rng))} ${capitalize(pick(NOUNS, rng))}`;
+}
+const textSpecs = [
+	{
+		name: "word",
+		doc: "A single word.",
+		result: t.string,
+		make: (rng) => pick(LOREM, rng)
+	},
+	{
+		name: "words",
+		doc: "Several words. `faker.words(5)` sets how many.",
+		result: t.string,
+		args: [optionalArg("count", t.number, "How many words.")],
+		make: (rng, args) => words(rng, numArg(args, 0, 3))
+	},
+	{
+		name: "sentence",
+		doc: "One sentence.",
+		result: t.string,
+		make: sentence
+	},
+	{
+		name: "sentences",
+		doc: "Several sentences. `faker.sentences(3)` sets how many.",
+		result: t.string,
+		args: [optionalArg("count", t.number, "How many sentences.")],
+		make: (rng, args) => sentences(rng, numArg(args, 0, 3))
+	},
+	{
+		name: "paragraph",
+		doc: "One paragraph.",
+		result: t.string,
+		make: paragraph
+	},
+	{
+		name: "paragraphs",
+		doc: "Several paragraphs, separated by blank lines. `faker.paragraphs(4)` sets how many.",
+		result: t.string,
+		args: [optionalArg("count", t.number, "How many paragraphs.")],
+		make: (rng, args) => times(numArg(args, 0, 2), () => paragraph(rng)).join("\n\n")
+	},
+	{
+		name: "title",
+		doc: "A short headline in title case.",
+		result: t.string,
+		make: title
+	}
+];
+//#endregion
+//#region src/faker/all-specs.ts
+/** Every `data.faker.*` verb. Adding a whole category is one line here. */
+const allFakerSpecs = [
+	...personSpecs,
+	...internetSpecs,
+	...addressSpecs,
+	...companySpecs,
+	...commerceSpecs,
+	...financeSpecs,
+	...datetimeSpecs,
+	...textSpecs,
+	...idSpecs,
+	...brazilSpecs
+];
+//#endregion
+//#region src/rng/mulberry32.ts
+/**
+* Mulberry32: a tiny, fast, fully deterministic PRNG.
+*
+* @param seed Any number. It is coerced to a uint32, so the same seed always
+* yields the same stream.
+* @returns A generator producing the next float in [0, 1) on each call.
+*/
+function mulberry32(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 | 0;
+		let t = Math.imul(state ^ state >>> 15, 1 | state);
+		t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+//#endregion
+//#region src/rng/shared-rng.ts
+/** The fixed seed. A constant seed is what makes every generated value reproducible. */
+const SEED = 1;
+let shared = mulberry32(SEED);
+/** The module-level deterministic PRNG shared by every generator in this package. */
+const rng = () => shared();
+/** Reset the shared PRNG to its seed so the same stream can be drawn again. Used by tests. */
+function resetRng() {
+	shared = mulberry32(SEED);
+}
+//#endregion
+//#region src/rng/shuffle.ts
+/**
+* Fisher-Yates shuffle driven by the given PRNG.
+*
+* @returns A new array holding the same elements in a new order. `items` is untouched.
+*/
+function shuffleWith(items, rng) {
+	const out = [...items];
+	for (let i = out.length - 1; i > 0; i -= 1) {
+		const j = Math.floor(rng() * (i + 1));
+		const tmp = out[i];
+		out[i] = out[j];
+		out[j] = tmp;
+	}
+	return out;
+}
+//#endregion
+//#region src/actions/faker-actions.ts
+/** Turn one spec into the `data.faker.<name>` verb, drawn from the shared PRNG. */
+function toAction(spec) {
+	return defineAction({
+		name: `faker.${spec.name}`,
+		doc: spec.doc,
+		args: spec.args,
+		result: spec.result,
+		run: (_ctx, input) => spec.make(rng, input.args)
+	});
+}
+/**
+* The `data.faker.*` verbs. Every value is deterministic under the shared seed,
+* so a failing run replays exactly. The catalogue itself lives in `faker/`.
+*/
+const fakerActions = allFakerSpecs.map(toAction);
+//#endregion
+//#region src/csv/parse-csv.ts
+/**
+* Parse a CSV string into row objects. The first line supplies the headers.
+*
+* A minimal splitter: it takes inline content only (never a path) and does not
+* understand quoting, so a quoted cell containing a comma splits in two.
+*
+* @param content The CSV text. Blank lines are skipped.
+* @returns One object per data line, keyed by header. Empty when there is no header line.
+*/
+function parseCsv(content) {
+	const [header, ...rows] = content.split(/\r?\n/).filter((line) => line.trim() !== "");
+	if (header === void 0) return [];
+	const headers = splitLine(header);
+	return rows.map((row) => toRow(headers, splitLine(row)));
+}
+function splitLine(line) {
+	return line.split(",").map((cell) => cell.trim());
+}
+function toRow(headers, cells) {
+	const row = {};
+	headers.forEach((key, index) => {
+		row[key] = cells[index] ?? "";
+	});
+	return row;
+}
+//#endregion
+//#region src/actions/parse-actions.ts
+/**
+* `data.csv(text)`: parse an inline CSV string into a list of `data.Row`.
+*
+* The first line names the columns. Every cell arrives as a string.
+*/
+const csv = defineAction({
+	name: "csv",
+	doc: "Parse an inline CSV string into an array of row objects (first line = headers).",
+	args: [arg("text", t.string, "The CSV itself. Its first line names the columns.")],
+	result: t.list(t.ref("data.Row")),
+	run: (_ctx, input) => parseCsv(String(input.args[0] ?? ""))
+});
+/**
+* `data.json(text)`: parse a JSON string into a value.
+*
+* Throws whatever `JSON.parse` throws when the text is not valid JSON.
+*/
+const json = defineAction({
+	name: "json",
+	doc: "Parse a JSON string into a value.",
+	args: [arg("text", t.string, "The JSON to read.")],
+	result: t.dynamic,
+	run: (_ctx, input) => JSON.parse(String(input.args[0] ?? "null"))
+});
+//#endregion
+//#region src/actions/random-actions.ts
+/** `data.oneOf("free", "pro")`: pick one of the given values via the shared PRNG. */
+const oneOf = defineAction({
+	name: "oneOf",
+	doc: "Pick one of the given values deterministically.",
+	args: [restArg("choices", t.dynamic, "The candidates. One of them comes back.")],
+	result: t.dynamic,
+	run: (_ctx, input) => input.args[Math.floor(rng() * input.args.length)]
+});
+/** `data.range(1, 10)`: a deterministic integer in the inclusive range [min, max]. */
+const range = defineAction({
+	name: "range",
+	doc: "A deterministic integer within the inclusive range [min, max].",
+	args: [arg("min", t.number, "The lowest it may be, included."), arg("max", t.number, "The highest it may be, included.")],
+	result: t.number,
+	run: (_ctx, input) => integerInRange(input)
+});
+function integerInRange(input) {
+	const min = Math.trunc(Number(input.args[0] ?? 0));
+	const max = Math.trunc(Number(input.args[1] ?? 0));
+	return min + Math.floor(rng() * (max - min + 1));
+}
+/** `data.shuffle([1, 2, 3])`: a deterministic permutation of the given array. */
+const shuffle = defineAction({
+	name: "shuffle",
+	doc: "A deterministic shuffle of the given array.",
+	args: [arg("values", t.list(t.dynamic), "What to shuffle. The original is left alone.")],
+	result: t.list(t.dynamic),
+	run: (_ctx, input) => shuffleWith(toArray(input.args[0]), rng)
+});
+function toArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+//#endregion
+//#region src/actions/index.ts
+/** Every verb in the `data` namespace. Adding one is a single line here. */
+const dataActions = [
+	...fakerActions,
+	oneOf,
+	range,
+	shuffle,
+	csv,
+	json
+];
+//#endregion
+//#region src/plugin.ts
+/**
+* The `data` plugin: pure, deterministic test-data generators.
+*
+* Every verb draws from a seeded module-level PRNG, so the same script replays the
+* same values. Nothing here does I/O, so there is no capability and no port to bind.
+*/
+const dataPlugin = definePlugin({
+	name: "venn/data",
+	version: "0.0.0",
+	namespace: "data",
+	actions: dataActions,
+	typeDefs: { 
+	/**
+	* One parsed CSV record. The keys come from the file's header line, so they
+	* cannot be named here. Only the cell type is knowable, and it is always a string.
+	*/
+Row: t.map(t.string) }
+});
+//#endregion
+export { ANCHOR, allFakerSpecs, cnpjDigits, cpfDigits, dataActions, dataPlugin, dataPlugin as default, eanDigit, email, firstName, fullName, ibanCheck, lastName, luhnDigit, mulberry32, parseCsv, resetRng, rng, shuffleWith, uuid };
+
+//# sourceMappingURL=index.js.map