@mionjs/run-types 0.8.10 → 0.13.0

package/dist/mion-pure-fns/@mionjs/run-types/qMsNYN8hy_sC8i.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FqMsNYN8hy_sC8i=[2,,,'@mionjs/run-types#pf_qMsNYN8hy_sC8i',[],'const MINUTES_PER_DAY = 1440;\n  // -1 when either character is not an ASCII digit, the value otherwise.\n  function twoDigitsVal(s, at) {\n    const tens = s.charCodeAt(at) - 48;\n    const ones = s.charCodeAt(at + 1) - 48;\n    if (tens < 0 || tens > 9 || ones < 0 || ones > 9) return -1;\n    return tens * 10 + ones;\n  }\n  return function _is_iso_tz(value) {\n    const len = value.length;\n    if (len < 9) return false;\n    let timeEnd;\n    let offsetMinutes;\n    const last = value.charCodeAt(len - 1);\n    if (last === 90 || last === 122) {\n      // \'Z\' / \'z\'\n      timeEnd = len - 1;\n      offsetMinutes = 0;\n    } else {\n      // An offset is always exactly `±HH:MM`, so its sign sits six from the end.\n      const at = len - 6;\n      if (at < 8) return false;\n      const sign = value.charCodeAt(at);\n      if (sign !== 43 && sign !== 45) return false;\n      if (value.charCodeAt(at + 3) !== 58) return false;\n      const offsetHours = twoDigitsVal(value, at + 1);\n      const offsetMins = twoDigitsVal(value, at + 4);\n      if (offsetHours < 0 || offsetHours > 23 || offsetMins < 0 || offsetMins > 59) return false;\n      offsetMinutes = (offsetHours * 60 + offsetMins) * (sign === 45 ? -1 : 1);\n      timeEnd = at;\n    }\n    // The time half: `HH:MM:SS` at 0-8, then an optional `.` + digit fraction.\n    if (timeEnd < 8) return false;\n    if (value.charCodeAt(2) !== 58 || value.charCodeAt(5) !== 58) return false;\n    const hours = twoDigitsVal(value, 0);\n    const mins = twoDigitsVal(value, 3);\n    const secs = twoDigitsVal(value, 6);\n    if (hours < 0 || hours > 23 || mins < 0 || mins > 59 || secs < 0 || secs > 60) return false;\n    if (timeEnd > 8) {\n      if (value.charCodeAt(8) !== 46 || timeEnd === 9) return false;\n      for (let i = 9; i < timeEnd; i++) {\n        const code = value.charCodeAt(i);\n        if (code < 48 || code > 57) return false;\n      }\n    }\n    if (secs !== 60) return true;\n    const utcMinutes = (hours * 60 + mins - offsetMinutes + MINUTES_PER_DAY * 2) % MINUTES_PER_DAY;\n    return utcMinutes === 23 * 60 + 59;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/rXVwGkGDX08BsQ.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FrXVwGkGDX08BsQ=[2,,,'@mionjs/run-types#pf_rXVwGkGDX08BsQ',[],'return function _err(\n    pλth,\n    εrr,\n    expected,\n    accessPath\n  ) {\n    const path = accessPath?.length ? [...pλth, ...accessPath] : [...pλth];\n    const runTypeErr = {expected, path};\n    εrr.push(runTypeErr);\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/rgWveqNi_HeFF8.js

@@ -0,0 +1,5 @@
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F5oCqd7YyfA9rEw} from './5oCqd7YyfA9rEw.js';
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FE29ul2pUOyD_Ay} from './E29ul2pUOyD_Ay.js';
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FGA20s6bj41GC1A} from './GA20s6bj41GC1A.js';
+import {__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FvLId7t0J8HNWlN} from './vLId7t0J8HNWlN.js';
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FrgWveqNi_HeFF8=[2,()=>[__rt_pf$2F$40mionjs$2Frun$2Dtypes$2F5oCqd7YyfA9rEw,__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FE29ul2pUOyD_Ay,__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FGA20s6bj41GC1A,__rt_pf$2F$40mionjs$2Frun$2Dtypes$2FvLId7t0J8HNWlN],,'@mionjs/run-types#pf_rgWveqNi_HeFF8',['utl'],'const punycodeDecodeFn = utl.getPureFn(\'@mionjs/run-types#pf_GA20s6bj41GC1A\');\n  const punycodeEncodeFn = utl.getPureFn(\'@mionjs/run-types#pf_5oCqd7YyfA9rEw\');\n  const isIdnaLabelFn = utl.getPureFn(\'@mionjs/run-types#pf_E29ul2pUOyD_Ay\');\n  const satisfiesBidiFn = utl.getPureFn(\'@mionjs/run-types#pf_vLId7t0J8HNWlN\');\n  // The wide stops are label separators for an internationalized name only.\n  const idnSeparatorRegexp = /[.。．｡]/;\n  const asciiSeparatorRegexp = /[.]/;\n  const asciiLabelRegexp = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;\n  // Matched positively rather than as a negated ASCII range: naming the control characters trips\n  // oxlint no-control-regex, and "is there a character above ASCII" says the same thing.\n  const nonAsciiRegexp = /[\\u0080-\\u{10FFFF}]/u;\n  // Returns the FAILURE MODE rather than a boolean: \'\' when the name is good, \'length\' (whole name or\n  // one label too long, or empty), \'label\' (a label breaks the host-name rules), \'punycode\' (an `xn--`\n  // label does not decode, or is not the canonical spelling of what it decodes to) or \'bidi\' (the\n  // right-to-left rule across the whole name). That feeds the `errorType` of the emitted format error;\n  // validate compares against \'\' and pays nothing for it.\n  return function _is_idn_hostname(value, params) {\n    if (value === \'\' || value.length > 253) return \'length\';\n    const labels = value.split(params.idn ? idnSeparatorRegexp : asciiSeparatorRegexp);\n    const decoded = [];\n    for (const label of labels) {\n      if (label === \'\') return \'label\';\n      if (label.length > 3 && label.slice(0, 4).toLowerCase() === \'xn--\') {\n        if (label.length > 63) return \'length\';\n        const payload = punycodeDecodeFn(label.slice(4));\n        // An A-label must decode, must not decode to something already ASCII,\n        // must be the canonical encoding of what it decodes to, and what it\n        // decodes to must itself be a valid label.\n        if (payload === false || payload === \'\') return \'punycode\';\n        if (!nonAsciiRegexp.test(payload)) return \'punycode\';\n        if (punycodeEncodeFn(payload) !== label.slice(4).toLowerCase()) return \'punycode\';\n        if (!isIdnaLabelFn(payload)) return \'label\';\n        decoded.push(payload);\n        continue;\n      }\n      if (asciiLabelRegexp.test(label)) {\n        decoded.push(label);\n        continue;\n      }\n      if (!params.idn) return \'label\';\n      if (!isIdnaLabelFn(label)) return \'label\';\n      // The 63-octet limit applies to the ENCODED form, so encode to measure.\n      const encoded = punycodeEncodeFn(label);\n      if (encoded === false) return \'label\';\n      if (encoded.length + 4 > 63) return \'length\';\n      decoded.push(label);\n    }\n    return satisfiesBidiFn(decoded) ? \'\' : \'bidi\';\n  };',['@mionjs/run-types#pf_5oCqd7YyfA9rEw','@mionjs/run-types#pf_E29ul2pUOyD_Ay','@mionjs/run-types#pf_GA20s6bj41GC1A','@mionjs/run-types#pf_vLId7t0J8HNWlN']];

