imagescript 3.2.0 → 3.3.0

package/dist/render/shapers/arabic.js

@@ -0,0 +1,284 @@
+/*!
+ * The Arabic shaper (Arabic, Syriac, and joining for Mongolian, N'Ko and others through USE), ported from HarfBuzz
+ * (hb-ot-shaper-arabic.cc)
+ * Copyright © 2010,2012 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and licenses/HarfBuzz.txt)
+ */
+import { generalCategory, isDefaultIgnorable, isMultiplied, ligComp, combiningClass, setCombiningClass } from "../buffer.js";
+import { syntheticLookup, applySynthetic } from "../layout.js";
+import { unicodeCategory } from "../shape.js";
+import { joiningType as joiningTable, ARABIC_SHAPING_FIRST, arabicShaping, arabicLigatures, arabicLigatures3, arabicMarkLigatures } from "../unicode-data.js";
+import { value } from "../unicode.js";
+const JOINING = { U: 0, L: 1, R: 2, D: 3, C: 3, T: 6, ALAPH: 4, DALATH_RISH: 5 };
+export const joiningType = (u, category) => {
+    const type = JOINING[value(joiningTable, u)];
+    if (type !== undefined)
+        return type;
+    return category === 12 || category === 11 || category === 1 ? 6 : 0;
+};
+const FEATURES = ['isol', 'fina', 'fin2', 'fin3', 'medi', 'med2', 'init'];
+const isSyriacFeature = (tag) => tag[3] === '2' || tag[3] === '3';
+const N = 7, ISOL = 0, FINA = 1, FIN2 = 2, FIN3 = 3, MEDI = 4, MED2 = 5, INIT = 6;
+const STATES = [
+    [[N, N, 0], [N, ISOL, 2], [N, ISOL, 1], [N, ISOL, 2], [N, ISOL, 1], [N, ISOL, 6]],
+    [[N, N, 0], [N, ISOL, 2], [N, ISOL, 1], [N, ISOL, 2], [N, FIN2, 5], [N, ISOL, 6]],
+    [[N, N, 0], [N, ISOL, 2], [INIT, FINA, 1], [INIT, FINA, 3], [INIT, FINA, 4], [INIT, FINA, 6]],
+    [[N, N, 0], [N, ISOL, 2], [MEDI, FINA, 1], [MEDI, FINA, 3], [MEDI, FINA, 4], [MEDI, FINA, 6]],
+    [[N, N, 0], [N, ISOL, 2], [MED2, ISOL, 1], [MED2, ISOL, 2], [MED2, FIN2, 5], [MED2, ISOL, 6]],
+    [[N, N, 0], [N, ISOL, 2], [ISOL, ISOL, 1], [ISOL, ISOL, 2], [ISOL, FIN2, 5], [ISOL, ISOL, 6]],
+    [[N, N, 0], [N, ISOL, 2], [N, ISOL, 1], [N, ISOL, 2], [N, FIN3, 5], [N, ISOL, 6]],
+];
+function fallbackPlan(plan, font) {
+    const lookups = [];
+    const features = ['init', 'medi', 'fina', 'isol', 'rlig', 'rlig', 'rlig'];
+    for (let i = 0; i < features.length; i++) {
+        const mask = plan.map.get1Mask(features[i]);
+        if (!mask)
+            continue;
+        let lookup = null;
+        if (i < 4) {
+            const single = new Map();
+            for (let k = 0; k < arabicShaping.length / 4; k++) {
+                const u = ARABIC_SHAPING_FIRST + k, s = arabicShaping[k * 4 + i];
+                const ug = font.glyph(u), sg = s && font.glyph(s);
+                if (!s || !ug || !sg || ug === sg)
+                    continue;
+                if (!single.has(ug))
+                    single.set(ug, sg);
+            }
+            if (single.size)
+                lookup = syntheticLookup(8, single, null);
+        }
+        else {
+            const table = i === 4 ? arabicLigatures3 : i === 5 ? arabicLigatures : arabicMarkLigatures;
+            const ligatures = new Map();
+            for (const [first, list] of table) {
+                const fg = font.glyph(first);
+                if (!fg)
+                    continue;
+                for (const entry of list) {
+                    const lg = font.glyph(entry[entry.length - 1]);
+                    if (!lg)
+                        continue;
+                    const components = entry.slice(0, -1).map(u => font.glyph(u));
+                    if (components.some(g => !g))
+                        continue;
+                    if (!ligatures.has(fg))
+                        ligatures.set(fg, []);
+                    ligatures.get(fg).push([components, lg]);
+                }
+            }
+            if (ligatures.size)
+                lookup = syntheticLookup(i === 6 ? 0 : 8, null, ligatures);
+        }
+        if (lookup)
+            lookups.push([lookup, mask]);
+    }
+    return lookups;
+}
+function fallbackShape(plan, font, buffer) {
+    const arabic = plan.data;
+    if (!arabic.doFallback)
+        return;
+    arabic.fallback ??= fallbackPlan(plan, font);
+    for (const [lookup, mask] of arabic.fallback)
+        applySynthetic(buffer, font.gdef, lookup, mask);
+}
+function recordStch(plan, _font, buffer) {
+    if (!plan.data.hasStch)
+        return;
+    for (const info of buffer.info)
+        if (isMultiplied(info)) {
+            info.category = ligComp(info) % 2 ? 9 : 8;
+            buffer.hasStch = true;
+        }
+}
+function collectFeatures(planner) {
+    const map = planner.map;
+    map.enableFeature('stch');
+    map.addGsubPause(recordStch);
+    map.enableFeature('ccmp', 8);
+    map.enableFeature('locl', 8);
+    map.addGsubPause(null);
+    for (const tag of FEATURES) {
+        const fallback = planner.script === 'Arab' && !isSyriacFeature(tag);
+        map.addFeature(tag, 8 | (fallback ? 2 : 0));
+        map.addGsubPause(null);
+    }
+    map.addGsubPause(null);
+    map.enableFeature('rlig', 8 | 2);
+    if (planner.script === 'Arab')
+        map.addGsubPause(fallbackShape);
+    map.enableFeature('calt', 8);
+    if (!map.hasFeature('rclt'))
+        map.addGsubPause(null);
+    map.enableFeature('liga', 8);
+    map.enableFeature('clig', 8);
+    map.enableFeature('mset', 8);
+}
+export function dataCreate(plan) {
+    const doFallback = plan.script === 'Arab' && FEATURES.every(tag => isSyriacFeature(tag) || plan.map.needsFallback(tag));
+    return { masks: [...FEATURES.map(tag => plan.map.get1Mask(tag)), 0], hasStch: !!plan.map.get1Mask('stch'), doFallback, fallback: null };
+}
+export function arabicJoining(buffer) {
+    const info = buffer.info;
+    let prev = -1, state = 0;
+    for (const u of buffer.context[0]) {
+        const type = joiningType(u, unicodeCategory(u));
+        if (type === 6)
+            continue;
+        state = STATES[state][type][2];
+        break;
+    }
+    for (let i = 0; i < info.length; i++) {
+        const type = joiningType(info[i].codepoint, generalCategory(info[i]));
+        if (type === 6) {
+            info[i].category = 7;
+            continue;
+        }
+        const entry = STATES[state][type];
+        if (entry[0] !== 7 && prev >= 0)
+            info[prev].category = entry[0];
+        info[i].category = entry[1];
+        prev = i;
+        state = entry[2];
+    }
+    for (const u of buffer.context[1]) {
+        const type = joiningType(u, unicodeCategory(u));
+        if (type === 6)
+            continue;
+        const entry = STATES[state][type];
+        if (entry[0] !== 7 && prev >= 0)
+            info[prev].category = entry[0];
+        break;
+    }
+}
+export function setupMasksArabic(arabic, buffer, script) {
+    arabicJoining(buffer);
+    const info = buffer.info;
+    if (script === 'Mong')
+        for (let i = 1; i < info.length; i++) {
+            const u = info[i].codepoint;
+            if (u >= 0x180b && u <= 0x180d || u === 0x180f)
+                info[i].category = info[i - 1].category;
+        }
+    for (const g of info)
+        g.mask |= arabic.masks[g.category];
+}
+const isWord = (category) => [2, 3, 6, 7, 10, 11, 12, 13,
+    14, 15, 23, 24, 25, 26].includes(category);
+const isStch = (info) => info.category === 8 || info.category === 9;
+function applyStch(buffer, font) {
+    if (!buffer.hasStch)
+        return;
+    const rtl = buffer.direction === 5;
+    if (!rtl)
+        buffer.reverse();
+    const MAX_GLYPHS = 256;
+    const info = buffer.info, out = [];
+    for (let i = info.length; i;) {
+        if (!isStch(info[i - 1])) {
+            out.push(info[--i]);
+            continue;
+        }
+        let wTotal = 0, wFixed = 0, wRepeating = 0, nFixed = 0, nRepeating = 0;
+        const end = i;
+        while (i && isStch(info[i - 1])) {
+            i--;
+            const width = font.advance(info[i].codepoint);
+            if (info[i].category === 8) {
+                wFixed += width;
+                nFixed++;
+            }
+            else {
+                wRepeating += width;
+                nRepeating++;
+            }
+        }
+        const start = i;
+        let context = i;
+        while (context && !isStch(info[context - 1]) && (isDefaultIgnorable(info[context - 1]) || isWord(generalCategory(info[context - 1])))) {
+            context--;
+            wTotal += info[context].xAdvance;
+        }
+        let copies = 0;
+        const wRemainingSigned = wTotal - wFixed;
+        let wRemaining = wTotal - wFixed;
+        if (wRemainingSigned > wRepeating && wRepeating > 0)
+            copies = Math.trunc(wRemainingSigned / wRepeating) - 1;
+        let overlap = 0;
+        const shortfall = wRemainingSigned - wRepeating * (copies + 1);
+        if (shortfall > 0 && nRepeating > 0) {
+            copies++;
+            const excess = (copies + 1) * wRepeating - wRemainingSigned;
+            if (excess > 0) {
+                overlap = Math.trunc(excess / (copies * nRepeating));
+                wRemaining = 0;
+            }
+        }
+        let maxCopies = 0;
+        if (nRepeating > 0 && nFixed + nRepeating < MAX_GLYPHS)
+            maxCopies = Math.trunc((MAX_GLYPHS - nFixed - nRepeating) / nRepeating);
+        copies = Math.min(copies, maxCopies);
+        let xOffset = Math.trunc(wRemaining / 2);
+        for (let k = end; k > start; k--) {
+            const width = font.advance(info[k - 1].codepoint);
+            const repeat = info[k - 1].category === 9 ? 1 + copies : 1;
+            info[k - 1].xAdvance = 0;
+            for (let n = 0; n < repeat; n++) {
+                if (rtl) {
+                    xOffset -= width;
+                    if (n > 0)
+                        xOffset += overlap;
+                }
+                info[k - 1].xOffset = xOffset;
+                out.push(info[k - 1].clone());
+                if (!rtl) {
+                    xOffset += width;
+                    if (n > 0)
+                        xOffset -= overlap;
+                }
+            }
+        }
+    }
+    out.reverse();
+    buffer.info = out;
+    if (!rtl)
+        buffer.reverse();
+}
+const MODIFIER_COMBINING_MARKS = new Set([0x0654, 0x0655, 0x0658, 0x06dc, 0x06e3, 0x06e7, 0x06e8, 0x08ca, 0x08cb, 0x08cd, 0x08ce, 0x08cf, 0x08d3, 0x08f3]);
+function reorderMarks(_plan, buffer, start, end) {
+    const info = buffer.info;
+    let i = start;
+    for (let cc = 220; cc <= 230; cc += 10) {
+        while (i < end && combiningClass(info[i]) < cc)
+            i++;
+        if (i === end)
+            break;
+        if (combiningClass(info[i]) > cc)
+            continue;
+        let j = i;
+        while (j < end && combiningClass(info[j]) === cc && MODIFIER_COMBINING_MARKS.has(info[j].codepoint))
+            j++;
+        if (i === j)
+            continue;
+        buffer.mergeClusters(start, j);
+        const moved = info.slice(i, j);
+        info.copyWithin(start + j - i, start, i);
+        for (let k = 0; k < moved.length; k++)
+            info[start + k] = moved[k];
+        const newStart = start + j - i, newCC = cc === 220 ? 25 : 26;
+        while (start < newStart)
+            setCombiningClass(info[start++], newCC);
+        i = j;
+    }
+}
+export const arabicShaper = {
+    collectFeatures,
+    dataCreate,
+    setupMasks: (plan, buffer) => setupMasksArabic(plan.data, buffer, plan.script),
+    postprocessGlyphs: (_plan, buffer, font) => applyStch(buffer, font),
+    reorderMarks,
+    normalization: 4,
+    zeroWidthMarks: 2,
+    fallbackPosition: true,
+};

