@2018kguo/recto 0.5.0 → 0.5.2

package/dist/assets.js

@@ -124,6 +124,22 @@ function loadFailure(name, url, reason, cause) {
         "somewhere it serves and pass that directory as `assetBase` (with Vite's dev server, add " +
         'optimizeDeps: { exclude: ["@2018kguo/recto"] } instead; a server bundle should keep the package external).', cause);
 }
+/**
+ * `read` of an asset's URL, sync or async, with any failure but a PdfError reported as that asset's
+ * `missing-asset`. Resolving the URL is inside it: under a blob: worker `import.meta.url` is no base.
+ */
+function located(name, base, read) {
+    let url = null;
+    const failure = (error) => error instanceof PdfError ? error : loadFailure(name, url, error instanceof Error ? error.message : String(error), error);
+    try {
+        url = assetUrl(name, base);
+        const result = read(url);
+        return (result instanceof Promise ? result.catch((error) => Promise.reject(failure(error))) : result);
+    }
+    catch (error) {
+        throw failure(error);
+    }
+}
 function notThisBuild(name, url, bytes) {
     return loadFailure(name, url, `the ${bytes.byteLength} bytes there are not this build's file (a server's fallback page, or a different version of the package)`);
 }
@@ -172,19 +188,7 @@ async function fetchBytes(name, url) {
 }
 /** The wasm, verified and then compiled. */
 export async function compileWasm(name, base) {
-    let url = null;
-    let bytes;
-    try {
-        // Inside the try: under a blob: worker `import.meta.url` is no base for a URL.
-        url = assetUrl(name, base);
-        bytes = (nodeFs() ? checked(name, url, readFromDisk(url)) : await fetchBytes(name, url));
-    }
-    catch (error) {
-        if (error instanceof PdfError) {
-            throw error;
-        }
-        throw loadFailure(name, url, error instanceof Error ? error.message : String(error), error);
-    }
+    const bytes = await located(name, base, async (url) => (nodeFs() ? checked(name, url, readFromDisk(url)) : await fetchBytes(name, url)));
     return await compiling(name, WebAssembly.compile(bytes));
 }
 function compiling(name, module) {
@@ -196,55 +200,31 @@ function compiling(name, module) {
 const loaded = new Map();
 /** Fetches and verifies assets ahead of time; a thread that can't read them when needed has to. */
 export async function preloadAssets(base, names) {
-    await Promise.all(names.map(async (name) => {
-        let url = null;
-        let bytes;
-        try {
-            url = assetUrl(name, base);
-            if (loaded.has(url.href)) {
-                return;
-            }
-            bytes = nodeFs() ? checked(name, url, readFromDisk(url)) : await fetchBytes(name, url);
-        }
-        catch (error) {
-            if (error instanceof PdfError) {
-                throw error;
-            }
-            throw loadFailure(name, url, error instanceof Error ? error.message : String(error), error);
+    await Promise.all(names.map((name) => located(name, base, async (url) => {
+        if (!loaded.has(url.href)) {
+            loaded.set(url.href, nodeFs() ? checked(name, url, readFromDisk(url)) : await fetchBytes(name, url));
         }
-        loaded.set(url.href, bytes);
-    }));
+    })));
 }
 /** An asset, read synchronously. Throws a PdfError rather than returning nothing. */
 export function loadAssetSync(name, base, hash) {
-    let url = null;
-    try {
-        url = assetUrl(name, base);
-        const cached = loaded.get(url.href);
-        if (cached) {
-            return cached;
+    return located(name, base, (url) => {
+        let bytes = loaded.get(url.href);
+        if (!bytes) {
+            bytes = readCheckedSync(name, base, hash);
+            loaded.set(url.href, bytes);
         }
-    }
-    catch (error) {
-        throw loadFailure(name, url, error instanceof Error ? error.message : String(error), error);
-    }
-    const bytes = readCheckedSync(name, base, hash);
-    loaded.set(url.href, bytes);
-    return bytes;
+        return bytes;
+    });
 }
 /** A file, read now and hashed before it's returned, and not kept: a part is compiled once. */
 export function readCheckedSync(name, base, hash) {
-    let url = null;
-    let bytes;
-    try {
-        url = assetUrl(name, base);
+    const [url, bytes] = located(name, base, (url) => {
         if (!canReadSync()) {
             throw new Error("this thread can only use assets fetched up front, and it was left out of preloadAssets");
         }
-        bytes = nodeFs() ? readFromDisk(url) : readSync(url);
-    }
-    catch (error) {
-        throw loadFailure(name, url, error instanceof Error ? error.message : String(error), error);
-    }
+        return [url, nodeFs() ? readFromDisk(url) : readSync(url)];
+    });
+    // Outside: a trap in the instance's hash is a crash, not a missing file.
     return checked(name, url, bytes, hash);
 }

package/dist/document.d.ts

@@ -273,10 +273,6 @@ export declare const ANNOT_SUBTYPE: {
     readonly stamp: 13;
     readonly widget: 20;
 };
-/**
- * An open PDF. Every call is synchronous CPU work on this thread. Closing is idempotent, and
- * every other method throws a PdfError with code "closed" afterwards.
- */
 /** A bookmark. `page` is -1 if it goes nowhere in this file; `url` is set if it links out. */
 export type PdfOutlineItem = {
     title: string;
@@ -284,6 +280,10 @@ export type PdfOutlineItem = {
     url: string | null;
     children: PdfOutlineItem[];
 };
+/**
+ * An open PDF. Every call is synchronous CPU work on this thread. Closing is idempotent, and
+ * every other method throws a PdfError with code "closed" afterwards.
+ */
 export interface PdfDocument {
     readonly pageCount: number;
     /** The document's bookmarks; empty if it has none. */

package/dist/document.js

@@ -253,16 +253,14 @@ export class RectoDocument {
         instance.openDocuments += 1;
         instance.documents.open += 1;
     }
+    /** Before every call: open, the page there (null for a call about the whole document), and the instance able to run it. */
     #check(index) {
         if (this.#closed) {
             throw new PdfError("closed", "this document is closed");
         }
-        if (!(Number.isInteger(index) && index >= 0 && index < this.pageCount)) {
+        if (index !== null && !(Number.isInteger(index) && index >= 0 && index < this.pageCount)) {
             throw new RangeError(`page ${index} is out of range (0..${this.pageCount - 1})`);
         }
-        this.#checkInstance();
-    }
-    #checkInstance() {
         if (this.#instance.abandoned) {
             this.#moveOffAbandoned();
         }
@@ -327,25 +325,16 @@ export class RectoDocument {
         return this.#call(() => toObjects(this.#doc.objects(index)));
     }
     pageLabels() {
-        if (this.#closed) {
-            throw new PdfError("closed", "this document is closed");
-        }
-        this.#checkInstance();
+        this.#check(null);
         return this.#call(() => this.#doc.pageLabels());
     }
     structureTruncated() {
-        if (this.#closed) {
-            throw new PdfError("closed", "this document is closed");
-        }
-        this.#checkInstance();
+        this.#check(null);
         const [pages, pageLabels, outline] = this.#call(() => this.#doc.structureTruncated());
         return { pages: pages === 1, pageLabels: pageLabels === 1, outline: outline === 1 };
     }
     outline() {
-        if (this.#closed) {
-            throw new PdfError("closed", "this document is closed");
-        }
-        this.#checkInstance();
+        this.#check(null);
         return this.#call(() => {
             const top = [];
             // The open item at each level; an item's parent is the last one a level up.

package/dist/engine.js

@@ -313,14 +313,11 @@ class RectoEngine {
             }, () => loader.failure);
         }
         catch (error) {
-            if (loader.failure && !(error instanceof WebAssembly.RuntimeError)) {
-                throw loader.failure;
-            }
-            throw engineFailure(instance, error);
+            throw loader.explain(loader.failure && !(error instanceof WebAssembly.RuntimeError) ? loader.failure : engineFailure(instance, error));
         }
         if (loader.failure) {
             doc.close();
-            throw loader.failure;
+            throw loader.explain(loader.failure);
         }
         return Object.assign(doc, { stats: () => loader.stats() });
     }

package/dist/ranged.d.ts

@@ -71,8 +71,9 @@ type Answer = {
  * fails throws. A suffix that isn't answered as one (a server that ignores or refuses it)
  * gives null, and isn't counted: the caller asks for the tail by its offset instead.
  */
-type Fetch = (requests: Request[], timeoutMs: number, limit: number) => (Answer | null)[];
-type FetchAsync = (requests: Request[], timeoutMs: number, limit: number) => Promise<(Answer | null)[]>;
+type Answers = (Answer | null)[];
+type Fetch = (requests: Request[], timeoutMs: number, limit: number) => Answers;
+type FetchAsync = (requests: Request[], timeoutMs: number, limit: number) => Promise<Answers>;
 /** Fetched chunks of one file and the policy for fetching more. */
 declare class RangeLoader {
     #private;
@@ -88,14 +89,18 @@ declare class RangeLoader {
         signal: AbortSignal | undefined;
     });
     stats(): PdfRangedStats;
-    /** Fetches chunks `firstChunk..endChunk`, keeping only those not held yet. */
-    fetchChunks(firstChunk: number, endChunk: number): void;
     /**
      * The first round: the head and, in parallel, the tail as a suffix, then the last
      * cross-reference section if the tail didn't hold it. A file the head covers needs no more;
      * a server that doesn't answer the suffix gets the tail by offset in a round of its own.
      */
     begin(fetchAsync: FetchAsync | null): Promise<void>;
+    /**
+     * `failure`, or when what's held shows the file isn't a PDF (see `notPdfBytes`), that it isn't: an
+     * error or sign-in page fails to parse, or runs into `maxBytes`, and neither says why. Only when
+     * enough of the first KiB is held to tell.
+     */
+    explain(failure: unknown): unknown;
     /**
      * The `startxref` offset in the fetched last chunk, if it names one. Null for a linearized
      * file, whose trailer points at the first-page section near the head.

package/dist/ranged.js

@@ -83,24 +83,18 @@ class RangeLoader {
             fileBytes: this.length,
         };
     }
-    /** Fetches chunks `firstChunk..endChunk`, keeping only those not held yet. */
-    fetchChunks(firstChunk, endChunk) {
+    /** Fetches chunks `firstChunk..endChunk`, keeping only those not held yet: a read's miss, so it blocks. */
+    #fetchChunks(firstChunk, endChunk) {
         const runs = this.#missing(firstChunk, endChunk);
         if (runs.length > 0) {
-            this.#absorb(this.#round(runs, (limit, timeoutMs, passesTotal) => this.#timed(passesTotal, () => this.#fetch(runs, timeoutMs, limit))));
+            this.#absorb(this.#round(runs, (limit, timeoutMs) => this.#fetch(runs, timeoutMs, limit)));
         }
     }
-    /** The same, through `fetchAsync` when there is one: before the parse, a browser need not block. */
-    async #fetchChunksAsync(firstChunk, endChunk, fetchAsync) {
-        await this.#fetchRunsAsync(this.#missing(firstChunk, endChunk), fetchAsync);
-    }
-    async #fetchRunsAsync(runs, fetchAsync) {
-        if (runs.length === 0) {
-            return;
+    /** A round before the parse: through `fetchAsync` when there is one, so a browser need not block. */
+    async #fetchAhead(requests, fetchAsync) {
+        if (requests.length > 0) {
+            this.#absorb(await this.#round(requests, (limit, timeoutMs) => fetchAsync ? fetchAsync(requests, timeoutMs, limit) : this.#fetch(requests, timeoutMs, limit)));
         }
-        this.#absorb(await this.#round(runs, (limit, timeoutMs, passesTotal) => fetchAsync
-            ? this.#timedAsync(passesTotal, fetchAsync(runs, timeoutMs, limit))
-            : this.#timed(passesTotal, () => this.#fetch(runs, timeoutMs, limit))));
     }
     /**
      * The first round: the head and, in parallel, the tail as a suffix, then the last
@@ -111,11 +105,7 @@ class RangeLoader {
         const tail = TAIL_CHUNKS * this.chunkBytes;
         // The head stops where the suffix starts, in a file shorter than the two.
         const head = { start: 0, end: HEAD_CHUNKS * this.chunkBytes, yieldTail: tail };
-        const requests = [head, { suffix: tail }];
-        const answers = await this.#round(requests, (limit, timeoutMs, passesTotal) => fetchAsync
-            ? this.#timedAsync(passesTotal, fetchAsync(requests, timeoutMs, limit))
-            : this.#timed(passesTotal, () => this.#fetch(requests, timeoutMs, limit)));
-        this.#absorb(answers);
+        await this.#fetchAhead([head, { suffix: tail }], fetchAsync);
         if (this.length <= 0) {
             throw new PdfError("invalid-file", "the file is empty");
         }
@@ -124,13 +114,13 @@ class RangeLoader {
         }
         // Without the suffix's answer, the head and the last chunk by their offsets, as one round.
         const totalChunks = Math.ceil(this.length / this.chunkBytes);
-        await this.#fetchRunsAsync([...this.#missing(0, Math.min(HEAD_CHUNKS, totalChunks)), ...this.#missing(Math.max(HEAD_CHUNKS, totalChunks - 1), totalChunks)], fetchAsync);
+        await this.#fetchAhead([...this.#missing(0, Math.min(HEAD_CHUNKS, totalChunks)), ...this.#missing(Math.max(HEAD_CHUNKS, totalChunks - 1), totalChunks)], fetchAsync);
         if (totalChunks > HEAD_CHUNKS) {
             // The tail names the last cross-reference section (`startxref`). Fetch all of it in one
             // round, rather than letting the parser discover it a chunk at a time.
             const xrefAt = this.startxref();
             if (xrefAt !== null && this.length - xrefAt <= MAX_READ_AHEAD_BYTES) {
-                await this.#fetchChunksAsync(Math.floor(xrefAt / this.chunkBytes), totalChunks, fetchAsync);
+                await this.#fetchAhead(this.#missing(Math.floor(xrefAt / this.chunkBytes), totalChunks), fetchAsync);
             }
         }
     }
@@ -169,7 +159,7 @@ class RangeLoader {
     }
     /**
      * One round trip for `requests`: the signal, the budget and the deadline checked first, then
-     * `fetch` with what's left of each.
+     * `fetch` with what's left of each. A timeout that's the deadline's says so.
      */
     #round(requests, fetch) {
         if (this.#signal?.aborted) {
@@ -187,27 +177,17 @@ class RangeLoader {
         }
         this.#rounds += 1;
         const passesTotal = left < this.#timeoutMs;
-        return fetch(this.#maxBytes - this.#bytesFetched, passesTotal ? Math.ceil(left) : this.#timeoutMs, passesTotal);
-    }
-    #passedTotal() {
-        return `the ranged read passed its ${this.#totalTimeoutMs} ms (totalTimeoutMs)`;
-    }
-    /** A round's timeout, when it's the deadline's, says so. */
-    #timed(passesTotal, fetch) {
+        const said = (error) => passesTotal && error.code === "timeout" ? new PdfError("timeout", this.#passedTotal(), error) : error;
         try {
-            return fetch();
+            const answers = fetch(this.#maxBytes - this.#bytesFetched, passesTotal ? Math.ceil(left) : this.#timeoutMs);
+            return (answers instanceof Promise ? answers.catch((error) => Promise.reject(said(error))) : answers);
         }
         catch (error) {
-            if (passesTotal && error.code === "timeout") {
-                throw new PdfError("timeout", this.#passedTotal(), error);
-            }
-            throw error;
+            throw said(error);
         }
     }
-    async #timedAsync(passesTotal, fetch) {
-        return await fetch.catch((error) => {
-            throw passesTotal && error.code === "timeout" ? new PdfError("timeout", this.#passedTotal(), error) : error;
-        });
+    #passedTotal() {
+        return `the ranged read passed its ${this.#totalTimeoutMs} ms (totalTimeoutMs)`;
     }
     /** Checks and keeps a round's answers; a suffix nobody answered is skipped. */
     #absorb(answers) {
@@ -277,6 +257,27 @@ class RangeLoader {
             }
         }
     }
+    /**
+     * `failure`, or when what's held shows the file isn't a PDF (see `notPdfBytes`), that it isn't: an
+     * error or sign-in page fails to parse, or runs into `maxBytes`, and neither says why. Only when
+     * enough of the first KiB is held to tell.
+     */
+    explain(failure) {
+        if (!(failure instanceof PdfError && (failure.code === "invalid-file" || overBudget.has(failure)))) {
+            return failure;
+        }
+        // The chunks held from the start on, at least the first KiB's worth when chunks are smaller.
+        const parts = [];
+        let held = 0;
+        for (let chunk = 0; held < Math.max(HEADER_BYTES, this.chunkBytes) && this.#chunks[chunk]; chunk++) {
+            parts.push(this.#chunks[chunk]);
+            held += this.#chunks[chunk].byteLength;
+        }
+        const head = parts.length > 0 ? concat(...parts) : this.#pieces.get(0)?.find((piece) => piece.start === 0)?.bytes;
+        return head && head.byteLength >= Math.min(HEADER_BYTES, this.length) && notPdfBytes(head, this.#chunks.at(-1))
+            ? notPdf(failure)
+            : failure;
+    }
     /**
      * The `startxref` offset in the fetched last chunk, if it names one. Null for a linearized
      * file, whose trailer points at the first-page section near the head.
@@ -284,12 +285,10 @@ class RangeLoader {
     startxref() {
         const first = this.#chunks[0];
         const last = this.#chunks.at(-1);
-        if (!first ||
-            !last ||
-            new TextDecoder("latin1").decode(first.subarray(0, 1024)).includes("/Linearized")) {
+        if (!first || !last || latin1(first.subarray(0, HEADER_BYTES)).includes("/Linearized")) {
             return null;
         }
-        const tail = new TextDecoder("latin1").decode(last.subarray(-1024));
+        const tail = latin1(last.subarray(-1024));
         const match = /startxref\s+(\d+)\s+%%EOF\s*$/u.exec(tail);
         const offset = match ? Number(match[1]) : Number.NaN;
         return offset >= 0 && offset < this.length ? offset : null;
@@ -334,7 +333,7 @@ class RangeLoader {
         for (let chunk = first; chunk <= last; chunk++) {
             if (!this.#chunks[chunk]) {
                 try {
-                    this.fetchChunks(...this.#window(chunk, last, lastAhead));
+                    this.#fetchChunks(...this.#window(chunk, last, lastAhead));
                 }
                 catch (error) {
                     this.failure =
@@ -388,7 +387,12 @@ export async function startRangeLoader(source, options = {}) {
         totalTimeoutMs: options.totalTimeoutMs ?? Number.POSITIVE_INFINITY,
         signal: options.signal,
     });
-    await loader.begin(asyncFetcherFor(source));
+    try {
+        await loader.begin(asyncFetcherFor(source));
+    }
+    catch (error) {
+        throw loader.explain(error);
+    }
     return loader;
 }
 /**
@@ -460,8 +464,32 @@ function readsOf(request, contentRange) {
 function rangeHeader(request) {
     return "suffix" in request ? `bytes=-${request.suffix}` : `bytes=${request.start}-${request.end - 1}`;
 }
+/** The budget's failures, which bytes that aren't a PDF explain better; not the address space's. */
+const overBudget = new WeakSet();
 function tooLarge(maxBytes) {
-    return new PdfError("too-large", `the ranged read would pass ${maxBytes} bytes (maxBytes); raise it or fetch the file whole`);
+    const error = new PdfError("too-large", `the ranged read would pass ${maxBytes} bytes (maxBytes); raise it or fetch the file whole`);
+    overBudget.add(error);
+    return error;
+}
+/** How far into a file a reader looks for its `%PDF` header. */
+const HEADER_BYTES = 1024;
+function latin1(bytes) {
+    return new TextDecoder("latin1").decode(bytes);
+}
+/**
+ * Whether a file's first and last bytes show it isn't a PDF: no `%PDF` where a reader looks for it,
+ * and no `endobj` or `startxref` either, which a damaged PDF that lost its header still has.
+ */
+function notPdfBytes(head, tail) {
+    const syntax = (bytes) => /endobj|startxref/u.test(latin1(bytes));
+    return !latin1(head.subarray(0, HEADER_BYTES)).includes("%PDF") && !syntax(head) && !(tail && syntax(tail));
+}
+function notPdf(cause) {
+    return new PdfError("invalid-file", `not a PDF: no %PDF header in its first ${HEADER_BYTES} bytes (an error or sign-in page?)`, cause);
+}
+/** A non-2xx answer: its status says more than anything read from its body would. */
+function httpFailure(status) {
+    return new PdfError("fetch-failed", `the server answered HTTP ${status}, not the file`, undefined, status);
 }
 /**
  * A server's answer as chunks to store, or a clear failure. Messages never carry the URL: a
@@ -471,12 +499,15 @@ function answerOf(range, status, contentRange, etag, bytes, limit, received = by
     if (status === 200 && !("suffix" in range)) {
         // The server ignored Range and sent the whole file: use it, while the budget allows.
         if (bytes.byteLength > limit) {
+            if (notPdfBytes(bytes.subarray(0, 1 << 16), bytes.subarray(-(1 << 16)))) {
+                throw notPdf();
+            }
             throw new PdfError("too-large", `the server does not answer Range requests, and the whole file is past the ${limit} bytes left of maxBytes`);
         }
         return { start: 0, bytes, length: bytes.byteLength, etag, status, received };
     }
     if (status !== 206) {
-        throw new PdfError("fetch-failed", `the ranged read failed (HTTP ${status})`, undefined, status);
+        throw httpFailure(status);
     }
     const match = /^bytes (\d+)-\d+\/(\d+)$/u.exec(contentRange?.trim() ?? "");
     if (!match) {
@@ -507,6 +538,7 @@ function suffixAnswerOf(suffix, status, contentRange, etag, bytes, received = by
     }
 }
 const NO_ANSWER = "the ranged read failed: the network, or a cross-origin server that does not allow it";
+/** A read's miss in a browser worker. The rounds with a suffix go through `fetch`, before the parse. */
 function fetchOverXhr(url, ranges, timeoutMs, limit) {
     const deadline = performance.now() + timeoutMs;
     return ranges.map((range) => {
@@ -528,9 +560,6 @@ function fetchOverXhr(url, ranges, timeoutMs, limit) {
         if (xhr.status === 0) {
             throw new PdfError("fetch-failed", NO_ANSWER);
         }
-        if ("suffix" in range) {
-            return suffixAnswerOf(range, xhr.status, xhr.getResponseHeader("Content-Range"), xhr.getResponseHeader("ETag"), new Uint8Array(xhr.response));
-        }
         return answerOf(range, xhr.status, xhr.getResponseHeader("Content-Range"), xhr.getResponseHeader("ETag"), new Uint8Array(xhr.response), limit);
     });
 }
@@ -568,6 +597,11 @@ async function fetchOverFetch(url, requests, timeoutMs, limit) {
                 suffixDone(null);
                 return null;
             }
+            if (!response.ok) {
+                // An error page: its status is the answer, and its body isn't worth downloading.
+                await response.body?.cancel();
+                throw httpFailure(response.status);
+            }
             const reader = byteReader(response.body);
             try {
                 if (response.status !== 206) {
@@ -656,10 +690,13 @@ function suffixGrace(took) {
 function delay(ms, value) {
     return new Promise((resolve) => setTimeout(() => resolve(value), ms));
 }
-function concat(a, b) {
-    const out = new Uint8Array(a.byteLength + b.byteLength);
-    out.set(a);
-    out.set(b, a.byteLength);
+function concat(...parts) {
+    const out = new Uint8Array(parts.reduce((sum, part) => sum + part.byteLength, 0));
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.byteLength;
+    }
     return out;
 }
 /**
@@ -711,16 +748,7 @@ function byteReader(body) {
                     spare = value.subarray(take);
                 }
             }
-            if (parts.length === 1) {
-                return parts[0];
-            }
-            const out = new Uint8Array(got);
-            let at = 0;
-            for (const part of parts) {
-                out.set(part, at);
-                at += part.byteLength;
-            }
-            return out;
+            return parts.length === 1 ? parts[0] : concat(...parts);
         },
         async cancel() {
             await (byob ?? plain)?.cancel().catch(() => undefined);
@@ -778,10 +806,9 @@ async function get(m, signal) {
   };
   try {
     // A 206 is read as far as the range runs (see readsOf), and a byte past to catch a longer one;
-    // a whole file, to a byte past the limit.
+    // a whole file, to a byte past the limit (answerOf says which).
     if (response.status !== 206) {
       const bytes = await read(m.limit + 1);
-      if (received > m.limit) return { ...reply, overLimit: true, bytes: new ArrayBuffer(0), received };
       return { ...reply, bytes: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength), received };
     }
     const total = Number((reply.contentRange || "").trim().split("/").pop());
@@ -904,7 +931,7 @@ function fetchOverThread(url, ranges, timeoutMs, limit) {
             pending.delete(reply.id);
             if ("suffix" in range) {
                 answers[order.get(range)] =
-                    reply.failed === undefined && !reply.overLimit
+                    reply.failed === undefined
                         ? suffixAnswerOf(range, reply.status, reply.contentRange, reply.etag, new Uint8Array(reply.bytes), reply.received)
                         : null;
                 continue;
@@ -913,9 +940,6 @@ function fetchOverThread(url, ranges, timeoutMs, limit) {
                 if (reply.failed !== undefined) {
                     throw new PdfError("fetch-failed", `the ranged read failed: ${reply.failed}`);
                 }
-                if (reply.overLimit) {
-                    throw tooLarge(limit);
-                }
                 answers[order.get(range)] = answerOf(range, reply.status, reply.contentRange, reply.etag, new Uint8Array(reply.bytes), limit, reply.received);
             }
             catch (error) {

package/dist/reading-order.d.ts

@@ -11,4 +11,11 @@ export type ReadingOrder = {
 };
 /** Break hints without a visible glyph, even when the font supplies bounds. */
 export declare function isInvisibleCodepoint(code: number): boolean;
+/**
+ * Quarter turns clockwise in the viewer frame that a char reads along: the
+ * page's clockwise /Rotate plus the char's angle, snapped to 0, 1, 2, 3. A
+ * char's angle is `atan2(c, a)`, which grows clockwise on the page (text
+ * turned θ counter-clockwise reads 2π - θ), so the two turns add.
+ */
+export declare function viewerTurn(rotation: number, angle: number): number;
 export declare function readingOrder(page: Pick<PdfPageText, "count" | "codepoints" | "flags" | "boxes" | "angles">, info: Pick<PdfPageInfo, "width" | "height" | "rotation">): ReadingOrder;

package/dist/reading-order.js

@@ -54,11 +54,13 @@ function streamOrder(page) {
     return { order, breaks, length };
 }
 /**
- * A char's quarter turn in the viewer frame: the page's clockwise /Rotate
- * less the char's own counter-clockwise angle, snapped to 0, 90, 180, 270.
+ * Quarter turns clockwise in the viewer frame that a char reads along: the
+ * page's clockwise /Rotate plus the char's angle, snapped to 0, 1, 2, 3. A
+ * char's angle is `atan2(c, a)`, which grows clockwise on the page (text
+ * turned θ counter-clockwise reads 2π - θ), so the two turns add.
  */
-function viewerTurn(rotation, angle) {
-    const degrees = rotation - (angle * 180) / Math.PI;
+export function viewerTurn(rotation, angle) {
+    const degrees = rotation + (angle * 180) / Math.PI;
     return ((Math.round(degrees / 90) % 4) + 4) % 4;
 }
 /**
@@ -126,8 +128,15 @@ function reflowedOrder(page, info) {
     }
     // Lines: sort by turn, then across; a new line starts where the centre
     // moves past the tolerance. Native traversal within a line is independent
-    // of the page rotation.
-    const byLine = Array.from({ length: n }, (_, k) => k).toSorted((p, q) => (turnOf[p] ?? 0) - (turnOf[q] ?? 0) || (across[p] ?? 0) - (across[q] ?? 0));
+    // of the page rotation. The turns come in the order the content stream
+    // first draws them, as on an upright page: a table's sideways header row
+    // drawn before its rows reads before them.
+    const turnRank = [n, n, n, n];
+    for (let k = n - 1; k >= 0; k--) {
+        turnRank[turnOf[k] ?? 0] = k;
+    }
+    const byLine = Array.from({ length: n }, (_, k) => k).toSorted((p, q) => (turnRank[turnOf[p] ?? 0] ?? 0) - (turnRank[turnOf[q] ?? 0] ?? 0) ||
+        (across[p] ?? 0) - (across[q] ?? 0));
     const lineOf = new Uint32Array(n);
     let line = 0;
     for (let k = 1; k < byLine.length; k++) {

package/dist/text-items.js

@@ -17,18 +17,13 @@
 // Data-oriented: one pass over the reading order's index column; the only
 // objects made are the items returned.
 import { ANNOT_SUBTYPE, } from "./document.js";
-import { BREAK_LINE, BREAK_SPACE, isInvisibleCodepoint, readingOrder, } from "./reading-order.js";
+import { BREAK_LINE, BREAK_SPACE, isInvisibleCodepoint, readingOrder, viewerTurn, } from "./reading-order.js";
 const SPACE_IN_FLOW_MAX_FACTOR = 0.6;
 const VERTICAL_SHIFT_RATIO = 0.25;
 /** Share of the em below the baseline in the layout's box rule (1 - GLYPH_ASCENT). */
 const DESCENT_SHARE = 0.2;
 const HYPHEN_MARK = 0x02;
 const HYPHEN = 0x2d;
-/** Quarter turns clockwise in the viewer frame that a char reads along. */
-function viewerTurn(rotation, angle) {
-    const degrees = rotation - (angle * 180) / Math.PI;
-    return ((Math.round(degrees / 90) % 4) + 4) % 4;
-}
 /** The token direction (counter-clockwise, y up) of a clockwise viewer turn. */
 const DIRECTION_OF_TURN = [0, 270, 180, 90];
 function isSpaceCode(code) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2018kguo/recto",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "A PDF engine for JavaScript: text with boxes, page objects, annotations and rendering, in Rust compiled to WebAssembly.",
   "license": "MIT",
   "repository": {

package/wasm/pins.mjs

@@ -1,9 +1,9 @@
 // Generated by scripts/package-wasm.mjs.
 export const PINS = {
-  "recto.wasm": "6ea5dcbefb46130b65af4e3e8abd4c36204ecff4beaa089960c5d24e58dd6345",
-  "recto-render.wasm": "903b95817bb9c23769db27cedf3a29a7b5d3dcff0c65fbe28c0d0191943d59b7",
-  "recto-more.wasm": "e612392af0129e4e2f9083605f56c1e39b6eca0e2c5fef6ee39b72849b384f9b",
-  "recto-rare.wasm": "da54f130b42290ff9ef8c0ba45a0f9f49545f038f3bcfa19c5ec75ac2e9f4e6e",
+  "recto.wasm": "8d19f0dab3a875e6eab985af29053e00abac3a89912781e99ce25d5c1aba276b",
+  "recto-render.wasm": "88f970ce7230e634a81109871183df9a9ba65b6383f85cae8f7f53cdc7c2a7e8",
+  "recto-more.wasm": "cbd76e2a6faf37fac557151a3fcea32f5db0ad4a6a5b840dac8657ee53d1bf08",
+  "recto-rare.wasm": "1fc8c60ac2a2eeb9b625393556ec7bba27a0caa26170caeeaed91d5134470917",
   "FoxitFixed.pfb": "b6c8fe53f134b8b6d4578cd2d544df4cee9624c4efa8d51a560fb40ea296101b",
   "FoxitFixedBold.pfb": "f1b7159702973f54fc86254ea38bcf3712b2a736eb3a0995751e9f4bb45ad603",
   "FoxitFixedBoldItalic.pfb": "8a000945843bd31add06aee63bf9fd41b7578b4f3242a4b7cd46349ad9d24d4d",

package/wasm/recto.gen.mjs

@@ -916,7 +916,7 @@ function sha256(bytes) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_ac777cef8e847b72: function(arg0, arg1) {
+        __wbg_Error_17e7c3613064979b: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
@@ -962,7 +962,7 @@ function __wbg_get_imports() {
             const ret = arg0.push(arg1);
             return ret;
         },
-        __wbg_set_0fd79ff56b8778a4: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_set_7c811f3f25847af5: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },