indycheck 0.1.2 → 0.2.1

package/dist/index.d.ts

@@ -144,10 +144,13 @@ export interface VoterParsed {
 }
 export interface VehicleParsed {
     registration: string;
-    state_code: string;
-    district: string;
+    series_type: "state" | "bharat";
+    state_code?: string;
+    district?: string;
     series: string;
     number: string;
+    year?: string;
+    suffix?: string;
 }
 export interface DetectParsed {
     type: string | null;

package/dist/index.js

@@ -905,6 +905,11 @@ function validateVehicle(input) {
         if (chars.length < 8 || chars.length > 10) {
             return fail("INVALID_LENGTH", "Vehicle registration number must be 8-10 characters (e.g. DL01AB1234)", "Vehicle registration number 8 se 10 character ka hona chahiye (jaise DL01AB1234)");
         }
+        // Bharat (BH) series: YYBH####XX — starts with 2 digits (the year),
+        // so it must be checked before the state format (2 leading letters).
+        if (chars.slice(0, 2).every(isAsciiDigit)) {
+            return validateBharat(cleaned, chars);
+        }
         if (!chars.slice(0, 2).every(isAsciiAlpha)) {
             return fail("INVALID_FORMAT", "Vehicle registration number must start with 2 state-code letters (e.g. DL01AB1234)", "Vehicle registration number 2 state-code akshar se shuru hona chahiye (jaise DL01AB1234)");
         }
@@ -927,12 +932,37 @@ function validateVehicle(input) {
             return fail("INVALID_FORMAT", "Vehicle registration format must be state letters + district digits + series letters + number digits (e.g. DL01AB1234). Registration numbers have no checksum, so only the format is checked", "Vehicle registration ka format state akshar + district digit + series akshar + number digit hona chahiye (jaise DL01AB1234). Registration number ka koi checksum nahi hai, isliye sirf format check hota hai");
         }
         const stateCode = chars.slice(0, 2).join("");
-        return ok("Vehicle registration format is valid. Registration numbers have no checksum, so this only checks the format", "Vehicle registration ka format sahi hai. Registration number ka koi checksum nahi hai, isliye sirf format check hua hai", { registration: cleaned, state_code: stateCode, district, series, number });
+        return ok("Vehicle registration format is valid. Registration numbers have no checksum, so this only checks the format", "Vehicle registration ka format sahi hai. Registration number ka koi checksum nahi hai, isliye sirf format check hua hai", { registration: cleaned, series_type: "state", state_code: stateCode, district, series, number });
     }
     catch {
         return invalidType();
     }
 }