package/dist/render/shapers/hangul.js

@@ -0,0 +1,142 @@
+/*!
+ * The Hangul shaper, ported from HarfBuzz (hb-ot-shaper-hangul.cc)
+ * Copyright © 2013 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and licenses/HarfBuzz.txt)
+ */
+const FEATURES = ['', 'ljmo', 'vjmo', 'tjmo'];
+const L_BASE = 0x1100, V_BASE = 0x1161, T_BASE = 0x11a7, L_COUNT = 19, V_COUNT = 21, T_COUNT = 28, S_BASE = 0xac00;
+const N_COUNT = V_COUNT * T_COUNT, S_COUNT = L_COUNT * N_COUNT;
+const isCombiningL = (u) => u >= L_BASE && u < L_BASE + L_COUNT;
+const isCombiningV = (u) => u >= V_BASE && u < V_BASE + V_COUNT;
+const isCombiningT = (u) => u > T_BASE && u < T_BASE + T_COUNT;
+const isCombinedS = (u) => u >= S_BASE && u < S_BASE + S_COUNT;
+const isL = (u) => u >= 0x1100 && u <= 0x115f || u >= 0xa960 && u <= 0xa97c;
+const isV = (u) => u >= 0x1160 && u <= 0x11a7 || u >= 0xd7b0 && u <= 0xd7c6;
+const isT = (u) => u >= 0x11a8 && u <= 0x11ff || u >= 0xd7cb && u <= 0xd7fb;
+const isTone = (u) => u >= 0x302e && u <= 0x302f;
+const isZeroWidth = (font, u) => {
+    const glyph = font.glyph(u);
+    return glyph !== 0 && font.advance(glyph) === 0;
+};
+function preprocessText(_plan, buffer, font) {
+    buffer.clearOutput();
+    let start = 0, end = 0;
+    const count = buffer.len;
+    for (buffer.idx = 0; buffer.idx < count && buffer.successful;) {
+        const u = buffer.cur().codepoint;
+        if (isTone(u)) {
+            if (start < end && end === buffer.outLen) {
+                buffer.nextGlyph();
+                if (!isZeroWidth(font, u)) {
+                    buffer.mergeOutClusters(start, end + 1);
+                    const info = buffer.outInfo, tone = info[end];
+                    for (let k = end; k > start; k--)
+                        info[k] = info[k - 1];
+                    info[start] = tone;
+                }
+            }
+            else if (font.hasGlyph(0x25cc))
+                buffer.replaceGlyphs(1, 2, isZeroWidth(font, u) ? [0x25cc, u] : [u, 0x25cc]);
+            else
+                buffer.nextGlyph();
+            start = end = buffer.outLen;
+            continue;
+        }
+        start = buffer.outLen;
+        if (isL(u) && buffer.idx + 1 < count) {
+            const l = u, v = buffer.cur(1).codepoint;
+            if (isV(v)) {
+                let t = 0, tindex = 0;
+                if (buffer.idx + 2 < count) {
+                    t = buffer.cur(2).codepoint;
+                    if (isT(t))
+                        tindex = t - T_BASE;
+                    else
+                        t = 0;
+                }
+                if (isCombiningL(l) && isCombiningV(v) && (t === 0 || isCombiningT(t))) {
+                    const s = S_BASE + (l - L_BASE) * N_COUNT + (v - V_BASE) * T_COUNT + tindex;
+                    if (font.hasGlyph(s)) {
+                        buffer.replaceGlyphs(t ? 3 : 2, 1, [s]);
+                        end = start + 1;
+                        continue;
+                    }
+                }
+                buffer.cur().category = 1;
+                buffer.nextGlyph();
+                buffer.cur().category = 2;
+                buffer.nextGlyph();
+                if (t) {
+                    buffer.cur().category = 3;
+                    buffer.nextGlyph();
+                    end = start + 3;
+                }
+                else
+                    end = start + 2;
+                if (!buffer.successful)
+                    break;
+                buffer.mergeOutClusters(start, end);
+                continue;
+            }
+        }
+        else if (isCombinedS(u)) {
+            const s = u, hasGlyph = font.hasGlyph(s);
+            const lindex = Math.floor((s - S_BASE) / N_COUNT), nindex = (s - S_BASE) % N_COUNT;
+            const vindex = Math.floor(nindex / T_COUNT), tindex = nindex % T_COUNT;
+            if (!tindex && buffer.idx + 1 < count && isCombiningT(buffer.cur(1).codepoint)) {
+                const combined = s + buffer.cur(1).codepoint - T_BASE;
+                if (font.hasGlyph(combined)) {
+                    buffer.replaceGlyphs(2, 1, [combined]);
+                    end = start + 1;
+                    continue;
+                }
+            }
+            if (!hasGlyph || !tindex && buffer.idx + 1 < count && isT(buffer.cur(1).codepoint)) {
+                const decomposed = [L_BASE + lindex, V_BASE + vindex, T_BASE + tindex];
+                if (font.hasGlyph(decomposed[0]) && font.hasGlyph(decomposed[1]) && (!tindex || font.hasGlyph(decomposed[2]))) {
+                    let length = tindex ? 3 : 2;
+                    buffer.replaceGlyphs(1, length, decomposed);
+                    if (hasGlyph && !tindex) {
+                        buffer.nextGlyph();
+                        length++;
+                    }
+                    if (!buffer.successful)
+                        break;
+                    const info = buffer.outInfo;
+                    end = start + length;
+                    let i = start;
+                    info[i++].category = 1;
+                    info[i++].category = 2;
+                    if (i < end)
+                        info[i++].category = 3;
+                    buffer.mergeOutClusters(start, end);
+                    continue;
+                }
+            }
+            if (hasGlyph)
+                end = start + 1;
+        }
+        buffer.nextGlyph();
+    }
+    buffer.sync();
+}
+export const hangulShaper = {
+    collectFeatures: planner => {
+        for (const tag of FEATURES.slice(1))
+            planner.map.addFeature(tag);
+    },
+    overrideFeatures: planner => planner.map.addFeature('calt'),
+    dataCreate: (plan) => ({ masks: FEATURES.map(tag => tag ? plan.map.get1Mask(tag) : 0), caltMask: plan.map.get1Mask('calt') }),
+    preprocessText,
+    setupMasks: (plan, buffer) => {
+        const hangul = plan.data;
+        for (const info of buffer.info) {
+            info.mask |= hangul.masks[info.category];
+            const u = info.codepoint;
+            if (isL(u) || isV(u) || isT(u))
+                info.mask &= ~hangul.caltMask;
+        }
+    },
+    normalization: 0,
+    zeroWidthMarks: 0,
+    fallbackPosition: true,
+};

