@zanii/blackbox 0.21.2 → 0.23.0

package/dist/pdf/arabic.js

@@ -0,0 +1,373 @@
+// Arabic text for the signed PDF (spec/pdf.md §6): contextual shaping to the Unicode Arabic
+// Presentation Forms (ArabicShaping.txt joining types, the lam-alef ligatures) and the Unicode
+// bidirectional algorithm (UAX #9) for one paragraph without explicit embeddings. Pure, driven by
+// the tables in spec/pdf/unicode-arabic.json, and identical to sdks/python/src/zanii_blackbox/
+// pdf_arabic.py (spec/vectors/arabic-text.json).
+function lookup(starts, values, fallback, cp) {
+    let lo = 0;
+    let hi = starts.length - 1;
+    let at = -1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (starts[mid] <= cp) {
+            at = mid;
+            lo = mid + 1;
+        }
+        else
+            hi = mid - 1;
+    }
+    return at < 0 ? fallback : values[at];
+}
+export function prepare(u) {
+    const bs = u.bidi.map((r) => r[0]);
+    const bv = u.bidi.map((r) => r[1]);
+    const js = u.joining.map((r) => r[0]);
+    return {
+        cls: (cp) => lookup(bs, bv, "L", cp),
+        jt: (cp) => {
+            const r = lookup(js, u.joining, null, cp);
+            return r && cp <= r[1] ? r[2] : "U";
+        },
+        forms: new Map(u.forms.map((r) => [r[0], r.slice(1)])),
+        lamAlef: new Map(u.lam_alef.map((r) => [r[0], r.slice(1)])),
+        mirror: new Map(u.mirror.map((r) => [r[0], r[1]])),
+        brackets: new Map(u.brackets.map((r) => [r[0], [r[1], r[2]]])),
+    };
+}
+const ISOLATES = new Set(["LRI", "RLI", "FSI", "PDI"]);
+/** Removed before shaping's output (X9): boundary neutrals and the embedding controls, which
+ * this subset doesn't implement. */
+const REMOVED = new Set(["BN", "LRE", "RLE", "LRO", "RLO", "PDF"]);
+/** Zero-width strong marks: they take part in the bidi pass but draw nothing. */
+const INVISIBLE = new Set([0x200e, 0x200f, 0x061c]);
+/** §6.1: the text as clusters, letters in their joining forms, lam-alef as one ligature. */
+export function shapeClusters(text, P) {
+    const chars = Array.from(text, (c) => c.codePointAt(0));
+    const types = chars.map((c) => P.jt(c));
+    const n = chars.length;
+    const near = (i, step) => {
+        let j = i + step;
+        while (j >= 0 && j < n && types[j] === "T")
+            j += step;
+        return j >= 0 && j < n ? types[j] : "U";
+    };
+    const joinsPrev = (i) => "RDC".includes(types[i]) && "DLC".includes(near(i, -1));
+    const joinsNext = (i) => "LDC".includes(types[i]) && "RDC".includes(near(i, 1));
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const c = chars[i];
+        const cls = P.cls(c);
+        if (REMOVED.has(cls))
+            continue;
+        const ch = String.fromCodePoint(c);
+        const last = out.at(-1);
+        if (cls === "NSM" && last && last.cps.length > 0) {
+            last.cps.push(c);
+            last.src += ch;
+            continue;
+        }
+        if (ISOLATES.has(cls) || INVISIBLE.has(c)) {
+            out.push({ cps: [], src: "", cls });
+            continue;
+        }
+        if (c === 0x0644) {
+            let k = i + 1;
+            while (k < n && types[k] === "T" && P.cls(chars[k]) === "NSM")
+                k++;
+            const lig = P.lamAlef.get(chars[k]);
+            if (k < n && lig) {
+                const form = joinsPrev(i) ? 1 : 0;
+                out.push({
+                    cps: [lig[form] || lig[0], ...chars.slice(i + 1, k)],
+                    src: String.fromCodePoint(...chars.slice(i, k + 1)),
+                    cls,
+                });
+                i = k;
+                continue;
+            }
+        }
+        const f = P.forms.get(c);
+        let cp = c;
+        if (f) {
+            const p = joinsPrev(i);
+            const x = joinsNext(i);
+            const form = p && x ? 3 : p ? 1 : x ? 2 : 0;
+            cp = f[form] || f[0] || c;
+        }
+        out.push({ cps: [cp], src: ch, cls });
+    }
+    return out;
+}
+/** §6.1: the shaped text (presentation forms, logical order). */
+export function shapeArabic(text, tables) {
+    return shapeClusters(text, prepare(tables))
+        .map((c) => String.fromCodePoint(...c.cps))
+        .join("");
+}
+// ---------------------------------------------------------------- UAX #9
+const strong = (t) => (t === "L" ? "L" : t === "R" || t === "EN" || t === "AN" ? "R" : "");
+const NI = new Set(["B", "S", "WS", "ON", "LRI", "RLI", "FSI", "PDI"]);
+const MAX_DEPTH = 60;
+/** §6.2: the embedding level of each cluster in a paragraph of level `p` (0 or 1). */
+export function bidiLevels(clusters, p, P) {
+    const n = clusters.length;
+    const cls = clusters.map((c) => c.cls);
+    const levels = new Array(n).fill(p);
+    // BD9: each isolate initiator with its matching PDI (-1: open to the paragraph's end)
+    const match = new Map();
+    const stack = [];
+    let overflow = 0;
+    for (let i = 0; i < n; i++) {
+        const t = cls[i];
+        if (t === "LRI" || t === "RLI" || t === "FSI") {
+            if (overflow || stack.length >= MAX_DEPTH) {
+                overflow++;
+                cls[i] = "ON";
+            }
+            else {
+                stack.push(i);
+                match.set(i, -1);
+            }
+        }
+        else if (t === "PDI") {
+            if (overflow) {
+                overflow--;
+                cls[i] = "ON";
+            }
+            else if (stack.length)
+                match.set(stack.pop(), i);
+        }
+    }
+    const contentEnd = (i) => {
+        const m = match.get(i);
+        return m < 0 ? n : m;
+    };
+    /** The indices of the isolating run sequence from `from` to `to` (nested contents skipped). */
+    const sequence = (from, to) => {
+        const out = [];
+        for (let i = from; i < to; i++) {
+            out.push(i);
+            if (match.has(i)) {
+                const e = contentEnd(i);
+                if (e < n)
+                    out.push(e);
+                i = e;
+            }
+        }
+        return out;
+    };
+    const firstStrong = (from, to) => {
+        for (let i = from; i < to; i++) {
+            const t = cls[i];
+            if (t === "L")
+                return 0;
+            if (t === "R" || t === "AL")
+                return 1;
+            if (match.has(i))
+                i = contentEnd(i);
+        }
+        return 0;
+    };
+    const run = (seq, level) => {
+        const t = seq.map((i) => cls[i]);
+        resolve(t, level, seq.map((i) => clusters[i]?.cps[0] ?? 0), P);
+        seq.forEach((i, k) => {
+            const x = t[k];
+            levels[i] =
+                level % 2 === 0
+                    ? level + (x === "R" ? 1 : x === "AN" || x === "EN" ? 2 : 0)
+                    : level + (x === "L" || x === "EN" || x === "AN" ? 1 : 0);
+        });
+        for (const i of seq) {
+            if (!match.has(i))
+                continue;
+            const kind = cls[i] === "FSI" ? (firstStrong(i + 1, contentEnd(i)) ? "RLI" : "LRI") : cls[i];
+            const odd = kind === "RLI";
+            const inner = level + 1 + (level % 2 === (odd ? 1 : 0) ? 1 : 0);
+            run(sequence(i + 1, contentEnd(i)), inner);
+        }
+    };
+    run(sequence(0, n), p);
+    return levels;
+}
+/** W1-W7, N0-N2 on one isolating run sequence's types `t` (in place). */
+function resolve(t, level, cps, P) {
+    const n = t.length;
+    const e = level % 2 ? "R" : "L";
+    const sos = e;
+    // W1
+    for (let k = 0; k < n; k++)
+        if (t[k] === "NSM")
+            t[k] = k === 0 ? sos : ISOLATES.has(t[k - 1]) ? "ON" : t[k - 1];
+    // W2, W3
+    let last = sos;
+    for (let k = 0; k < n; k++) {
+        const x = t[k];
+        if (x === "L" || x === "R" || x === "AL")
+            last = x;
+        else if (x === "EN" && last === "AL")
+            t[k] = "AN";
+    }
+    for (let k = 0; k < n; k++)
+        if (t[k] === "AL")
+            t[k] = "R";
+    // W4
+    for (let k = 1; k < n - 1; k++) {
+        const a = t[k - 1];
+        const b = t[k + 1];
+        if (t[k] === "ES" && a === "EN" && b === "EN")
+            t[k] = "EN";
+        else if (t[k] === "CS" && a === b && (a === "EN" || a === "AN"))
+            t[k] = a;
+    }
+    // W5
+    for (let k = 0; k < n; k++) {
+        if (t[k] !== "ET")
+            continue;
+        let j = k;
+        while (j < n && t[j] === "ET")
+            j++;
+        if (t[k - 1] === "EN" || t[j] === "EN")
+            for (let q = k; q < j; q++)
+                t[q] = "EN";
+        k = j - 1;
+    }
+    // W6
+    for (let k = 0; k < n; k++)
+        if (t[k] === "ES" || t[k] === "ET" || t[k] === "CS")
+            t[k] = "ON";
+    // W7
+    last = sos;
+    for (let k = 0; k < n; k++) {
+        const x = t[k];
+        if (x === "L" || x === "R")
+            last = x;
+        else if (x === "EN" && last === "L")
+            t[k] = "L";
+    }
+    // N0: bracket pairs (BD16), in the order of their opening brackets
+    const canon = (cp) => (cp === 0x2329 ? 0x3008 : cp === 0x232a ? 0x3009 : cp);
+    const pairs = [];
+    const open = [];
+    for (let k = 0; k < n; k++) {
+        const b = P.brackets.get(cps[k]);
+        if (!b || t[k] !== "ON")
+            continue;
+        if (b[1] === "o") {
+            if (open.length === 63)
+                break;
+            open.push([canon(b[0]), k]);
+        }
+        else
+            for (let s = open.length - 1; s >= 0; s--)
+                if (open[s][0] === canon(cps[k])) {
+                    pairs.push([open[s][1], k]);
+                    open.length = s;
+                    break;
+                }
+    }
+    pairs.sort((a, b) => a[0] - b[0]);
+    const opp = e === "L" ? "R" : "L";
+    for (const [o, c] of pairs) {
+        let hasE = false;
+        let hasOpp = false;
+        for (let k = o + 1; k < c; k++) {
+            const s = strong(t[k]);
+            if (s === e)
+                hasE = true;
+            else if (s === opp)
+                hasOpp = true;
+        }
+        let dir = "";
+        if (hasE)
+            dir = e;
+        else if (hasOpp) {
+            let before = sos;
+            for (let k = o - 1; k >= 0; k--) {
+                const s = strong(t[k]);
+                if (s) {
+                    before = s;
+                    break;
+                }
+            }
+            dir = before === opp ? opp : e;
+        }
+        if (dir) {
+            t[o] = dir;
+            t[c] = dir;
+        }
+    }
+    // N1, N2
+    for (let k = 0; k < n; k++) {
+        if (!NI.has(t[k]))
+            continue;
+        let j = k;
+        while (j < n && NI.has(t[j]))
+            j++;
+        const before = k === 0 ? sos : strong(t[k - 1]);
+        const after = j === n ? sos : strong(t[j]);
+        const dir = before === after ? before : e;
+        for (let q = k; q < j; q++)
+            t[q] = dir;
+        k = j - 1;
+    }
+}
+/** L1-L2 and L4 for one line (`line`: cluster indices in logical order): the indices in visual
+ * order, controls left out, each cluster's code points with mirroring applied, and whether its
+ * level is odd (right to left). */
+export function reorderLine(line, clusters, levels, p, P) {
+    const lv = line.map((i) => levels[i]);
+    // L1: segment separators, and whitespace before them or at the end of the line
+    let trailing = true;
+    for (let k = line.length - 1; k >= 0; k--) {
+        const t = clusters[line[k]]?.cls;
+        if (t === "S" || t === "B") {
+            lv[k] = p;
+            trailing = true;
+        }
+        else if (t === "WS" || ISOLATES.has(t)) {
+            if (trailing)
+                lv[k] = p;
+        }
+        else
+            trailing = false;
+    }
+    // L2
+    const order = line.map((_, k) => k);
+    const high = Math.max(p, ...lv);
+    const low = Math.min(high, ...lv);
+    const lowOdd = low % 2 ? low : low + 1;
+    for (let l = high; l >= lowOdd; l--)
+        for (let k = 0; k < order.length; k++) {
+            if (lv[order[k]] < l)
+                continue;
+            let j = k;
+            while (j < order.length && lv[order[j]] >= l)
+                j++;
+            order.splice(k, j - k, ...order.slice(k, j).reverse());
+            k = j - 1;
+        }
+    const out = [];
+    for (const k of order) {
+        const index = line[k];
+        const c = clusters[index];
+        if (c.cps.length === 0)
+            continue;
+        const m = lv[k] % 2 ? P.mirror.get(c.cps[0]) : undefined;
+        out.push({
+            index,
+            cps: m === undefined ? c.cps : [m, ...c.cps.slice(1)],
+            odd: lv[k] % 2 === 1,
+        });
+    }
+    return out;
+}
+/** §6.2: one line of text, shaped and in visual (left to right) order, in a paragraph of level `p`. */
+export function visualLine(text, p, tables) {
+    const P = prepare(tables);
+    const clusters = shapeClusters(text, P);
+    const levels = bidiLevels(clusters, p, P);
+    return reorderLine(clusters.map((_, i) => i), clusters, levels, p, P)
+        .map((c) => String.fromCodePoint(...c.cps))
+        .join("");
+}