package/dist/mion-pure-fns/@mionjs/run-types/s-tZDRlQfCG5m2.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2Fs$2DtZDRlQfCG5m2=[2,,,'@mionjs/run-types#pf_s-tZDRlQfCG5m2',[],'// Parses the ISO-8601 duration tail into years, months, weeks, days, hours, minutes and seconds.\n  function parseDuration(tail) {\n    const out = {years: 0, months: 0, weeks: 0, days: 0, hours: 0, minutes: 0, seconds: 0};\n    const body = tail.substring(1); // drop leading \'P\'\n    const tIdx = body.indexOf(\'T\');\n    const datePart = tIdx === -1 ? body : body.substring(0, tIdx);\n    const timePart = tIdx === -1 ? \'\' : body.substring(tIdx + 1);\n    const eat = (segment, map) => {\n      const re = /(\\d+)([A-Z])/g;\n      let m;\n      while ((m = re.exec(segment)) !== null) {\n        const key = map[m[2]];\n        if (key) out[key] = Number(m[1]);\n      }\n    };\n    eat(datePart, {Y: \'years\', M: \'months\', W: \'weeks\', D: \'days\'});\n    eat(timePart, {H: \'hours\', M: \'minutes\', S: \'seconds\'});\n    return out;\n  }\n  return function _relative_now_key(spec, scale) {\n    const now = new Date();\n    if (scale === \'timeOfDay\') {\n      let ms = now.getUTCHours() * 3600000 + now.getUTCMinutes() * 60000 + now.getUTCSeconds() * 1000 + now.getUTCMilliseconds();\n      if (spec !== \'now\') {\n        const sign = spec[3] === \'-\' ? -1 : 1;\n        const d = parseDuration(spec.substring(4));\n        ms += sign * (d.hours * 3600000 + d.minutes * 60000 + d.seconds * 1000);\n      }\n      return ms;\n    }\n    const result = new Date(now.getTime());\n    if (spec !== \'now\') {\n      const sign = spec[3] === \'-\' ? -1 : 1;\n      const d = parseDuration(spec.substring(4));\n      // Calendar-correct: Y/M via setUTCMonth (handles month length), then W/D and time as fixed offsets.\n      result.setUTCFullYear(result.getUTCFullYear() + sign * d.years);\n      result.setUTCMonth(result.getUTCMonth() + sign * d.months);\n      result.setUTCDate(result.getUTCDate() + sign * (d.weeks * 7 + d.days));\n      result.setTime(result.getTime() + sign * (d.hours * 3600000 + d.minutes * 60000 + d.seconds * 1000));\n    }\n    if (scale === \'epochDate\') {\n      // Floor to UTC midnight, the scale dateStrToMs uses (it builds dates at 00:00:00Z).\n      return Date.UTC(result.getUTCFullYear(), result.getUTCMonth(), result.getUTCDate(), 0, 0, 0, 0);\n    }\n    return result.getTime();\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/t-ntJ9S0FuxkC2.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2Ft$2DntJ9S0FuxkC2=[2,,,'@mionjs/run-types#pf_t-ntJ9S0FuxkC2',[],'return function _time_to_ms(value, layout) {\n    let body = value;\n    if (layout === \'ISO\' || layout === \'HH:mm:ss[.mmm]TZ\') {\n      if (body.endsWith(\'Z\') || body.endsWith(\'z\')) {\n        body = body.substring(0, body.length - 1);\n      } else {\n        const plus = body.indexOf(\'+\');\n        const minus = body.lastIndexOf(\'-\');\n        const cut = plus !== -1 ? plus : minus;\n        if (cut > 0) body = body.substring(0, cut);\n      }\n    }\n    let hours = 0;\n    let mins = 0;\n    let secMs = 0;\n    if (layout === \'HH\') return Number(body) * 3600000;\n    if (layout === \'mm\') return Number(body) * 60000;\n    if (layout === \'ss\') return Number(body) * 1000;\n    const parts = body.split(\':\');\n    if (layout === \'HH:mm\') {\n      hours = Number(parts[0]);\n      mins = Number(parts[1]);\n    } else if (layout === \'mm:ss\') {\n      mins = Number(parts[0]);\n      secMs = Number(parts[1]) * 1000;\n    } else {\n      // A dateTime bound parses its time half as \'ISO\' regardless of the declared nested layout, so\n      // the value may legitimately carry fewer segments (an \'HH:mm\' nested time → \'14:30\'). The\n      // structural check already validated it, so a tolerant key is enough: absent segments are 0.\n      hours = Number(parts[0]);\n      mins = parts[1] ? Number(parts[1]) : 0;\n      if (parts[2]) {\n        const secParts = parts[2].split(\'.\');\n        secMs = Number(secParts[0]) * 1000 + (secParts[1] ? Number(secParts[1]) : 0);\n      }\n    }\n    return hours * 3600000 + mins * 60000 + secMs;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/tfRjnFZVF8lqI_.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FtfRjnFZVF8lqI_=[2,,,'@mionjs/run-types#pf_tfRjnFZVF8lqI_',[],'return function _hasUnknownKeysFromArray(obj, keys) {\n    for (const prop in obj) {\n      let found = false;\n      for (let j = 0; j < keys.length; j++) {\n        if (keys[j] === prop) {\n          found = true;\n          break;\n        }\n      }\n      if (!found) return true;\n    }\n    return false;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/vLId7t0J8HNWlN.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FvLId7t0J8HNWlN=[2,,,'@mionjs/run-types#pf_vLId7t0J8HNWlN',[],'const rtlRegexp =\n    /[\\p{Script=Hebrew}\\p{Script=Arabic}\\p{Script=Syriac}\\p{Script=Thaana}\\p{Script=Nko}\\p{Script=Samaritan}\\p{Script=Mandaic}\\p{Script=Adlam}]/u;\n  const letterRegexp = /\\p{L}/u;\n  const arabicNumberRegexp = /[٠-٩٫٬]/u;\n  const europeanNumberRegexp = /[0-9۰-۹]/u;\n  return function _satisfies_bidi(labels) {\n    // A right-to-left LETTER is what makes the whole name a Bidi domain; a\n    // digit or sign that merely lives in an RTL script does not.\n    const isRtlLetter = (char) => rtlRegexp.test(char) && letterRegexp.test(char);\n    if (!labels.some((label) => [...label].some(isRtlLetter))) return true;\n    for (const label of labels) {\n      const chars = [...label];\n      if (!letterRegexp.test(chars[0])) return false;\n      if (isRtlLetter(chars[0])) {\n        // An RTL label may carry European OR Arabic-Indic digits, never both.\n        if (arabicNumberRegexp.test(label) && europeanNumberRegexp.test(label)) return false;\n      } else if (chars.some(isRtlLetter)) {\n        return false;\n      }\n    }\n    return true;\n  };',[]];

package/dist/mion-pure-fns/@mionjs/run-types/zXMPEMyjGR4ZRc.js

@@ -0,0 +1 @@
+export const __rt_pf$2F$40mionjs$2Frun$2Dtypes$2FzXMPEMyjGR4ZRc=[2,,,'@mionjs/run-types#pf_zXMPEMyjGR4ZRc',[],'// The `nav` / `dfs` closures are created ONCE at materialisation, but ALL mutable state rides the per-call `st`, so\n  // invocations are fully isolated and the walked graph is GC-able the moment findCycle returns.\n\n  // Follow one edge path from `val`, branching at iteration segments, then descend into the reached value as tracked node `toNode`.\n  const nav = (val, segs, si, toNode, st) => {\n    if (si === segs.length) return dfs(val, toNode, st);\n    const seg = segs[si];\n    const kind = seg[0];\n    if (kind === \'k\') {\n      const child = val === null || typeof val !== \'object\' ? undefined : (val)[seg[1]];\n      if (child === undefined || child === null) return false;\n      st.path.push(seg[1]);\n      const hit = nav(child, segs, si + 1, toNode, st);\n      if (hit) return true;\n      st.path.pop();\n      return false;\n    }\n    if (kind === \'a\') {\n      if (!Array.isArray(val)) return false;\n      for (let i = 0; i < val.length; i++) {\n        const el = val[i];\n        if (el === undefined || el === null) continue;\n        st.path.push(i);\n        if (nav(el, segs, si + 1, toNode, st)) return true;\n        st.path.pop();\n      }\n      return false;\n    }\n    if (kind === \'i\') {\n      if (val === null || typeof val !== \'object\') return false;\n      for (const key of Object.keys(val)) {\n        const pv = (val)[key];\n        if (pv === undefined || pv === null) continue;\n        st.path.push(key);\n        if (nav(pv, segs, si + 1, toNode, st)) return true;\n        st.path.pop();\n      }\n      return false;\n    }\n    if (kind === \'s\') {\n      if (!(val instanceof Set)) return false;\n      let index = 0;\n      for (const el of val) {\n        if (el !== undefined && el !== null) {\n          st.path.push(index);\n          if (nav(el, segs, si + 1, toNode, st)) return true;\n          st.path.pop();\n        }\n        index++;\n      }\n      return false;\n    }\n    if (kind === \'mk\' || kind === \'mv\') {\n      if (!(val instanceof Map)) return false;\n      let index = 0;\n      for (const entry of val) {\n        const member = kind === \'mk\' ? entry[0] : entry[1];\n        if (member !== undefined && member !== null) {\n          st.path.push((kind === \'mk\' ? \'mapKey[\' : \'mapValue[\') + index + \']\');\n          if (nav(member, segs, si + 1, toNode, st)) return true;\n          st.path.pop();\n        }\n        index++;\n      }\n      return false;\n    }\n    return false;\n  };\n\n  // Non-tracked nodes (the root, when its own type isn\'t circular) are traversed without stacking.\n  const dfs = (val, node, st) => {\n    if (val === null || typeof val !== \'object\') return false;\n    // Sound to skip: a cycle THROUGH `val` is caught during `val`\'s own descent, so an acyclic subtree is path-independent.\n    const known = st.safe[node];\n    if (known !== undefined && known.has(val)) return false;\n    const isTracked = !!st.c[node];\n    if (isTracked) {\n      if (st.stack.indexOf(val) !== -1) return true;\n      st.stack.push(val);\n    }\n    const outgoing = st.e[node];\n    for (let i = 0; i < outgoing.length; i++) {\n      if (nav(val, outgoing[i].p, 0, outgoing[i].t, st)) return true;\n    }\n    // LIFO: this frame pushed `val` on entry, so pop removes exactly it.\n    if (isTracked) st.stack.pop();\n    // Clean subtree → memoize so a shared / DAG re-arrival skips it.\n    let bucket = st.safe[node];\n    if (bucket === undefined) {\n      bucket = new Set();\n      st.safe[node] = bucket;\n    }\n    bucket.add(val);\n    return false;\n  };\n\n  return function findCycle(value, skeleton) {\n    if (value === null || typeof value !== \'object\' || !skeleton) return null;\n    const st = {c: skeleton.c, e: skeleton.e, stack: [], path: [], safe: []};\n    return dfs(value, 0, st) ? st.path.slice() : null;\n  };',[]];

package/dist/mion-pure-fns/index.json

@@ -0,0 +1,236 @@
+{
+  "format": 1,
+  "package": "@mionjs/run-types",
+  "pureFns": [
+    {
+      "id": "@mionjs/run-types#pf_-y__pOnrgnvRMz",
+      "bindingName": "isDateString_MDY",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_0ofEnb55W0BDIY",
+      "bindingName": "uniqueArrayItems",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_18wDCH5CXZoQKV",
+      "bindingName": "isCreditCard",
+      "file": "src/formats/string/credit-card-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_2xtQHAMu-yOBo6",
+      "bindingName": "isTimeString_mmss",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_5oCqd7YyfA9rEw",
+      "bindingName": "punycodeEncode",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_6E7qWsIwaFRGn6",
+      "bindingName": "isSecondsWithMs",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_6xkN1Qfs9nqO79",
+      "bindingName": "countEnumKeys",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_8Mj42N3ytEEn67",
+      "bindingName": "canonicalJson",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_A3KjzpjelkcBST",
+      "bindingName": "matchesCardNetwork",
+      "file": "src/formats/string/credit-card-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_AgOXcprpjsrTKk",
+      "bindingName": "isUUID",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_E29ul2pUOyD_Ay",
+      "bindingName": "isIdnaLabel",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_EG8OkOOSnT9bZn",
+      "bindingName": "isLocalHost",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_EYsxRHRDgAykA_",
+      "bindingName": "isTimeZone",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_Eube1z0GFHuqlM",
+      "bindingName": "isDateString_DM",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_GA20s6bj41GC1A",
+      "bindingName": "punycodeDecode",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_GfQK19ktpvibuZ",
+      "bindingName": "isDateString_YM",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_IyjvBbz0zSlgCJ",
+      "bindingName": "isTimeString_HHmmss",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_LqTR2O-h6MYq9J",
+      "bindingName": "isEmailAddress",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_MnJ72PqkyXHiSP",
+      "bindingName": "isDateString",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_NJ9TCGDnkv_9Mn",
+      "bindingName": "isDateString_MD",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_OCJ1B0-ZCAwagS",
+      "bindingName": "isTimeString_ISO",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_PQVLEBllZckw8I",
+      "bindingName": "isDateString_DMY",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_Qd_9GJQlOCVqDe",
+      "bindingName": "isEcmaRegex",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_R0IFkkw4SM2gvv",
+      "bindingName": "uniqueMapEntries",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_THkAA-KNR1HeAe",
+      "bindingName": "dateStrToMs",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_VJiknJ2exR2oMF",
+      "bindingName": "luhnSum",
+      "file": "src/formats/string/credit-card-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_XYGjy-tcgDROBw",
+      "bindingName": "uniqueSetMembers",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_Z2sc5xQPKB0oav",
+      "bindingName": "codePointLength",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf__3Pmrr5aNmyNi4",
+      "bindingName": "isIPV4",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_cgwpjq6rGsI8jb",
+      "bindingName": "isMinutes",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_d8U9HjmMsNFd6Z",
+      "bindingName": "isHours",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_fL3v1v6aVZwJ7-",
+      "bindingName": "getUnknownKeysFromArray",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_gFl-yXbCxJqWgQ",
+      "bindingName": "isDateString_YMD",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_hiotRbfSKFAuK4",
+      "bindingName": "isTimeString_HHmm",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_lFYcgG5ZSI-8em",
+      "bindingName": "isSecondsWithLeap",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_n_ZOWff4X3qBMQ",
+      "bindingName": "isSeconds",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_ndkQPoji6DFHx2",
+      "bindingName": "isIPV6",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_nsU8QeJCuCF8Kr",
+      "bindingName": "cardNetworkRules",
+      "file": "src/formats/string/credit-card-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_qMsNYN8hy_sC8i",
+      "bindingName": "isTimeString_ISO_TZ",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_rXVwGkGDX08BsQ",
+      "bindingName": "newRunTypeErr",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_rgWveqNi_HeFF8",
+      "bindingName": "isIdnHostname",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_s-tZDRlQfCG5m2",
+      "bindingName": "relativeNowKey",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_t-ntJ9S0FuxkC2",
+      "bindingName": "timeStrToMs",
+      "file": "src/formats/datetime/dateTime-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_tfRjnFZVF8lqI_",
+      "bindingName": "hasUnknownKeysFromArray",
+      "file": "src/runtypes/pure-fns-utils.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_vLId7t0J8HNWlN",
+      "bindingName": "satisfiesBidi",
+      "file": "src/formats/string/string-formats-pure-fns.ts"
+    },
+    {
+      "id": "@mionjs/run-types#pf_zXMPEMyjGR4ZRc",
+      "bindingName": "findCycle",
+      "file": "src/runtypes/circular-pure-fns.ts"
+    }
+  ]
+}

package/dist/mocking/childMatch.d.ts

@@ -0,0 +1,4 @@
+import type { RunType } from '../runtypes/types.ts';
+export declare function childSchemaMatches(value: unknown, child: RunType): boolean;
+export declare function isMockSamplingError(error: unknown): boolean;
+//# sourceMappingURL=childMatch.d.ts.map

package/dist/mocking/childMatch.js

@@ -0,0 +1,354 @@
+import { RunTypeKind } from '../go-generated/runTypeKind.generated.js';
+import { getRTUtils } from '../runtypes/rtUtils.js';
+import { structuralFormatAccepts } from './structuralFormat.js';
+import { isMultipleOf } from './isMultipleOf.js';
+const MAX_MATCH_DEPTH = 16;
+export function childSchemaMatches(value, child) {
+    return matches(value, child, 0);
+}
+function matches(value, node, depth) {
+    if (depth > MAX_MATCH_DEPTH)
+        throw childMatchError('recursion exceeded MAX_MATCH_DEPTH');
+    const kind = node.kind;
+    switch (kind) {
+        case RunTypeKind.ref: {
+            const resolved = getRTUtils().getRunType(node.id);
+            if (!resolved)
+                throw childMatchError(`unresolvable ref '${String(node.id)}'`);
+            return matches(value, resolved, depth + 1);
+        }
+        case RunTypeKind.any:
+        case RunTypeKind.unknown:
+            return true;
+        case RunTypeKind.never:
+            return false;
+        case RunTypeKind.null:
+            return value === null;
+        case RunTypeKind.undefined:
+        case RunTypeKind.void:
+            return value === undefined;
+        case RunTypeKind.boolean:
+            return typeof value === 'boolean';
+        case RunTypeKind.string:
+            return typeof value === 'string' && formatMatches(value, node.formatAnnotation);
+        case RunTypeKind.number:
+            return Number.isFinite(value) && numberParamsMatch(value, node.formatAnnotation);
+        case RunTypeKind.bigint:
+            return typeof value === 'bigint' && bigintParamsMatch(value, node.formatAnnotation);
+        case RunTypeKind.literal:
+            return literalMatches(value, node);
+        case RunTypeKind.enum: {
+            const values = Array.isArray(node.values) ? node.values : [];
+            return values.some((entry) => entry === value);
+        }
+        case RunTypeKind.object:
+            return (typeof value === 'object' &&
+                value !== null &&
+                structuralFormatAccepts(value, node.formatAnnotation) &&
+                patternKeysSatisfied(value, node, depth));
+        case RunTypeKind.array:
+            if (!Array.isArray(value) || !structuralFormatAccepts(value, node.formatAnnotation))
+                return false;
+            if (!containsSatisfied(value, node, depth))
+                return false;
+            return node.child ? value.every((item) => matches(item, node.child, depth + 1)) : true;
+        case RunTypeKind.tuple: {
+            if (!Array.isArray(value))
+                return false;
+            if (!structuralFormatAccepts(value, node.formatAnnotation))
+                return false;
+            if (!containsSatisfied(value, node, depth))
+                return false;
+            const members = node.children ?? [];
+            const lastMember = members[members.length - 1];
+            const restMember = lastMember !== undefined && restElement(lastMember) !== undefined ? lastMember : undefined;
+            const fixed = restMember === undefined ? members : members.slice(0, -1);
+            const required = fixed.filter((member) => !member.optional).length;
+            if (value.length < required)
+                return false;
+            if (restMember === undefined && value.length > fixed.length)
+                return false;
+            return value.every((item, i) => {
+                if (i < fixed.length)
+                    return fixed[i] ? matches(item, memberChild(fixed[i]), depth + 1) : false;
+                const element = restElement(restMember);
+                return element === undefined ? true : matches(item, element, depth + 1);
+            });
+        }
+        case RunTypeKind.union:
+            return (node.children ?? []).some((arm) => matches(value, arm, depth + 1));
+        case RunTypeKind.objectLiteral: {
+            if (typeof value !== 'object' || value === null || Array.isArray(value))
+                return false;
+            if (!structuralFormatAccepts(value, node.formatAnnotation))
+                return false;
+            if (!patternKeysSatisfied(value, node, depth))
+                return false;
+            const record = value;
+            for (const member of node.children ?? []) {
+                if (member.kind === RunTypeKind.indexSignature) {
+                    const valueChild = member.child;
+                    if (valueChild && !Object.values(record).every((entry) => matches(entry, valueChild, depth + 1)))
+                        return false;
+                    continue;
+                }
+                const name = member.name;
+                if (name === undefined)
+                    continue;
+                if (!(name in record)) {
+                    if (member.optional)
+                        continue;
+                    return false;
+                }
+                if (!matches(record[name], memberChild(member), depth + 1))
+                    return false;
+            }
+            return true;
+        }
+        default:
+            throw childMatchError(`cannot test a candidate against child kind ${kind}`);
+    }
+}
+function memberChild(member) {
+    return member.child ?? member;
+}
+function containsSatisfied(items, node, depth) {
+    const entries = node.contains;
+    if (!entries || entries.length === 0)
+        return true;
+    for (const entry of entries) {
+        let count = 0;
+        for (const item of items)
+            if (matches(item, entry.child, depth + 1))
+                count++;
+        if (count < entry.min)
+            return false;
+        if (entry.max >= 0 && count > entry.max)
+            return false;
+    }
+    return true;
+}
+function patternKeysSatisfied(record, node, depth) {
+    const patternProps = node.patternProps;
+    if (patternProps && patternProps.length > 0) {
+        for (const entry of patternProps) {
+            for (const [key, entryValue] of Object.entries(record)) {
+                if (new RegExp(entry.source).test(key) && !matches(entryValue, entry.value, depth + 1))
+                    return false;
+            }
+        }
+    }
+    const propNames = node.propNames;
+    if (propNames && propNames.length > 0) {
+        for (const entry of propNames) {
+            for (const key of Object.keys(record)) {
+                if (!matches(key, entry, depth + 1))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+function restElement(member) {
+    if (member.kind === RunTypeKind.rest)
+        return member.child;
+    if (Array.isArray(member.flags) && member.flags.includes('rest'))
+        return member.child;
+    const child = member.child;
+    if (child && child.kind === RunTypeKind.rest)
+        return child.child;
+    return undefined;
+}
+function literalMatches(value, node) {
+    const literal = node.literal;
+    if (Array.isArray(node.flags) && node.flags.includes('bigint')) {
+        return typeof value === 'bigint' && value.toString() === String(literal);
+    }
+    return value === literal;
+}
+function patternTest(param, value) {
+    const pattern = param;
+    if (!pattern || typeof pattern.source !== 'string') {
+        throw childMatchError('pattern param without a literal source');
+    }
+    return new RegExp(pattern.source, typeof pattern.flags === 'string' ? pattern.flags : '').test(value);
+}
+const NAMED_STRING_FORMATS = {
+    email: (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value),
+    uuid: (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value),
+    date: (value) => /^\d{4}-\d{2}-\d{2}$/.test(value),
+    time: (value) => /^\d{2}:\d{2}(:\d{2})?/.test(value),
+    dateTime: (value) => /^\d{4}-\d{2}-\d{2}[Tt ]/.test(value),
+    ip: (value) => /^(\d{1,3}\.){3}\d{1,3}$/.test(value) || value.includes(':'),
+    domain: (value) => /^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(value),
+    url: (value) => {
+        try {
+            new URL(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+function formatMatches(value, annotation) {
+    if (!annotation)
+        return true;
+    const name = annotation.name;
+    const params = annotation.params ?? {};
+    if (name === 'stringFormat')
+        return stringParamsMatch(value, params);
+    if (params.pattern)
+        return stringParamsMatch(value, params);
+    const named = NAMED_STRING_FORMATS[name];
+    if (!named)
+        throw childMatchError(`no runtime test for string format '${name}'`);
+    return named(value);
+}
+function stringParamsMatch(value, params) {
+    for (const [key, param] of Object.entries(params)) {
+        switch (key) {
+            case 'contentMediaType': {
+                if (param !== 'application/json')
+                    break;
+                try {
+                    JSON.parse(params.contentEncoding === 'base64' ? atob(value) : value);
+                }
+                catch {
+                    return false;
+                }
+                break;
+            }
+            case 'contentEncoding':
+                break;
+            case 'minLength':
+                if (typeof param === 'number' && value.length < param)
+                    return false;
+                break;
+            case 'maxLength':
+                if (typeof param === 'number' && value.length > param)
+                    return false;
+                break;
+            case 'length':
+                if (typeof param === 'number' && value.length !== param)
+                    return false;
+                break;
+            case 'pattern':
+                if (!patternTest(param, value))
+                    return false;
+                break;
+            case 'allowedChars':
+                if (!patternTest(param, value))
+                    return false;
+                break;
+            case 'disallowedChars':
+                if (patternTest(param, value))
+                    return false;
+                break;
+            case 'allowedValues':
+                if (Array.isArray(param) && !param.includes(value))
+                    return false;
+                break;
+            case 'disallowedValues':
+                if (Array.isArray(param) && param.includes(value))
+                    return false;
+                break;
+            case 'idna':
+                if (param !== 'ascii')
+                    throw childMatchError(`no runtime test for idna '${String(param)}'`);
+                break;
+            case 'mockSamples':
+                break;
+            default:
+                throw childMatchError(`no runtime test for string param '${key}'`);
+        }
+    }
+    return true;
+}
+function numberParamsMatch(value, annotation) {
+    if (!annotation)
+        return true;
+    const params = annotation.params ?? {};
+    for (const [key, param] of Object.entries(params)) {
+        switch (key) {
+            case 'min':
+                if (typeof param === 'number' && value < param)
+                    return false;
+                break;
+            case 'max':
+                if (typeof param === 'number' && value > param)
+                    return false;
+                break;
+            case 'gt':
+                if (typeof param === 'number' && value <= param)
+                    return false;
+                break;
+            case 'lt':
+                if (typeof param === 'number' && value >= param)
+                    return false;
+                break;
+            case 'integer':
+                if (param === true && !Number.isInteger(value))
+                    return false;
+                break;
+            case 'multipleOf': {
+                const tolerance = params.multipleOfTolerance;
+                if (typeof param === 'number' &&
+                    param !== 0 &&
+                    !isMultipleOf(value, param, typeof tolerance === 'number' ? tolerance : undefined))
+                    return false;
+                break;
+            }
+            case 'multipleOfTolerance':
+            case 'isCurrency':
+            case 'mockSamples':
+                break;
+            default:
+                throw childMatchError(`no runtime test for number param '${key}'`);
+        }
+    }
+    return true;
+}
+function bigintParamsMatch(value, annotation) {
+    if (!annotation)
+        return true;
+    const params = annotation.params ?? {};
+    for (const [key, param] of Object.entries(params)) {
+        switch (key) {
+            case 'min':
+                if (value < BigInt(param))
+                    return false;
+                break;
+            case 'max':
+                if (value > BigInt(param))
+                    return false;
+                break;
+            case 'gt':
+                if (value <= BigInt(param))
+                    return false;
+                break;
+            case 'lt':
+                if (value >= BigInt(param))
+                    return false;
+                break;
+            case 'multipleOf': {
+                const divisor = BigInt(param);
+                if (divisor !== 0n && value % divisor !== 0n)
+                    return false;
+                break;
+            }
+            case 'mockSamples':
+                break;
+            default:
+                throw childMatchError(`no runtime test for bigint param '${key}'`);
+        }
+    }
+    return true;
+}
+function childMatchError(reason) {
+    return new Error(`Cannot mock a constrained child (${reason}). Provide a MockData pool for this type (enrich) with values that satisfy the constraint.`);
+}
+export function isMockSamplingError(error) {
+    return error instanceof Error && error.message.startsWith('Cannot mock a constrained child');
+}
+//# sourceMappingURL=childMatch.js.map