@parselo/scanner-core 0.0.1 → 0.1.0

package/dist/canonical.d.ts

@@ -1,4 +1,5 @@
 import type { AamvaResult } from "./aamva";
+import type { MagstripeResult } from "./magstripe";
 export type FieldSource = "barcode" | "ocr" | "mrz";
 export interface CanonicalField {
     value: string;
@@ -27,4 +28,5 @@ export interface CanonicalDocument {
     };
     raw: Record<string, string>;
 }
+export declare function magstripeToCanonical(m: MagstripeResult, confidence?: number): CanonicalDocument;
 export declare function toCanonical(a: AamvaResult, confidence?: number): CanonicalDocument;

package/dist/canonical.js

@@ -2,6 +2,32 @@
 // One stable output shape every document maps into, regardless of source
 // (barcode now; OCR/MRZ later). Each field carries its value, a confidence,
 // and which path produced it, so the future merge step can prefer ground truth.
+export function magstripeToCanonical(m, confidence = 1.0) {
+    const field = (value) => value !== undefined ? { value, confidence, source: "barcode" } : undefined;
+    const province = m.jurisdiction ?? m.addressRegion ?? "";
+    const jurisdiction = province ? `CA-${province}` : "CA";
+    return {
+        documentType: "drivers_license",
+        jurisdiction,
+        fields: {
+            firstName: field(m.firstName),
+            lastName: field(m.lastName),
+            dateOfBirth: field(m.dateOfBirth),
+            expiryDate: field(m.expiryDate),
+            documentNumber: field(m.documentNumber),
+            sex: field(m.sex),
+            addressStreet: field(m.addressStreet),
+            addressCity: field(m.addressCity),
+            addressRegion: field(m.addressRegion),
+            addressPostalCode: field(m.addressPostalCode),
+        },
+        raw: {
+            track1: m.raw.track1 ?? "",
+            track2: m.raw.track2 ?? "",
+            track3: m.raw.track3 ?? "",
+        },
+    };
+}
 export function toCanonical(a, confidence = 1.0) {
     const e = a.elements;
     const field = (code) => e[code] !== undefined ? { value: e[code], confidence, source: "barcode" } : undefined;

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { type CanonicalDocument } from "./canonical";
 import { type LicenseResult } from "./license";
 import { type AnalyticsConfig } from "./analytics";
 export * from "./aamva";
+export * from "./magstripe";
 export * from "./canonical";
 export * from "./license";
 export * from "./analytics";

package/dist/index.js

@@ -5,10 +5,12 @@
 // The native PDF417 decode is supplied by the plugin's Swift/Kotlin bridge via
 // the BarcodeNative interface, so this orchestration is platform-agnostic.
 import { parseAamva } from "./aamva";
-import { toCanonical } from "./canonical";
+import { parseMagstripe } from "./magstripe";
+import { toCanonical, magstripeToCanonical } from "./canonical";
 import { verifyLicense, isExpired } from "./license";
 import { ScanAnalytics } from "./analytics";
 export * from "./aamva";
+export * from "./magstripe";
 export * from "./canonical";
 export * from "./license";
 export * from "./analytics";
@@ -48,14 +50,30 @@ export class Scanner {
             await this.emit("unknown", "", false, "low");
             return { ok: false, error: "no_barcode" };
         }
-        // (3) PARSE ------------------------------------------------------------
-        const aamva = parseAamva(raw);
-        if (!aamva.isAamva) {
+        // (3) PARSE — route to the correct parser based on format signature ------
+        const trimmedRaw = raw.replace(/^[\x00-\x1f\s]+/, "");
+        let document;
+        if (trimmedRaw.startsWith("@") || raw.includes("ANSI ")) {
+            const aamva = parseAamva(raw);
+            if (!aamva.isAamva) {
+                await this.emit("unknown", "", false, "low");
+                return { ok: false, error: "not_aamva" };
+            }
+            document = toCanonical(aamva);
+        }
+        else if (trimmedRaw.startsWith("%")) {
+            const ms = parseMagstripe(raw);
+            if (!ms.isMagstripe) {
+                await this.emit("unknown", "", false, "low");
+                return { ok: false, error: "not_aamva" };
+            }
+            document = magstripeToCanonical(ms);
+        }
+        else {
             await this.emit("unknown", "", false, "low");
             return { ok: false, error: "not_aamva" };
         }
-        // (4) CANONICAL --------------------------------------------------------
-        const document = toCanonical(aamva);
+        // (4) CANONICAL already set above --------------------------------------
         // (5) ANALYTICS (PII-FREE) --------------------------------------------
         await this.emit(document.documentType, document.jurisdiction, true, "high");
         // (6) RETURN -----------------------------------------------------------

package/dist/magstripe.d.ts

@@ -0,0 +1,21 @@
+export interface MagstripeResult {
+    isMagstripe: boolean;
+    jurisdiction?: string;
+    iin?: string;
+    lastName?: string;
+    firstName?: string;
+    dateOfBirth?: string;
+    expiryDate?: string;
+    documentNumber?: string;
+    sex?: string;
+    addressStreet?: string;
+    addressCity?: string;
+    addressRegion?: string;
+    addressPostalCode?: string;
+    raw: {
+        track1?: string;
+        track2?: string;
+        track3?: string;
+    };
+}
+export declare function parseMagstripe(raw: string): MagstripeResult;

package/dist/magstripe.js

@@ -0,0 +1,133 @@
+// magstripe.ts
+// Parser for the AAMVA magnetic-stripe track format used by some Canadian provinces
+// (confirmed BC; likely ON/AB). Three tracks concatenated in one PDF417 payload:
+//   Track 1  %...?   jurisdiction + name + address
+//   Track 2  ;...?   IIN + document number + expiry (YYMM) + DOB (CCYYMMDD)
+//   Track 3  ...?    postal code + physical description (layout varies by jurisdiction)
+//
+// Reference: AAMVA DL/ID Card Design Standard, magnetic-stripe annex.
+// Returns the last calendar day of a 1-based month in the given year.
+function lastDayOfMonth(year, month) {
+    // Date(y, m, 0) with 0-indexed month m = last day of month (m-1); passing 1-based month directly works.
+    return new Date(year, month, 0).getDate();
+}
+function applyTrack1(out, t1) {
+    // Format: jurisdiction(2) + city + ^ + SURNAME[,]$GIVEN NAMES + ^ + STREET$CITY PROVINCE
+    const parts = t1.split("^");
+    if (parts.length < 2)
+        return;
+    out.jurisdiction = parts[0].slice(0, 2);
+    const namePart = parts[1];
+    const dollar = namePart.indexOf("$");
+    if (dollar !== -1) {
+        out.lastName = namePart.slice(0, dollar).replace(/,+$/, "").trim();
+        out.firstName = namePart.slice(dollar + 1).trim();
+    }
+    else {
+        out.lastName = namePart.replace(/,+$/, "").trim();
+    }
+    if (parts.length < 3)
+        return;
+    const addrPart = parts[2].trim();
+    const addrDollar = addrPart.indexOf("$");
+    if (addrDollar === -1) {
+        out.addressStreet = addrPart;
+        return;
+    }
+    out.addressStreet = addrPart.slice(0, addrDollar).trim();
+    const cityProv = addrPart.slice(addrDollar + 1).trim();
+    // Province is the trailing space-separated token (always 2 chars); city is the rest.
+    const lastSpace = cityProv.lastIndexOf(" ");
+    if (lastSpace !== -1) {
+        out.addressCity = cityProv.slice(0, lastSpace).trim();
+        out.addressRegion = cityProv.slice(lastSpace + 1).trim();
+    }
+    else if (cityProv.length >= 2) {
+        out.addressRegion = cityProv.slice(-2);
+        out.addressCity = cityProv.slice(0, -2).trim();
+    }
+}
+function applyTrack2(out, t2) {
+    // Format: IIN(6) + document-number + = + expiry-YYMM(4) + DOB-CCYYMMDD(8) + = + [discretionary]
+    if (t2.length < 7)
+        return;
+    out.iin = t2.slice(0, 6);
+    const eq1 = t2.indexOf("=");
+    if (eq1 === -1)
+        return;
+    out.documentNumber = t2.slice(6, eq1);
+    const after = t2.slice(eq1 + 1);
+    if (after.length < 12)
+        return;
+    const expiryYYMM = after.slice(0, 4);
+    const dobCCYYMMDD = after.slice(4, 12);
+    if (/^\d{4}$/.test(expiryYYMM)) {
+        const yy = parseInt(expiryYYMM.slice(0, 2), 10);
+        const mm = parseInt(expiryYYMM.slice(2, 4), 10);
+        const year = yy < 70 ? 2000 + yy : 1900 + yy;
+        const day = lastDayOfMonth(year, mm);
+        out.expiryDate = `${year}-${String(mm).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+    }
+    if (/^\d{8}$/.test(dobCCYYMMDD)) {
+        out.dateOfBirth =
+            `${dobCCYYMMDD.slice(0, 4)}-${dobCCYYMMDD.slice(4, 6)}-${dobCCYYMMDD.slice(6, 8)}`;
+    }
+}
+function applyTrack3(out, t3) {
+    // Track 3 layout varies by jurisdiction — extract only what we can identify reliably.
+    // Canadian postal code: letter-digit-letter-digit-letter-digit (no space in raw)
+    const postalMatch = t3.match(/([A-Z]\d[A-Z]\d[A-Z]\d)/);
+    if (postalMatch) {
+        const p = postalMatch[1];
+        out.addressPostalCode = `${p.slice(0, 3)} ${p.slice(3)}`;
+    }
+    // Sex: M or F immediately followed by 3 digits (height in cm)
+    const physMatch = t3.match(/([MF])(\d{3})/);
+    if (physMatch)
+        out.sex = physMatch[1];
+}
+export function parseMagstripe(raw) {
+    const out = { isMagstripe: false, raw: {} };
+    // Strip leading control/whitespace for format detection; keep raw intact for track extraction.
+    const s = raw.replace(/^[\x00-\x1f\s]+/, "");
+    if (!s.startsWith("%"))
+        return out;
+    // Track 1: % sentinel to first ?
+    const t1End = s.indexOf("?");
+    if (t1End === -1)
+        return out;
+    const t1 = s.slice(1, t1End);
+    if (!t1.includes("^"))
+        return out; // must have the field-separator to be a DL track 1
+    out.isMagstripe = true;
+    out.raw.track1 = t1;
+    applyTrack1(out, t1);
+    // Track 2: ; sentinel somewhere after track 1
+    const after1 = s.slice(t1End + 1);
+    const t2SentinelPos = after1.indexOf(";");
+    if (t2SentinelPos === -1)
+        return out;
+    const t2ContentStart = t2SentinelPos + 1;
+    const t2End = after1.indexOf("?", t2ContentStart);
+    if (t2End === -1)
+        return out;
+    const t2 = after1.slice(t2ContentStart, t2End);
+    out.raw.track2 = t2;
+    applyTrack2(out, t2);
+    // Track 3: everything after track 2's ? up to the last ? in the string.
+    // Inter-track bytes (e.g. "_%0A" — an underscore + percent-encoded LF) are stripped.
+    const afterT2 = after1.slice(t2End + 1);
+    const t3LastQ = afterT2.lastIndexOf("?");
+    if (t3LastQ > 0) {
+        const t3Section = afterT2.slice(0, t3LastQ);
+        // Decode any percent-encoded sequences in the inter-track gap, then strip
+        // leading non-uppercase chars (underscores, decoded control chars, etc.).
+        const t3Decoded = t3Section.replace(/%([0-9A-Fa-f]{2})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+        const t3 = t3Decoded.replace(/^[^A-Z]+/, "");
+        if (t3.length > 0) {
+            out.raw.track3 = t3;
+            applyTrack3(out, t3);
+        }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parselo/scanner-core",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/parselo-io/parselo-sdk.git",