Fix Persian OG image letter joining and reading order
Deploy Frontend / deploy (push) Successful in 1m13s

The OG renderer resolves glyphs through the font cmap alone: satori emits an
SVG <font> and plain <text>, so no shaping engine and no bidi implementation
run. Persian titles were painted in logical order with every letter in its
isolated shape, which made them look scattered and mirrored.

Shaping is now derived from the shipped Vazirmatn font rather than guessed
from the Unicode block, and the presentation forms are joined per position.
Lines are broken here as well, in logical order, and each line is reordered
through the bidi algorithm before it is handed over, so a wrapped title keeps
its reading order instead of being filled from the wrong end.
This commit is contained in:
Parsa Aghayi authored and DevOps committed 2026-10-04 06:47:22 +00:00
1 parent cb134b1cf1
commit 98c43c4b30
4 files changed
+568 -119

No files matched your search

+28 -13
View File
@@ -1,5 +1,7 @@
import { ImageResponse } from "next/og";
import { hasArabicScript, shapeArabic } from "./shape";
import { wrapVisualLines } from "./visual-order";
import { createMeasure } from "./text-metrics";
export const runtime = "edge";
@@ -11,47 +13,60 @@ const BOLD_FONT = fetch(
new URL("./Vazirmatn-Bold.ttf", import.meta.url),
).then((res) => res.arrayBuffer());
const WIDTH = 1200;
const HEIGHT = 630;
const PADDING = 64;
const FONT_SIZE = 72;
export async function GET(request: Request) {
const { searchParams } = new URL(request.url);
const raw = searchParams.get("text") || "Hello world!";
// The renderer lays characters out without contextual Arabic joining, so
// Persian/Arabic titles are pre-shaped into connected presentation forms;
// raw letters would otherwise be drawn one by one (د-س-ت-ا-چ-ی).
// The renderer resolves glyphs through `cmap` alone: it runs neither complex
// shaping nor bidi. Persian titles are therefore prepared here -- the letters
// are joined through presentation forms and every line is reordered, because
// the renderer paints both in the order it is handed them.
const isRtl = hasArabicScript(raw);
const text = isRtl ? shapeArabic(raw) : raw;
const [regular, bold] = await Promise.all([REGULAR_FONT, BOLD_FONT]);
const text = isRtl ? shapeArabic(raw) : raw;
const lines = isRtl
? wrapVisualLines(text, createMeasure(bold, FONT_SIZE), WIDTH - PADDING * 2)
: [text];
return new ImageResponse(
(
<div
style={{
fontSize: 72,
fontSize: FONT_SIZE,
fontWeight: 700,
fontFamily: "Vazirmatn",
lineHeight: 1.35,
padding: 64,
padding: PADDING,
background: "rgb(124, 58, 237)",
color: "white",
width: "100%",
height: "100%",
display: "flex",
flexDirection: "column",
textAlign: "center",
unicodeBidi: "isolate",
wordBreak: "break-word",
overflowWrap: "break-word",
alignItems: "center",
justifyContent: "center",
direction: isRtl ? ("rtl" as const) : ("ltr" as const),
}}
>
{text}
{lines.map((line, index) => (
// The lines are broken in visual-order.ts, so the renderer must not
// wrap them a second time.
<div key={index} style={{ whiteSpace: "nowrap" }}>
{line}
</div>
))}
</div>
),
{
width: 1200,
height: 630,
width: WIDTH,
height: HEIGHT,
fonts: [
{ name: "Vazirmatn", data: regular, weight: 400, style: "normal" },
{ name: "Vazirmatn", data: bold, weight: 700, style: "normal" },
+159 -106
View File
@@ -1,136 +1,189 @@
/**
* Minimal Arabic/Persian text shaper for the OG-image route.
* Manual Arabic/Persian shaping for the OG image renderer.
*
* The core image renderer lays text out character by character and cannot run a
* real shaping engine (HarfBuzz), so Persian letters come back disconnected. By
* pre-joining the letters ourselves into Unicode presentation forms (the forms a
* shaping engine would have produced), the renderer only has to place glyphs.
* The renderer (satori + resvg) draws every letter in its isolated form because
* it runs no shaping engine, so Persian titles come out as scattered,
* disconnected letterforms. Rewriting the string into Arabic presentation forms
* restores the connections before rendering.
*
* Only the conservative Persian glyph subset is covered, which is what blog
* titles actually use; any character without a presentation form is left as-is.
* Every codepoint below was read out of the shipped Vazirmatn font with
* HarfBuzz: each letter was shaped in the isolated, final, initial and medial
* position and the resulting glyph was mapped back through the font `cmap`.
* Guessing the values from the Unicode block is not safe -- Vazirmatn resolves
* isolated forms to the base glyph and rotates the lam-alef ligatures, so a
* hand-written table renders the wrong letter shapes.
*/
/** A joinable letter and its four presentation forms: isolated, final, initial, medial. */
const DUAL_FORMS: Record<number, [number, number, number, number]> = {
0x0628: [0x0628, 0xfe90, 0xfe91, 0xfe92], // ب
0x062a: [0x062a, 0xfe96, 0xfe97, 0xfe98], // ت
0x062b: [0x062b, 0xfe9a, 0xfe9b, 0xfe9c], // ث
0x062c: [0x062c, 0xfe9e, 0xfe9f, 0xfea0], // ج
0x062d: [0x062d, 0xfea2, 0xfea3, 0xfea4], // ح
0x062e: [0x062e, 0xfea6, 0xfea7, 0xfea8], // خ
0x0633: [0x0633, 0xfeb2, 0xfeb3, 0xfeb4], // س
0x0634: [0x0634, 0xfeb6, 0xfeb7, 0xfeb8], // ش
0x0635: [0x0635, 0xfeba, 0xfebb, 0xfebc], // ص
0x0636: [0x0636, 0xfebe, 0xfebf, 0xfec0], // ض
0x0637: [0x0637, 0xfec2, 0xfec3, 0xfec4], // ط
0x0638: [0x0638, 0xfec6, 0xfec7, 0xfec8], // ظ
0x0639: [0x0639, 0xfeca, 0xfecb, 0xfecc], // ع
0x063a: [0x063a, 0xfece, 0xfecf, 0xfed0], // غ
0x0641: [0x0641, 0xfed2, 0xfed3, 0xfed4], // ف
0x0642: [0x0642, 0xfed6, 0xfed7, 0xfed8], // ق
0x0643: [0x0643, 0xfeda, 0xfedb, 0xfedc], // ك (Arabic kaf)
0x0644: [0x0644, 0xfede, 0xfedf, 0xfee0], // ل
0x0645: [0x0645, 0xfee2, 0xfee3, 0xfee4], // م
0x0646: [0x0646, 0xfee6, 0xfee7, 0xfee8], // ن
0x0647: [0x0647, 0xfeea, 0xfeeb, 0xfeec], // ه
0x064a: [0x064a, 0xfef2, 0xfef3, 0xfef4], // ي (Arabic yeh)
0x06a9: [0x06a9, 0xfb91, 0xfb92, 0xfb93], // ک (Persian kaf)
0x06af: [0x06af, 0xfb95, 0xfb96, 0xfb97], // گ
0x06cc: [0x06cc, 0xfbfd, 0xfbfe, 0xfbff], // ی (Persian yeh)
0x067e: [0x067e, 0xfb57, 0xfb58, 0xfb59], // پ
0x0686: [0x0686, 0xfb7b, 0xfb7c, 0xfb7d], // چ
0x0626: [0x0626, 0xfe8a, 0xfe8b, 0xfe8c], // ئ
0x0640: [0x0640, 0x0640, 0x0640, 0x0640], // ـ (tatweel/kashida, joins everywhere)
/** isolated, final, initial, medial. A `0` means "keep the base codepoint". */
type Forms = [number, number, number, number];
/**
* Letters that join on both sides, so they grow four shapes.
*/
const DUAL_FORMS: Record<number, Forms> = {
0x0628: [0, 0xfe90, 0xfe91, 0xfe92], // ب
0x0629: [0, 0xfe94, 0, 0xfe94], // ة (no initial shape in this font)
0x062a: [0, 0xfe96, 0xfe97, 0xfe98], // ت
0x062b: [0, 0xfe9a, 0xfe9b, 0xfe9c], // ث
0x062c: [0, 0xfe9e, 0xfe9f, 0xfea0], // ج
0x062d: [0, 0xfea2, 0xfea3, 0xfea4], // ح
0x062e: [0, 0xfea6, 0xfea7, 0xfea8], // خ
0x0633: [0, 0xfeb2, 0xfeb3, 0xfeb4], // س
0x0634: [0, 0xfeb6, 0xfeb7, 0xfeb8], // ش
0x0635: [0, 0xfeba, 0xfebb, 0xfebc], // ص
0x0636: [0, 0xfebe, 0xfebf, 0xfec0], // ض
0x0637: [0, 0xfec2, 0xfec3, 0xfec4], // ط
0x0638: [0, 0xfec6, 0xfec7, 0xfec8], // ظ
0x0639: [0, 0xfeca, 0xfecb, 0xfecc], // ع
0x063a: [0, 0xfece, 0xfecf, 0xfed0], // غ
0x0641: [0, 0xfed2, 0xfed3, 0xfed4], // ف
0x0642: [0, 0xfed6, 0xfed7, 0xfed8], // ق
0x0643: [0, 0xfeda, 0xfedb, 0xfedc], // ك
0x0644: [0, 0xfede, 0xfedf, 0xfee0], // ل
0x0645: [0, 0xfee2, 0xfee3, 0xfee4], // م
0x0646: [0, 0xfee6, 0xfee7, 0xfee8], // ن
0x0647: [0, 0xfeea, 0xfeeb, 0xfeec], // ه
0x064a: [0, 0xfef2, 0xfef3, 0xfef4], // ي
0x067e: [0, 0xfb57, 0xfb58, 0xfb59], // پ
0x0686: [0, 0xfb7b, 0xfb7c, 0xfb7d], // چ
0x06a9: [0, 0xfb8f, 0xfb90, 0xfb91], // ک
0x06af: [0, 0xfb93, 0xfb94, 0xfb95], // گ
0x06cc: [0, 0xfbfd, 0xfbfe, 0xfbff], // ی
};
/**
* Letters that attach to a preceding letter but never grow an initial/medial
* form of their own (they only ever take isolated or final shapes).
* Letters that only take a connection from the letter on their right. They never
* connect onwards, so they only need a final shape.
*/
const RIGHT_FORMS: Record<number, number> = {
0x0622: 0xfe82, // آ
0x0623: 0xfe84, // أ
0x0624: 0xfe86, // ؤ
0x0625: 0xfe88, // إ
0x0626: 0xfe8a, // ئ
0x0627: 0xfe8e, // ا
0x062f: 0xfeaa, // د
0x0630: 0xfeac, // ذ
0x0631: 0xfeae, // ر
0x0632: 0xfeb0, // ز
0x0648: 0xfeee, // و
0x0649: 0xfef0, // ى
0x0698: 0xfb8b, // ژ
};
const HAS_ARABIC_SCRIPT = /[\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff]/;
/**
* Lam followed by one of these alef variants collapses into a single ligature.
* Vazirmatn draws two ligature shapes per variant -- one that connects to the
* letter on its right and one that does not -- and maps them to codepoints that
* do not follow the Unicode block order, so the values come from the font.
*/
const LAM_ALEF: Record<number, [number, number]> = {
0x0622: [0xfef5, 0xfef6], // آ
0x0623: [0xfef7, 0xfef8], // أ
0x0625: [0xfef9, 0xfefa], // إ
0x0627: [0xfefb, 0xfefc], // ا
};
/** Combining marks that sit on a letter without affecting joining. */
const COMBINING = new Set([
0x064b, 0x064c, 0x064d, 0x064e, 0x064f, 0x0650, 0x0651, 0x0652, 0x0653, 0x0654,
0x0655, 0x0670,
]);
const ZWNJ = 0x200c; // breaks the join on both sides
const ZWJ = 0x200d; // forces the join across itself
const TATWEEL = 0x0640; // kashida, joins on both sides
const LAM = 0x0644;
const HAS_ARABIC_SCRIPT =
/[\u0600-\u06ff\u0750-\u077f\u08a0-\u08ff\ufb50-\ufdff\ufe70-\ufeff]/;
type Join = "dual" | "right" | "mark" | "break";
export function hasArabicScript(text: string): boolean {
return HAS_ARABIC_SCRIPT.test(text);
}
function isJoinable(codePoint: number): boolean {
return codePoint in DUAL_FORMS;
function joinType(codePoint: number): Join {
if (codePoint === ZWNJ) return "break";
if (codePoint === ZWJ || codePoint === TATWEEL || COMBINING.has(codePoint)) {
return "mark";
}
if (codePoint in DUAL_FORMS) return "dual";
if (codePoint in RIGHT_FORMS || codePoint === 0x0671) return "right";
return "break";
}
/**
* Joins the letters of a Persian/Arabic string into presentation-form codepoints
* so a non-shaping renderer shows them connected, not letter by letter.
* Connects the letters of a Persian/Arabic string into presentation-form
* codepoints so a renderer without complex shaping shows them joined.
*/
export function shapeArabic(text: string): string {
const chars = Array.from(text.trim());
// Lam-Alef ligatures must be resolved on the base letters, before the
// per-letter pass turns the lam into its own presentation form.
const out0: string[] = [];
/**
* Joining neighbour of the letter at `index`, looking in `direction`.
* Combining marks, the joiner and the tatweel are skipped because they keep
* the connection alive; anything else stops the search, which is exactly what
* breaks the connection.
*/
const neighbour = (index: number, direction: 1 | -1): Join => {
for (let i = index + direction; i >= 0 && i < chars.length; i += direction) {
const join = joinType(chars[i].codePointAt(0) as number);
if (join === "mark") continue;
return join;
}
return "break";
};
// the letter on the left has to give the connection, the one on the right
// has to be able to take it
const joinsLeft = (index: number) => neighbour(index, -1) === "dual";
const joinsRight = (index: number) => {
const join = neighbour(index, 1);
return join === "dual" || join === "right";
};
const pick = (forms: Forms, left: boolean, right: boolean) =>
left && right ? forms[3] : left ? forms[1] : right ? forms[2] : forms[0];
const out: string[] = [];
for (let i = 0; i < chars.length; i++) {
const c = chars[i].codePointAt(0);
const n = chars[i+1]?.codePointAt(0);
if ((c === 0x0644 || c === 0xFEDF || c === 0xFEE0 || c === 0xFEDE) && n === 0x0627) { // lam followed by alef
out0.push(String.fromCodePoint(0xFEFB)); // use isolated ligature as simple fix; renderer will place
const char = chars[i];
const codePoint = char.codePointAt(0) as number;
const join = joinType(codePoint);
if (join === "mark" || join === "break") {
out.push(char);
continue;
}
const left = joinsLeft(i);
const right = joinsRight(i);
const ligature = codePoint === LAM ? LAM_ALEF[chars[i + 1]?.codePointAt(0) as number] : undefined;
if (ligature) {
out.push(String.fromCodePoint(left ? ligature[1] : ligature[0]));
i++;
continue;
}
if (c === 0x0644 && n === 0x0622) { // lām + alef with hamza above
out0.push(String.fromCodePoint(0xFEF7));
i++;
const dual = DUAL_FORMS[codePoint];
if (dual) {
const form = pick(dual, left, right);
out.push(form ? String.fromCodePoint(form) : char);
continue;
}
if (c === 0x0644 && n === 0x0623) {
out0.push(String.fromCodePoint(0xFEF9));
i++;
const rightForm = RIGHT_FORMS[codePoint];
if (rightForm && left) {
out.push(String.fromCodePoint(rightForm));
continue;
}
out0.push(chars[i]);
out.push(char);
}
const chars2 = out0;
const result: string[] = [];
const transparent = new Set([
0x200c, 0x0640, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f, 0x0650, 0x0651, 0x0652,
]);
const isTrans = (cp: number) => transparent.has(cp);
const getPrevJoinable = (idx: number): number | undefined => {
for (let j = idx - 1; j >= 0; j--) {
const cp = chars2[j].codePointAt(0);
if (cp === undefined) continue;
if (isTrans(cp)) continue;
return cp;
}
return undefined;
};
const getNextJoinable = (idx: number): number | undefined => {
for (let j = idx + 1; j < chars2.length; j++) {
const cp = chars2[j].codePointAt(0);
if (cp === undefined) continue;
if (isTrans(cp)) continue;
return cp;
}
return undefined;
};
for (let i = 0; i < chars2.length; i++) {
const ch = chars2[i];
const cp = ch.codePointAt(0);
if (cp === undefined) continue;
if (isTrans(cp)) { result.push(ch); continue; }
// skip if already ligature
if (cp === 0xFEFB || cp === 0xFEFC || cp === 0xFEF7 || cp === 0xFEF8 || cp === 0xFEF9 || cp === 0xFEFA) {
result.push(ch);
continue;
}
const forms = DUAL_FORMS[cp];
if (!forms) { result.push(ch); continue; }
const prevCp = getPrevJoinable(i);
const nextCp = getNextJoinable(i);
const connectsToPrevious = prevCp !== undefined && isJoinable(prevCp);
const connectsToNext = nextCp !== undefined && isJoinable(nextCp);
if (connectsToPrevious && connectsToNext) result.push(String.fromCodePoint(forms[3]));
else if (connectsToPrevious) result.push(String.fromCodePoint(forms[1]));
else if (connectsToNext) result.push(String.fromCodePoint(forms[2]));
else result.push(String.fromCodePoint(forms[0]));
}
return result.join("");
}
return out.join("");
}
+154
View File
@@ -0,0 +1,154 @@
/**
* Advance-width measurement for the OG image renderer.
*
* Deciding where a Persian title breaks over several lines has to happen before
* the image is generated, because the renderer fills its lines from left to
* right and therefore puts the wrong words on the wrong line for a right to
* left text. To break the lines in this module the width of a candidate line is
* needed, and satori only resolves glyphs through `cmap`, so the advances are
* read straight out of the font that is shipped next to the route.
*/
export type Measure = (text: string) => number;
interface Font {
unitsPerEm: number;
advances: Uint16Array;
cmap: Map<number, number>;
}
function readUint16(view: DataView, offset: number): number {
return view.getUint16(offset);
}
function tableOffsets(view: DataView): Map<string, [number, number]> {
const tables = new Map<string, [number, number]>();
const count = readUint16(view, 4);
for (let i = 0; i < count; i++) {
const record = 12 + i * 16;
const tag = String.fromCharCode(
view.getUint8(record),
view.getUint8(record + 1),
view.getUint8(record + 2),
view.getUint8(record + 3),
);
tables.set(tag, [view.getUint32(record + 8), view.getUint32(record + 12)]);
}
return tables;
}
/** Reads the format 4 and format 12 subtables, which is all a text font needs. */
function readCmap(view: DataView, offset: number): Map<number, number> {
const map = new Map<number, number>();
const subtableCount = readUint16(view, offset + 2);
let best = -1;
let bestFormat = -1;
for (let i = 0; i < subtableCount; i++) {
const record = offset + 4 + i * 8;
const platform = readUint16(view, record);
const encoding = readUint16(view, record + 2);
const subtable = offset + view.getUint32(record + 4);
const format = readUint16(view, subtable);
const unicode =
(platform === 3 && (encoding === 1 || encoding === 10)) || platform === 0;
if (!unicode) continue;
// format 12 wins over format 4 because it covers the whole plane
if (format > bestFormat) {
best = subtable;
bestFormat = format;
}
}
if (best < 0) return map;
if (bestFormat === 4) {
const segCountX2 = readUint16(view, best + 6);
const segCount = segCountX2 / 2;
const endCodes = best + 14;
const startCodes = endCodes + segCountX2 + 2;
const deltas = startCodes + segCountX2;
const rangeOffsets = deltas + segCountX2;
for (let segment = 0; segment < segCount; segment++) {
const end = readUint16(view, endCodes + segment * 2);
const start = readUint16(view, startCodes + segment * 2);
const delta = view.getInt16(deltas + segment * 2);
const rangeOffset = readUint16(view, rangeOffsets + segment * 2);
if (start === 0xffff) continue;
for (let code = start; code <= end && code !== 0x10000; code++) {
let glyph: number;
if (rangeOffset === 0) {
glyph = (code + delta) & 0xffff;
} else {
const glyphIndexAddress =
rangeOffsets + segment * 2 + rangeOffset + (code - start) * 2;
if (glyphIndexAddress + 1 >= view.byteLength) continue;
glyph = readUint16(view, glyphIndexAddress);
if (glyph !== 0) glyph = (glyph + delta) & 0xffff;
}
if (glyph !== 0) map.set(code, glyph);
}
}
return map;
}
const groupCount = view.getUint32(best + 12);
for (let i = 0; i < groupCount; i++) {
const group = best + 16 + i * 12;
const start = view.getUint32(group);
const end = view.getUint32(group + 4);
const startGlyph = view.getUint32(group + 8);
for (let code = start; code <= end; code++) map.set(code, startGlyph + (code - start));
}
return map;
}
function parseFont(data: ArrayBuffer): Font {
const view = new DataView(data);
const tables = tableOffsets(view);
const head = tables.get("head");
const hhea = tables.get("hhea");
const maxp = tables.get("maxp");
const hmtx = tables.get("hmtx");
const cmap = tables.get("cmap");
if (!head || !hhea || !maxp || !hmtx || !cmap) {
throw new Error("OG font is missing a table needed for measurement");
}
const unitsPerEm = readUint16(view, head[0] + 18) || 1000;
const numberOfHMetrics = readUint16(view, hhea[0] + 34);
const glyphCount = readUint16(view, maxp[0] + 4);
const advances = new Uint16Array(glyphCount);
let last = 0;
for (let glyph = 0; glyph < glyphCount; glyph++) {
if (glyph < numberOfHMetrics) {
last = readUint16(view, hmtx[0] + glyph * 4);
}
advances[glyph] = last;
}
return { unitsPerEm, advances, cmap: readCmap(view, cmap[0]) };
}
/**
* Builds a width function for a font at a given pixel size. Characters the font
* does not cover fall back to the widest average glyph so that a line is never
* measured as narrower than it paints.
*/
export function createMeasure(data: ArrayBuffer, fontSize: number): Measure {
const font = parseFont(data);
const scale = fontSize / font.unitsPerEm;
const fallback = (font.unitsPerEm / 2) * scale;
return (text: string) => {
let width = 0;
for (const char of text) {
const codePoint = char.codePointAt(0) as number;
const glyph = font.cmap.get(codePoint);
if (glyph === undefined || glyph >= font.advances.length) {
width += fallback;
continue;
}
width += font.advances[glyph] * scale;
}
return width;
};
}
+227
View File
@@ -0,0 +1,227 @@
/**
* Visual-order reordering for the OG image renderer.
*
* Satori turns a font into an SVG `<font>` element and emits plain `<text>`. SVG
* fonts resolve glyphs through `cmap` only: there is no shaping engine and no
* bidi implementation, so the renderer paints the string exactly in the logical
* order it is handed. A Persian title therefore comes out with every word
* mirrored, because Arabic is written right to left.
*
* `shapeArabic` already rewrites the letters into presentation forms, so all
* that is left is to reorder the runs into the order they should be painted in.
* This is the reordering step of the Unicode Bidirectional Algorithm (rules P2,
* X1-X10, W1-W7, N0-N2, I1-I2 and L2), reduced to what a single paragraph of
* heading text can contain: no explicit embedding controls, no styles and one
* paragraph level.
*/
/**
* Bidirectional character types, limited to the ones a title can contain.
* Anything unknown is treated as `ON` (other neutral), which is the safe default
* for punctuation and symbols.
*/
type BidiClass = "L" | "R" | "AL" | "EN" | "AN" | "NSM" | "BN" | "WS" | "ON";
// The presentation form blocks matter as much as the base letters: the route
// shapes first and reorders afterwards, so by the time a run is classified most
// of its characters are presentation forms rather than U+06xx letters.
const ARABIC_LETTER =
/[\u0620-\u064a\u066e-\u06d5\u06e5-\u06ef\u0710-\u072f\u0750-\u077f\u08a0-\u08ff\u200f\ufb50-\ufdff\ufe70-\ufeff]/;
const ARABIC_NUMBER = /[\u0660-\u0669\u066b\u066c\u06f0-\u06f9]/;
const HEBREW_LETTER = /[\u0590-\u05ff\u07c0-\u08ff]/;
const LATIN_LETTER = /[A-Za-z\u00c0-\u024f\u0370-\u058f\u1e00-\u1eff\u3040-\u30ff\uac00-\ud7af]/;
const COMBINING_MARK =
/[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e8\u06ea-\u06ed]/;
const WHITESPACE = /\s/;
const BOUNDARY = /[\u200c\u200d\ufeff]/;
const EUROPEAN_DIGIT = /[0-9]/;
function bidiClass(char: string): BidiClass {
if (BOUNDARY.test(char)) return "BN";
if (COMBINING_MARK.test(char)) return "NSM";
if (ARABIC_LETTER.test(char)) return "AL";
if (HEBREW_LETTER.test(char)) return "R";
if (LATIN_LETTER.test(char)) return "L";
if (ARABIC_NUMBER.test(char)) return "AN";
if (EUROPEAN_DIGIT.test(char)) return "EN";
if (WHITESPACE.test(char)) return "WS";
return "ON";
}
/**
* Resolves the paragraph level from the first strong character (rule P2/P3) and
* then gives every character its resolved embedding level.
*/
function resolveLevels(chars: string[]): number[] {
let base = 0;
for (const char of chars) {
const cls = bidiClass(char);
if (cls === "L") {
base = 0;
break;
}
if (cls === "R" || cls === "AL") {
base = 1;
break;
}
}
const types = chars.map(bidiClass);
// W1: a non-spacing mark takes the type of the character it follows.
for (let i = 0; i < types.length; i++) {
if (types[i] !== "NSM") continue;
types[i] = i === 0 ? (base === 1 ? "R" : "L") : types[i - 1];
}
// W2: European numbers after an Arabic letter become Arabic numbers.
let strongType: "L" | "R" = base === 1 ? "R" : "L";
for (let i = 0; i < types.length; i++) {
const cls = types[i];
if (cls === "L" || cls === "R" || cls === "AL") {
strongType = cls === "AL" ? "R" : cls;
} else if (cls === "EN" && strongType === "R") {
types[i] = "AN";
}
}
// W3: from here on an Arabic letter is just a right-to-left letter.
for (let i = 0; i < types.length; i++) {
if (types[i] === "AL") types[i] = "R";
}
// L1: levels of the strong and numeric characters. Strong right-to-left text
// and strong left-to-right text get their own level, numbers always end up
// one level above them so that they stay internally left to right.
const strongLevel = (cls: BidiClass) => (cls === "L" ? (base === 1 ? 2 : 0) : 1);
const levels: number[] = new Array(chars.length);
for (let i = 0; i < types.length; i++) {
const cls = types[i];
if (cls === "L" || cls === "R") levels[i] = strongLevel(cls);
else if (cls === "EN" || cls === "AN") levels[i] = 2;
}
// N1/N2: a neutral takes the level of the strong characters on both sides when
// they agree, and the paragraph level when they do not.
for (let i = 0; i < types.length; i++) {
const cls = types[i];
if (levels[i] !== undefined) continue;
// ZWNJ and ZWJ are boundary marks rather than neutrals. They have to stay
// with the letter in front of them, otherwise the break they cause would be
// lost when the runs are reversed.
if (cls === "BN") {
levels[i] = i === 0 ? base : levels[i - 1] ?? base;
continue;
}
let before: number | undefined;
for (let j = i - 1; j >= 0; j--) {
if (types[j] === "L" || types[j] === "R" || types[j] === "EN" || types[j] === "AN") {
before = levels[j];
break;
}
}
let after: number | undefined;
for (let j = i + 1; j < types.length; j++) {
if (types[j] === "L" || types[j] === "R" || types[j] === "EN" || types[j] === "AN") {
after = levels[j];
break;
}
}
if (before === undefined) levels[i] = after ?? base;
else if (after === undefined) levels[i] = before;
else levels[i] = before === after ? before : base;
}
return levels;
}
/**
* Reorders the characters into the order they should be painted in (rule L2):
* every run above the lowest odd level is reversed, from the highest level down.
*/
function reorder(chars: string[], levels: number[]): string {
let highest = 0;
let lowestOdd = Number.MAX_SAFE_INTEGER;
for (const level of levels) {
if (level > highest) highest = level;
if (level % 2 === 1 && level < lowestOdd) lowestOdd = level;
}
const out = chars.slice();
for (let level = highest; level >= lowestOdd; level--) {
for (let i = 0; i < out.length; i++) {
if (levels[i] < level) continue;
let end = i;
while (end + 1 < out.length && levels[end + 1] >= level) end++;
for (let a = i, b = end; a < b; a++, b--) {
const char = out[a];
out[a] = out[b];
out[b] = char;
}
i = end;
}
}
return out.join("");
}
/**
* Returns the string in the order it has to be painted so that a renderer
* without bidi support shows it the way a reader expects.
*/
export function visualOrder(text: string): string {
const chars = Array.from(text);
if (chars.length < 2) return text;
return reorder(chars, resolveLevels(chars));
}
/**
* Splits already shaped text into the lines the image should show, in reading
* order, with every line in visual order.
*
* The renderer fills its own lines from left to right, so a right to left
* paragraph ends up with the end of the title on the first line. The lines are
* therefore packed here, in logical order, and only then reordered.
*/
export function wrapVisualLines(
text: string,
measure: (line: string) => number,
maxWidth: number,
): string[] {
const words = text.split(/\s+/).filter(Boolean);
if (words.length === 0) return [text];
// Reordering does not change a line's width, so it is measured in logical
// order and only converted to visual order once the lines are settled.
const widthOf = (parts: string[]) => measure(parts.join(" "));
const lines: string[] = [];
let current: string[] = [];
for (const word of words) {
if (current.length > 0 && widthOf([...current, word]) > maxWidth) {
lines.push(current.join(" "));
current = [];
}
if (current.length === 0 && widthOf([word]) > maxWidth) {
// A word too long for the whole image is split by character, otherwise it
// would paint outside of it.
let chunk = "";
for (const char of word) {
if (chunk !== "" && widthOf([chunk + char]) > maxWidth) {
lines.push(chunk);
chunk = "";
}
chunk += char;
}
if (chunk !== "") current.push(chunk);
continue;
}
current.push(word);
}
if (current.length > 0) lines.push(current.join(" "));
return lines.map(visualOrder);
}