package/dist/render/shapers/hebrew.js

@@ -0,0 +1,49 @@
+/*!
+ * The Hebrew shaper, ported from HarfBuzz (hb-ot-shaper-hebrew.cc)
+ * Copyright © 2010,2012 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and licenses/HarfBuzz.txt)
+ */
+import { combiningClass } from "../buffer.js";
+import { compose } from "../shape.js";
+const DAGESH_FORMS = [0xfb30, 0xfb31, 0xfb32, 0xfb33, 0xfb34, 0xfb35, 0xfb36, 0, 0xfb38, 0xfb39, 0xfb3a, 0xfb3b, 0xfb3c, 0, 0xfb3e, 0, 0xfb40, 0xfb41, 0,
+    0xfb43, 0xfb44, 0, 0xfb46, 0xfb47, 0xfb48, 0xfb49, 0xfb4a];
+const PRESENTATION = {
+    0x05b4: { 0x05d9: 0xfb1d },
+    0x05b7: { 0x05f2: 0xfb1f, 0x05d0: 0xfb2e },
+    0x05b8: { 0x05d0: 0xfb2f },
+    0x05b9: { 0x05d5: 0xfb4b },
+    0x05bf: { 0x05d1: 0xfb4c, 0x05db: 0xfb4d, 0x05e4: 0xfb4e },
+    0x05c1: { 0x05e9: 0xfb2a, 0xfb49: 0xfb2c },
+    0x05c2: { 0x05e9: 0xfb2b, 0xfb49: 0xfb2d },
+};
+export const hebrewShaper = {
+    compose: (c, a, b) => {
+        const found = compose(a, b);
+        if (found || c.plan.hasGposMark)
+            return found;
+        if (b === 0x05bc) {
+            if (a >= 0x05d0 && a <= 0x05ea)
+                return DAGESH_FORMS[a - 0x05d0];
+            if (a === 0xfb2a)
+                return 0xfb2c;
+            if (a === 0xfb2b)
+                return 0xfb2d;
+            return 0;
+        }
+        return PRESENTATION[b]?.[a] ?? 0;
+    },
+    reorderMarks: (_plan, buffer, start, end) => {
+        const info = buffer.info;
+        for (let i = start + 2; i < end; i++) {
+            const c0 = combiningClass(info[i - 2]), c1 = combiningClass(info[i - 1]), c2 = combiningClass(info[i]);
+            if ((c0 === 20 || c0 === 21) && (c1 === 22 || c1 === 23) && (c2 === 25 || c2 === 220)) {
+                buffer.mergeClusters(i - 1, i + 1);
+                [info[i - 1], info[i]] = [info[i], info[i - 1]];
+                break;
+            }
+        }
+    },
+    gposTag: 'hebr',
+    normalization: 4,
+    zeroWidthMarks: 2,
+    fallbackPosition: true,
+};

