@cosyte/synth 0.0.1

package/dist/index.cjs

@@ -0,0 +1,535 @@
+'use strict';
+
+// src/rng/splitmix32.ts
+function splitmix32(seed) {
+  let a = seed | 0;
+  return function next() {
+    a = a + 2654435769 | 0;
+    let t = a ^ a >>> 16;
+    t = Math.imul(t, 569420461);
+    t = t ^ t >>> 15;
+    t = Math.imul(t, 1935289751);
+    t = t ^ t >>> 15;
+    return t >>> 0;
+  };
+}
+
+// src/rng/sfc32.ts
+function sfc32Next(s) {
+  s.a |= 0;
+  s.b |= 0;
+  s.c |= 0;
+  s.d |= 0;
+  const t = (s.a + s.b | 0) + s.d | 0;
+  s.d = s.d + 1 | 0;
+  s.a = s.b ^ s.b >>> 9;
+  s.b = s.c + (s.c << 3) | 0;
+  s.c = s.c << 21 | s.c >>> 11;
+  s.c = s.c + t | 0;
+  return t >>> 0;
+}
+
+// src/rng/rng.ts
+var Sfc32Rng = class {
+  seed;
+  #state;
+  constructor(seed) {
+    this.seed = seed | 0;
+    const mix = splitmix32(this.seed);
+    this.#state = { a: mix(), b: mix(), c: mix(), d: mix() };
+    for (let i = 0; i < 8; i += 1) sfc32Next(this.#state);
+  }
+  nextUint32() {
+    return sfc32Next(this.#state);
+  }
+  float() {
+    return this.nextUint32() / 4294967296;
+  }
+  int(min, max) {
+    if (max < min) throw new RangeError(`Rng.int: max (${String(max)}) < min (${String(min)})`);
+    const span = max - min + 1;
+    return min + Math.floor(this.float() * span);
+  }
+  bool(p = 0.5) {
+    return this.float() < p;
+  }
+  pick(items) {
+    if (items.length === 0) throw new RangeError("Rng.pick: empty array");
+    return items[this.int(0, items.length - 1)];
+  }
+  digits(n) {
+    let out = "";
+    for (let i = 0; i < n; i += 1) out += String(this.int(0, 9));
+    return out;
+  }
+};
+function createRng(seed) {
+  return new Sfc32Rng(seed);
+}
+
+// src/safe/reserved.ts
+var SYNTHETIC_ASSIGNING_AUTHORITY = Object.freeze({
+  /** The human-readable assigning-authority namespace id (HL7 HD.1). */
+  namespaceId: "COSYTE-SYNTH",
+  /** The universal id — an OID under HL7's example arc `2.16.840.1.113883.19` (HD.2). */
+  universalId: "2.16.840.1.113883.19.999",
+  /** The universal id type (HD.3). */
+  universalIdType: "ISO"
+});
+var RESERVED_EMAIL_DOMAINS = Object.freeze([
+  "example.com",
+  "example.org",
+  "example.net"
+]);
+var TEST_NET_V4_PREFIXES = Object.freeze([
+  "192.0.2",
+  // TEST-NET-1
+  "198.51.100",
+  // TEST-NET-2
+  "203.0.113"
+  // TEST-NET-3
+]);
+var DOC_V6_PREFIX = "2001:db8";
+var NPI_LUHN_PREFIX = "80840";
+function luhnMod10(digits) {
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    let d = digits.charCodeAt(i) - 48;
+    if (d < 0 || d > 9) continue;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10;
+}
+function npiCheckDigit(base9) {
+  const partial = luhnMod10(`${NPI_LUHN_PREFIX}${base9}0`);
+  return (10 - partial) % 10;
+}
+var DEA_REGISTRANT_TYPES = Object.freeze([
+  "A",
+  "B",
+  "F",
+  "G",
+  "M",
+  "P",
+  "R",
+  "X"
+]);
+function deaCheckDigit(base6) {
+  let odd = 0;
+  let even = 0;
+  for (let i = 0; i < 6; i += 1) {
+    const digit = base6.charCodeAt(i) - 48;
+    if (i % 2 === 0) odd += digit;
+    else even += digit;
+  }
+  return (odd + 2 * even) % 10;
+}
+function isSyntheticDea(value) {
+  const compact = value.replace(/[\s-]/g, "").toUpperCase();
+  if (!/^[A-Z]{2}\d{7}$/.test(compact)) return false;
+  const digits = compact.slice(2);
+  const check = digits.charCodeAt(6) - 48;
+  return deaCheckDigit(digits.slice(0, 6)) !== check;
+}
+function isSyntheticNpi(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 10) return false;
+  return luhnMod10(`${NPI_LUHN_PREFIX}${digits}`) !== 0;
+}
+function isSyntheticSsn(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 9) return false;
+  const area = Number(digits.slice(0, 3));
+  return area === 0 || area === 666 || area >= 900;
+}
+function isSyntheticPhone(value) {
+  const digits = value.replace(/\D/g, "");
+  const tail = digits.slice(-7);
+  return /^555 ?01\d\d$/.test(tail) || /^55501\d\d$/.test(tail);
+}
+function isSyntheticEmail(value) {
+  const at = value.lastIndexOf("@");
+  if (at < 0) return false;
+  const domain = value.slice(at + 1).toLowerCase();
+  if (RESERVED_EMAIL_DOMAINS.includes(domain)) return true;
+  return /\.(example|test|invalid|localhost)$/.test(domain);
+}
+function isSyntheticIp(value) {
+  if (value.toLowerCase().startsWith(`${DOC_V6_PREFIX}:`)) return true;
+  return TEST_NET_V4_PREFIXES.some((prefix) => value.startsWith(`${prefix}.`));
+}
+
+// src/safe/names-pool.ts
+var SYNTHETIC_GIVEN_NAMES = Object.freeze([
+  "Testina",
+  "Fixtura",
+  "Synthos",
+  "Placeholda",
+  "Sampleton",
+  "Prototius",
+  "Stubbina",
+  "Exampla",
+  "Quilliam",
+  "Fabrica",
+  "Simula",
+  "Testry",
+  "Seedwin",
+  "Corpora",
+  "Reprodo",
+  "Mocktavia",
+  "Dummett",
+  "Voidwin",
+  "Deteria",
+  "Randomir"
+]);
+var SYNTHETIC_FAMILY_NAMES = Object.freeze([
+  "Testerson",
+  "Fauxman",
+  "Placeholt",
+  "Mockridge",
+  "Fixtingham",
+  "Synthwell",
+  "Dummerton",
+  "Examplewood",
+  "Fabricant",
+  "Simulacre",
+  "Nonesuch",
+  "Seedman",
+  "Corpusworth",
+  "Reprodus",
+  "Voidmark",
+  "Deterwood",
+  "Randomson",
+  "Quillfeather",
+  "Notreal",
+  "Genfield"
+]);
+var SYNTHETIC_STREET_NAMES = Object.freeze([
+  "Fixture Lane",
+  "Sample Street",
+  "Placeholder Avenue",
+  "Synthetic Way",
+  "Example Boulevard",
+  "Testing Terrace",
+  "Mock Road",
+  "Prototype Court"
+]);
+var SYNTHETIC_CITY_NAMES = Object.freeze([
+  "Faketon",
+  "Synthville",
+  "Exampleburg",
+  "Testford",
+  "Mockhaven",
+  "Fixtureton"
+]);
+
+// src/safe/providers.ts
+function ssn(rng, block = "never-issued") {
+  if (block === "advertising") {
+    return `987-65-432${String(rng.int(0, 9))}`;
+  }
+  const area = rng.int(900, 999);
+  const group = rng.digits(2);
+  const serial = rng.digits(4);
+  return `${String(area)}-${group}-${serial}`;
+}
+function phone(rng) {
+  const area = `${String(rng.int(2, 9))}${rng.digits(2)}`;
+  const line = `01${rng.digits(2)}`;
+  return `(${area}) 555-${line}`;
+}
+function name(rng) {
+  return { given: rng.pick(SYNTHETIC_GIVEN_NAMES), family: rng.pick(SYNTHETIC_FAMILY_NAMES) };
+}
+function email(rng, person) {
+  const domain = rng.pick(RESERVED_EMAIL_DOMAINS);
+  const slug = person ? `${person.given}.${person.family}`.toLowerCase() : `synth${rng.digits(6)}`;
+  return `${slug}@${domain}`;
+}
+function ipv4(rng) {
+  return `${rng.pick(TEST_NET_V4_PREFIXES)}.${String(rng.int(1, 254))}`;
+}
+function ipv6(rng) {
+  const tail = rng.nextUint32().toString(16).padStart(4, "0").slice(-4);
+  return `${DOC_V6_PREFIX}::${tail}`;
+}
+function uuid(rng) {
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i += 1) bytes[i] = rng.int(0, 255);
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+function npi(rng) {
+  const base9 = rng.digits(9);
+  const wrongCheck = (npiCheckDigit(base9) + 1) % 10;
+  return `${base9}${String(wrongCheck)}`;
+}
+function dea(rng, person) {
+  const type = rng.pick(DEA_REGISTRANT_TYPES);
+  const initialSource = person?.family ?? rng.pick(SYNTHETIC_FAMILY_NAMES);
+  const initial = initialSource.slice(0, 1).toUpperCase();
+  const base6 = rng.digits(6);
+  const wrongCheck = (deaCheckDigit(base6) + 1) % 10;
+  return `${type}${initial}${base6}${String(wrongCheck)}`;
+}
+function identifier(rng, typeCode = "MR") {
+  return {
+    value: rng.digits(8),
+    typeCode,
+    assigningAuthority: SYNTHETIC_ASSIGNING_AUTHORITY.namespaceId,
+    assigningAuthorityOid: SYNTHETIC_ASSIGNING_AUTHORITY.universalId
+  };
+}
+function address(rng) {
+  const number = rng.int(1, 9999);
+  return {
+    street: `${String(number)} ${rng.pick(SYNTHETIC_STREET_NAMES)}`,
+    city: rng.pick(SYNTHETIC_CITY_NAMES),
+    state: rng.pick(US_STATES),
+    zip: "00000"
+  };
+}
+function dateYmd(rng, minYear = 1930, maxYear = 2010) {
+  const year = rng.int(minYear, maxYear);
+  const month = rng.int(1, 12);
+  const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+  const day = rng.int(1, daysInMonth);
+  return `${String(year).padStart(4, "0")}${String(month).padStart(2, "0")}${String(day).padStart(2, "0")}`;
+}
+var US_STATES = Object.freeze([
+  "AL",
+  "AK",
+  "AZ",
+  "AR",
+  "CA",
+  "CO",
+  "CT",
+  "DE",
+  "FL",
+  "GA",
+  "HI",
+  "ID",
+  "IL",
+  "IN",
+  "IA",
+  "KS",
+  "KY",
+  "LA",
+  "ME",
+  "MD",
+  "MA",
+  "MI",
+  "MN",
+  "MS",
+  "MO",
+  "MT",
+  "NE",
+  "NV",
+  "NH",
+  "NJ",
+  "NM",
+  "NY",
+  "NC",
+  "ND",
+  "OH",
+  "OK",
+  "OR",
+  "PA",
+  "RI",
+  "SC",
+  "SD",
+  "TN",
+  "TX",
+  "UT",
+  "VT",
+  "VA",
+  "WA",
+  "WV",
+  "WI",
+  "WY"
+]);
+
+// src/safe/index.ts
+var safe = Object.freeze({
+  ssn,
+  phone,
+  name,
+  email,
+  ipv4,
+  ipv6,
+  uuid,
+  identifier,
+  address,
+  dateYmd,
+  npi,
+  dea
+});
+
+// src/corpus.ts
+function makeCorpus(seed, artifacts, quirks = []) {
+  const counts = {};
+  const formats = /* @__PURE__ */ new Set();
+  const frozenArtifacts = artifacts.map((a) => {
+    counts[a.kind] = (counts[a.kind] ?? 0) + 1;
+    formats.add(a.format);
+    return Object.freeze({ ...a, warnings: Object.freeze([...a.warnings]) });
+  });
+  const manifest = Object.freeze({
+    formats: Object.freeze([...formats]),
+    counts: Object.freeze(counts),
+    quirks: Object.freeze([...quirks])
+  });
+  return Object.freeze({
+    seed,
+    manifest,
+    artifacts: Object.freeze(frozenArtifacts)
+  });
+}
+
+// src/profile.ts
+function defineSynthProfile(spec) {
+  if (typeof spec.name !== "string" || spec.name.trim().length === 0) {
+    throw new TypeError("defineSynthProfile: `name` is required and must be a non-empty string.");
+  }
+  return Object.freeze({
+    name: spec.name,
+    ...spec.givenNames ? { givenNames: Object.freeze([...spec.givenNames]) } : {},
+    ...spec.familyNames ? { familyNames: Object.freeze([...spec.familyNames]) } : {},
+    quirks: Object.freeze([...spec.quirks ?? []])
+  });
+}
+
+// src/codes.ts
+var SYNTH_FATAL_CODES = {
+  /**
+   * A format was requested that this build cannot generate through a real parser builder/serializer
+   * (e.g. ASTM before `@cosyte/astm`'s serializer ships). Fatal — never a hand-written byte fallback.
+   */
+  SYNTH_UNSUPPORTED_FORMAT: "SYNTH_UNSUPPORTED_FORMAT",
+  /**
+   * A vendor quirk was requested that the target format's profile system does not support. Fatal —
+   * never a silent no-op and never a fabricated quirk.
+   */
+  SYNTH_UNSUPPORTED_QUIRK: "SYNTH_UNSUPPORTED_QUIRK"
+};
+var SynthError = class extends Error {
+  /** The stable fatal code. */
+  code;
+  /**
+   * @param code - The stable {@link SynthFatalCode}.
+   * @param message - A human-readable detail (never contains PHI — there is none).
+   */
+  constructor(code, message) {
+    super(message);
+    this.name = "SynthError";
+    this.code = code;
+  }
+};
+
+// src/quirk.ts
+var PROFILE_QUIRK_APPLIED = "PROFILE_QUIRK_APPLIED";
+function sameCodeSet(a, b) {
+  if (a.length !== b.length) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of a) counts.set(c, (counts.get(c) ?? 0) + 1);
+  for (const c of b) {
+    const n = counts.get(c);
+    if (n === void 0) return false;
+    if (n === 1) counts.delete(c);
+    else counts.set(c, n - 1);
+  }
+  return counts.size === 0;
+}
+function resolveQuirk(registry, format, name2) {
+  const descriptor = registry[name2];
+  if (descriptor === void 0) {
+    const supported = Object.keys(registry).sort().join(", ");
+    throw new SynthError(
+      SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_QUIRK,
+      `${format}: unsupported quirk "${name2}". The ${format} profile system supports: ${supported}.`
+    );
+  }
+  return descriptor;
+}
+function profileTolerated(disposition, intendedWarnings, warningsUnderProfile) {
+  const stillHasIntended = intendedWarnings.some((c) => warningsUnderProfile.includes(c));
+  switch (disposition) {
+    case "suppressed":
+      return !stillHasIntended;
+    case "rebadged":
+      return !stillHasIntended && warningsUnderProfile.includes(PROFILE_QUIRK_APPLIED);
+    case "bare":
+      return false;
+  }
+}
+function assertIntendedWarnings(quirk, intendedWarnings, bareWarnings) {
+  if (!sameCodeSet(bareWarnings, intendedWarnings)) {
+    throw new Error(
+      `quirk "${quirk}": the intended-warning contract does not hold \u2014 expected exactly [${intendedWarnings.join(", ")}] but a bare parse produced [${bareWarnings.join(", ")}]. Refusing to emit a mislabeled fixture.`
+    );
+  }
+}
+function validateProfileQuirks(profile, registry, format) {
+  for (const name2 of profile.quirks) resolveQuirk(registry, format, name2);
+  return profile.quirks;
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+exports.DEA_REGISTRANT_TYPES = DEA_REGISTRANT_TYPES;
+exports.DOC_V6_PREFIX = DOC_V6_PREFIX;
+exports.NPI_LUHN_PREFIX = NPI_LUHN_PREFIX;
+exports.PROFILE_QUIRK_APPLIED = PROFILE_QUIRK_APPLIED;
+exports.RESERVED_EMAIL_DOMAINS = RESERVED_EMAIL_DOMAINS;
+exports.SYNTHETIC_ASSIGNING_AUTHORITY = SYNTHETIC_ASSIGNING_AUTHORITY;
+exports.SYNTHETIC_CITY_NAMES = SYNTHETIC_CITY_NAMES;
+exports.SYNTHETIC_FAMILY_NAMES = SYNTHETIC_FAMILY_NAMES;
+exports.SYNTHETIC_GIVEN_NAMES = SYNTHETIC_GIVEN_NAMES;
+exports.SYNTHETIC_STREET_NAMES = SYNTHETIC_STREET_NAMES;
+exports.SYNTH_FATAL_CODES = SYNTH_FATAL_CODES;
+exports.SynthError = SynthError;
+exports.TEST_NET_V4_PREFIXES = TEST_NET_V4_PREFIXES;
+exports.VERSION = VERSION;
+exports.address = address;
+exports.assertIntendedWarnings = assertIntendedWarnings;
+exports.createRng = createRng;
+exports.dateYmd = dateYmd;
+exports.dea = dea;
+exports.deaCheckDigit = deaCheckDigit;
+exports.defineSynthProfile = defineSynthProfile;
+exports.email = email;
+exports.identifier = identifier;
+exports.ipv4 = ipv4;
+exports.ipv6 = ipv6;
+exports.isSyntheticDea = isSyntheticDea;
+exports.isSyntheticEmail = isSyntheticEmail;
+exports.isSyntheticIp = isSyntheticIp;
+exports.isSyntheticNpi = isSyntheticNpi;
+exports.isSyntheticPhone = isSyntheticPhone;
+exports.isSyntheticSsn = isSyntheticSsn;
+exports.luhnMod10 = luhnMod10;
+exports.makeCorpus = makeCorpus;
+exports.name = name;
+exports.npi = npi;
+exports.npiCheckDigit = npiCheckDigit;
+exports.phone = phone;
+exports.profileTolerated = profileTolerated;
+exports.resolveQuirk = resolveQuirk;
+exports.safe = safe;
+exports.sameCodeSet = sameCodeSet;
+exports.sfc32Next = sfc32Next;
+exports.splitmix32 = splitmix32;
+exports.ssn = ssn;
+exports.uuid = uuid;
+exports.validateProfileQuirks = validateProfileQuirks;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map