@zipbul/baker 2.2.0 → 3.0.1

package/dist/src/rules/string.js

@@ -0,0 +1,1998 @@
+import { makePlannedRule, makeRule, planCompare, planLength, planOr } from '../rule-plan.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function makeStringRule(name, validate, buildEmit, requiresType = 'string', constraints = {}) {
+    return makeRule({
+        name,
+        requiresType,
+        constraints,
+        validate: value => typeof value === 'string' && validate(value),
+        emit: buildEmit,
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Group A: Length / Range
+// ─────────────────────────────────────────────────────────────────────────────
+function minLength(min) {
+    const plan = { cacheKey: 'length', failure: planCompare(planLength(), '<', min) };
+    return makePlannedRule({
+        name: 'minLength',
+        requiresType: 'string',
+        constraints: { min },
+        plan,
+        validate: value => typeof value === 'string' && value.length >= min,
+    });
+}
+function maxLength(max) {
+    const plan = { cacheKey: 'length', failure: planCompare(planLength(), '>', max) };
+    return makePlannedRule({
+        name: 'maxLength',
+        requiresType: 'string',
+        constraints: { max },
+        plan,
+        validate: value => typeof value === 'string' && value.length <= max,
+    });
+}
+function length(minLen, maxLen) {
+    const plan = {
+        cacheKey: 'length',
+        failure: planOr(planCompare(planLength(), '<', minLen), planCompare(planLength(), '>', maxLen)),
+    };
+    return makePlannedRule({
+        name: 'length',
+        requiresType: 'string',
+        constraints: { min: minLen, max: maxLen },
+        plan,
+        validate: value => typeof value === 'string' && value.length >= minLen && value.length <= maxLen,
+    });
+}
+function contains(seed) {
+    return makeRule({
+        name: 'contains',
+        requiresType: 'string',
+        constraints: { seed },
+        validate: value => typeof value === 'string' && value.includes(seed),
+        emit: (varName, ctx) => {
+            const i = ctx.addRef(seed);
+            return `if (!${varName}.includes(refs[${i}])) ${ctx.fail('contains')};`;
+        },
+    });
+}
+function notContains(seed) {
+    return makeRule({
+        name: 'notContains',
+        requiresType: 'string',
+        constraints: { seed },
+        validate: value => typeof value === 'string' && !value.includes(seed),
+        emit: (varName, ctx) => {
+            const i = ctx.addRef(seed);
+            return `if (${varName}.includes(refs[${i}])) ${ctx.fail('notContains')};`;
+        },
+    });
+}
+function matches(pattern, modifiers) {
+    const re = pattern instanceof RegExp ? pattern : new RegExp(pattern, modifiers);
+    return makeRule({
+        name: 'matches',
+        requiresType: 'string',
+        constraints: { pattern: re.source },
+        validate: value => typeof value === 'string' && re.test(value),
+        emit: (varName, ctx) => {
+            const i = ctx.addRegex(re);
+            return `if (!re[${i}].test(${varName})) ${ctx.fail('matches')};`;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Group B: Simple Boolean Checks
+// ─────────────────────────────────────────────────────────────────────────────
+const isLowercase = makeRule({
+    name: 'isLowercase',
+    requiresType: 'string',
+    constraints: {},
+    validate: value => typeof value === 'string' && value === value.toLowerCase(),
+    emit: (varName, ctx) => `if (${varName} !== ${varName}.toLowerCase()) ${ctx.fail('isLowercase')};`,
+});
+const isUppercase = makeRule({
+    name: 'isUppercase',
+    requiresType: 'string',
+    constraints: {},
+    validate: value => typeof value === 'string' && value === value.toUpperCase(),
+    emit: (varName, ctx) => `if (${varName} !== ${varName}.toUpperCase()) ${ctx.fail('isUppercase')};`,
+});
+// ASCII: all code points in [0x00, 0x7F]
+const ASCII_RE = new RegExp(`^[${String.fromCharCode(0)}-${String.fromCharCode(0x7f)}]*$`);
+const isAscii = makeStringRule('isAscii', v => ASCII_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(ASCII_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isAscii')};`;
+});
+// Alpha — [a-zA-Z]+ singleton
+const ALPHA_DEFAULT_RE = /^[a-zA-Z]+$/;
+// length > 0 guard is dead — `+` quantifier requires ≥1 char so the regex returns false on empty.
+const isAlpha = makeStringRule('isAlpha', v => ALPHA_DEFAULT_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(ALPHA_DEFAULT_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isAlpha')};`;
+});
+// Alphanumeric — [a-zA-Z0-9]+ singleton (same empty-input rationale as isAlpha)
+const ALNUM_DEFAULT_RE = /^[a-zA-Z0-9]+$/;
+const isAlphanumeric = makeStringRule('isAlphanumeric', v => ALNUM_DEFAULT_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(ALNUM_DEFAULT_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isAlphanumeric')};`;
+});
+// HTTP token — RFC 9110 §5.6.2: token = 1*tchar.
+// tchar = "!"/"#"/"$"/"%"/"&"/"'"/"*"/"+"/"-"/"."/"^"/"_"/"`"/"|"/"~" / DIGIT / ALPHA.
+// Used for HTTP method names and header field-names (not field-values). The hyphen is
+// escaped so it stays literal — an unescaped `+-.` would form a range that admits ",".
+const HTTP_TOKEN_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const isHttpToken = makeStringRule('isHttpToken', v => HTTP_TOKEN_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(HTTP_TOKEN_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isHttpToken')};`;
+});
+// BooleanString: 'true' | 'false' | '1' | '0'
+const isBooleanString = makeRule({
+    name: 'isBooleanString',
+    requiresType: 'string',
+    constraints: {},
+    validate: value => value === 'true' || value === 'false' || value === '1' || value === '0',
+    emit: (varName, ctx) => `if (${varName} !== 'true' && ${varName} !== 'false' && ${varName} !== '1' && ${varName} !== '0') ${ctx.fail('isBooleanString')};`,
+});
+const NO_SYMBOLS_RE = /^[0-9]+$/;
+// A numeric string: optional sign, integer/decimal/leading-dot form. No whitespace, hex, or
+// exponent — `Number()` coercion accepted all of those (e.g. "   ", "0x1A", "1e5"), which is far
+// looser than "is this string a number". Matches validator.js's default isNumeric behavior.
+const NUMERIC_STRING_RE = /^[+-]?(?:[0-9]*\.)?[0-9]+$/;
+function isNumberString(options) {
+    const noSymbols = options?.no_symbols ?? false;
+    const re = noSymbols ? NO_SYMBOLS_RE : NUMERIC_STRING_RE;
+    return makeStringRule('isNumberString', (s) => re.test(s), (varName, ctx) => {
+        const i = ctx.addRegex(re);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isNumberString')};`;
+    }, 'string', { no_symbols: noSymbols });
+}
+function isDecimal() {
+    // Require a digit after the dot — `\d+(?:\.\d*)?` accepted a dangling "5.".
+    const decimalRe = /^[-+]?(?:\d+(?:\.\d+)?|\.\d+)$/;
+    return makeStringRule('isDecimal', v => decimalRe.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(decimalRe);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isDecimal')};`;
+    });
+}
+// Full-width characters (Unicode fullwidth forms)
+const FULLWIDTH_RE = /[^\u0020-\u007E\uFF61-\uFF9F]/;
+// Empty-string guard is redundant — non-anchored char-class regex returns false on empty input.
+const isFullWidth = makeStringRule('isFullWidth', v => FULLWIDTH_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(FULLWIDTH_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isFullWidth')};`;
+});
+// Half-width characters
+const HALFWIDTH_RE = /[\u0020-\u007E\uFF61-\uFF9F]/;
+const isHalfWidth = makeStringRule('isHalfWidth', v => HALFWIDTH_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(HALFWIDTH_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isHalfWidth')};`;
+});
+// Variable-width: must contain both full-width AND half-width
+const isVariableWidth = makeStringRule('isVariableWidth', v => FULLWIDTH_RE.test(v) && HALFWIDTH_RE.test(v), (varName, ctx) => {
+    const i1 = ctx.addRegex(FULLWIDTH_RE);
+    const i2 = ctx.addRegex(HALFWIDTH_RE);
+    return `if (!re[${i1}].test(${varName}) || !re[${i2}].test(${varName})) ${ctx.fail('isVariableWidth')};`;
+});
+// Multibyte: any character outside Latin-1 / half-width range
+const MULTIBYTE_RE = new RegExp(`[^${String.fromCharCode(0)}-${String.fromCharCode(0xff)}]`);
+const isMultibyte = makeStringRule('isMultibyte', v => MULTIBYTE_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(MULTIBYTE_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isMultibyte')};`;
+});
+// Surrogate pairs
+const SURROGATE_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/;
+const isSurrogatePair = makeStringRule('isSurrogatePair', v => SURROGATE_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(SURROGATE_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isSurrogatePair')};`;
+});
+// Hexadecimal
+const HEX_RE = /^[0-9a-fA-F]+$/;
+const isHexadecimal = makeStringRule('isHexadecimal', v => HEX_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(HEX_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isHexadecimal')};`;
+});
+// Octal
+const OCTAL_RE = /^(0[oO])?[0-7]+$/;
+const isOctal = makeStringRule('isOctal', v => OCTAL_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(OCTAL_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isOctal')};`;
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// Group C: Regex-based
+// ─────────────────────────────────────────────────────────────────────────────
+// Email — RFC 5322 simplified
+const EMAIL_RE = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/;
+function isEmail() {
+    return makeStringRule('isEmail', v => EMAIL_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(EMAIL_RE);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isEmail')};`;
+    }, 'string', { format: 'email' });
+}
+const URL_PROTOCOLS_DEFAULT = ['http', 'https', 'ftp'];
+function isURL(options) {
+    const protocols = options?.protocols ?? URL_PROTOCOLS_DEFAULT;
+    const protocolPattern = protocols.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    const re = new RegExp(`^(?:${protocolPattern}):\\/\\/(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)(?::(6553[0-5]|655[0-2]\\d|65[0-4]\\d{2}|6[0-4]\\d{3}|[1-5]\\d{4}|[1-9]\\d{0,3}|0))?(?:\\/[^\\s]*)?$`);
+    return makeRule({
+        name: 'isURL',
+        requiresType: 'string',
+        constraints: { format: 'uri', protocols },
+        validate: value => typeof value === 'string' && re.test(value),
+        emit: (varName, ctx) => {
+            const i = ctx.addRegex(re);
+            return `if (!re[${i}].test(${varName})) ${ctx.fail('isURL')};`;
+        },
+    });
+}
+// UUID
+const UUID_RE = {
+    all: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+    1: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-1[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/,
+    2: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-2[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/,
+    3: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-3[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/,
+    4: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/,
+    5: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-5[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/,
+};
+function isUUID(version) {
+    const re = version != null ? UUID_RE[version] : UUID_RE.all;
+    return makeStringRule('isUUID', v => re.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(re);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isUUID')};`;
+    }, 'string', { format: 'uuid', version });
+}
+// IP
+const IPV4_RE = /^(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/;
+const IPV6_RE = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}$|^(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}$|^(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}$|^[0-9a-fA-F]{1,4}:(?::[0-9a-fA-F]{1,4}){1,6}$|^::$|^::1$|^::(?:ffff(?::0{1,4})?:)?(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$|^(?:[0-9a-fA-F]{1,4}:){1,4}:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+function isIP(version) {
+    return makeRule({
+        name: 'isIP',
+        requiresType: 'string',
+        constraints: { version },
+        validate: value => {
+            if (typeof value !== 'string') {
+                return false;
+            }
+            if (version === 4) {
+                return IPV4_RE.test(value);
+            }
+            if (version === 6) {
+                return IPV6_RE.test(value);
+            }
+            return IPV4_RE.test(value) || IPV6_RE.test(value);
+        },
+        emit: (varName, ctx) => {
+            if (version === 4) {
+                const i = ctx.addRegex(IPV4_RE);
+                return `if (!re[${i}].test(${varName})) ${ctx.fail('isIP')};`;
+            }
+            if (version === 6) {
+                const i = ctx.addRegex(IPV6_RE);
+                return `if (!re[${i}].test(${varName})) ${ctx.fail('isIP')};`;
+            }
+            const i4 = ctx.addRegex(IPV4_RE);
+            const i6 = ctx.addRegex(IPV6_RE);
+            return `if (!re[${i4}].test(${varName}) && !re[${i6}].test(${varName})) ${ctx.fail('isIP')};`;
+        },
+    });
+}
+// HexColor: #RGB or #RRGGBB
+const HEX_COLOR_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const isHexColor = makeStringRule('isHexColor', v => HEX_COLOR_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(HEX_COLOR_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isHexColor')};`;
+});
+// RgbColor
+const RGB_RE = /^rgb\(\s*(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\s*,\s*(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\s*,\s*(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\s*\)$/;
+const RGBA_RE = /^rgba\(\s*(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\s*,\s*(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\s*,\s*(25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\s*,\s*(0|0?\.\d+|1(\.0+)?)\s*\)$/;
+// Percent forms: rgb(...) must NOT have alpha; rgba(...) MUST have alpha.
+const RGB_PERCENT_NOALPHA_RE = /^rgb\(\s*(\d{1,2}|100)%\s*,\s*(\d{1,2}|100)%\s*,\s*(\d{1,2}|100)%\s*\)$/;
+const RGBA_PERCENT_RE = /^rgba\(\s*(\d{1,2}|100)%\s*,\s*(\d{1,2}|100)%\s*,\s*(\d{1,2}|100)%\s*,\s*(0|0?\.\d+|1(?:\.0+)?)\s*\)$/;
+function isRgbColor(includePercentValues = false) {
+    return makeRule({
+        name: 'isRgbColor',
+        requiresType: 'string',
+        constraints: { includePercentValues },
+        validate: value => {
+            if (typeof value !== 'string') {
+                return false;
+            }
+            if (includePercentValues) {
+                return RGB_PERCENT_NOALPHA_RE.test(value) || RGBA_PERCENT_RE.test(value) || RGB_RE.test(value) || RGBA_RE.test(value);
+            }
+            return RGB_RE.test(value) || RGBA_RE.test(value);
+        },
+        emit: (varName, ctx) => {
+            if (includePercentValues) {
+                const ip1 = ctx.addRegex(RGB_PERCENT_NOALPHA_RE);
+                const ip2 = ctx.addRegex(RGBA_PERCENT_RE);
+                const ip3 = ctx.addRegex(RGB_RE);
+                const ip4 = ctx.addRegex(RGBA_RE);
+                return `if (!re[${ip1}].test(${varName}) && !re[${ip2}].test(${varName}) && !re[${ip3}].test(${varName}) && !re[${ip4}].test(${varName})) ${ctx.fail('isRgbColor')};`;
+            }
+            const i1 = ctx.addRegex(RGB_RE);
+            const i2 = ctx.addRegex(RGBA_RE);
+            return `if (!re[${i1}].test(${varName}) && !re[${i2}].test(${varName})) ${ctx.fail('isRgbColor')};`;
+        },
+    });
+}
+// HSL: hsl(H, S%, L%) or hsla(H, S%, L%, A)
+// Alpha belongs to hsla() only — `hsla?(...)?` previously let hsl() carry alpha and hsla() omit it.
+const HSL_RE = /^(?:hsl\(\s*(?:360|3[0-5]\d|[12]\d{2}|[1-9]\d|\d)\s*,\s*(?:100|[1-9]\d|\d)%\s*,\s*(?:100|[1-9]\d|\d)%\s*\)|hsla\(\s*(?:360|3[0-5]\d|[12]\d{2}|[1-9]\d|\d)\s*,\s*(?:100|[1-9]\d|\d)%\s*,\s*(?:100|[1-9]\d|\d)%\s*,\s*(?:0|0?\.\d+|1(?:\.0+)?)\s*\))$/;
+const isHSL = makeStringRule('isHSL', v => HSL_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(HSL_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isHSL')};`;
+});
+const MAC_COLON_RE = /^[0-9a-fA-F]{2}(?::[0-9a-fA-F]{2}){5}$/;
+const MAC_HYPHEN_RE = /^[0-9a-fA-F]{2}(?:-[0-9a-fA-F]{2}){5}$/;
+const MAC_NO_SEP_RE = /^[0-9a-fA-F]{12}$/;
+function isMACAddress(options) {
+    return makeRule({
+        name: 'isMACAddress',
+        requiresType: 'string',
+        constraints: { no_separators: options?.no_separators },
+        validate: value => {
+            if (typeof value !== 'string') {
+                return false;
+            }
+            if (options?.no_separators) {
+                return MAC_NO_SEP_RE.test(value);
+            }
+            return MAC_COLON_RE.test(value) || MAC_HYPHEN_RE.test(value);
+        },
+        emit: (varName, ctx) => {
+            if (options?.no_separators) {
+                const i = ctx.addRegex(MAC_NO_SEP_RE);
+                return `if (!re[${i}].test(${varName})) ${ctx.fail('isMACAddress')};`;
+            }
+            const i1 = ctx.addRegex(MAC_COLON_RE);
+            const i2 = ctx.addRegex(MAC_HYPHEN_RE);
+            return `if (!re[${i1}].test(${varName}) && !re[${i2}].test(${varName})) ${ctx.fail('isMACAddress')};`;
+        },
+    });
+}
+// ISBN
+function validateISBN10(str) {
+    const s = str.replace(/[-\s]/g, '');
+    if (!/^\d{9}[\dX]$/.test(s)) {
+        return false;
+    }
+    let sum = 0;
+    for (let i = 0; i < 9; i++) {
+        sum += (10 - i) * (s.charCodeAt(i) - 48);
+    }
+    const last = s[9] === 'X' ? 10 : s.charCodeAt(9) - 48;
+    sum += last;
+    return sum % 11 === 0;
+}
+function validateISBN13(str) {
+    const s = str.replace(/[-\s]/g, '');
+    if (!/^\d{13}$/.test(s)) {
+        return false;
+    }
+    let sum = 0;
+    for (let i = 0; i < 12; i++) {
+        sum += (s.charCodeAt(i) - 48) * (i % 2 === 0 ? 1 : 3);
+    }
+    const check = (10 - (sum % 10)) % 10;
+    return check === s.charCodeAt(12) - 48;
+}
+function isISBN(version) {
+    const validateFn = (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        if (version === 10) {
+            return validateISBN10(value);
+        }
+        if (version === 13) {
+            return validateISBN13(value);
+        }
+        return validateISBN10(value) || validateISBN13(value);
+    };
+    const emitISBN10 = (v) => `{var s=${v}.replace(/[-\\s]/g,'');` +
+        `if(!/^\\d{9}[\\dX]$/.test(s)){%%FAIL%%}` +
+        `else{var sm=0;for(var i=0;i<9;i++)sm+=(10-i)*(s.charCodeAt(i)-48);` +
+        `var l=s[9]==='X'?10:(s.charCodeAt(9)-48);sm+=l;` +
+        `if(sm%11!==0){%%FAIL%%}}}`;
+    const emitISBN13 = (v) => `{var s=${v}.replace(/[-\\s]/g,'');` +
+        `if(!/^\\d{13}$/.test(s)){%%FAIL%%}` +
+        `else{var sm=0;for(var i=0;i<12;i++)sm+=(s.charCodeAt(i)-48)*(i%2===0?1:3);` +
+        `var ck=(10-(sm%10))%10;` +
+        `if(ck!==(s.charCodeAt(12)-48)){%%FAIL%%}}}`;
+    return makeRule({
+        name: 'isISBN',
+        requiresType: 'string',
+        constraints: { version },
+        validate: validateFn,
+        emit: (varName, ctx) => {
+            const fail = ctx.fail('isISBN');
+            if (version === 10) {
+                return emitISBN10(varName).replace(/%%FAIL%%/g, fail);
+            }
+            if (version === 13) {
+                return emitISBN13(varName).replace(/%%FAIL%%/g, fail);
+            }
+            const emit10 = emitISBN10(varName).replace(/%%FAIL%%/g, '__isbn_ok=false');
+            const emit13 = emitISBN13(varName).replace(/%%FAIL%%/g, '__isbn_ok=false');
+            return `{var __isbn_ok=true;${emit10} if(!__isbn_ok){__isbn_ok=true;${emit13}} if(!__isbn_ok)${fail};}`;
+        },
+    });
+}
+// ISIN — ISO 6166
+const ISIN_RE = /^[A-Z]{2}[A-Z0-9]{9}[0-9]$/;
+function validateISINStr(v) {
+    if (!ISIN_RE.test(v)) {
+        return false;
+    }
+    // Luhn mod10 on expanded digits — walk right-to-left, expanding letters as A=10..Z=35 on the fly.
+    // No intermediate string/array allocations.
+    let sum = 0;
+    let alternate = false;
+    for (let i = v.length - 1; i >= 0; i--) {
+        const code = v.charCodeAt(i);
+        if (code <= 57) {
+            // ASCII digit '0'..'9'
+            let n = code - 48;
+            if (alternate) {
+                n *= 2;
+                if (n > 9) {
+                    n -= 9;
+                }
+            }
+            sum += n;
+            alternate = !alternate;
+        }
+        else {
+            // ASCII letter 'A'..'Z' → two-digit value, ones first when walking right-to-left
+            const value = code - 55;
+            const ones = value % 10;
+            let n = ones;
+            if (alternate) {
+                n *= 2;
+                if (n > 9) {
+                    n -= 9;
+                }
+            }
+            sum += n;
+            alternate = !alternate;
+            n = (value - ones) / 10;
+            if (alternate) {
+                n *= 2;
+                if (n > 9) {
+                    n -= 9;
+                }
+            }
+            sum += n;
+            alternate = !alternate;
+        }
+    }
+    return sum % 10 === 0;
+}
+const isISIN = makeStringRule('isISIN', validateISINStr, (varName, ctx) => {
+    const i = ctx.addRegex(ISIN_RE);
+    return (`if (!re[${i}].test(${varName})) ${ctx.fail('isISIN')};\n` +
+        `else { var isSum=0,isAlt=false;\n` +
+        `for(var isI=${varName}.length-1;isI>=0;isI--){var isCd=${varName}.charCodeAt(isI);` +
+        `if(isCd<=57){var isN=isCd-48;if(isAlt){isN*=2;if(isN>9)isN-=9;}isSum+=isN;isAlt=!isAlt;}` +
+        `else{var isVal=isCd-55;var isO=isVal%10;var isN=isO;if(isAlt){isN*=2;if(isN>9)isN-=9;}isSum+=isN;isAlt=!isAlt;` +
+        `isN=(isVal-isO)/10;if(isAlt){isN*=2;if(isN>9)isN-=9;}isSum+=isN;isAlt=!isAlt;}}\n` +
+        `if(isSum%10!==0)${ctx.fail('isISIN')}; }`);
+});
+// ISO 8601
+const ISO8601_RE = /^\d{4}(?:-\d{2}(?:-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?)?)?$/;
+// Strict ISO8601: requires month/day AND hour/minute/second to be valid values
+function validateISO8601Strict(v) {
+    if (!ISO8601_RE.test(v)) {
+        return false;
+    }
+    const m = v.match(/^(\d{4})-(\d{2})(?:-(\d{2}))?/);
+    if (!m) {
+        return true;
+    } // year-only — no month/day to range-check
+    const month = Number(m[2]);
+    if (month < 1 || month > 12) {
+        return false;
+    }
+    if (m[3] !== undefined) {
+        const day = Number(m[3]);
+        const maxDay = new Date(Number(m[1]), month, 0).getDate();
+        if (day < 1 || day > maxDay) {
+            return false;
+        }
+    }
+    // Time component check: hour 0-23, minute 0-59, second 0-60 (leap second).
+    const tm = v.match(/T(\d{2}):(\d{2}):(\d{2})/);
+    if (!tm) {
+        return true;
+    }
+    const hh = Number(tm[1]);
+    const mm = Number(tm[2]);
+    const ss = Number(tm[3]);
+    return hh >= 0 && hh <= 23 && mm >= 0 && mm <= 59 && ss >= 0 && ss <= 60;
+}
+function isISO8601(options) {
+    if (options?.strict) {
+        const validateStrict = (v) => typeof v === 'string' && validateISO8601Strict(v);
+        return makeRule({
+            name: 'isISO8601',
+            requiresType: 'string',
+            constraints: { format: 'date-time', strict: true },
+            validate: validateStrict,
+            emit: (varName, ctx) => {
+                const i = ctx.addRegex(ISO8601_RE);
+                return (`if (!re[${i}].test(${varName})) ${ctx.fail('isISO8601')};\n` +
+                    `else { var dm=${varName}.match(/^(\\d{4})-(\\d{2})(?:-(\\d{2}))?/);` +
+                    `if(dm){var mo=Number(dm[2]);` +
+                    `if(mo<1||mo>12){${ctx.fail('isISO8601')}}` +
+                    `else if(dm[3]!==undefined){var da=Number(dm[3]),md=new Date(Number(dm[1]),mo,0).getDate();` +
+                    `if(da<1||da>md){${ctx.fail('isISO8601')}}}}` +
+                    `var tm=${varName}.match(/T(\\d{2}):(\\d{2}):(\\d{2})/);` +
+                    `if(tm){var hh=Number(tm[1]),mm=Number(tm[2]),ss=Number(tm[3]);` +
+                    `if(hh<0||hh>23||mm<0||mm>59||ss<0||ss>60)${ctx.fail('isISO8601')};} }`);
+            },
+        });
+    }
+    // non-strict: both validate and emit use same ISO8601_RE
+    return makeStringRule('isISO8601', v => ISO8601_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(ISO8601_RE);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isISO8601')};`;
+    }, 'string', { format: 'date-time', strict: false });
+}
+// ISRC — ISO 3901
+const ISRC_RE = /^[A-Z]{2}-[A-Z0-9]{3}-\d{2}-\d{5}$|^[A-Z]{2}[A-Z0-9]{3}\d{7}$/;
+const isISRC = makeStringRule('isISRC', v => ISRC_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(ISRC_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isISRC')};`;
+});
+function validateISSN(value, options) {
+    const requireHyphen = options?.requireHyphen !== false;
+    const s = requireHyphen ? value : value.replace(/-/g, '');
+    // Format with hyphen: NNNN-NNNX, without: NNNNNNXX
+    const re = requireHyphen ? /^\d{4}-\d{3}[\dX]$/ : /^\d{7}[\dX]$/;
+    if (!re.test(s)) {
+        return false;
+    }
+    const digits = s.replace(/-/g, '');
+    let sum = 0;
+    for (let i = 0; i < 7; i++) {
+        sum += (8 - i) * (digits.charCodeAt(i) - 48);
+    }
+    const last = digits[7] === 'X' ? 10 : digits.charCodeAt(7) - 48;
+    sum += last;
+    return sum % 11 === 0;
+}
+function isISSN(options) {
+    const requireHyphen = options?.requireHyphen !== false;
+    const validateIssn = (value) => typeof value === 'string' && validateISSN(value, options);
+    const formatRe = requireHyphen ? /^\d{4}-\d{3}[\dX]$/ : /^\d{7}[\dX]$/;
+    return makeRule({
+        name: 'isISSN',
+        requiresType: 'string',
+        constraints: { requireHyphen: options?.requireHyphen },
+        validate: validateIssn,
+        emit: (varName, ctx) => {
+            const ri = ctx.addRegex(formatRe);
+            const strip = requireHyphen ? varName : `${varName}.replace(/-/g,'')`;
+            return (`{var issn=${strip};` +
+                `if(!re[${ri}].test(issn)){${ctx.fail('isISSN')}}` +
+                `else{var id=issn.replace(/-/g,''),iss=0;` +
+                `for(var ii=0;ii<7;ii++)iss+=(8-ii)*(id.charCodeAt(ii)-48);` +
+                `var il=id[7]==='X'?10:(id.charCodeAt(7)-48);iss+=il;` +
+                `if(iss%11!==0)${ctx.fail('isISSN')};}}`);
+        },
+    });
+}
+// JWT — 3-part dot-separated base64url
+const JWT_RE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+const isJWT = makeStringRule('isJWT', v => JWT_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(JWT_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isJWT')};`;
+});
+// LatLong
+const LAT_LONG_RE = /^[-+]?([1-8]?\d(?:\.\d+)?|90(?:\.0+)?),\s*[-+]?(180(?:\.0+)?|1[0-7]\d(?:\.\d+)?|\d{1,2}(?:\.\d+)?)$/;
+function isLatLong() {
+    return makeStringRule('isLatLong', v => LAT_LONG_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(LAT_LONG_RE);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isLatLong')};`;
+    });
+}
+// Locale — BCP 47 simplified
+const LOCALE_RE = /^[a-zA-Z]{2,3}(?:-[a-zA-Z]{4})?(?:-(?:[a-zA-Z]{2}|\d{3}))?(?:-[a-zA-Z\d]{5,8})*$/;
+const isLocale = makeStringRule('isLocale', v => LOCALE_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(LOCALE_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isLocale')};`;
+});
+// DataURI
+const DATA_URI_RE = /^data:([a-zA-Z0-9!#$&\-^_]+\/[a-zA-Z0-9!#$&\-^_]+)(?:;[a-zA-Z0-9-]+=[a-zA-Z0-9-]+)*(?:;base64)?,[\s\S]*$/;
+const isDataURI = makeStringRule('isDataURI', v => DATA_URI_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(DATA_URI_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isDataURI')};`;
+});
+function isFQDN(options) {
+    const requireTld = options?.require_tld !== false;
+    const allowUnderscores = options?.allow_underscores ?? false;
+    const allowTrailingDot = options?.allow_trailing_dot ?? false;
+    const partRe = allowUnderscores ? /^[a-zA-Z0-9_-]+$/ : /^[a-zA-Z0-9-]+$/;
+    const validateFqdn = (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        let str = value;
+        if (allowTrailingDot && str.endsWith('.')) {
+            str = str.slice(0, -1);
+        }
+        if (str.length === 0) {
+            return false;
+        }
+        const parts = str.split('.');
+        if (requireTld && parts.length < 2) {
+            return false;
+        }
+        if (requireTld) {
+            const tld = parts[parts.length - 1];
+            if (!tld || tld.length < 2 || !/^[a-zA-Z]{2,}$/.test(tld)) {
+                return false;
+            }
+        }
+        return parts.every(part => {
+            if (part.length === 0 || part.length > 63) {
+                return false;
+            }
+            if (!partRe.test(part)) {
+                return false;
+            }
+            if (!allowUnderscores && (part.startsWith('-') || part.endsWith('-'))) {
+                return false;
+            }
+            return true;
+        });
+    };
+    return makeRule({
+        name: 'isFQDN',
+        requiresType: 'string',
+        constraints: {
+            require_tld: options?.require_tld,
+            allow_underscores: options?.allow_underscores,
+            allow_trailing_dot: options?.allow_trailing_dot,
+        },
+        validate: validateFqdn,
+        emit: (varName, ctx) => {
+            const ri = ctx.addRegex(partRe);
+            const tldRi = requireTld ? ctx.addRegex(/^[a-zA-Z]{2,}$/) : -1;
+            // Inline for-loop instead of fp.every(function(p){...}) — avoids per-call closure
+            // allocation inside the JIT executor.
+            const partCheck = `if(p.length===0||p.length>63){fqOk=false;break;}` +
+                `if(!re[${ri}].test(p)){fqOk=false;break;}` +
+                (allowUnderscores ? '' : `if(p[0]==='-'||p[p.length-1]==='-'){fqOk=false;break;}`);
+            const loopBlock = `var fqOk=true;for(var fi=0;fi<fp.length;fi++){var p=fp[fi];${partCheck}}if(!fqOk)${ctx.fail('isFQDN')};`;
+            let code = `{var fq=${varName};`;
+            if (allowTrailingDot) {
+                code += `if(fq.endsWith('.'))fq=fq.slice(0,-1);`;
+            }
+            code += `if(fq.length===0)${ctx.fail('isFQDN')};`;
+            code += `else{var fp=fq.split('.');`;
+            if (requireTld) {
+                code += `if(fp.length<2)${ctx.fail('isFQDN')};`;
+                code += `else{var tld=fp[fp.length-1];`;
+                code += `if(!tld||tld.length<2||!re[${tldRi}].test(tld))${ctx.fail('isFQDN')};`;
+                code += `else{${loopBlock}}`; // close tld inner else block
+                code += '}'; // close tld outer else block
+            }
+            else {
+                code += loopBlock;
+            }
+            code += '}'; // close split else{
+            code += '}'; // close outer {
+            return code;
+        },
+    });
+}
+// Port — 0 to 65535
+const PORT_RE = /^(?:6553[0-5]|655[0-2]\d|65[0-4]\d{2}|6[0-4]\d{3}|[1-5]\d{4}|[1-9]\d{1,3}|\d)$/;
+const isPort = makeStringRule('isPort', v => PORT_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(PORT_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isPort')};`;
+});
+// EAN (EAN-8 and EAN-13 with checksum)
+function validateEAN(value) {
+    if (!/^\d{8}$/.test(value) && !/^\d{13}$/.test(value)) {
+        return false;
+    }
+    // Walk via charCodeAt — no split/map array allocations
+    const len = value.length;
+    let sum = 0;
+    for (let i = 0; i < len - 1; i++) {
+        const d = value.charCodeAt(i) - 48;
+        sum += d * (len === 8 ? (i % 2 === 0 ? 3 : 1) : i % 2 === 0 ? 1 : 3);
+    }
+    const check = (10 - (sum % 10)) % 10;
+    return check === value.charCodeAt(len - 1) - 48;
+}
+const isEAN = makeStringRule('isEAN', validateEAN, (varName, ctx) => {
+    const re8 = ctx.addRegex(/^\d{8}$/);
+    const re13 = ctx.addRegex(/^\d{13}$/);
+    return (`{var ev=${varName};` +
+        `if(!re[${re8}].test(ev)&&!re[${re13}].test(ev)){${ctx.fail('isEAN')}}` +
+        `else{var el=ev.length,es=0;` +
+        `for(var ei=0;ei<el-1;ei++){var ed=ev.charCodeAt(ei)-48;es+=ed*(el===8?(ei%2===0?3:1):(ei%2===0?1:3));}` +
+        `var ec=(10-(es%10))%10;` +
+        `if(ec!==(ev.charCodeAt(el-1)-48))${ctx.fail('isEAN')};}}`);
+});
+// ISO 3166-1 Alpha-2
+const ISO31661A2_CODES = new Set([
+    'AD',
+    'AE',
+    'AF',
+    'AG',
+    'AI',
+    'AL',
+    'AM',
+    'AO',
+    'AQ',
+    'AR',
+    'AS',
+    'AT',
+    'AU',
+    'AW',
+    'AX',
+    'AZ',
+    'BA',
+    'BB',
+    'BD',
+    'BE',
+    'BF',
+    'BG',
+    'BH',
+    'BI',
+    'BJ',
+    'BL',
+    'BM',
+    'BN',
+    'BO',
+    'BQ',
+    'BR',
+    'BS',
+    'BT',
+    'BV',
+    'BW',
+    'BY',
+    'BZ',
+    'CA',
+    'CC',
+    'CD',
+    'CF',
+    'CG',
+    'CH',
+    'CI',
+    'CK',
+    'CL',
+    'CM',
+    'CN',
+    'CO',
+    'CR',
+    'CU',
+    'CV',
+    'CW',
+    'CX',
+    'CY',
+    'CZ',
+    'DE',
+    'DJ',
+    'DK',
+    'DM',
+    'DO',
+    'DZ',
+    'EC',
+    'EE',
+    'EG',
+    'EH',
+    'ER',
+    'ES',
+    'ET',
+    'FI',
+    'FJ',
+    'FK',
+    'FM',
+    'FO',
+    'FR',
+    'GA',
+    'GB',
+    'GD',
+    'GE',
+    'GF',
+    'GG',
+    'GH',
+    'GI',
+    'GL',
+    'GM',
+    'GN',
+    'GP',
+    'GQ',
+    'GR',
+    'GS',
+    'GT',
+    'GU',
+    'GW',
+    'GY',
+    'HK',
+    'HM',
+    'HN',
+    'HR',
+    'HT',
+    'HU',
+    'ID',
+    'IE',
+    'IL',
+    'IM',
+    'IN',
+    'IO',
+    'IQ',
+    'IR',
+    'IS',
+    'IT',
+    'JE',
+    'JM',
+    'JO',
+    'JP',
+    'KE',
+    'KG',
+    'KH',
+    'KI',
+    'KM',
+    'KN',
+    'KP',
+    'KR',
+    'KW',
+    'KY',
+    'KZ',
+    'LA',
+    'LB',
+    'LC',
+    'LI',
+    'LK',
+    'LR',
+    'LS',
+    'LT',
+    'LU',
+    'LV',
+    'LY',
+    'MA',
+    'MC',
+    'MD',
+    'ME',
+    'MF',
+    'MG',
+    'MH',
+    'MK',
+    'ML',
+    'MM',
+    'MN',
+    'MO',
+    'MP',
+    'MQ',
+    'MR',
+    'MS',
+    'MT',
+    'MU',
+    'MV',
+    'MW',
+    'MX',
+    'MY',
+    'MZ',
+    'NA',
+    'NC',
+    'NE',
+    'NF',
+    'NG',
+    'NI',
+    'NL',
+    'NO',
+    'NP',
+    'NR',
+    'NU',
+    'NZ',
+    'OM',
+    'PA',
+    'PE',
+    'PF',
+    'PG',
+    'PH',
+    'PK',
+    'PL',
+    'PM',
+    'PN',
+    'PR',
+    'PS',
+    'PT',
+    'PW',
+    'PY',
+    'QA',
+    'RE',
+    'RO',
+    'RS',
+    'RU',
+    'RW',
+    'SA',
+    'SB',
+    'SC',
+    'SD',
+    'SE',
+    'SG',
+    'SH',
+    'SI',
+    'SJ',
+    'SK',
+    'SL',
+    'SM',
+    'SN',
+    'SO',
+    'SR',
+    'SS',
+    'ST',
+    'SV',
+    'SX',
+    'SY',
+    'SZ',
+    'TC',
+    'TD',
+    'TF',
+    'TG',
+    'TH',
+    'TJ',
+    'TK',
+    'TL',
+    'TM',
+    'TN',
+    'TO',
+    'TR',
+    'TT',
+    'TV',
+    'TW',
+    'TZ',
+    'UA',
+    'UG',
+    'UM',
+    'US',
+    'UY',
+    'UZ',
+    'VA',
+    'VC',
+    'VE',
+    'VG',
+    'VI',
+    'VN',
+    'VU',
+    'WF',
+    'WS',
+    'YE',
+    'YT',
+    'ZA',
+    'ZM',
+    'ZW',
+]);
+const isISO31661Alpha2 = makeRule({
+    name: 'isISO31661Alpha2',
+    requiresType: 'string',
+    constraints: {},
+    validate: value => typeof value === 'string' && ISO31661A2_CODES.has(value.toUpperCase()),
+    emit: (varName, ctx) => {
+        const i = ctx.addRef(ISO31661A2_CODES);
+        return `if (!refs[${i}].has(${varName}.toUpperCase())) ${ctx.fail('isISO31661Alpha2')};`;
+    },
+});
+// ISO 3166-1 Alpha-3
+const ISO31661A3_CODES = new Set([
+    'ABW',
+    'AFG',
+    'AGO',
+    'AIA',
+    'ALA',
+    'ALB',
+    'AND',
+    'ANT',
+    'ARE',
+    'ARG',
+    'ARM',
+    'ASM',
+    'ATA',
+    'ATF',
+    'ATG',
+    'AUS',
+    'AUT',
+    'AZE',
+    'BDI',
+    'BEL',
+    'BEN',
+    'BES',
+    'BFA',
+    'BGD',
+    'BGR',
+    'BHR',
+    'BHS',
+    'BIH',
+    'BLM',
+    'BLR',
+    'BLZ',
+    'BMU',
+    'BOL',
+    'BRA',
+    'BRB',
+    'BRN',
+    'BTN',
+    'BVT',
+    'BWA',
+    'CAF',
+    'CAN',
+    'CCK',
+    'CHE',
+    'CHL',
+    'CHN',
+    'CIV',
+    'CMR',
+    'COD',
+    'COG',
+    'COK',
+    'COL',
+    'COM',
+    'CPV',
+    'CRI',
+    'CUB',
+    'CUW',
+    'CXR',
+    'CYM',
+    'CYP',
+    'CZE',
+    'DEU',
+    'DJI',
+    'DMA',
+    'DNK',
+    'DOM',
+    'DZA',
+    'ECU',
+    'EGY',
+    'ERI',
+    'ESH',
+    'ESP',
+    'EST',
+    'ETH',
+    'FIN',
+    'FJI',
+    'FLK',
+    'FRA',
+    'FRO',
+    'FSM',
+    'GAB',
+    'GBR',
+    'GEO',
+    'GGY',
+    'GHA',
+    'GIB',
+    'GIN',
+    'GLP',
+    'GMB',
+    'GNB',
+    'GNQ',
+    'GRC',
+    'GRD',
+    'GRL',
+    'GTM',
+    'GUF',
+    'GUM',
+    'GUY',
+    'HKG',
+    'HMD',
+    'HND',
+    'HRV',
+    'HTI',
+    'HUN',
+    'IDN',
+    'IMN',
+    'IND',
+    'IOT',
+    'IRL',
+    'IRN',
+    'IRQ',
+    'ISL',
+    'ISR',
+    'ITA',
+    'JAM',
+    'JEY',
+    'JOR',
+    'JPN',
+    'KAZ',
+    'KEN',
+    'KGZ',
+    'KHM',
+    'KIR',
+    'KNA',
+    'KOR',
+    'KWT',
+    'LAO',
+    'LBN',
+    'LBR',
+    'LBY',
+    'LCA',
+    'LIE',
+    'LKA',
+    'LSO',
+    'LTU',
+    'LUX',
+    'LVA',
+    'MAC',
+    'MAF',
+    'MAR',
+    'MCO',
+    'MDA',
+    'MDG',
+    'MDV',
+    'MEX',
+    'MHL',
+    'MKD',
+    'MLI',
+    'MLT',
+    'MMR',
+    'MNE',
+    'MNG',
+    'MNP',
+    'MOZ',
+    'MRT',
+    'MSR',
+    'MTQ',
+    'MUS',
+    'MWI',
+    'MYS',
+    'MYT',
+    'NAM',
+    'NCL',
+    'NER',
+    'NFK',
+    'NGA',
+    'NIC',
+    'NIU',
+    'NLD',
+    'NOR',
+    'NPL',
+    'NRU',
+    'NZL',
+    'OMN',
+    'PAK',
+    'PAN',
+    'PCN',
+    'PER',
+    'PHL',
+    'PLW',
+    'PNG',
+    'POL',
+    'PRI',
+    'PRK',
+    'PRT',
+    'PRY',
+    'PSE',
+    'PYF',
+    'QAT',
+    'REU',
+    'ROU',
+    'RUS',
+    'RWA',
+    'SAU',
+    'SDN',
+    'SEN',
+    'SGP',
+    'SGS',
+    'SHN',
+    'SJM',
+    'SLB',
+    'SLE',
+    'SLV',
+    'SMR',
+    'SOM',
+    'SPM',
+    'SRB',
+    'SSD',
+    'STP',
+    'SUR',
+    'SVK',
+    'SVN',
+    'SWE',
+    'SWZ',
+    'SXM',
+    'SYC',
+    'SYR',
+    'TCA',
+    'TCD',
+    'TGO',
+    'THA',
+    'TJK',
+    'TKL',
+    'TKM',
+    'TLS',
+    'TON',
+    'TTO',
+    'TUN',
+    'TUR',
+    'TUV',
+    'TWN',
+    'TZA',
+    'UGA',
+    'UKR',
+    'UMI',
+    'URY',
+    'USA',
+    'UZB',
+    'VAT',
+    'VCT',
+    'VEN',
+    'VGB',
+    'VIR',
+    'VNM',
+    'VUT',
+    'WLF',
+    'WSM',
+    'YEM',
+    'ZAF',
+    'ZMB',
+    'ZWE',
+]);
+const isISO31661Alpha3 = makeRule({
+    name: 'isISO31661Alpha3',
+    requiresType: 'string',
+    constraints: {},
+    validate: value => typeof value === 'string' && ISO31661A3_CODES.has(value.toUpperCase()),
+    emit: (varName, ctx) => {
+        const i = ctx.addRef(ISO31661A3_CODES);
+        return `if (!refs[${i}].has(${varName}.toUpperCase())) ${ctx.fail('isISO31661Alpha3')};`;
+    },
+});
+// BIC / SWIFT code — case-insensitive via /i flag avoids per-call .toUpperCase() string allocation
+const BIC_RE = /^[A-Z]{6}[A-Z0-9]{2}(?:[A-Z0-9]{3})?$/i;
+const isBIC = makeStringRule('isBIC', v => BIC_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(BIC_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isBIC')};`;
+});
+// Firebase Push ID — 20 chars, base64url charset (-0-9A-Za-z_)
+const FIREBASE_RE = /^[a-zA-Z0-9_-]{20}$/;
+const isFirebasePushId = makeStringRule('isFirebasePushId', v => FIREBASE_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(FIREBASE_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isFirebasePushId')};`;
+});
+// SemVer — Semantic Versioning 2.0
+const SEMVER_RE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+const isSemVer = makeStringRule('isSemVer', v => SEMVER_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(SEMVER_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isSemVer')};`;
+});
+// MongoDB ObjectId — 24-char hex
+const MONGO_ID_RE = /^[0-9a-fA-F]{24}$/;
+const isMongoId = makeStringRule('isMongoId', v => MONGO_ID_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(MONGO_ID_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isMongoId')};`;
+});
+// JSON
+const validateJsonString = (value) => {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const isJSON = makeRule({
+    name: 'isJSON',
+    requiresType: 'string',
+    constraints: {},
+    validate: validateJsonString,
+    emit: (varName, ctx) => `try { JSON.parse(${varName}); } catch { ${ctx.fail('isJSON')}; }`,
+});
+// Base32
+const BASE32_RE = /^[A-Z2-7]+=*$/i;
+// Empty-string fails the `+`-quantified regex anyway, so the explicit length===0 check is dead.
+function isBase32() {
+    return makeStringRule('isBase32', v => v.length % 8 === 0 && BASE32_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(BASE32_RE);
+        return `if (${varName}.length % 8 !== 0 || !re[${i}].test(${varName})) ${ctx.fail('isBase32')};`;
+    });
+}
+// Base58
+const BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]+$/;
+const isBase58 = makeStringRule('isBase58', v => BASE58_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(BASE58_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isBase58')};`;
+});
+// Base64
+const BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/;
+const BASE64_URL_RE = /^[A-Za-z0-9_-]+={0,2}$/;
+function isBase64(options) {
+    const re = options?.urlSafe ? BASE64_URL_RE : BASE64_RE;
+    // Empty-string check is redundant — both base64 regexes require ≥1 char and fail on empty input.
+    return makeStringRule('isBase64', v => re.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(re);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isBase64')};`;
+    }, 'string', { urlSafe: options?.urlSafe });
+}
+// DateString — ISO 8601 date only (YYYY-MM-DD) with calendar validity (day must exist in month/year).
+const DATE_STRING_RE = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
+function isCalendarValidDate(v) {
+    if (!DATE_STRING_RE.test(v)) {
+        return false;
+    }
+    const y = Number(v.slice(0, 4));
+    const m = Number(v.slice(5, 7));
+    const d = Number(v.slice(8, 10));
+    const maxDay = new Date(y, m, 0).getDate();
+    return d >= 1 && d <= maxDay;
+}
+function isDateString() {
+    return makeStringRule('isDateString', isCalendarValidDate, (varName, ctx) => {
+        const i = ctx.addRegex(DATE_STRING_RE);
+        return (`if (!re[${i}].test(${varName})) ${ctx.fail('isDateString')};\n` +
+            `else { var y=Number(${varName}.slice(0,4)),m=Number(${varName}.slice(5,7)),d=Number(${varName}.slice(8,10));` +
+            `var md=new Date(y,m,0).getDate(); if(d<1||d>md)${ctx.fail('isDateString')}; }`);
+    });
+}
+// MimeType
+const MIME_TYPE_RE = /^(application|audio|font|image|message|model|multipart|text|video)\/[a-zA-Z0-9][a-zA-Z0-9!#$&\-^_.+]*(?:;.+)?$/;
+const isMimeType = makeStringRule('isMimeType', v => MIME_TYPE_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(MIME_TYPE_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isMimeType')};`;
+});
+// Currency
+// A single optional sign, either before the `$` (`-$5`, `+5`) or after it (`$-5`, `$+5`) — never
+// both. The previous `[-+]?\$?-?` allowed two signs (e.g. `+-5`, `-$-5`).
+const CURRENCY_RE = /^(?:[-+]?\$?|\$[-+]?)(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d{1,2})?$/;
+function isCurrency() {
+    // Currency regex requires at least one digit; empty input fails the regex by itself.
+    return makeStringRule('isCurrency', v => CURRENCY_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(CURRENCY_RE);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isCurrency')};`;
+    });
+}
+// Magnet URI
+const MAGNET_URI_RE = /^magnet:\?xt=urn:[a-z0-9]+:[a-z0-9]{32,40}(?:&[a-z][a-z0-9.]*=[^&\s]*)*$/i;
+const isMagnetURI = makeStringRule('isMagnetURI', v => MAGNET_URI_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(MAGNET_URI_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isMagnetURI')};`;
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// Group D: Algorithm-based
+// ─────────────────────────────────────────────────────────────────────────────
+// Credit Card — Luhn algorithm (§4.8 C)
+function luhn(str) {
+    const s = str.replace(/[\s-]/g, '');
+    if (s.length === 0 || !/^\d+$/.test(s)) {
+        return false;
+    }
+    let sum = 0;
+    let alternate = false;
+    for (let i = s.length - 1; i >= 0; i--) {
+        let n = s.charCodeAt(i) - 48;
+        if (alternate) {
+            n *= 2;
+            if (n > 9) {
+                n -= 9;
+            }
+        }
+        sum += n;
+        alternate = !alternate;
+    }
+    return sum % 10 === 0;
+}
+const isCreditCard = makeRule({
+    name: 'isCreditCard',
+    requiresType: 'string',
+    constraints: {},
+    validate: value => typeof value === 'string' && luhn(value),
+    emit: (varName, ctx) => `{
+  var cs=${varName}.replace(/[\\s-]/g,'');
+  if(cs.length===0||!/^\\d+$/.test(cs)){${ctx.fail('isCreditCard')}}
+  else{var sum=0,alt=false;
+  for(var ci=cs.length-1;ci>=0;ci--){var cn=cs.charCodeAt(ci)-48;if(alt){cn*=2;if(cn>9)cn-=9;}sum+=cn;alt=!alt;}
+  if(sum%10!==0)${ctx.fail('isCreditCard')};}
+}`,
+});
+const IBAN_COUNTRY_LENGTH = {
+    AD: 24,
+    AE: 23,
+    AL: 28,
+    AT: 20,
+    AZ: 28,
+    BA: 20,
+    BE: 16,
+    BG: 22,
+    BH: 22,
+    BR: 29,
+    CH: 21,
+    CR: 22,
+    CY: 28,
+    CZ: 24,
+    DE: 22,
+    DK: 18,
+    DO: 28,
+    EE: 20,
+    ES: 24,
+    FI: 18,
+    FO: 18,
+    FR: 27,
+    GB: 22,
+    GE: 22,
+    GI: 23,
+    GL: 18,
+    GR: 27,
+    GT: 28,
+    HR: 21,
+    HU: 28,
+    IE: 22,
+    IL: 23,
+    IS: 26,
+    IT: 27,
+    JO: 30,
+    KW: 30,
+    KZ: 20,
+    LB: 28,
+    LC: 32,
+    LI: 21,
+    LT: 20,
+    LU: 20,
+    LV: 21,
+    MC: 27,
+    MD: 24,
+    ME: 22,
+    MK: 19,
+    MR: 27,
+    MT: 31,
+    MU: 30,
+    NL: 18,
+    NO: 15,
+    PK: 24,
+    PL: 28,
+    PS: 29,
+    PT: 25,
+    QA: 29,
+    RO: 24,
+    RS: 22,
+    SA: 24,
+    SC: 31,
+    SE: 24,
+    SI: 19,
+    SK: 24,
+    SM: 27,
+    ST: 25,
+    SV: 28,
+    TL: 23,
+    TN: 24,
+    TR: 26,
+    UA: 29,
+    VA: 22,
+    VG: 24,
+    XK: 20,
+};
+function validateIBAN(value, options) {
+    let s = options?.allowSpaces ? value.replace(/\s/g, '') : value;
+    s = s.toUpperCase();
+    if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(s)) {
+        return false;
+    }
+    const country = s.slice(0, 2);
+    const expectedLength = IBAN_COUNTRY_LENGTH[country];
+    if (expectedLength !== undefined && s.length !== expectedLength) {
+        return false;
+    }
+    // Rearrange: move first 4 chars to end
+    const rearranged = s.slice(4) + s.slice(0, 4);
+    // Walk char-by-char accumulating mod 97 — no .replace/closure, no String() coercion,
+    // no parseInt() allocations.
+    let remainder = 0;
+    for (let i = 0; i < rearranged.length; i++) {
+        const code = rearranged.charCodeAt(i);
+        if (code <= 57) {
+            // digit
+            remainder = (remainder * 10 + (code - 48)) % 97;
+        }
+        else {
+            // letter A-Z → two digits (value = code - 55)
+            const value = code - 55;
+            remainder = (remainder * 100 + value) % 97;
+        }
+    }
+    return remainder === 1;
+}
+function isIBAN(options) {
+    const allowSpaces = options?.allowSpaces ?? false;
+    const validateIban = (value) => typeof value === 'string' && validateIBAN(value, options);
+    return makeRule({
+        name: 'isIBAN',
+        requiresType: 'string',
+        constraints: { allowSpaces: options?.allowSpaces },
+        validate: validateIban,
+        emit: (varName, ctx) => {
+            const baseRi = ctx.addRegex(/^[A-Z]{2}\d{2}[A-Z0-9]+$/);
+            const tableIdx = ctx.addRef(IBAN_COUNTRY_LENGTH);
+            let code = '{';
+            code += `var ib=${allowSpaces ? `${varName}.replace(/\\s/g,'')` : varName}.toUpperCase();`;
+            code += `if(!re[${baseRi}].test(ib)){${ctx.fail('isIBAN')}}`;
+            code += `else{var ic=ib.slice(0,2),il=refs[${tableIdx}][ic];`;
+            code += `if(il!==undefined&&ib.length!==il){${ctx.fail('isIBAN')}}`;
+            code += `else{var ir=ib.slice(4)+ib.slice(0,4);`;
+            // Walk char-by-char for mod 97 — no .replace closure, no parseInt allocation
+            code += `var im=0;for(var ii=0;ii<ir.length;ii++){var cc=ir.charCodeAt(ii);`;
+            code += `if(cc<=57){im=(im*10+(cc-48))%97;}else{im=(im*100+(cc-55))%97;}}`;
+            code += `if(im!==1)${ctx.fail('isIBAN')};}}}`;
+            return code;
+        },
+    });
+}
+// ByteLength — counts UTF-8 bytes via Buffer.byteLength
+function isByteLength(min, max) {
+    const validateByteLength = (value) => {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        const byteLen = Buffer.byteLength(value, 'utf8');
+        if (byteLen < min) {
+            return false;
+        }
+        if (max !== undefined && byteLen > max) {
+            return false;
+        }
+        return true;
+    };
+    return makeRule({
+        name: 'isByteLength',
+        requiresType: 'string',
+        constraints: { min, max },
+        validate: validateByteLength,
+        emit: (varName, ctx) => {
+            let code = `{var bl=Buffer.byteLength(${varName},'utf8');`;
+            code += `if(bl<${min})${ctx.fail('isByteLength')};`;
+            if (max !== undefined) {
+                code += `else if(bl>${max})${ctx.fail('isByteLength')};`;
+            }
+            code += '}';
+            return code;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Group E: New Validators
+// ─────────────────────────────────────────────────────────────────────────────
+// isHash — per-algorithm hex regex (§4.8 B: regex inline)
+const HASH_REGEXES = {
+    md5: /^[a-f0-9]{32}$/i,
+    md4: /^[a-f0-9]{32}$/i,
+    md2: /^[a-f0-9]{32}$/i,
+    sha1: /^[a-f0-9]{40}$/i,
+    sha256: /^[a-f0-9]{64}$/i,
+    sha384: /^[a-f0-9]{96}$/i,
+    sha512: /^[a-f0-9]{128}$/i,
+    ripemd128: /^[a-f0-9]{32}$/i,
+    ripemd160: /^[a-f0-9]{40}$/i,
+    'tiger128,3': /^[a-f0-9]{32}$/i,
+    'tiger128,4': /^[a-f0-9]{32}$/i,
+    'tiger160,3': /^[a-f0-9]{40}$/i,
+    'tiger160,4': /^[a-f0-9]{40}$/i,
+    'tiger192,3': /^[a-f0-9]{48}$/i,
+    'tiger192,4': /^[a-f0-9]{48}$/i,
+    crc32: /^[a-f0-9]{8}$/i,
+    crc32b: /^[a-f0-9]{8}$/i,
+};
+function isHash(algorithm) {
+    const re = HASH_REGEXES[algorithm];
+    return makeRule({
+        name: 'isHash',
+        requiresType: 'string',
+        constraints: { algorithm },
+        validate: value => typeof value === 'string' && !!re && re.test(value),
+        emit: (varName, ctx) => {
+            if (!re) {
+                return ctx.fail('isHash') + ';';
+            }
+            const i = ctx.addRegex(re);
+            return `if (!re[${i}].test(${varName})) ${ctx.fail('isHash')};`;
+        },
+    });
+}
+// isRFC3339 — RFC 3339 datetime (§4.8 B)
+const RFC3339_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/i;
+const isRFC3339 = makeStringRule('isRFC3339', v => RFC3339_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(RFC3339_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isRFC3339')};`;
+});
+// isMilitaryTime — HH:MM 24-hour format (§4.8 B)
+const MILITARY_TIME_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
+const isMilitaryTime = makeStringRule('isMilitaryTime', v => MILITARY_TIME_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(MILITARY_TIME_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isMilitaryTime')};`;
+});
+// isLatitude — string or number, -90 to 90 (requiresType none)
+function checkLatitude(value) {
+    if (typeof value === 'number') {
+        return value >= -90 && value <= 90;
+    }
+    if (typeof value === 'string') {
+        const n = parseFloat(value);
+        if (isNaN(n)) {
+            return false;
+        }
+        // parseFloat('90abc') = 90 — strict regex check rejects trailing garbage
+        if (!/^-?\d+(\.\d+)?$/.test(value)) {
+            return false;
+        }
+        return n >= -90 && n <= 90;
+    }
+    return false;
+}
+const isLatitude = makeRule({
+    name: 'isLatitude',
+    constraints: {},
+    validate: checkLatitude,
+    emit: (varName, ctx) => {
+        const ri = ctx.addRegex(/^-?\d+(\.\d+)?$/);
+        return (`if(typeof ${varName}==='number'){if(${varName}<-90||${varName}>90)${ctx.fail('isLatitude')};}` +
+            `else if(typeof ${varName}==='string'){` +
+            // Regex catches non-numeric strings; if it matches, parseFloat is guaranteed valid (no isNaN check needed)
+            `if(!re[${ri}].test(${varName})){${ctx.fail('isLatitude')}}` +
+            `else{var lt=parseFloat(${varName});if(lt<-90||lt>90)${ctx.fail('isLatitude')};}}` +
+            `else{${ctx.fail('isLatitude')};}`);
+    },
+});
+// isLongitude — string or number, -180 to 180 (requiresType none)
+function checkLongitude(value) {
+    if (typeof value === 'number') {
+        return value >= -180 && value <= 180;
+    }
+    if (typeof value === 'string') {
+        const n = parseFloat(value);
+        if (isNaN(n)) {
+            return false;
+        }
+        if (!/^-?\d+(\.\d+)?$/.test(value)) {
+            return false;
+        }
+        return n >= -180 && n <= 180;
+    }
+    return false;
+}
+const isLongitude = makeRule({
+    name: 'isLongitude',
+    constraints: {},
+    validate: checkLongitude,
+    emit: (varName, ctx) => {
+        const ri = ctx.addRegex(/^-?\d+(\.\d+)?$/);
+        return (`if(typeof ${varName}==='number'){if(${varName}<-180||${varName}>180)${ctx.fail('isLongitude')};}` +
+            `else if(typeof ${varName}==='string'){` +
+            `if(!re[${ri}].test(${varName})){${ctx.fail('isLongitude')}}` +
+            `else{var ln=parseFloat(${varName});if(ln<-180||ln>180)${ctx.fail('isLongitude')};}}` +
+            `else{${ctx.fail('isLongitude')};}`);
+    },
+});
+// isEthereumAddress — 0x + 40 hex chars (§4.8 B)
+const ETH_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+const isEthereumAddress = makeStringRule('isEthereumAddress', v => ETH_ADDRESS_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(ETH_ADDRESS_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isEthereumAddress')};`;
+});
+// isBtcAddress — P2PKH (1...), P2SH (3...), bech32 (bc1...) (§4.8 B)
+const BTC_P2PKH_RE = /^1[a-km-zA-HJ-NP-Z1-9]{25,34}$/;
+const BTC_P2SH_RE = /^3[a-km-zA-HJ-NP-Z1-9]{25,34}$/;
+const BTC_BECH32_RE = /^(bc1)[a-z0-9]{6,87}$/;
+const isBtcAddress = makeStringRule('isBtcAddress', v => BTC_P2PKH_RE.test(v) || BTC_P2SH_RE.test(v) || BTC_BECH32_RE.test(v), (varName, ctx) => {
+    const i1 = ctx.addRegex(BTC_P2PKH_RE);
+    const i2 = ctx.addRegex(BTC_P2SH_RE);
+    const i3 = ctx.addRegex(BTC_BECH32_RE);
+    return `if (!re[${i1}].test(${varName}) && !re[${i2}].test(${varName}) && !re[${i3}].test(${varName})) ${ctx.fail('isBtcAddress')};`;
+});
+// isISO4217CurrencyCode — ISO 4217 currency code set (§4.8 C: ref-based)
+const ISO4217_CODES = new Set([
+    'AED',
+    'AFN',
+    'ALL',
+    'AMD',
+    'ANG',
+    'AOA',
+    'ARS',
+    'AUD',
+    'AWG',
+    'AZN',
+    'BAM',
+    'BBD',
+    'BDT',
+    'BGN',
+    'BHD',
+    'BIF',
+    'BMD',
+    'BND',
+    'BOB',
+    'BOV',
+    'BRL',
+    'BSD',
+    'BTN',
+    'BWP',
+    'BYN',
+    'BZD',
+    'CAD',
+    'CDF',
+    'CHE',
+    'CHF',
+    'CHW',
+    'CLF',
+    'CLP',
+    'CNY',
+    'COP',
+    'COU',
+    'CRC',
+    'CUC',
+    'CUP',
+    'CVE',
+    'CZK',
+    'DJF',
+    'DKK',
+    'DOP',
+    'DZD',
+    'EGP',
+    'ERN',
+    'ETB',
+    'EUR',
+    'FJD',
+    'FKP',
+    'GBP',
+    'GEL',
+    'GHS',
+    'GIP',
+    'GMD',
+    'GNF',
+    'GTQ',
+    'GYD',
+    'HKD',
+    'HNL',
+    'HRK',
+    'HTG',
+    'HUF',
+    'IDR',
+    'ILS',
+    'INR',
+    'IQD',
+    'IRR',
+    'ISK',
+    'JMD',
+    'JOD',
+    'JPY',
+    'KES',
+    'KGS',
+    'KHR',
+    'KMF',
+    'KPW',
+    'KRW',
+    'KWD',
+    'KYD',
+    'KZT',
+    'LAK',
+    'LBP',
+    'LKR',
+    'LRD',
+    'LSL',
+    'LYD',
+    'MAD',
+    'MDL',
+    'MGA',
+    'MKD',
+    'MMK',
+    'MNT',
+    'MOP',
+    'MRU',
+    'MUR',
+    'MVR',
+    'MWK',
+    'MXN',
+    'MXV',
+    'MYR',
+    'MZN',
+    'NAD',
+    'NGN',
+    'NIO',
+    'NOK',
+    'NPR',
+    'NZD',
+    'OMR',
+    'PAB',
+    'PEN',
+    'PGK',
+    'PHP',
+    'PKR',
+    'PLN',
+    'PYG',
+    'QAR',
+    'RON',
+    'RSD',
+    'RUB',
+    'RWF',
+    'SAR',
+    'SBD',
+    'SCR',
+    'SDG',
+    'SEK',
+    'SGD',
+    'SHP',
+    'SLE',
+    'SLL',
+    'SOS',
+    'SRD',
+    'SSP',
+    'STN',
+    'SVC',
+    'SYP',
+    'SZL',
+    'THB',
+    'TJS',
+    'TMT',
+    'TND',
+    'TOP',
+    'TRY',
+    'TTD',
+    'TWD',
+    'TZS',
+    'UAH',
+    'UGX',
+    'USD',
+    'USN',
+    'UYI',
+    'UYU',
+    'UYW',
+    'UZS',
+    'VED',
+    'VES',
+    'VND',
+    'VUV',
+    'WST',
+    'XAF',
+    'XAG',
+    'XAU',
+    'XBA',
+    'XBB',
+    'XBC',
+    'XBD',
+    'XCD',
+    'XDR',
+    'XOF',
+    'XPD',
+    'XPF',
+    'XPT',
+    'XSU',
+    'XTS',
+    'XUA',
+    'YER',
+    'ZAR',
+    'ZMW',
+    'ZWL',
+]);
+const isISO4217CurrencyCode = makeStringRule('isISO4217CurrencyCode', v => ISO4217_CODES.has(v), (varName, ctx) => {
+    const i = ctx.addRef(ISO4217_CODES);
+    return `if (!refs[${i}].has(${varName})) ${ctx.fail('isISO4217CurrencyCode')};`;
+});
+// isPhoneNumber — E.164 international phone number (§4.8 B)
+const PHONE_E164_RE = /^\+[1-9]\d{6,14}$/;
+const isPhoneNumber = makeStringRule('isPhoneNumber', v => PHONE_E164_RE.test(v), (varName, ctx) => {
+    const i = ctx.addRegex(PHONE_E164_RE);
+    return `if (!re[${i}].test(${varName})) ${ctx.fail('isPhoneNumber')};`;
+});
+function isStrongPassword(options) {
+    const minLength = options?.minLength ?? 8;
+    const minLower = options?.minLowercase ?? 1;
+    const minUpper = options?.minUppercase ?? 1;
+    const minNums = options?.minNumbers ?? 1;
+    const minSymbols = options?.minSymbols ?? 1;
+    // Single-pass character classification — counts all categories in one scan.
+    // Replaces 4× v.match(/.../g) which allocates 4 result arrays per call.
+    const validate = (v) => {
+        if (v.length < minLength) {
+            return false;
+        }
+        let lower = 0;
+        let upper = 0;
+        let nums = 0;
+        let symbols = 0;
+        for (let i = 0; i < v.length; i++) {
+            const c = v.charCodeAt(i);
+            if (c >= 97 && c <= 122) {
+                lower++;
+            }
+            else if (c >= 65 && c <= 90) {
+                upper++;
+            }
+            else if (c >= 48 && c <= 57) {
+                nums++;
+            }
+            else {
+                symbols++;
+            }
+        }
+        return lower >= minLower && upper >= minUpper && nums >= minNums && symbols >= minSymbols;
+    };
+    return makeRule({
+        name: 'isStrongPassword',
+        requiresType: 'string',
+        constraints: {},
+        validate: value => typeof value === 'string' && validate(value),
+        emit: (varName, ctx) => {
+            // Inline single-pass scan in the JIT executor — no regex match[] allocations
+            const failExpr = ctx.fail('isStrongPassword');
+            const checks = [];
+            if (minLower > 0) {
+                checks.push(`spLo<${minLower}`);
+            }
+            if (minUpper > 0) {
+                checks.push(`spUp<${minUpper}`);
+            }
+            if (minNums > 0) {
+                checks.push(`spNum<${minNums}`);
+            }
+            if (minSymbols > 0) {
+                checks.push(`spSym<${minSymbols}`);
+            }
+            const guard = checks.length === 0 ? '' : `if(${checks.join('||')}){${failExpr}}`;
+            return (`if(${varName}.length<${minLength}){${failExpr}}else{` +
+                `var spLo=0,spUp=0,spNum=0,spSym=0;` +
+                `for(var spI=0;spI<${varName}.length;spI++){var spC=${varName}.charCodeAt(spI);` +
+                `if(spC>=97&&spC<=122)spLo++;else if(spC>=65&&spC<=90)spUp++;else if(spC>=48&&spC<=57)spNum++;else spSym++;}` +
+                guard +
+                `}`);
+        },
+    });
+}
+// isTaxId — locale-specific tax identifier (§4.8 C: factory)
+const TAX_ID_REGEXES = {
+    US: /^\d{2}-\d{7}$/, // EIN format: XX-XXXXXXX
+    KR: /^\d{3}-\d{2}-\d{5}$/, // Business Registration Number: XXX-XX-XXXXX
+    DE: /^\d{11}$/, // Steuernummer: 11 digits
+    FR: /^[0-9]{13}$/, // SIRET: 13 digits
+    GB: /^\d{10}$/, // UTR: 10 digits
+    IT: /^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$/i, // Codice Fiscale
+    ES: /^[0-9A-Z]\d{7}[0-9A-Z]$/i, // NIF/NIE/CIF
+    AU: /^\d{11}$/, // ABN: 11 digits
+    CA: /^\d{9}$/, // BN: 9 digits
+    IN: /^[A-Z]{5}\d{4}[A-Z]$/i, // PAN: XXXXX9999X
+};
+function isTaxId(locale) {
+    const re = TAX_ID_REGEXES[locale];
+    return makeRule({
+        name: 'isTaxId',
+        requiresType: 'string',
+        constraints: { locale },
+        validate: value => typeof value === 'string' && !!re && re.test(value),
+        emit: (varName, ctx) => {
+            if (!re) {
+                return ctx.fail('isTaxId') + ';';
+            }
+            const i = ctx.addRegex(re);
+            return `if (!re[${i}].test(${varName})) ${ctx.fail('isTaxId')};`;
+        },
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// ULID
+// ─────────────────────────────────────────────────────────────────────────────
+const ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+function isULID() {
+    return makeStringRule('isULID', v => ULID_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(ULID_RE);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isULID')};`;
+    }, 'string', { format: 'ulid' });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// CUID2
+// ─────────────────────────────────────────────────────────────────────────────
+// CUID2 spec: length 24-32, lowercase alphanum, starts with a-z.
+const CUID2_RE = /^[a-z][0-9a-z]{23,31}$/;
+function isCUID2() {
+    return makeStringRule('isCUID2', v => CUID2_RE.test(v), (varName, ctx) => {
+        const i = ctx.addRegex(CUID2_RE);
+        return `if (!re[${i}].test(${varName})) ${ctx.fail('isCUID2')};`;
+    }, 'string', { format: 'cuid2' });
+}
+export { minLength, maxLength, length, contains, notContains, matches, isLowercase, isUppercase, isAscii, isAlpha, isAlphanumeric, isHttpToken, isBooleanString, isNumberString, isDecimal, isFullWidth, isHalfWidth, isVariableWidth, isMultibyte, isSurrogatePair, isHexadecimal, isOctal, isEmail, isURL, isUUID, isIP, isHexColor, isRgbColor, isHSL, isMACAddress, isISBN, isISIN, isISO8601, isISRC, isISSN, isJWT, isLatLong, isLocale, isDataURI, isFQDN, isPort, isEAN, isISO31661Alpha2, isISO31661Alpha3, isBIC, isFirebasePushId, isSemVer, isMongoId, isJSON, isBase32, isBase58, isBase64, isDateString, isMimeType, isCurrency, isMagnetURI, isCreditCard, isIBAN, isByteLength, isHash, isRFC3339, isMilitaryTime, isLatitude, isLongitude, isEthereumAddress, isBtcAddress, isISO4217CurrencyCode, isPhoneNumber, isStrongPassword, isTaxId, isULID, isCUID2, };