package/dist/render/shapers/index.js

@@ -0,0 +1,52 @@
+/*!
+ * The shaper for a script, ported from HarfBuzz (hb-ot-shaper.hh)
+ * Copyright © 2010,2012 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and licenses/HarfBuzz.txt)
+ */
+import { defaultShaper, shaperFor } from "../shape.js";
+import { arabicShaper } from "./arabic.js";
+import { hebrewShaper } from "./hebrew.js";
+import { thaiShaper } from "./thai.js";
+import { hangulShaper } from "./hangul.js";
+import { indicShaper } from "./indic.js";
+import { khmerShaper } from "./khmer.js";
+import { myanmarShaper } from "./myanmar.js";
+import { useShaper } from "./use.js";
+const USE_SCRIPTS = new Set(['Tibt', 'Mong', 'Sinh', 'Buhd', 'Hano', 'Tglg', 'Tagb', 'Limb', 'Tale', 'Bugi', 'Khar', 'Sylo', 'Tfng', 'Bali', 'Nkoo', 'Phag',
+    'Cham', 'Kali', 'Lepc', 'Rjng', 'Saur', 'Sund', 'Egyp', 'Java', 'Kthi', 'Mtei', 'Lana', 'Tavt', 'Batk', 'Brah', 'Mand', 'Cakm', 'Plrd', 'Shrd', 'Takr',
+    'Dupl', 'Gran', 'Khoj', 'Sind', 'Mahj', 'Mani', 'Modi', 'Hmng', 'Phlp', 'Sidd', 'Tirh', 'Ahom', 'Mult', 'Adlm', 'Bhks', 'Marc', 'Newa', 'Gonm', 'Soyo',
+    'Zanb', 'Dogr', 'Gong', 'Rohg', 'Maka', 'Medf', 'Sogo', 'Sogd', 'Elym', 'Nand', 'Hmnp', 'Wcho', 'Chrs', 'Diak', 'Kits', 'Yezi', 'Cpmn', 'Ougr', 'Tnsa',
+    'Toto', 'Vith', 'Kawi', 'Nagm', 'Gara', 'Gukh', 'Krai', 'Onao', 'Sunu', 'Todr', 'Tutg', 'Berf', 'Sidt', 'Tayo', 'Tols', 'Jurc', 'Pcun', 'Seal']);
+const INDIC_SCRIPTS = new Set(['Beng', 'Deva', 'Gujr', 'Guru', 'Knda', 'Mlym', 'Orya', 'Taml', 'Telu']);
+const shapers = {};
+export const registerShaper = (name, shaper) => {
+    shapers[name] = shaper;
+};
+registerShaper('arabic', arabicShaper);
+registerShaper('hebrew', hebrewShaper);
+registerShaper('thai', thaiShaper);
+registerShaper('hangul', hangulShaper);
+registerShaper('indic', indicShaper);
+registerShaper('khmer', khmerShaper);
+registerShaper('myanmar', myanmarShaper);
+registerShaper('use', useShaper);
+shaperFor.categorize = (script, _direction, gsubScript) => {
+    const pick = (name) => shapers[name] ?? defaultShaper;
+    const generic = gsubScript === 'DFLT' || gsubScript === 'latn';
+    if (script === 'Arab' || script === 'Syrc')
+        return gsubScript !== 'DFLT' || script === 'Arab' ? pick('arabic') : defaultShaper;
+    if (script === 'Thai' || script === 'Laoo')
+        return pick('thai');
+    if (script === 'Hang')
+        return pick('hangul');
+    if (script === 'Hebr')
+        return pick('hebrew');
+    if (INDIC_SCRIPTS.has(script))
+        return generic ? defaultShaper : gsubScript[3] === '3' ? pick('use') : pick('indic');
+    if (script === 'Khmr')
+        return pick('khmer');
+    if (script === 'Mymr')
+        return generic || gsubScript === 'mymr' ? defaultShaper : pick('myanmar');
+    if (USE_SCRIPTS.has(script))
+        return generic ? defaultShaper : pick('use');
+    return defaultShaper;
+};