+/** Bharat (BH) series: `YYBH####XX` — called only when the cleaned input starts with digits. */
+function validateBharat(cleaned, chars) {
+    const notBharat = (en, hi) => fail("INVALID_FORMAT", en, hi);
+    const shapeOk = chars.length === 10 &&
+        chars[2] === "B" &&
+        chars[3] === "H" &&
+        chars.slice(4, 8).every(isAsciiDigit) &&
+        chars.slice(8, 10).every(isAsciiAlpha);
+    if (!shapeOk) {
+        return notBharat("Vehicle registration number must start with 2 state-code letters (e.g. DL01AB1234), or be a Bharat series number (e.g. 22BH1234AA)", "Vehicle registration number 2 state-code akshar se shuru hona chahiye (jaise DL01AB1234), ya Bharat series number hona chahiye (jaise 22BH1234AA)");
+    }
+    const year = chars.slice(0, 2).join("");
+    if (Number(year) < 21) {
+        return notBharat("Bharat (BH) series numbers start from 2021 — the year must be 21 or later (e.g. 22BH1234AA)", "Bharat (BH) series number 2021 se shuru hue hain — saal 21 ya usse baad ka hona chahiye (jaise 22BH1234AA)");
+    }
+    const number = chars.slice(4, 8).join("");
+    if (number === "0000") {
+        return notBharat("Bharat (BH) series number must be 0001-9999 (e.g. 22BH1234AA)", "Bharat (BH) series number 0001 se 9999 ke beech hona chahiye (jaise 22BH1234AA)");
+    }
+    const suffix = chars.slice(8, 10).join("");
+    if (suffix.includes("I") || suffix.includes("O")) {
+        return notBharat("Bharat (BH) series suffix letters cannot be I or O (e.g. 22BH1234AA)", "Bharat (BH) series ke aakhiri akshar I ya O nahi ho sakte (jaise 22BH1234AA)");
+    }
+    return ok("Bharat (BH) series vehicle registration format is valid. Registration numbers have no checksum, so this only checks the format", "Bharat (BH) series vehicle registration ka format sahi hai. Registration number ka koi checksum nahi hai, isliye sirf format check hua hai", { registration: cleaned, series_type: "bharat", year, series: "BH", number, suffix });
+}
 /** Alias for `validateVehicle`. */
 function validateVehicleRegistration(input) {
     return validateVehicle(input);

package/dist/native.d.ts

@@ -0,0 +1,122 @@
+/**
+ * indycheck — optional native (napi-rs) backend.
+ *
+ * Same public API as the pure-TypeScript mirror in `./index`, but the
+ * validation itself runs in the compiled Rust core through the
+ * napi-rs addon in `crates/indycheck-napi` instead of the TypeScript
+ * re-implementation. The addon is optional: when it is not built (or
+ * cannot be loaded) every function below falls back to `./index`
+ * silently, so the package works with no native code at all.
+ *
+ * How it loads: `isNativeAvailable()` tries, in order,
+ *  1. `INDYCHECK_NATIVE_PATH` — a path to the addon's `index.js` (or
+ *     directly to a `.node` file), when the env var is set;
+ *  2. `crates/indycheck-napi/index.js` relative to this file (works
+ *     from both `src/` under vitest and `dist/`);
+ *  3. the same path found by walking up from the current working
+ *     directory to a repo checkout.
+ * The `.node` binary itself is never committed to the repo — build it
+ * with `npm run build` in `crates/indycheck-napi` (see its README).
+ *
+ * Shape note: the Rust wrappers return JSON strings (see
+ * `crates/indycheck-napi/src/lib.rs`); they are parsed here into the
+ * same `{ valid, code, reason_en, reason_hi, parsed }` objects the
+ * TypeScript implementation returns. `detect` in Rust returns only
+ * the type string ("pan" | "aadhaar" | ... | "unknown"), so the
+ * `ValidationResult<DetectParsed>` shape is rebuilt here from the
+ * native type + the matching native validator, exactly like
+ * `detect` in `./index`. `validateMany` in Rust returns a bare
+ * `ValidationResult[]` (one per input, in order); the
+ * `input` / `type` / totals wrapper is rebuilt here with the same
+ * `VALID` / `SOME_INVALID` codes and reason strings as `./index`.
+ * The `*WithOptions` variants have no native equivalent (the Rust
+ * core's options live behind different entry points), so they always
+ * use the TypeScript implementation.
+ *
+ * Every function here never throws on bad input, like `./index`.
+ */
+import type { AadhaarParsed, CinParsed, DetectParsed, GstinParsed, IfscParsed, LlpinParsed, MobileParsed, PincodeParsed, TanParsed, UpiParsed, ValidateManyParsed, ValidationResult, VehicleParsed, VoterParsed } from "./index";
+import * as tsImpl from "./index";
+import type { PanParsed } from "./index";
+/** `true` when the native addon loaded and can be used. */
+export declare function isNativeAvailable(): boolean;
+/** Which backend the functions below are currently using. */
+export declare function backend(): "native" | "typescript";
+export declare function validatePan(input: unknown): ValidationResult<PanParsed>;
+export declare function validateAadhaar(input: unknown): ValidationResult<AadhaarParsed>;
+export declare function validateGstin(input: unknown): ValidationResult<GstinParsed>;
+export declare function validateIfsc(input: unknown): ValidationResult<IfscParsed>;
+export declare function validateUpi(input: unknown): ValidationResult<UpiParsed>;
+export declare function validateMobile(input: unknown): ValidationResult<MobileParsed>;
+export declare function validatePincode(input: unknown): ValidationResult<PincodeParsed>;
+export declare function validateTan(input: unknown): ValidationResult<TanParsed>;
+export declare function validateCin(input: unknown): ValidationResult<CinParsed>;
+export declare function validateLlpin(input: unknown): ValidationResult<LlpinParsed>;
+export declare function validateVoterId(input: unknown): ValidationResult<VoterParsed>;
+/** Alias for `validateVoterId`: EPIC is the name printed on the card. */
+export declare function validateEpic(input: unknown): ValidationResult<VoterParsed>;
+export declare function validateVehicle(input: unknown): ValidationResult<VehicleParsed>;
+/** Alias for `validateVehicle`. */
+export declare function validateVehicleRegistration(input: unknown): ValidationResult<VehicleParsed>;
+/** The Rust `detect` string for a trimmed input. */
+export declare function detectType(input: string): string;
+export declare function detect(input: unknown): ValidationResult<DetectParsed>;
+export declare function validateMany(inputs: unknown): ValidationResult<ValidateManyParsed>;
+export declare function formatMobile(input: unknown): ValidationResult<MobileParsed>;
+export declare function formatPan(input: unknown): string | null;
+export declare function formatGstin(input: unknown): string | null;
+export declare function maskAadhaar(input: unknown): ValidationResult<AadhaarParsed>;
+export declare function maskPan(input: unknown): string;
+export declare function maskMobile(input: unknown): string;
+export declare function generatePan(entity?: unknown): string;
+export declare function generateAadhaar(): string;
+export declare function generateGstin(stateCode?: unknown): string;
+export declare function generateMobile(): string;
+export declare const validateMobileWithOptions: typeof tsImpl.validateMobileWithOptions;
+export declare const validatePanWithOptions: typeof tsImpl.validatePanWithOptions;
+export declare const validateAadhaarWithOptions: typeof tsImpl.validateAadhaarWithOptions;
+export declare const validateGstinWithOptions: typeof tsImpl.validateGstinWithOptions;
+export declare const formatMobileWithOptions: typeof tsImpl.formatMobileWithOptions;
+export declare const defaultOptions: typeof tsImpl.defaultOptions;
+export declare const lenientOptions: typeof tsImpl.lenientOptions;
+export declare const noSpacesHyphensOptions: typeof tsImpl.noSpacesHyphensOptions;
+declare const _default: {
+    backend: typeof backend;
+    isNativeAvailable: typeof isNativeAvailable;
+    validateMobile: typeof validateMobile;
+    validatePan: typeof validatePan;
+    validateAadhaar: typeof validateAadhaar;
+    validateGstin: typeof validateGstin;
+    validateIfsc: typeof validateIfsc;
+    validateUpi: typeof validateUpi;
+    validatePincode: typeof validatePincode;
+    validateTan: typeof validateTan;
+    validateCin: typeof validateCin;
+    validateLlpin: typeof validateLlpin;
+    validateVoterId: typeof validateVoterId;
+    validateEpic: typeof validateEpic;
+    validateVehicle: typeof validateVehicle;
+    validateVehicleRegistration: typeof validateVehicleRegistration;
+    validateMobileWithOptions: typeof tsImpl.validateMobileWithOptions;
+    validatePanWithOptions: typeof tsImpl.validatePanWithOptions;
+    validateAadhaarWithOptions: typeof tsImpl.validateAadhaarWithOptions;
+    validateGstinWithOptions: typeof tsImpl.validateGstinWithOptions;
+    formatMobile: typeof formatMobile;
+    formatMobileWithOptions: typeof tsImpl.formatMobileWithOptions;
+    formatPan: typeof formatPan;
+    formatGstin: typeof formatGstin;
+    maskAadhaar: typeof maskAadhaar;
+    maskPan: typeof maskPan;
+    maskMobile: typeof maskMobile;
+    generatePan: typeof generatePan;
+    generateAadhaar: typeof generateAadhaar;
+    generateGstin: typeof generateGstin;
+    generateMobile: typeof generateMobile;
+    defaultOptions: typeof tsImpl.defaultOptions;
+    lenientOptions: typeof tsImpl.lenientOptions;
+    noSpacesHyphensOptions: typeof tsImpl.noSpacesHyphensOptions;
+    detect: typeof detect;
+    detectType: typeof detectType;
+    validateMany: typeof validateMany;
+};
+export default _default;

package/dist/native.js

@@ -0,0 +1,518 @@
+"use strict";
+/**
+ * indycheck — optional native (napi-rs) backend.
+ *
+ * Same public API as the pure-TypeScript mirror in `./index`, but the
+ * validation itself runs in the compiled Rust core through the
+ * napi-rs addon in `crates/indycheck-napi` instead of the TypeScript
+ * re-implementation. The addon is optional: when it is not built (or
+ * cannot be loaded) every function below falls back to `./index`
+ * silently, so the package works with no native code at all.
+ *
+ * How it loads: `isNativeAvailable()` tries, in order,
+ *  1. `INDYCHECK_NATIVE_PATH` — a path to the addon's `index.js` (or
+ *     directly to a `.node` file), when the env var is set;
+ *  2. `crates/indycheck-napi/index.js` relative to this file (works
+ *     from both `src/` under vitest and `dist/`);
+ *  3. the same path found by walking up from the current working
+ *     directory to a repo checkout.
+ * The `.node` binary itself is never committed to the repo — build it
+ * with `npm run build` in `crates/indycheck-napi` (see its README).
+ *
+ * Shape note: the Rust wrappers return JSON strings (see
+ * `crates/indycheck-napi/src/lib.rs`); they are parsed here into the
+ * same `{ valid, code, reason_en, reason_hi, parsed }` objects the
+ * TypeScript implementation returns. `detect` in Rust returns only
+ * the type string ("pan" | "aadhaar" | ... | "unknown"), so the
+ * `ValidationResult<DetectParsed>` shape is rebuilt here from the
+ * native type + the matching native validator, exactly like
+ * `detect` in `./index`. `validateMany` in Rust returns a bare
+ * `ValidationResult[]` (one per input, in order); the
+ * `input` / `type` / totals wrapper is rebuilt here with the same
+ * `VALID` / `SOME_INVALID` codes and reason strings as `./index`.
+ * The `*WithOptions` variants have no native equivalent (the Rust
+ * core's options live behind different entry points), so they always
+ * use the TypeScript implementation.
+ *
+ * Every function here never throws on bad input, like `./index`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSpacesHyphensOptions = exports.lenientOptions = exports.defaultOptions = exports.formatMobileWithOptions = exports.validateGstinWithOptions = exports.validateAadhaarWithOptions = exports.validatePanWithOptions = exports.validateMobileWithOptions = void 0;
+exports.isNativeAvailable = isNativeAvailable;
+exports.backend = backend;
+exports.validatePan = validatePan;
+exports.validateAadhaar = validateAadhaar;
+exports.validateGstin = validateGstin;
+exports.validateIfsc = validateIfsc;
+exports.validateUpi = validateUpi;
+exports.validateMobile = validateMobile;
+exports.validatePincode = validatePincode;
+exports.validateTan = validateTan;
+exports.validateCin = validateCin;
+exports.validateLlpin = validateLlpin;
+exports.validateVoterId = validateVoterId;
+exports.validateEpic = validateEpic;
+exports.validateVehicle = validateVehicle;
+exports.validateVehicleRegistration = validateVehicleRegistration;
+exports.detectType = detectType;
+exports.detect = detect;
+exports.validateMany = validateMany;
+exports.formatMobile = formatMobile;
+exports.formatPan = formatPan;
+exports.formatGstin = formatGstin;
+exports.maskAadhaar = maskAadhaar;
+exports.maskPan = maskPan;
+exports.maskMobile = maskMobile;
+exports.generatePan = generatePan;
+exports.generateAadhaar = generateAadhaar;
+exports.generateGstin = generateGstin;
+exports.generateMobile = generateMobile;
+const node_module_1 = require("node:module");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const tsImpl = __importStar(require("./index"));
+const nativeRequire = (0, node_module_1.createRequire)((0, node_path_1.join)(process.cwd(), "package.json"));
+function bindingCandidates() {
+    const envPath = process.env.INDYCHECK_NATIVE_PATH;
+    // An explicit path is authoritative: if it cannot be loaded, the
+    // addon is treated as absent (TypeScript fallback) instead of
+    // silently loading a different binary.
+    if (envPath)
+        return [envPath];
+    const candidates = [];
+    // CommonJS: relative to this file (dist/ or src/ under packages/js).
+    if (typeof __dirname !== "undefined") {
+        candidates.push((0, node_path_1.join)(__dirname, "..", "..", "..", "crates", "indycheck-napi", "index.js"));
+    }
+    // Walk up from the working directory to a repo checkout (covers
+    // vitest, where __dirname is not defined, and `npm test` from anywhere).
+    let dir = process.cwd();
+    for (let i = 0; i < 6; i++) {
+        candidates.push((0, node_path_1.join)(dir, "crates", "indycheck-napi", "index.js"));
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return [...new Set(candidates)].filter((c) => (0, node_fs_1.existsSync)(c));
+}
+let binding = null;
+let attempted = false;
+function loadBinding() {
+    if (attempted)
+        return binding;
+    attempted = true;
+    for (const candidate of bindingCandidates()) {
+        try {
+            const mod = nativeRequire(candidate);
+            if (mod &&
+                typeof mod.validatePan === "function" &&
+                typeof mod.validateVehicle === "function" &&
+                typeof mod.detect === "function" &&
+                typeof mod.validateMany === "function") {
+                binding = mod;
+                break;
+            }
+        }
+        catch {
+            // Not built / not loadable here — try the next candidate.
+        }
+    }
+    return binding;
+}
+/** `true` when the native addon loaded and can be used. */
+function isNativeAvailable() {
+    return loadBinding() !== null;
+}
+/** Which backend the functions below are currently using. */
+function backend() {
+    return loadBinding() !== null ? "native" : "typescript";
+}
+// ---------------------------------------------------------------------------
+// Call helpers
+// ---------------------------------------------------------------------------
+/** Rust `ValidationResult::err` omits `parsed` from the JSON entirely
+ *  (serde `skip_serializing_if`), while the TS mirror sets it to
+ *  `null` — normalise so both backends return identical shapes. */
+function normalizeResult(r) {
+    if (r.parsed === undefined)
+        r.parsed = null;
+    return r;
+}
+/** Run a native call that returns a JSON `ValidationResult`; on any
+ *  failure (missing addon, bad JSON) use the TypeScript fallback. */
+function callJson(fn, fallback) {
+    const b = loadBinding();
+    if (b === null)
+        return fallback();
+    try {
+        return normalizeResult(JSON.parse(fn(b)));
+    }
+    catch {
+        return fallback();
+    }
+}
+/** Run a native call returning a plain value; fall back on any failure. */
+function callPlain(fn, fallback) {
+    const b = loadBinding();
+    if (b === null)
+        return fallback();
+    try {
+        return fn(b);
+    }
+    catch {
+        return fallback();
+    }
+}
+/** Native validator for a `detect` type string, or null for "unknown". */
+function validateByNativeType(b, type, input) {
+    let json;
+    switch (type) {
+        case "pan":
+            json = b.validatePan(input);
+            break;
+        case "aadhaar":
+            json = b.validateAadhaar(input);
+            break;
+        case "gstin":
+            json = b.validateGstin(input);
+            break;
+        case "ifsc":
+            json = b.validateIfsc(input);
+            break;
+        case "upi":
+            json = b.validateUpi(input);
+            break;
+        case "mobile":
+            json = b.validateMobile(input);
+            break;
+        case "pincode":
+            json = b.validatePincode(input);
+            break;
+        case "tan":
+            json = b.validateTan(input);
+            break;
+        case "cin":
+            json = b.validateCin(input);
+            break;
+        case "llpin":
+            json = b.validateLlpin(input);
+            break;
+        case "voter":
+            json = b.validateVoterId(input);
+            break;
+        case "vehicle":
+            json = b.validateVehicle(input);
+            break;
+        default:
+            return null;
+    }
+    return normalizeResult(JSON.parse(json));
+}
+// ---------------------------------------------------------------------------
+// Validators — native when available, TypeScript otherwise
+// ---------------------------------------------------------------------------
+function validatePan(input) {
+    if (typeof input !== "string")
+        return tsImpl.validatePan(input);
+    return callJson((b) => b.validatePan(input), () => tsImpl.validatePan(input));
+}
+function validateAadhaar(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateAadhaar(input);
+    return callJson((b) => b.validateAadhaar(input), () => tsImpl.validateAadhaar(input));
+}
+function validateGstin(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateGstin(input);
+    return callJson((b) => b.validateGstin(input), () => tsImpl.validateGstin(input));
+}
+function validateIfsc(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateIfsc(input);
+    return callJson((b) => b.validateIfsc(input), () => tsImpl.validateIfsc(input));
+}
+function validateUpi(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateUpi(input);
+    return callJson((b) => b.validateUpi(input), () => tsImpl.validateUpi(input));
+}
+function validateMobile(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateMobile(input);
+    return callJson((b) => b.validateMobile(input), () => tsImpl.validateMobile(input));
+}
+function validatePincode(input) {
+    if (typeof input !== "string")
+        return tsImpl.validatePincode(input);
+    return callJson((b) => b.validatePincode(input), () => tsImpl.validatePincode(input));
+}
+function validateTan(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateTan(input);
+    return callJson((b) => b.validateTan(input), () => tsImpl.validateTan(input));
+}
+function validateCin(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateCin(input);
+    return callJson((b) => b.validateCin(input), () => tsImpl.validateCin(input));
+}
+function validateLlpin(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateLlpin(input);
+    return callJson((b) => b.validateLlpin(input), () => tsImpl.validateLlpin(input));
+}
+function validateVoterId(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateVoterId(input);
+    return callJson((b) => b.validateVoterId(input), () => tsImpl.validateVoterId(input));
+}
+/** Alias for `validateVoterId`: EPIC is the name printed on the card. */
+function validateEpic(input) {
+    return validateVoterId(input);
+}
+function validateVehicle(input) {
+    if (typeof input !== "string")
+        return tsImpl.validateVehicle(input);
+    return callJson((b) => b.validateVehicle(input), () => tsImpl.validateVehicle(input));
+}
+/** Alias for `validateVehicle`. */
+function validateVehicleRegistration(input) {
+    return validateVehicle(input);
+}
+// ---------------------------------------------------------------------------
+// detect / validateMany — shapes rebuilt from the native primitives
+// ---------------------------------------------------------------------------
+/** The Rust `detect` string for a trimmed input. */
+function detectType(input) {
+    const b = loadBinding();
+    if (b === null)
+        return tsImpl.detectType(input);
+    try {
+        return b.detect(input);
+    }
+    catch {
+        return tsImpl.detectType(input);
+    }
+}
+function detect(input) {
+    if (typeof input !== "string")
+        return tsImpl.detect(input);
+    const b = loadBinding();
+    if (b === null)
+        return tsImpl.detect(input);
+    try {
+        const type = b.detect(input);
+        const trimmed = input.trim();
+        if (type === "unknown") {
+            return {
+                valid: false,
+                code: "UNKNOWN_TYPE",
+                reason_en: "Could not detect the type of this input",
+                reason_hi: "Is input ka type pehchana nahi ja saka",
+                parsed: { type: "unknown", value: trimmed, result: null },
+            };
+        }
+        const result = validateByNativeType(b, type, input);
+        if (result === null)
+            return tsImpl.detect(input);
+        return {
+            valid: result.valid,
+            code: result.code,
+            reason_en: result.reason_en,
+            reason_hi: result.reason_hi,
+            parsed: { type, value: trimmed, result },
+        };
+    }
+    catch {
+        return tsImpl.detect(input);
+    }
+}
+function validateMany(inputs) {
+    if (!Array.isArray(inputs) || inputs.length === 0) {
+        return tsImpl.validateMany(inputs);
+    }
+    if (!inputs.every((item) => typeof item === "string")) {
+        // Typed `{ value, type }` entries and non-strings are a
+        // TypeScript-wrapper feature — the native batch takes strings only.
+        return tsImpl.validateMany(inputs);
+    }
+    const b = loadBinding();
+    if (b === null)
+        return tsImpl.validateMany(inputs);
+    try {
+        const results = JSON.parse(b.validateMany(inputs));
+        const items = inputs.map((item, i) => {
+            const result = normalizeResult(results[i]);
+            const type = b.detect(item);
+            return {
+                input: item,
+                type: type === "unknown" ? null : type,
+                valid: result.valid,
+                code: result.code,
+                reason_en: result.reason_en,
+                reason_hi: result.reason_hi,
+                parsed: result.parsed,
+            };
+        });
+        const validCount = items.filter((r) => r.valid).length;
+        const invalidCount = items.length - validCount;
+        const parsed = {
+            results: items,
+            total: items.length,
+            validCount,
+            invalidCount,
+        };
+        if (invalidCount === 0) {
+            return {
+                valid: true,
+                code: "VALID",
+                reason_en: "All inputs are valid.",
+                reason_hi: "Saare input sahi hain.",
+                parsed,
+            };
+        }
+        return {
+            valid: false,
+            code: "SOME_INVALID",
+            reason_en: "Some inputs are invalid.",
+            reason_hi: "Kuch input galat hain.",
+            parsed,
+        };
+    }
+    catch {
+        return tsImpl.validateMany(inputs);
+    }
+}
+// ---------------------------------------------------------------------------
+// Format / mask — same contracts as ./index
+// ---------------------------------------------------------------------------
+function formatMobile(input) {
+    // Same contract as validateMobile (see ./index).
+    return validateMobile(input);
+}
+function formatPan(input) {
+    if (typeof input !== "string")
+        return tsImpl.formatPan(input);
+    return callPlain((b) => b.formatPan(input), () => tsImpl.formatPan(input));
+}
+function formatGstin(input) {
+    if (typeof input !== "string")
+        return tsImpl.formatGstin(input);
+    return callPlain((b) => b.formatGstin(input), () => tsImpl.formatGstin(input));
+}
+function maskAadhaar(input) {
+    // Same contract as validateAadhaar (see ./index) — NOT the Rust
+    // `mask_aadhaar` string function, which masks any 12-digit string.
+    return validateAadhaar(input);
+}
+function maskPan(input) {
+    if (typeof input !== "string")
+        return tsImpl.maskPan(input);
+    return callPlain((b) => b.maskPan(input), () => tsImpl.maskPan(input));
+}
+function maskMobile(input) {
+    if (typeof input !== "string")
+        return tsImpl.maskMobile(input);
+    return callPlain((b) => b.maskMobile(input), () => tsImpl.maskMobile(input));
+}
+// ---------------------------------------------------------------------------
+// Mock test-data generators — TEST DATA ONLY, never real issued IDs
+// ---------------------------------------------------------------------------
+function generatePan(entity) {
+    const code = typeof entity === "string" && entity.length > 0 ? entity : "P";
+    return callPlain((b) => b.generatePan(code), () => tsImpl.generatePan(entity));
+}
+function generateAadhaar() {
+    return callPlain((b) => b.generateAadhaar(), () => tsImpl.generateAadhaar());
+}
+function generateGstin(stateCode) {
+    const code = typeof stateCode === "string" ? stateCode : "18";
+    return callPlain((b) => b.generateGstin(code), () => tsImpl.generateGstin(stateCode));
+}
+function generateMobile() {
+    return callPlain((b) => b.generateMobile(), () => tsImpl.generateMobile());
+}
+// ---------------------------------------------------------------------------
+// Options variants — no native equivalent; always TypeScript
+// ---------------------------------------------------------------------------
+exports.validateMobileWithOptions = tsImpl.validateMobileWithOptions;
+exports.validatePanWithOptions = tsImpl.validatePanWithOptions;
+exports.validateAadhaarWithOptions = tsImpl.validateAadhaarWithOptions;
+exports.validateGstinWithOptions = tsImpl.validateGstinWithOptions;
+exports.formatMobileWithOptions = tsImpl.formatMobileWithOptions;
+exports.defaultOptions = tsImpl.defaultOptions;
+exports.lenientOptions = tsImpl.lenientOptions;
+exports.noSpacesHyphensOptions = tsImpl.noSpacesHyphensOptions;
+exports.default = {
+    backend,
+    isNativeAvailable,
+    validateMobile,
+    validatePan,
+    validateAadhaar,
+    validateGstin,
+    validateIfsc,
+    validateUpi,
+    validatePincode,
+    validateTan,
+    validateCin,
+    validateLlpin,
+    validateVoterId,
+    validateEpic,
+    validateVehicle,
+    validateVehicleRegistration,
+    validateMobileWithOptions: exports.validateMobileWithOptions,
+    validatePanWithOptions: exports.validatePanWithOptions,
+    validateAadhaarWithOptions: exports.validateAadhaarWithOptions,
+    validateGstinWithOptions: exports.validateGstinWithOptions,
+    formatMobile,
+    formatMobileWithOptions: exports.formatMobileWithOptions,
+    formatPan,
+    formatGstin,
+    maskAadhaar,
+    maskPan,
+    maskMobile,
+    generatePan,
+    generateAadhaar,
+    generateGstin,
+    generateMobile,
+    defaultOptions: exports.defaultOptions,
+    lenientOptions: exports.lenientOptions,
+    noSpacesHyphensOptions: exports.noSpacesHyphensOptions,
+    detect,
+    detectType,
+    validateMany,
+};

package/package.json

@@ -33,9 +33,10 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "native:build": "npm --prefix ../../crates/indycheck-napi run build",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   },
   "types": "dist/index.d.ts",
-  "version": "0.1.2"
+  "version": "0.2.1"
 }