@unisim/doc 0.6.0 → 0.8.0

package/README.md

@@ -50,6 +50,17 @@ reader has to drop is reported through `RichDoc.notices` rather than discovered
 later — the failure worth designing against is someone assuming the output is a
 copy.
 
+**Right-to-left text** (Hebrew; Arabic letters are ordered too) is put into
+visual order by `src/bidi.ts`, a hand-written subset of the Unicode
+Bidirectional Algorithm (UAX #9) — hand-written rather than `bidi-js` because
+this package has no dependencies. Levels are resolved per paragraph and each
+wrapped line is reordered on its own; a paragraph whose first letter is
+right-to-left is right-aligned, and its list markers and quote bar move to the
+right. Not done: explicit embedding/isolate controls (ignored), Arabic shaping
+(letters are not joined), and right-to-left column order in tables. An
+all-Latin document's PDF is byte-identical to 0.7.0's — the self-test holds it
+to a hash.
+
 ## Two writers, on purpose
 
 The PDF writer here goes through `pdfcore` — base-14 fonts, its own AFM tables,

package/dist/bidi.d.ts

@@ -0,0 +1,51 @@
+type Level = number;
+/** True if `text` holds a right-to-left letter (or an Arabic digit, or an RLM). */
+export declare function hasRtl(text: string): boolean;
+/** The glyph to draw for `ch` at an odd (right-to-left) level. */
+export declare function mirrorOf(ch: string): string;
+/**
+ * The paragraph's direction (P2/P3): 1 if its first strong letter is
+ * right-to-left, else 0. A paragraph with no letters at all is left-to-right.
+ */
+export declare function paragraphLevel(text: string): 0 | 1;
+export interface BidiParagraph {
+    /** The paragraph's own level: 0 left-to-right, 1 right-to-left. */
+    base: 0 | 1;
+    /** The resolved embedding level of every UTF-16 code unit of the input. */
+    levels: Uint8Array;
+}
+/**
+ * Resolve the embedding level of every character in one paragraph (rules
+ * P2–I2). Returns `null` for a paragraph with nothing right-to-left in it
+ * (unless `base` forces it right-to-left), so a caller can keep its all-Latin
+ * path exactly as it was.
+ *
+ * `base` forces the paragraph direction; left out, it comes from the text.
+ */
+export declare function resolveLevels(text: string, base?: 0 | 1): BidiParagraph | null;
+/** One thing to place on a line: a base character and the marks on it. */
+export interface BidiCluster {
+    text: string;
+    level: Level;
+}
+/**
+ * Split `text` into clusters — a character plus any combining marks after it —
+ * each carrying the level of its first code unit. A mark must be drawn AFTER
+ * its base whichever way the line runs (rule L3), so they reverse as one.
+ */
+export declare function clustersOf(text: string, levels: ArrayLike<number>): BidiCluster[];
+/**
+ * Put one rendered line's clusters into visual (left-to-right) order: rule L1
+ * (trailing whitespace and tabs to the paragraph level) then L2 (reverse every
+ * run at or above each odd level, highest first). Returns a new array; each
+ * item's `level` is the one it was DRAWN at, so the caller can mirror (L4).
+ */
+export declare function reorderLine<T extends BidiCluster>(line: readonly T[], base: 0 | 1): T[];
+/**
+ * One line of text as it will be SEEN, left to right — the whole algorithm in
+ * one call, for a caller that draws a single line (a label, a list marker) and
+ * for the tests. Text with nothing right-to-left in it is returned unchanged.
+ */
+export declare function visualOrder(text: string, base?: 0 | 1): string;
+export {};
+//# sourceMappingURL=bidi.d.ts.map

package/dist/bidi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bidi.d.ts","sourceRoot":"","sources":["../src/bidi.ts"],"names":[],"mappings":"AA+DA,KAAK,KAAK,GAAG,MAAM,CAAA;AAKnB,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5C;AAuJD,kEAAkE;AAClE,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CASlD;AAED,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAA;IACX,2EAA2E;IAC3E,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,aAAa,GAAG,IAAI,CAqG9E;AA6DD,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,KAAK,CAAA;CACb;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,WAAW,EAAE,CAejF;AAID;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CA+BvF;AAYD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,MAAM,CAM9D"}

package/dist/bidi.js

@@ -0,0 +1,587 @@
+// ---------------------------------------------------------------------------
+// Right-to-left text, in the order it is SEEN.
+//
+// A PDF content stream draws glyphs left to right, one after another, and that
+// is all it does. Hebrew is stored first-letter-first like every other script,
+// so drawn as stored it comes out mirrored: שלום עולם read backwards. Nothing
+// in a PDF viewer fixes that for you — the reordering is the WRITER's job, and
+// until this file existed nothing here did it.
+//
+// WHY A HAND-WRITTEN SUBSET OF UAX #9 AND NOT `bidi-js`
+// ------------------------------------------------------
+// This package has NO RUNTIME DEPENDENCIES and says so in its README: one of
+// its two consumers (Universal Converter) is sold on being offline from first
+// visit with nothing fetched. `bidi-js` is a fine library, but it is ~60 KB of
+// generated Unicode tables for the whole of UAX #9 — explicit embeddings,
+// isolates, every script — to serve a writer that can only ever draw what its
+// fallback face (Liberation Sans) holds: Latin, Greek, Cyrillic and Hebrew.
+// What that needs is the implicit algorithm on one paragraph, which is short
+// and well specified. So this is exactly that, rule by rule, with the rule
+// names from the standard on each step so it can be checked against it:
+//
+//   P2/P3  paragraph direction from the first strong character
+//   W1–W7  weak types (marks, numbers, separators)
+//   N0     paired brackets
+//   N1–N2  neutrals
+//   I1–I2  implicit levels
+//   L1     trailing whitespace back to the paragraph level (per line)
+//   L2     reverse runs, highest level first (per line)
+//   L3     combining marks stay AFTER their base (reversed as clusters)
+//   L4     mirrored glyphs — '(' in right-to-left text is drawn as ')'
+//
+// NOT DONE, on purpose: explicit embeddings and isolates (LRE/RLE/LRO/RLO/PDF,
+// LRI/RLI/FSI/PDI) are treated as invisible no-ops, and Arabic is ordered but
+// not SHAPED (no joining forms) — Liberation Sans has no Arabic anyway. The
+// character classes cover Latin, Greek, Cyrillic, Hebrew, Arabic and common
+// punctuation; anything unlisted is a strong left-to-right letter, which is the
+// right answer for every other script the suite can draw.
+//
+// ⚠️ LEVELS ARE RESOLVED PER PARAGRAPH, ORDER IS APPLIED PER LINE. The standard
+// is explicit about this and it matters: whether the comma at the end of a
+// wrapped line belongs to the Hebrew before it or the English after it depends
+// on text that may be on the NEXT line. So the writer resolves levels once on
+// the whole paragraph, wraps in logical order, and only then reorders each
+// rendered line — never the other way round, which would wrap a reversed
+// paragraph and put its last words on the first line.
+// ---------------------------------------------------------------------------
+// Bidi classes, as small integers so the per-character arrays are typed arrays.
+const L = 0;
+const R = 1;
+const AL = 2;
+const EN = 3;
+const ES = 4;
+const ET = 5;
+const AN = 6;
+const CS = 7;
+const NSM = 8;
+const BN = 9;
+const B = 10;
+const S = 11;
+const WS = 12;
+const ON = 13;
+/** Anything that can make a paragraph need reordering at all. */
+const RTL_TRIGGER = /[֐-ࣿיִ-﷿ﹰ-ﻼ‏؜]/;
+/** True if `text` holds a right-to-left letter (or an Arabic digit, or an RLM). */
+export function hasRtl(text) {
+    return RTL_TRIGGER.test(text);
+}
+function inRange(c, lo, hi) {
+    return c >= lo && c <= hi;
+}
+/** Combining marks — they belong to the character before them. */
+function isMark(c) {
+    return (inRange(c, 0x0300, 0x036f) ||
+        inRange(c, 0x0483, 0x0489) ||
+        inRange(c, 0x0591, 0x05bd) ||
+        c === 0x05bf ||
+        c === 0x05c1 || c === 0x05c2 ||
+        c === 0x05c4 || c === 0x05c5 ||
+        c === 0x05c7 ||
+        inRange(c, 0x0610, 0x061a) ||
+        inRange(c, 0x064b, 0x065f) ||
+        c === 0x0670 ||
+        inRange(c, 0x06d6, 0x06dc) ||
+        inRange(c, 0x06df, 0x06e4) ||
+        c === 0x06e7 || c === 0x06e8 ||
+        inRange(c, 0x06ea, 0x06ed) ||
+        inRange(c, 0x08d3, 0x08ff) && c !== 0x08e2 ||
+        c === 0xfb1e ||
+        inRange(c, 0x20d0, 0x20ff) ||
+        inRange(c, 0xfe00, 0xfe0f) ||
+        inRange(c, 0xfe20, 0xfe2f));
+}
+/** The Bidi_Class of a code point, for the scripts this writer can draw. */
+function classOf(c) {
+    // ASCII first: it is nearly every character in nearly every document.
+    if (c < 0x80) {
+        if (c >= 0x30 && c <= 0x39)
+            return EN;
+        if ((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a))
+            return L;
+        if (c === 0x20 || c === 0x0c)
+            return WS;
+        if (c === 0x09 || c === 0x0b || c === 0x1f)
+            return S;
+        if (c === 0x0a || c === 0x0d || (c >= 0x1c && c <= 0x1e))
+            return B;
+        if (c < 0x20 || c === 0x7f)
+            return BN;
+        if (c === 0x2b || c === 0x2d)
+            return ES; // + -
+        if (c >= 0x23 && c <= 0x25)
+            return ET; // # $ %
+        if (c === 0x2c || c === 0x2e || c === 0x2f || c === 0x3a)
+            return CS; // , . / :
+        return ON;
+    }
+    if (isMark(c))
+        return NSM;
+    // Latin-1 supplement
+    if (c < 0x100) {
+        if (c === 0x85)
+            return B;
+        if (c < 0xa0)
+            return BN;
+        if (c === 0xa0)
+            return CS;
+        if (c === 0xad)
+            return BN;
+        if (c === 0xb2 || c === 0xb3 || c === 0xb9)
+            return EN;
+        if ((c >= 0xa2 && c <= 0xa5) || c === 0xb0 || c === 0xb1)
+            return ET;
+        if (c === 0xaa || c === 0xb5 || c === 0xba || c >= 0xc0) {
+            return c === 0xd7 || c === 0xf7 ? ON : L;
+        }
+        return ON;
+    }
+    // Hebrew
+    if (c >= 0x0590 && c <= 0x05ff)
+        return R;
+    // Arabic
+    if (c >= 0x0600 && c <= 0x06ff) {
+        if (c <= 0x0605 || (c >= 0x0660 && c <= 0x0669) || c === 0x066b || c === 0x066c || c === 0x06dd)
+            return AN;
+        if (c === 0x060c)
+            return CS;
+        if (c === 0x066a)
+            return ET;
+        if (c >= 0x06f0 && c <= 0x06f9)
+            return EN;
+        if (c === 0x0609 || c === 0x060a)
+            return ET;
+        if (c === 0x060e || c === 0x060f || c === 0x06de || c === 0x06e9)
+            return ON;
+        return AL;
+    }
+    if (c >= 0x0700 && c <= 0x074f)
+        return AL; // Syriac
+    if (c >= 0x0750 && c <= 0x077f)
+        return AL; // Arabic supplement
+    if (c >= 0x0780 && c <= 0x07bf)
+        return AL; // Thaana
+    if (c >= 0x07c0 && c <= 0x085f)
+        return R; // NKo, Samaritan, Mandaic
+    if (c >= 0x0860 && c <= 0x08ff)
+        return AL; // Syriac/Arabic extended
+    if (c >= 0xfb1d && c <= 0xfb4f)
+        return c === 0xfb29 ? ES : R; // Hebrew presentation forms
+    if (c >= 0xfb50 && c <= 0xfdff)
+        return c === 0xfd3e || c === 0xfd3f ? ON : AL;
+    if (c >= 0xfe70 && c <= 0xfefe)
+        return AL;
+    if (c === 0xfeff)
+        return BN;
+    // General punctuation and friends
+    if (c >= 0x2000 && c <= 0x200a)
+        return WS;
+    if (c >= 0x200b && c <= 0x200d)
+        return BN;
+    if (c === 0x200e)
+        return L; // LRM
+    if (c === 0x200f)
+        return R; // RLM
+    if (c === 0x2028)
+        return WS;
+    if (c === 0x2029)
+        return B;
+    if ((c >= 0x202a && c <= 0x202e) || (c >= 0x2066 && c <= 0x2069))
+        return BN; // embeddings/isolates: unsupported, ignored
+    if (c === 0x202f)
+        return CS;
+    if (c >= 0x2030 && c <= 0x2034)
+        return ET;
+    if (c === 0x2044)
+        return CS;
+    if (c === 0x205f)
+        return WS;
+    if (c >= 0x2060 && c <= 0x2064)
+        return BN;
+    if (c >= 0x2010 && c <= 0x205e)
+        return ON;
+    if (c === 0x2070 || (c >= 0x2074 && c <= 0x2079) || (c >= 0x2080 && c <= 0x2089))
+        return EN;
+    if (c === 0x207a || c === 0x207b || c === 0x208a || c === 0x208b)
+        return ES;
+    if (c >= 0x207c && c <= 0x207e)
+        return ON;
+    if (c >= 0x208c && c <= 0x208e)
+        return ON;
+    if (c >= 0x20a0 && c <= 0x20cf)
+        return ET; // currency
+    if (c === 0x2212)
+        return ES;
+    if (c === 0x2213)
+        return ET;
+    if (c === 0x212e)
+        return ET;
+    if (c >= 0x2100 && c <= 0x214f)
+        return L; // letterlike: mostly L, a few ON — L is the safe default
+    if (c >= 0x2150 && c <= 0x218f)
+        return ON;
+    if (c >= 0x2190 && c <= 0x2bff)
+        return ON; // arrows, maths, box drawing, shapes, dingbats
+    if (c === 0x1680 || c === 0x3000)
+        return WS;
+    if (c >= 0x3001 && c <= 0x3004)
+        return ON;
+    if (c >= 0x3008 && c <= 0x3020)
+        return ON;
+    if (c >= 0xfe50 && c <= 0xfe6f) {
+        if (c === 0xfe50 || c === 0xfe52 || c === 0xfe55)
+            return CS;
+        if (c === 0xfe62 || c === 0xfe63)
+            return ES;
+        if (c === 0xfe5f || c === 0xfe69 || c === 0xfe6a)
+            return ET;
+        return ON;
+    }
+    if (c >= 0xff01 && c <= 0xff20) {
+        if (c >= 0xff10 && c <= 0xff19)
+            return EN;
+        if (c === 0xff0b || c === 0xff0d)
+            return ES;
+        if (c >= 0xff03 && c <= 0xff05)
+            return ET;
+        if (c === 0xff0c || c === 0xff0e || c === 0xff0f || c === 0xff1a)
+            return CS;
+        return ON;
+    }
+    if (c >= 0x10800 && c <= 0x10fff)
+        return R; // historic RTL scripts
+    if (c >= 0x1e800 && c <= 0x1efff)
+        return R;
+    return L;
+}
+/** Bidi_Mirroring_Glyph for the pairs a document is likely to hold. */
+const MIRROR = {
+    '(': ')', ')': '(', '[': ']', ']': '[', '{': '}', '}': '{', '<': '>', '>': '<',
+    '\u00ab': '\u00bb', '\u00bb': '\u00ab', // « »
+    '\u2039': '\u203a', '\u203a': '\u2039', // ‹ ›
+    '\u2264': '\u2265', '\u2265': '\u2264', // ≤ ≥
+    '\u226a': '\u226b', '\u226b': '\u226a', // ≪ ≫
+    '\u2045': '\u2046', '\u2046': '\u2045', // ⁅ ⁆
+    '\u207d': '\u207e', '\u207e': '\u207d', // superscript ( )
+    '\u208d': '\u208e', '\u208e': '\u208d', // subscript ( )
+    '\u2329': '\u232a', '\u232a': '\u2329', // angle brackets
+    '\u3008': '\u3009', '\u3009': '\u3008',
+};
+/** Bidi_Paired_Bracket, opening → closing, for rule N0. */
+const OPENING = {
+    '(': ')', '[': ']', '{': '}',
+    '\u2045': '\u2046', '\u207d': '\u207e', '\u208d': '\u208e', '\u2329': '\u232a', '\u3008': '\u3009',
+};
+const CLOSING = new Set(Object.values(OPENING));
+/** The glyph to draw for `ch` at an odd (right-to-left) level. */
+export function mirrorOf(ch) {
+    return MIRROR[ch] ?? ch;
+}
+/**
+ * The paragraph's direction (P2/P3): 1 if its first strong letter is
+ * right-to-left, else 0. A paragraph with no letters at all is left-to-right.
+ */
+export function paragraphLevel(text) {
+    for (let i = 0; i < text.length; i += 1) {
+        const cp = text.codePointAt(i);
+        if (cp > 0xffff)
+            i += 1;
+        const t = classOf(cp);
+        if (t === L)
+            return 0;
+        if (t === R || t === AL)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Resolve the embedding level of every character in one paragraph (rules
+ * P2–I2). Returns `null` for a paragraph with nothing right-to-left in it
+ * (unless `base` forces it right-to-left), so a caller can keep its all-Latin
+ * path exactly as it was.
+ *
+ * `base` forces the paragraph direction; left out, it comes from the text.
+ */
+export function resolveLevels(text, base) {
+    // A paragraph FORCED right-to-left needs resolving even with no Hebrew in
+    // it: "1." in a Hebrew list reads ".1".
+    if (base !== 1 && !hasRtl(text))
+        return null;
+    const e = base ?? paragraphLevel(text);
+    const n = text.length;
+    const orig = new Uint8Array(n);
+    for (let i = 0; i < n; i += 1) {
+        const cp = text.codePointAt(i);
+        orig[i] = classOf(cp);
+        if (cp > 0xffff) {
+            // The low surrogate travels with its high one.
+            orig[i + 1] = orig[i] === NSM ? NSM : orig[i];
+            i += 1;
+        }
+    }
+    // A surrogate pair's second half is not a character of its own: treated as a
+    // mark, it simply takes whatever its first half resolves to.
+    const types = new Uint8Array(orig);
+    for (let i = 0; i < n; i += 1) {
+        const cp = text.charCodeAt(i);
+        if (cp >= 0xdc00 && cp <= 0xdfff && i > 0)
+            types[i] = NSM;
+    }
+    const sos = e === 1 ? R : L;
+    const eos = sos;
+    // X9 (approximately): boundary-neutral characters behave like marks, taking
+    // the type of what they follow. Removing them outright would shift every
+    // index after them; this keeps the arrays aligned with the text.
+    for (let i = 0; i < n; i += 1)
+        if (types[i] === BN)
+            types[i] = NSM;
+    // W1: a mark takes the type of the character before it.
+    for (let i = 0; i < n; i += 1) {
+        if (types[i] === NSM)
+            types[i] = i === 0 ? sos : types[i - 1];
+    }
+    // W2: European digits after Arabic letters are Arabic digits.
+    let lastStrong = sos;
+    for (let i = 0; i < n; i += 1) {
+        const t = types[i];
+        if (t === L || t === R || t === AL)
+            lastStrong = t;
+        else if (t === EN && lastStrong === AL)
+            types[i] = AN;
+    }
+    // W3: Arabic letters are right-to-left letters from here on.
+    for (let i = 0; i < n; i += 1)
+        if (types[i] === AL)
+            types[i] = R;
+    // W4: one separator between two numbers of the same kind joins them.
+    for (let i = 1; i < n - 1; i += 1) {
+        const t = types[i];
+        const prev = types[i - 1];
+        const next = types[i + 1];
+        if (t === ES && prev === EN && next === EN)
+            types[i] = EN;
+        else if (t === CS && prev === EN && next === EN)
+            types[i] = EN;
+        else if (t === CS && prev === AN && next === AN)
+            types[i] = AN;
+    }
+    // W5: currency and percent signs touching a European number join it.
+    for (let i = 0; i < n; i += 1) {
+        if (types[i] !== ET)
+            continue;
+        let j = i;
+        while (j < n && types[j] === ET)
+            j += 1;
+        const touches = (i > 0 && types[i - 1] === EN) || (j < n && types[j] === EN);
+        if (touches)
+            for (let k = i; k < j; k += 1)
+                types[k] = EN;
+        i = j - 1;
+    }
+    // W6: any separator left over is a neutral.
+    for (let i = 0; i < n; i += 1) {
+        const t = types[i];
+        if (t === ES || t === ET || t === CS)
+            types[i] = ON;
+    }
+    // W7: European numbers after a left-to-right letter are left-to-right.
+    lastStrong = sos;
+    for (let i = 0; i < n; i += 1) {
+        const t = types[i];
+        if (t === L || t === R)
+            lastStrong = t;
+        else if (t === EN && lastStrong === L)
+            types[i] = L;
+    }
+    // N0: paired brackets resolve together, from what they enclose.
+    resolveBrackets(text, orig, types, e, sos);
+    // N1/N2: a run of neutrals between two things of the same direction takes
+    // that direction; otherwise the paragraph's. Numbers count as right-to-left.
+    const isNeutral = (t) => t === ON || t === WS || t === S || t === B;
+    const strongDir = (t) => (t === L ? L : R); // only called on L, R, EN, AN
+    for (let i = 0; i < n; i += 1) {
+        if (!isNeutral(types[i]))
+            continue;
+        let j = i;
+        while (j < n && isNeutral(types[j]))
+            j += 1;
+        const before = i === 0 ? sos : strongDir(types[i - 1]);
+        const after = j === n ? eos : strongDir(types[j]);
+        const dir = before === after ? before : e === 1 ? R : L;
+        for (let k = i; k < j; k += 1)
+            types[k] = dir;
+        i = j - 1;
+    }
+    // I1/I2: implicit levels.
+    const levels = new Uint8Array(n);
+    for (let i = 0; i < n; i += 1) {
+        const t = types[i];
+        if (e === 0)
+            levels[i] = t === R ? 1 : t === AN || t === EN ? 2 : 0;
+        else
+            levels[i] = t === L || t === EN || t === AN ? 2 : 1;
+    }
+    return { base: e, levels };
+}
+/**
+ * Rule N0 (UAX #9 §3.3.5), with BD16's pairing: a bracket pair takes the
+ * paragraph's direction if it encloses anything of that direction, else the
+ * opposite one if it encloses that AND the text before it agrees.
+ */
+function resolveBrackets(text, orig, types, e, sos) {
+    const pairs = [];
+    const stack = [];
+    for (let i = 0; i < text.length; i += 1) {
+        if (types[i] !== ON)
+            continue;
+        const ch = text[i];
+        const close = OPENING[ch];
+        if (close) {
+            if (stack.length === 63)
+                break; // BD16: stop at the stack limit
+            stack.push({ close, at: i });
+        }
+        else if (CLOSING.has(ch)) {
+            for (let s = stack.length - 1; s >= 0; s -= 1) {
+                if (stack[s].close === ch) {
+                    pairs.push([stack[s].at, i]);
+                    stack.length = s;
+                    break;
+                }
+            }
+        }
+    }
+    pairs.sort((a, b) => a[0] - b[0]);
+    const embed = e === 1 ? R : L;
+    const opposite = e === 1 ? L : R;
+    const strongOf = (t) => t === L ? L : t === R || t === AL || t === EN || t === AN ? R : null;
+    for (const [open, close] of pairs) {
+        let foundEmbed = false;
+        let foundOpposite = false;
+        for (let k = open + 1; k < close; k += 1) {
+            const s = strongOf(types[k]);
+            if (s === embed) {
+                foundEmbed = true;
+                break;
+            }
+            if (s === opposite)
+                foundOpposite = true;
+        }
+        let dir = null;
+        if (foundEmbed)
+            dir = embed;
+        else if (foundOpposite) {
+            let before = sos;
+            for (let k = open - 1; k >= 0; k -= 1) {
+                const s = strongOf(types[k]);
+                if (s !== null) {
+                    before = s;
+                    break;
+                }
+            }
+            dir = before === opposite ? opposite : embed;
+        }
+        if (dir === null)
+            continue;
+        for (const at of [open, close]) {
+            types[at] = dir;
+            // Marks on a bracket follow it (they were made ON by W1).
+            for (let k = at + 1; k < text.length && orig[k] === NSM; k += 1)
+                types[k] = dir;
+        }
+    }
+}
+/**
+ * Split `text` into clusters — a character plus any combining marks after it —
+ * each carrying the level of its first code unit. A mark must be drawn AFTER
+ * its base whichever way the line runs (rule L3), so they reverse as one.
+ */
+export function clustersOf(text, levels) {
+    const out = [];
+    let i = 0;
+    while (i < text.length) {
+        const start = i;
+        const cp = text.codePointAt(i);
+        i += cp > 0xffff ? 2 : 1;
+        while (i < text.length) {
+            const next = text.codePointAt(i);
+            if (!isMark(next) && next !== 0x200d)
+                break;
+            i += next > 0xffff ? 2 : 1;
+        }
+        out.push({ text: text.slice(start, i), level: levels[start] ?? 0 });
+    }
+    return out;
+}
+const WHITESPACE = /^\s+$/; // \s includes U+2028, which stands in for a hard break
+/**
+ * Put one rendered line's clusters into visual (left-to-right) order: rule L1
+ * (trailing whitespace and tabs to the paragraph level) then L2 (reverse every
+ * run at or above each odd level, highest first). Returns a new array; each
+ * item's `level` is the one it was DRAWN at, so the caller can mirror (L4).
+ */
+export function reorderLine(line, base) {
+    const items = line.map((c) => ({ ...c }));
+    // L1: tabs, whitespace before a tab, and whitespace at the end of the line.
+    let trailing = true;
+    for (let i = items.length - 1; i >= 0; i -= 1) {
+        const t = items[i].text;
+        if (t === '\t') {
+            items[i].level = base;
+            trailing = true;
+            continue;
+        }
+        if (WHITESPACE.test(t)) {
+            if (trailing)
+                items[i].level = base;
+            continue;
+        }
+        trailing = false;
+    }
+    // L2
+    let highest = 0;
+    let lowestOdd = 255;
+    for (const c of items) {
+        if (c.level > highest)
+            highest = c.level;
+        if (c.level % 2 === 1 && c.level < lowestOdd)
+            lowestOdd = c.level;
+    }
+    for (let level = highest; level >= lowestOdd && level > 0; level -= 1) {
+        let i = 0;
+        while (i < items.length) {
+            if (items[i].level < level) {
+                i += 1;
+                continue;
+            }
+            let j = i;
+            while (j < items.length && items[j].level >= level)
+                j += 1;
+            reverse(items, i, j - 1);
+            i = j;
+        }
+    }
+    return items;
+}
+function reverse(a, from, to) {
+    while (from < to) {
+        const t = a[from];
+        a[from] = a[to];
+        a[to] = t;
+        from += 1;
+        to -= 1;
+    }
+}
+/**
+ * One line of text as it will be SEEN, left to right — the whole algorithm in
+ * one call, for a caller that draws a single line (a label, a list marker) and
+ * for the tests. Text with nothing right-to-left in it is returned unchanged.
+ */
+export function visualOrder(text, base) {
+    const para = resolveLevels(text, base);
+    if (!para)
+        return text;
+    return reorderLine(clustersOf(text, para.levels), para.base)
+        .map((c) => (c.level % 2 === 1 ? mirrorOf(c.text) : c.text))
+        .join('');
+}
+//# sourceMappingURL=bidi.js.map