postext 1.14.0 → 1.15.0

package/dist/bidi.js

@@ -0,0 +1,851 @@
+/**
+ * The Unicode Bidirectional Algorithm (UAX #9), shared by the measurer and
+ * every renderer the way `writingMode.ts` shares vertical orientation.
+ *
+ * Arabic and Hebrew run right to left, digits and Latin words inside them
+ * left to right, and the order in which a line's pieces are painted follows
+ * from the characters themselves: their `Bidi_Class`, the paragraph's base
+ * direction and any explicit isolates (`:rtl[…]`, `:ltr[…]`, or the Unicode
+ * controls U+2066–U+2069). {@link resolveParagraph} resolves a paragraph's
+ * embedding levels (rules P2–P3, X1–X10, W1–W7, N0–N2, I1–I2); the line
+ * functions apply L1 (trailing white space back to the paragraph level) and
+ * L2 (reversal) to one line of it once the line breaker has cut it, so the
+ * breaker works on the logical text and never needs to know about
+ * direction. L3 (combining marks) is the shaper's business and L4
+ * (mirroring) is {@link mirroredChar}.
+ *
+ * Text is UTF-16: levels are kept per code unit, a surrogate pair's two
+ * units always share one level, and the order functions return the index
+ * of each code point's first unit. Characters rule X9 removes (embedding
+ * and override controls, `BN`) get the level of the character before them,
+ * so they never split a run; they paint nothing.
+ *
+ * Conformance: the full `BidiCharacterTest.txt` and `BidiTest.txt` of
+ * Unicode 18 pass (see `__tests__/bidi.test.ts`). The data tables are in
+ * `bidiData.ts`, generated by `scripts/gen-bidi-data.mjs`.
+ */
+import { BIDI_CLASS_RANGES, BRACKET_PAIRS, JOINING_TYPE_RANGES, MIRROR_PAIRS } from './bidiData';
+/** Every `Bidi_Class`, by its code in the data tables. */
+export const BIDI_CLASS_NAMES = Object.freeze([
+    'L', 'R', 'AL', 'EN', 'ES', 'ET', 'AN', 'CS', 'NSM', 'BN', 'B', 'S', 'WS', 'ON',
+    'LRE', 'LRO', 'RLE', 'RLO', 'PDF', 'LRI', 'RLI', 'FSI', 'PDI',
+]);
+// The class codes (indices into BIDI_CLASS_NAMES).
+const L = 0, R = 1, AL = 2, EN = 3, ES = 4, ET = 5, AN = 6, CS = 7, NSM = 8, BN = 9, B = 10, S = 11, WS = 12, ON = 13;
+const LRE = 14, LRO = 15, RLE = 16, RLO = 17, PDF = 18, LRI = 19, RLI = 20, FSI = 21, PDI = 22;
+/** Internal: the second unit of a surrogate pair. Removed like `BN`, and
+ *  always given its first unit's level. */
+const TAIL = 23;
+/** The deepest embedding level (UAX #9 BD2). */
+const MAX_DEPTH = 125;
+// ---------------------------------------------------------------------------
+// Character data
+/** Bidi classes of the BMP, one byte per code point, built on first use. */
+let bmpClasses = null;
+function buildBmpClasses() {
+    const table = new Uint8Array(0x10000);
+    for (let i = 0; i < BIDI_CLASS_RANGES.length; i += 3) {
+        const first = BIDI_CLASS_RANGES[i];
+        if (first > 0xFFFF)
+            break;
+        table.fill(BIDI_CLASS_RANGES[i + 2], first, Math.min(BIDI_CLASS_RANGES[i + 1], 0xFFFF) + 1);
+    }
+    bmpClasses = table;
+    return table;
+}
+/** The value of `[first, last, value]` triples holding `cp`, else `def`. */
+function rangeLookup(ranges, cp, def) {
+    let lo = 0;
+    let hi = ranges.length / 3 - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        if (cp < ranges[mid * 3])
+            hi = mid - 1;
+        else if (cp > ranges[mid * 3 + 1])
+            lo = mid + 1;
+        else
+            return ranges[mid * 3 + 2];
+    }
+    return def;
+}
+/** A code point's `Bidi_Class` as its numeric code (an index into
+ *  {@link BIDI_CLASS_NAMES}). */
+function classCode(cp) {
+    if (cp < 0x10000)
+        return (bmpClasses ?? buildBmpClasses())[cp];
+    return rangeLookup(BIDI_CLASS_RANGES, cp, L);
+}
+/** A code point's Unicode `Bidi_Class`. */
+export function bidiClassOf(cp) {
+    return BIDI_CLASS_NAMES[classCode(cp)];
+}
+/** Whether a code point is a right-to-left letter (`Bidi_Class` `R` or
+ *  `AL`): Hebrew, Arabic, Syriac, Thaana, N'Ko, Adlam and the other
+ *  scripts written from right to left. Digits, punctuation and marks are
+ *  not, whatever text they sit in. */
+export function isRtlScriptChar(cp) {
+    const c = classCode(cp);
+    return c === R || c === AL;
+}
+/**
+ * Whether a paragraph needs the bidi algorithm at all: it holds a
+ * right-to-left letter or a control that opens a right-to-left embedding,
+ * override or isolate. Text without one, in a left-to-right paragraph,
+ * resolves to even levels throughout and paints in logical order, so the
+ * layout can skip the algorithm (and stays exactly as it was). Arabic-Indic
+ * digits alone do not count: they run left to right.
+ */
+export function needsBidi(text) {
+    for (let i = 0; i < text.length; i++) {
+        const u = text.charCodeAt(i);
+        // Nothing below the Hebrew block is right to left.
+        if (u < 0x0590)
+            continue;
+        let cp = u;
+        if (u >= 0xD800 && u <= 0xDBFF && i + 1 < text.length) {
+            const lo = text.charCodeAt(i + 1);
+            if (lo >= 0xDC00 && lo <= 0xDFFF) {
+                cp = ((u - 0xD800) << 10) + (lo - 0xDC00) + 0x10000;
+                i++;
+            }
+        }
+        const c = classCode(cp);
+        if (c === R || c === AL || c === RLE || c === RLO || c === RLI)
+            return true;
+    }
+    return false;
+}
+let mirrors = null;
+/**
+ * The mirrored form of a character (`Bidi_Mirroring_Glyph`, rule L4): `)`
+ * for `(`, `»` for `«`, `≥` for `≤`. A renderer paints it in place of the
+ * character when the character's resolved level is odd and the font does
+ * not mirror it itself (OpenType `rtlm`). A character without a mirror is
+ * returned unchanged, as is anything longer than one code point.
+ *
+ * The ornate parentheses of Quranic text, U+FD3E ﴾ and U+FD3F ﴿, have no
+ * mirror and are not paired brackets: Unicode 14 gave them their present
+ * general categories (FD3F opens, FD3E closes, as they are written in
+ * Arabic) and keeps them out of `BidiMirroring.txt` and `BidiBrackets.txt`
+ * on purpose, so they always paint as they are encoded.
+ */
+export function mirroredChar(ch) {
+    const cp = ch.codePointAt(0);
+    if (cp === undefined || ch.length > (cp > 0xFFFF ? 2 : 1))
+        return ch;
+    const m = mirroredCodePoint(cp);
+    return m === cp ? ch : String.fromCodePoint(m);
+}
+/** The mirrored form of a code point (see {@link mirroredChar}), or the
+ *  code point itself when it has none. */
+export function mirroredCodePoint(cp) {
+    if (!mirrors) {
+        mirrors = new Map();
+        for (let i = 0; i < MIRROR_PAIRS.length; i += 2)
+            mirrors.set(MIRROR_PAIRS[i], MIRROR_PAIRS[i + 1]);
+    }
+    return mirrors.get(cp) ?? cp;
+}
+/** Paired brackets (`Bidi_Paired_Bracket`): opening bracket → its closing
+ *  bracket, and the reverse; built on first use. */
+let bracketOpen = null;
+let bracketClose = null;
+function bracketTables() {
+    bracketOpen = new Map();
+    bracketClose = new Map();
+    for (let i = 0; i < BRACKET_PAIRS.length; i += 2) {
+        bracketOpen.set(BRACKET_PAIRS[i], BRACKET_PAIRS[i + 1]);
+        bracketClose.set(BRACKET_PAIRS[i + 1], BRACKET_PAIRS[i]);
+    }
+}
+/** A bracket as rule BD16 compares it: the angle brackets U+2329/U+232A are
+ *  canonically equivalent to U+3008/U+3009, so either closes the other. */
+function canonicalBracket(cp) {
+    return cp === 0x2329 ? 0x3008 : cp === 0x232A ? 0x3009 : cp;
+}
+const JOINING_TYPE_NAMES = ['U', 'C', 'D', 'R', 'L', 'T'];
+// The joining codes.
+const JT_U = 0, JT_C = 1, JT_D = 2, JT_R = 3, JT_L = 4, JT_T = 5;
+function joiningCode(cp) {
+    // Below U+00AD every character is non-joining.
+    if (cp < 0xAD)
+        return JT_U;
+    return rangeLookup(JOINING_TYPE_RANGES, cp, JT_U);
+}
+/** A code point's Unicode `Joining_Type`. */
+export function joiningTypeOf(cp) {
+    return JOINING_TYPE_NAMES[joiningCode(cp)];
+}
+/** Whether a text holds a letter of a joining script: a character that is
+ *  dual-, right- or left-joining (Arabic, Syriac, N'Ko, Mongolian, Adlam…).
+ *  Join-causing characters alone do not count: a ZWJ also sits inside emoji
+ *  sequences. */
+export function hasJoiningScript(text) {
+    for (let i = 0; i < text.length; i++) {
+        const cp = text.codePointAt(i);
+        if (cp > 0xFFFF)
+            i++;
+        const j = joiningCode(cp);
+        if (j === JT_D || j === JT_R || j === JT_L)
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether the character starting at `index` is joined to the next
+ * non-transparent character of `text` (cursive Arabic: the two letters
+ * connect, so a cut, a style change or a kashida between them must keep
+ * the connection). It joins when it joins forward (`D`, `L`, `C`) and the
+ * next one joins backward (`D`, `R`, `C`); transparent marks between them
+ * (harakat) are skipped. `false` at the end of the text, and when `index`
+ * itself is a transparent mark.
+ */
+export function joinsWithNext(text, index) {
+    const cp = text.codePointAt(index);
+    if (cp === undefined)
+        return false;
+    const a = joiningCode(cp);
+    if (a !== JT_D && a !== JT_L && a !== JT_C)
+        return false;
+    for (let i = index + (cp > 0xFFFF ? 2 : 1); i < text.length;) {
+        const next = text.codePointAt(i);
+        const b = joiningCode(next);
+        if (b === JT_T) {
+            i += next > 0xFFFF ? 2 : 1;
+            continue;
+        }
+        return (b === JT_D || b === JT_R || b === JT_C) && !(a === JT_C && b === JT_C);
+    }
+    return false;
+}
+/** Whether any two characters of a text join (see {@link joinsWithNext}):
+ *  a word that must be measured, cut and painted as one shaped run. */
+export function joinsLetters(text) {
+    for (let i = 0; i < text.length; i++) {
+        if (joinsWithNext(text, i))
+            return true;
+        if (text.charCodeAt(i) >= 0xD800 && text.charCodeAt(i) <= 0xDBFF)
+            i++;
+    }
+    return false;
+}
+/** The class codes of a text, one per UTF-16 unit (a pair's second unit is
+ *  {@link TAIL}). */
+function classesOf(text) {
+    const n = text.length;
+    const out = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+        const u = text.charCodeAt(i);
+        if (u >= 0xD800 && u <= 0xDBFF && i + 1 < n) {
+            const lo = text.charCodeAt(i + 1);
+            if (lo >= 0xDC00 && lo <= 0xDFFF) {
+                out[i] = classCode(((u - 0xD800) << 10) + (lo - 0xDC00) + 0x10000);
+                out[++i] = TAIL;
+                continue;
+            }
+        }
+        out[i] = classCode(u);
+    }
+    return out;
+}
+const isIsolateInitiator = (c) => c === LRI || c === RLI || c === FSI;
+/** Removed by rule X9 (kept in the text, given a neighbour's level). */
+const isRemoved = (c) => c === BN || c === TAIL || (c >= LRE && c <= PDF);
+/**
+ * Resolve the embedding levels of one paragraph (UAX #9 up to I2). `base`
+ * is the paragraph direction: `ltr`, `rtl`, or `auto` for the direction of
+ * its first strong letter (left to right when it has none). `isolates`
+ * sets stretches of the text as directional isolates, as if their bounds
+ * held RLI/LRI and PDI controls (the inline `:rtl[…]` and `:ltr[…]`); the
+ * text itself may also hold the Unicode controls. A paragraph separator
+ * (`B`) ends the embeddings opened before it, as at the end of a paragraph;
+ * callers split the text at paragraph breaks first (rule P1).
+ */
+export function resolveParagraph(text, base = 'auto', isolates) {
+    const classes = classesOf(text);
+    const baseLevel = base === 'rtl' ? 1 : base === 'ltr' ? 0 : -1;
+    if (!isolates || isolates.length === 0) {
+        const { levels, paragraphLevel } = resolveClasses(classes, baseLevel, text, null);
+        return { text, paragraphLevel, levels, classes };
+    }
+    // Insert the isolate controls as virtual characters, resolve, and read
+    // the levels of the text's own characters back.
+    const opens = [...isolates].filter((s) => s.end >= s.start)
+        .sort((a, b) => a.start - b.start || b.end - a.end);
+    const closes = [...opens].sort((a, b) => a.end - b.end || b.start - a.start);
+    const total = text.length + opens.length * 2;
+    const ext = new Uint8Array(total);
+    const map = new Int32Array(total);
+    let o = 0;
+    let c = 0;
+    let k = 0;
+    for (let i = 0; i <= text.length; i++) {
+        while (c < closes.length && closes[c].end === i) {
+            ext[k] = PDI;
+            map[k++] = -1;
+            c++;
+        }
+        while (o < opens.length && opens[o].start === i) {
+            ext[k] = opens[o].direction === 'rtl' ? RLI : LRI;
+            map[k++] = -1;
+            o++;
+        }
+        if (i < text.length) {
+            ext[k] = classes[i];
+            map[k++] = i;
+        }
+    }
+    const resolved = resolveClasses(ext, baseLevel, text, map);
+    const levels = new Uint8Array(text.length);
+    for (let j = 0; j < total; j++)
+        if (map[j] >= 0)
+            levels[map[j]] = resolved.levels[j];
+    return { text, paragraphLevel: resolved.paragraphLevel, levels, classes };
+}
+/** The chain of isolates a span sits in, outermost first. */
+function isolateChain(d) {
+    const chain = [];
+    for (let at = d; at; at = at.outer)
+        chain.unshift(at);
+    return chain;
+}
+/**
+ * The isolates of a paragraph's spans (`InlineSpan.direction`, set by
+ * `:rtl[…]` and `:ltr[…]`) as ranges of their joined text. Spans of one
+ * isolate share its `id`; an isolate nested in another names it as `outer`.
+ */
+export function spanIsolates(spans) {
+    const out = [];
+    const open = [];
+    let at = 0;
+    const closeTo = (depth) => {
+        while (open.length > depth) {
+            const top = open.pop();
+            out.push({ start: top.start, end: at, direction: top.d.dir });
+        }
+    };
+    for (const span of spans) {
+        const chain = isolateChain(span.direction);
+        let same = 0;
+        while (same < open.length && same < chain.length && open[same].d.id === chain[same].id && open[same].d.dir === chain[same].dir)
+            same++;
+        closeTo(same);
+        for (let i = same; i < chain.length; i++)
+            open.push({ d: chain[i], start: at });
+        at += span.text.length;
+    }
+    closeTo(0);
+    return out.sort((a, b) => a.start - b.start || b.end - a.end);
+}
+/** {@link resolveParagraph} for a paragraph given as its spans: the text is
+ *  their texts joined, and their `direction` isolates apply. */
+export function resolveSpans(spans, base = 'auto') {
+    let text = '';
+    for (const s of spans)
+        text += s.text;
+    return resolveParagraph(text, base, spanIsolates(spans));
+}
+/**
+ * The algorithm proper, on class codes. `text` (with `map` from class
+ * positions to text positions, `-1` for a virtual control) gives the code
+ * units the paired-bracket rule reads; without it no bracket pairs.
+ * @internal Exported for the conformance tests (`BidiTest.txt` lists
+ * classes, not characters).
+ */
+export function resolveClasses(cls, baseLevel, text, map) {
+    const n = cls.length;
+    const types = new Uint8Array(cls);
+    const levels = new Uint8Array(n);
+    // BD9: the PDI matching each isolate initiator, and the reverse.
+    const matchPdi = new Int32Array(n).fill(-1);
+    const matchInit = new Int32Array(n).fill(-1);
+    {
+        const stack = new Int32Array(n);
+        let sp = 0;
+        for (let i = 0; i < n; i++) {
+            const c = cls[i];
+            if (isIsolateInitiator(c))
+                stack[sp++] = i;
+            else if (c === PDI && sp > 0) {
+                const j = stack[--sp];
+                matchPdi[j] = i;
+                matchInit[i] = j;
+            }
+            else if (c === B)
+                sp = 0;
+        }
+    }
+    // P2–P3: the first strong letter outside isolates, from `from` to `to`.
+    const firstStrong = (from, to) => {
+        for (let i = from; i < to; i++) {
+            const c = cls[i];
+            if (c === L)
+                return 0;
+            if (c === R || c === AL)
+                return 1;
+            if (isIsolateInitiator(c)) {
+                if (matchPdi[i] < 0)
+                    return -1;
+                i = matchPdi[i];
+            }
+            else if (c === B)
+                return -1;
+        }
+        return -1;
+    };
+    const paragraphLevel = baseLevel >= 0 ? baseLevel : firstStrong(0, n) === 1 ? 1 : 0;
+    // X1–X8: explicit levels and directions.
+    const stLevel = new Uint8Array(MAX_DEPTH + 2);
+    const stOverride = new Uint8Array(MAX_DEPTH + 2); // 0 none, else L + 1 or R + 1
+    const stIsolate = new Uint8Array(MAX_DEPTH + 2);
+    let sp = 1;
+    stLevel[0] = paragraphLevel;
+    let overflowIsolates = 0;
+    let overflowEmbeddings = 0;
+    let validIsolates = 0;
+    for (let i = 0; i < n; i++) {
+        const c = cls[i];
+        switch (c) {
+            case RLE:
+            case LRE:
+            case RLO:
+            case LRO: {
+                const cur = stLevel[sp - 1];
+                const next = c === RLE || c === RLO ? (cur + 1) | 1 : (cur + 2) & ~1;
+                if (next <= MAX_DEPTH && overflowIsolates === 0 && overflowEmbeddings === 0) {
+                    stLevel[sp] = next;
+                    stOverride[sp] = c === LRO ? L + 1 : c === RLO ? R + 1 : 0;
+                    stIsolate[sp++] = 0;
+                }
+                else if (overflowIsolates === 0)
+                    overflowEmbeddings++;
+                levels[i] = stLevel[sp - 1];
+                break;
+            }
+            case RLI:
+            case LRI:
+            case FSI: {
+                levels[i] = stLevel[sp - 1];
+                if (stOverride[sp - 1])
+                    types[i] = stOverride[sp - 1] - 1;
+                const rtl = c === RLI || (c === FSI && firstStrong(i + 1, matchPdi[i] >= 0 ? matchPdi[i] : n) === 1);
+                const cur = stLevel[sp - 1];
+                const next = rtl ? (cur + 1) | 1 : (cur + 2) & ~1;
+                if (next <= MAX_DEPTH && overflowIsolates === 0 && overflowEmbeddings === 0) {
+                    validIsolates++;
+                    stLevel[sp] = next;
+                    stOverride[sp] = 0;
+                    stIsolate[sp++] = 1;
+                }
+                else
+                    overflowIsolates++;
+                break;
+            }
+            case PDI:
+                if (overflowIsolates > 0)
+                    overflowIsolates--;
+                else if (validIsolates > 0) {
+                    overflowEmbeddings = 0;
+                    while (!stIsolate[sp - 1])
+                        sp--;
+                    sp--;
+                    validIsolates--;
+                }
+                levels[i] = stLevel[sp - 1];
+                if (stOverride[sp - 1])
+                    types[i] = stOverride[sp - 1] - 1;
+                break;
+            case PDF:
+                if (overflowIsolates === 0) {
+                    if (overflowEmbeddings > 0)
+                        overflowEmbeddings--;
+                    else if (!stIsolate[sp - 1] && sp >= 2)
+                        sp--;
+                }
+                levels[i] = stLevel[sp - 1];
+                break;
+            case B:
+                // X8: a paragraph separator ends every embedding.
+                levels[i] = paragraphLevel;
+                sp = 1;
+                overflowIsolates = overflowEmbeddings = validIsolates = 0;
+                break;
+            case BN:
+            case TAIL:
+                levels[i] = stLevel[sp - 1];
+                break;
+            default:
+                levels[i] = stLevel[sp - 1];
+                if (stOverride[sp - 1])
+                    types[i] = stOverride[sp - 1] - 1;
+        }
+    }
+    // The explicit levels, kept: the sequences below read their neighbours'
+    // levels before the implicit rules change them.
+    const explicit = levels.slice();
+    // X9: the characters the rest of the algorithm sees.
+    const kept = new Int32Array(n);
+    let m = 0;
+    for (let i = 0; i < n; i++)
+        if (!isRemoved(cls[i]))
+            kept[m++] = i;
+    // X10: level runs, chained into isolating run sequences across isolates.
+    const runStart = [];
+    for (let k = 0; k < m; k++)
+        if (k === 0 || explicit[kept[k]] !== explicit[kept[k - 1]])
+            runStart.push(k);
+    const runCount = runStart.length;
+    const runOfFirst = new Int32Array(n).fill(-1);
+    for (let r = 0; r < runCount; r++)
+        runOfFirst[kept[runStart[r]]] = r;
+    const runEnd = (r) => (r + 1 < runCount ? runStart[r + 1] : m);
+    const seq = new Int32Array(m);
+    let brackets = null;
+    // Runs already chained into an earlier sequence (opened by a matched PDI).
+    const chained = new Uint8Array(runCount);
+    for (let r = 0; r < runCount; r++) {
+        if (chained[r])
+            continue;
+        let len = 0;
+        let run = r;
+        for (;;) {
+            const end = runEnd(run);
+            for (let k = runStart[run]; k < end; k++)
+                seq[len++] = kept[k];
+            const last = kept[end - 1];
+            if (!isIsolateInitiator(cls[last]) || matchPdi[last] < 0)
+                break;
+            const next = runOfFirst[matchPdi[last]];
+            if (next < 0)
+                break;
+            chained[next] = 1;
+            run = next;
+        }
+        const level = explicit[seq[0]];
+        const firstK = keptIndexOf(kept, m, seq[0]);
+        const before = firstK > 0 ? explicit[kept[firstK - 1]] : paragraphLevel;
+        const last = seq[len - 1];
+        let after = paragraphLevel;
+        if (!isIsolateInitiator(cls[last])) {
+            const lastK = keptIndexOf(kept, m, last);
+            if (lastK + 1 < m)
+                after = explicit[kept[lastK + 1]];
+        }
+        const sos = Math.max(before, level) & 1 ? R : L;
+        const eos = Math.max(after, level) & 1 ? R : L;
+        if (text !== null && !brackets)
+            brackets = { open: new Int32Array(63), want: new Int32Array(63), pairs: [] };
+        resolveSequence(seq, len, level, sos, eos, cls, types, levels, text, map, brackets);
+    }
+    // Removed characters take the level of the character before them.
+    for (let i = 0; i < n; i++)
+        if (isRemoved(cls[i]))
+            levels[i] = i > 0 ? levels[i - 1] : paragraphLevel;
+    return { levels, paragraphLevel };
+}
+/** The position of character `i` among the kept ones (binary search). */
+function keptIndexOf(kept, m, i) {
+    let lo = 0;
+    let hi = m - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const v = kept[mid];
+        if (v < i)
+            lo = mid + 1;
+        else if (v > i)
+            hi = mid - 1;
+        else
+            return mid;
+    }
+    return -1;
+}
+/** The direction a resolved type counts as in N0–N1: `EN` and `AN` as `R`;
+ *  -1 for a neutral. */
+function strongOf(t) {
+    if (t === L)
+        return L;
+    if (t === R || t === EN || t === AN)
+        return R;
+    return -1;
+}
+const isNeutralOrIsolate = (t) => t === B || t === S || t === WS || t === ON || t === LRI || t === RLI || t === FSI || t === PDI;
+/** Rules W1–I2 on one isolating run sequence (`seq[0..len)`, text
+ *  positions in order). */
+function resolveSequence(seq, len, level, sos, eos, cls, types, levels, text, map, brackets) {
+    // W1: marks take the type of what they follow.
+    for (let k = 0; k < len; k++) {
+        const i = seq[k];
+        if (types[i] !== NSM)
+            continue;
+        if (k === 0)
+            types[i] = sos;
+        else {
+            const prev = types[seq[k - 1]];
+            types[i] = prev === LRI || prev === RLI || prev === FSI || prev === PDI ? ON : prev;
+        }
+    }
+    // W2–W3: European digits after Arabic letters are Arabic; AL is R.
+    let strong = sos;
+    for (let k = 0; k < len; k++) {
+        const i = seq[k];
+        const t = types[i];
+        if (t === L || t === R || t === AL)
+            strong = t;
+        else if (t === EN && strong === AL)
+            types[i] = AN;
+    }
+    for (let k = 0; k < len; k++)
+        if (types[seq[k]] === AL)
+            types[seq[k]] = R;
+    // W4: one separator between two numbers of a kind joins them.
+    for (let k = 1; k + 1 < len; k++) {
+        const i = seq[k];
+        const t = types[i];
+        if (t !== ES && t !== CS)
+            continue;
+        const prev = types[seq[k - 1]];
+        const next = types[seq[k + 1]];
+        if (prev === EN && next === EN)
+            types[i] = EN;
+        else if (t === CS && prev === AN && next === AN)
+            types[i] = AN;
+    }
+    // W5: terminators next to European digits are digits.
+    for (let k = 0; k < len; k++) {
+        if (types[seq[k]] !== ET)
+            continue;
+        let e = k;
+        while (e < len && types[seq[e]] === ET)
+            e++;
+        if ((k > 0 && types[seq[k - 1]] === EN) || (e < len && types[seq[e]] === EN)) {
+            for (let j = k; j < e; j++)
+                types[seq[j]] = EN;
+        }
+        k = e - 1;
+    }
+    // W6: other separators and terminators are neutral.
+    for (let k = 0; k < len; k++) {
+        const t = types[seq[k]];
+        if (t === ES || t === ET || t === CS)
+            types[seq[k]] = ON;
+    }
+    // W7: European digits in left-to-right context are L.
+    strong = sos;
+    for (let k = 0; k < len; k++) {
+        const i = seq[k];
+        const t = types[i];
+        if (t === L || t === R)
+            strong = t;
+        else if (t === EN && strong === L)
+            types[i] = L;
+    }
+    const embedding = level & 1 ? R : L;
+    // N0: paired brackets take the direction of what they enclose.
+    if (text !== null && brackets) {
+        if (!bracketOpen)
+            bracketTables();
+        const { open, want, pairs } = brackets;
+        pairs.length = 0;
+        let sp = 0;
+        for (let k = 0; k < len; k++) {
+            const i = seq[k];
+            if (types[i] !== ON)
+                continue;
+            const at = map ? map[i] : i;
+            if (at < 0)
+                continue;
+            const cp = text.charCodeAt(at);
+            const closing = bracketOpen.get(cp);
+            if (closing !== undefined) {
+                if (sp === 63)
+                    break; // BD16: stack full, no more pairs.
+                open[sp] = k;
+                want[sp++] = canonicalBracket(closing);
+                continue;
+            }
+            if (!bracketClose.has(cp))
+                continue;
+            const c = canonicalBracket(cp);
+            for (let j = sp - 1; j >= 0; j--) {
+                if (want[j] !== c)
+                    continue;
+                pairs.push(open[j], k);
+                sp = j;
+                break;
+            }
+        }
+        if (pairs.length > 0) {
+            // In order of their opening brackets.
+            const order = [];
+            for (let p = 0; p < pairs.length; p += 2)
+                order.push(p);
+            order.sort((a, b) => pairs[a] - pairs[b]);
+            for (const p of order) {
+                const o = pairs[p];
+                const c = pairs[p + 1];
+                let found = -1;
+                for (let k = o + 1; k < c; k++) {
+                    const s = strongOf(types[seq[k]]);
+                    if (s < 0)
+                        continue;
+                    if (s === embedding) {
+                        found = embedding;
+                        break;
+                    }
+                    found = s;
+                }
+                if (found < 0)
+                    continue;
+                let dir = embedding;
+                if (found !== embedding) {
+                    let context = sos;
+                    for (let k = o - 1; k >= 0; k--) {
+                        const s = strongOf(types[seq[k]]);
+                        if (s >= 0) {
+                            context = s;
+                            break;
+                        }
+                    }
+                    dir = context === found ? found : embedding;
+                }
+                types[seq[o]] = dir;
+                types[seq[c]] = dir;
+                // Marks on a bracket follow it.
+                for (let k = o + 1; k < len && cls[seq[k]] === NSM; k++)
+                    types[seq[k]] = dir;
+                for (let k = c + 1; k < len && cls[seq[k]] === NSM; k++)
+                    types[seq[k]] = dir;
+            }
+        }
+    }
+    // N1–N2: neutrals between two of a direction take it, else the
+    // embedding direction.
+    for (let k = 0; k < len; k++) {
+        if (!isNeutralOrIsolate(types[seq[k]]))
+            continue;
+        let e = k;
+        while (e < len && isNeutralOrIsolate(types[seq[e]]))
+            e++;
+        const lead = k === 0 ? sos : strongOf(types[seq[k - 1]]);
+        const trail = e === len ? eos : strongOf(types[seq[e]]);
+        const dir = lead === trail ? lead : embedding;
+        for (let j = k; j < e; j++)
+            types[seq[j]] = dir;
+        k = e - 1;
+    }
+    // I1–I2: implicit levels.
+    for (let k = 0; k < len; k++) {
+        const i = seq[k];
+        const t = types[i];
+        if (level & 1) {
+            if (t === L || t === EN || t === AN)
+                levels[i] = level + 1;
+        }
+        else if (t === R)
+            levels[i] = level + 1;
+        else if (t === AN || t === EN)
+            levels[i] = level + 2;
+    }
+}
+// ---------------------------------------------------------------------------
+// Lines
+/**
+ * The levels of one line of a paragraph, `[start, end)` in UTF-16 units,
+ * after rule L1: segment and paragraph separators, and the white space and
+ * isolate controls before them or at the end of the line, go back to the
+ * paragraph level (a space that ends an Arabic line inside an English
+ * paragraph sits at the line's right end, not inside the Arabic run).
+ * Index 0 of the result is the line's first unit.
+ */
+export function lineLevels(par, start = 0, end = par.levels.length) {
+    const out = par.levels.slice(start, end);
+    const cls = par.classes;
+    let trailing = true;
+    for (let i = end - 1; i >= start; i--) {
+        const c = cls[i];
+        if (c === TAIL)
+            continue;
+        if (c === S || c === B) {
+            out[i - start] = par.paragraphLevel;
+            trailing = true;
+        }
+        else if (trailing && (c === WS || c === LRI || c === RLI || c === FSI || c === PDI || isRemoved(c))) {
+            out[i - start] = par.paragraphLevel;
+        }
+        else
+            trailing = false;
+    }
+    // A pair's second unit keeps its first unit's level.
+    for (let i = start + 1; i < end; i++)
+        if (cls[i] === TAIL)
+            out[i - start] = out[i - start - 1];
+    return out;
+}
+/**
+ * Rule L2 on any sequence of items with levels (characters, or a line's
+ * segments with the level of each): the indices of `levels[start..end)`
+ * from left to right. Every run at or above each odd level is reversed,
+ * from the highest level down.
+ */
+export function visualOrder(levels, start = 0, end = levels.length) {
+    const order = [];
+    let max = 0;
+    let minOdd = 255;
+    for (let i = start; i < end; i++) {
+        order.push(i);
+        const lv = levels[i];
+        if (lv > max)
+            max = lv;
+        if (lv & 1 && lv < minOdd)
+            minOdd = lv;
+    }
+    for (let lv = max; lv >= minOdd && lv > 0; lv--) {
+        for (let k = 0; k < order.length; k++) {
+            if (levels[order[k]] < lv)
+                continue;
+            let e = k;
+            while (e < order.length && levels[order[e]] >= lv)
+                e++;
+            for (let a = k, b = e - 1; a < b; a++, b--) {
+                const t = order[a];
+                order[a] = order[b];
+                order[b] = t;
+            }
+            k = e;
+        }
+    }
+    return order;
+}
+/**
+ * The characters of one line of a paragraph in visual order, left to right
+ * (rules L1 and L2): the index, in the paragraph's text, of each code
+ * point's first unit.
+ */
+export function lineVisualOrder(par, start = 0, end = par.levels.length) {
+    const lv = lineLevels(par, start, end);
+    const order = visualOrder(lv);
+    const out = [];
+    for (const k of order)
+        if (par.classes[start + k] !== TAIL)
+            out.push(start + k);
+    return out;
+}
+/**
+ * One line of a paragraph as runs of one level each, in visual order (left
+ * to right): what a renderer paints, each run shaped in its own direction
+ * (an odd level is right to left). Rules L1 and L2.
+ */
+export function lineRuns(par, start = 0, end = par.levels.length) {
+    const lv = lineLevels(par, start, end);
+    const runs = [];
+    for (let i = 0; i < lv.length;) {
+        let e = i + 1;
+        while (e < lv.length && lv[e] === lv[i])
+            e++;
+        runs.push({ start: start + i, end: start + e, level: lv[i] });
+        i = e;
+    }
+    const runLevels = runs.map((r) => r.level);
+    return visualOrder(runLevels).map((k) => runs[k]);
+}
+//# sourceMappingURL=bidi.js.map