package/dist/pdf/index.d.ts

@@ -0,0 +1,77 @@
+import { type UnicodeTables } from "./arabic.ts";
+export interface FontMetrics {
+    name: string;
+    first_char: number;
+    widths: number[];
+    ascent: number;
+    descent: number;
+    cap_height: number;
+    bbox: number[];
+    italic_angle: number;
+    stem_v: number;
+    flags: number;
+}
+/** spec/pdf/arabic-metrics.json */
+export interface ArabicMetrics extends Omit<FontMetrics, "first_char" | "widths"> {
+    /** [code point, glyph id, advance, yMin, yMax] */
+    glyphs: number[][];
+    /** [code point, horizontal center] of the zero-advance marks */
+    marks: number[][];
+    /** [glyph id, the text it stands for, as hex code points] */
+    to_unicode: Array<[number, string]>;
+}
+/** spec/pdf.md §2a-§2b: the Arabic font subset, its metrics and the Unicode tables. */
+export interface ArabicAssets {
+    font: Uint8Array;
+    metrics: ArabicMetrics;
+    unicode: UnicodeTables;
+}
+/** spec/pdf.md §2: the files in spec/pdf/, as the caller read them. Without `arabic`, text
+ * outside WinAnsi is drawn as "?" and nothing is reordered. */
+export interface PdfAssets {
+    font: Uint8Array;
+    metrics: FontMetrics;
+    icc: Uint8Array;
+    arabic?: ArabicAssets;
+}
+export interface PdfAttachment {
+    name: string;
+    mime: string;
+    /** PDF/A-3 AFRelationship: the evidence (`Data`), or the same report in another form. */
+    relationship: "Data" | "Alternative" | "Source";
+    description: string;
+    bytes: Uint8Array;
+}
+export interface PdfInput {
+    title: string;
+    markdown: string;
+    attachments: PdfAttachment[];
+    /** ISO-8601 UTC with Z: the signing time. */
+    at: string;
+    /** The drawn text's language: "ar" lays every line out right to left (§6). Default "en". */
+    lang?: "en" | "ar";
+}
+/** spec/pdf.md §3: the identity's self-signed X.509 certificate (v1, CN = its did:key). */
+export declare function pdfCertificate(seed: Uint8Array): Uint8Array;
+/** spec/pdf.md: the report as a signed PDF/A-3b file. `seed` is the signer's Ed25519 seed. */
+export declare function reportPdf(input: PdfInput, seed: Uint8Array, assets: PdfAssets): Uint8Array;
+export interface PdfVerification {
+    ok: boolean;
+    signer: string | null;
+    signed_at: string | null;
+    pdfa: {
+        ok: boolean;
+        problems: string[];
+    };
+    attachments: Array<{
+        name: string;
+        mime: string;
+        relationship: string;
+        sha256: string;
+        size: number;
+    }>;
+    problems: string[];
+}
+/** spec/pdf.md §4: checks the signature (the ByteRange digest and the CMS signature, against the
+ * certificate inside) and the PDF/A-3b structure as far as it can be checked offline. */
+export declare function verifyPdf(pdf: Uint8Array): PdfVerification;