imagescript 3.2.0 → 3.3.0

package/dist/render/shapers/machine.js

@@ -0,0 +1,129 @@
+export const cat = (...categories) => ({ kind: 'set', categories: new Set(categories), negated: false });
+export const any = { kind: 'set', categories: null, negated: false };
+export const seq = (...items) => ({ kind: 'seq', items });
+export const alt = (...items) => ({ kind: 'alt', items });
+export const opt = (...items) => ({ kind: 'repeat', item: seq(...items), min: 0, max: 1 });
+export const star = (...items) => ({ kind: 'repeat', item: seq(...items), min: 0, max: Infinity });
+export const plus = (...items) => ({ kind: 'repeat', item: seq(...items), min: 1, max: Infinity });
+export function scanner(patterns) {
+    const states = [];
+    const add = () => states.push({ test: null, next: [], accept: -1 }) - 1;
+    const build = (e, start) => {
+        switch (e.kind) {
+            case 'set': {
+                const end = add(), { categories, negated } = e;
+                const s = add();
+                states[start].next.push(s);
+                states[s].test = categories === null ? () => true : negated ? c => !categories.has(c) : c => categories.has(c);
+                states[s].next.push(end);
+                return end;
+            }
+            case 'seq': {
+                let s = start;
+                for (const item of e.items)
+                    s = build(item, s);
+                return s;
+            }
+            case 'alt': {
+                const end = add();
+                for (const item of e.items) {
+                    const s = add();
+                    states[start].next.push(s);
+                    states[build(item, s)].next.push(end);
+                }
+                return end;
+            }
+            case 'repeat': {
+                if (e.min === 1)
+                    return build({ ...e, min: 0 }, build(e.item, start));
+                const end = add();
+                if (e.max === 1) {
+                    states[start].next.push(end);
+                    states[build(e.item, start)].next.push(end);
+                    return end;
+                }
+                const loop = add();
+                states[start].next.push(loop);
+                states[loop].next.push(end);
+                states[build(e.item, loop)].next.push(loop);
+                return end;
+            }
+        }
+    };
+    const root = add();
+    for (const [i, [pattern]] of patterns.entries()) {
+        const s = add();
+        states[root].next.push(s);
+        states[build(pattern, s)].accept = i;
+    }
+    const closure = (set) => {
+        const seen = new Uint8Array(states.length), out = [];
+        const stack = set.slice();
+        while (stack.length) {
+            const s = stack.pop();
+            if (seen[s])
+                continue;
+            seen[s] = 1;
+            out.push(s);
+            if (states[s].test === null)
+                for (const n of states[s].next)
+                    stack.push(n);
+        }
+        return out;
+    };
+    const dfaStates = new Map();
+    const dfa = (set) => {
+        set.sort((a, b) => a - b);
+        const key = set.join(',');
+        let state = dfaStates.get(key);
+        if (!state) {
+            let accept = -1;
+            for (const s of set)
+                if (states[s].accept >= 0 && (accept < 0 || states[s].accept < accept))
+                    accept = states[s].accept;
+            dfaStates.set(key, state = { next: new Map(), accept, states: set });
+        }
+        return state;
+    };
+    const step = (state, category) => {
+        let next = state.next.get(category);
+        if (next === undefined) {
+            const targets = [];
+            for (const s of state.states) {
+                const test = states[s].test;
+                if (test && test(category))
+                    targets.push(...states[s].next);
+            }
+            next = targets.length ? dfa(closure(targets)) : null;
+            if (next && !next.states.length)
+                next = null;
+            state.next.set(category, next);
+        }
+        return next;
+    };
+    const start = dfa(closure([root]));
+    return categories => {
+        const syllables = [];
+        for (let p = 0; p < categories.length;) {
+            let state = start, bestLength = 0, bestPattern = -1;
+            for (let q = p; q < categories.length && state; q++) {
+                state = step(state, categories[q]);
+                if (state && state.accept >= 0) {
+                    bestLength = q - p + 1;
+                    bestPattern = state.accept;
+                }
+            }
+            if (bestLength === 0) {
+                bestLength = 1;
+                bestPattern = patterns.length - 1;
+            }
+            syllables.push([p, p + bestLength, patterns[bestPattern][1]]);
+            p += bestLength;
+        }
+        return syllables;
+    };
+}
+export function lazyScanner(patterns) {
+    let scan = null;
+    return categories => (scan ??= scanner(patterns()))(categories);
+}

package/dist/render/shapers/myanmar.js

@@ -0,0 +1,121 @@
+/*!
+ * The Myanmar shaper, ported from HarfBuzz (hb-ot-shaper-myanmar.cc, hb-ot-shaper-myanmar-machine.rl)
+ * Copyright © 2011,2012,2013 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and licenses/HarfBuzz.txt)
+ */
+import { lazyScanner, cat, seq, alt, opt, star, any } from "./machine.js";
+import { forEachSyllable, insertDottedCircles } from "./syllabic.js";
+import { indicProperties, isOneOf, setSyllables } from "./indic.js";
+const findSyllables = lazyScanner(() => {
+    const j = cat(6, 5);
+    const k = seq(cat(15), cat(32), cat(4));
+    const sm = cat(8, 57);
+    const c = cat(1, 15);
+    const medialGroup = seq(opt(cat(38)), opt(cat(32)), opt(cat(36)), opt(alt(seq(cat(37), opt(cat(35)), opt(cat(41))), seq(cat(35), opt(cat(41))), cat(41)), opt(cat(32))));
+    const mainVowelGroup = seq(star(cat(22), opt(cat(40))), star(cat(20)), star(cat(21)), star(cat(9)), opt(cat(3), opt(cat(32))));
+    const postVowelGroup = seq(cat(23), opt(cat(35)), opt(cat(41)), star(cat(32)), star(cat(20)), star(cat(9)), opt(cat(3), opt(cat(32))));
+    const toneGroup = alt(sm, seq(cat(39), star(cat(9)), opt(cat(3)), opt(cat(32))));
+    const complexSyllableTail = seq(star(cat(32)), medialGroup, mainVowelGroup, star(postVowelGroup), star(toneGroup), opt(j));
+    const syllableTail = seq(star(cat(4), alt(c, cat(2)), opt(cat(40))), alt(cat(4), complexSyllableTail));
+    const consonantSyllable = seq(opt(alt(k, cat(18))), alt(c, cat(2), cat(10), cat(11)), opt(cat(40)), syllableTail);
+    const brokenCluster = seq(opt(k), opt(cat(40)), syllableTail);
+    return [
+        [consonantSyllable, 0],
+        [alt(j, cat(57)), 2],
+        [brokenCluster, 1],
+        [any, 2],
+    ];
+});
+const CONSONANTS = [1, 18, 15, 2, 10, 11];
+const isConsonant = (info) => isOneOf(info, CONSONANTS);
+function reorderConsonantSyllable(buffer, start, end) {
+    const info = buffer.info;
+    let base = end, hasReph = false, limit = start;
+    if (start + 3 <= end && info[start].category === 15 && info[start + 1].category === 32 && info[start + 2].category === 4) {
+        limit += 3;
+        base = start;
+        hasReph = true;
+    }
+    if (!hasReph)
+        base = limit;
+    for (let i = limit; i < end; i++)
+        if (isConsonant(info[i])) {
+            base = i;
+            break;
+        }
+    let i = start;
+    for (; i < start + (hasReph ? 3 : 0); i++)
+        info[i].position = 5;
+    for (; i < base; i++)
+        info[i].position = 3;
+    if (i < end)
+        info[i++].position = 4;
+    let pos = 5;
+    for (; i < end; i++) {
+        const category = info[i].category;
+        if (category === 36)
+            info[i].position = 3;
+        else if (category === 22)
+            info[i].position = 2;
+        else if (category === 40)
+            info[i].position = info[i - 1].position;
+        else if (pos === 5 && category === 21)
+            info[i].position = pos = 8;
+        else if (pos === 8 && category === 9)
+            info[i].position = 7;
+        else if (pos === 8 && category === 21)
+            info[i].position = pos;
+        else if (pos === 8)
+            info[i].position = pos = 9;
+        else
+            info[i].position = pos;
+    }
+    buffer.sort(start, end, (a, b) => a.position - b.position);
+    let firstLeftMatra = end, lastLeftMatra = end;
+    for (let k = start; k < end; k++)
+        if (info[k].position === 2) {
+            if (firstLeftMatra === end)
+                firstLeftMatra = k;
+            lastLeftMatra = k;
+        }
+    if (firstLeftMatra < lastLeftMatra) {
+        buffer.reverseRange(firstLeftMatra, lastLeftMatra + 1);
+        let k = firstLeftMatra;
+        for (let j = k; j <= lastLeftMatra; j++)
+            if (info[j].category === 22) {
+                buffer.reverseRange(k, j + 1);
+                k = j + 1;
+            }
+    }
+}
+function reorder(_plan, font, buffer) {
+    insertDottedCircles(font, buffer, 1, 11, -1, -1);
+    forEachSyllable(buffer, (start, end) => {
+        const type = buffer.info[start].syllable & 0x0f;
+        if (type === 0 || type === 1)
+            reorderConsonantSyllable(buffer, start, end);
+    });
+}
+function collectFeatures(planner) {
+    const map = planner.map;
+    map.addGsubPause((_plan, _font, buffer) => setSyllables(buffer, findSyllables(buffer.info.map(info => info.category)), 1));
+    map.enableFeature('locl', 64);
+    map.enableFeature('ccmp', 64);
+    map.addGsubPause(reorder);
+    for (const tag of ['rphf', 'pref', 'blwf', 'pstf']) {
+        map.enableFeature(tag, 8 | 64);
+        map.addGsubPause(null);
+    }
+    map.addGsubPause(null);
+    for (const tag of ['pres', 'abvs', 'blws', 'psts'])
+        map.enableFeature(tag, 8);
+}
+export const myanmarShaper = {
+    collectFeatures,
+    setupMasks: (_plan, buffer) => {
+        for (const info of buffer.info)
+            info.category = indicProperties(info.codepoint)[0];
+    },
+    normalization: 3,
+    zeroWidthMarks: 1,
+    fallbackPosition: false,
+};

package/dist/render/shapers/syllabic.js

@@ -0,0 +1,100 @@
+/*!
+ * Helpers of the syllabic shapers, ported from HarfBuzz (hb-ot-shaper-syllabic.cc, hb-ot-shaper-vowel-constraints.cc)
+ * Copyright © 2021 Behdad Esfahbod, © 2018 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and
+ * licenses/HarfBuzz.txt)
+ */
+import { GlyphInfo } from "../buffer.js";
+import { scriptOf } from "../shape.js";
+import { vowelConstraints } from "../unicode-data.js";
+export function nextSyllable(buffer, start) {
+    const info = buffer.info;
+    if (start >= info.length)
+        return info.length;
+    const syllable = info[start].syllable;
+    while (++start < info.length && syllable === info[start].syllable)
+        ;
+    return start;
+}
+export function forEachSyllable(buffer, f) {
+    for (let start = 0, end = buffer.len ? nextSyllable(buffer, 0) : 0; start < buffer.len; start = end, end = nextSyllable(buffer, start))
+        f(start, end);
+}
+export function insertDottedCircles(font, buffer, brokenType, category, repha, position) {
+    if (!buffer.hasBrokenSyllable)
+        return false;
+    const glyph = font.glyph(0x25cc);
+    if (!glyph)
+        return false;
+    buffer.clearOutput();
+    buffer.idx = 0;
+    let last = 0;
+    while (buffer.idx < buffer.len && buffer.successful) {
+        const syllable = buffer.cur().syllable;
+        if (last !== syllable && (syllable & 0x0f) === brokenType) {
+            last = syllable;
+            const info = new GlyphInfo();
+            info.codepoint = glyph;
+            info.category = category;
+            if (position !== -1)
+                info.position = position;
+            info.cluster = buffer.cur().cluster;
+            info.mask = buffer.cur().mask;
+            info.syllable = syllable;
+            if (repha !== -1)
+                while (buffer.idx < buffer.len && buffer.successful && last === buffer.cur().syllable && buffer.cur().category === repha)
+                    buffer.nextGlyph();
+            buffer.outputInfo(info);
+        }
+        else
+            buffer.nextGlyph();
+    }
+    buffer.sync();
+    return true;
+}
+let constraints = null;
+function constraintsOf(script) {
+    if (!constraints) {
+        constraints = new Map();
+        for (const sequence of vowelConstraints) {
+            const s = scriptOf(sequence[0]);
+            let list = constraints.get(s);
+            if (!list)
+                constraints.set(s, list = []);
+            list.push(sequence);
+        }
+        for (const list of constraints.values())
+            list.sort((a, b) => a.length - b.length);
+    }
+    return constraints.get(script) ?? [];
+}
+export function vowelConstraintsPreprocess(buffer) {
+    const list = constraintsOf(buffer.script);
+    if (!list.length)
+        return;
+    buffer.clearOutput();
+    const count = buffer.len;
+    for (buffer.idx = 0; buffer.idx + 1 < count && buffer.successful;) {
+        let matched = null;
+        for (const sequence of list) {
+            if (buffer.idx + sequence.length > count)
+                continue;
+            let k = 0;
+            while (k < sequence.length && buffer.info[buffer.idx + k].codepoint === sequence[k])
+                k++;
+            if (k === sequence.length) {
+                matched = sequence;
+                break;
+            }
+        }
+        if (!matched) {
+            buffer.nextGlyph();
+            continue;
+        }
+        for (let k = 0; k < matched.length - 1; k++)
+            buffer.nextGlyph();
+        const circle = buffer.outputGlyph(0x25cc);
+        circle.unicodeProps &= ~128;
+        buffer.nextGlyph();
+    }
+    buffer.sync();
+}

package/dist/render/shapers/thai.js

@@ -0,0 +1,125 @@
+/*!
+ * The Thai and Lao shaper, ported from HarfBuzz (hb-ot-shaper-thai.cc)
+ * Copyright © 2010,2012 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and licenses/HarfBuzz.txt)
+ */
+import { setGeneralCategory } from "../buffer.js";
+const consonantType = (u) => {
+    if (u === 0x0e1b || u === 0x0e1d || u === 0x0e1f)
+        return 1;
+    if (u === 0x0e0d || u === 0x0e10)
+        return 2;
+    if (u === 0x0e0e || u === 0x0e0f)
+        return 3;
+    if (u >= 0x0e01 && u <= 0x0e2e)
+        return 0;
+    return 4;
+};
+const markType = (u) => {
+    if (u === 0x0e31 || u >= 0x0e34 && u <= 0x0e37 || u === 0x0e47 || u >= 0x0e4d && u <= 0x0e4e)
+        return 0;
+    if (u >= 0x0e38 && u <= 0x0e3a)
+        return 1;
+    if (u >= 0x0e48 && u <= 0x0e4c)
+        return 2;
+    return 3;
+};
+const PUA = {
+    [1]: [[0x0e48, 0xf70a, 0xf88b], [0x0e49, 0xf70b, 0xf88e], [0x0e4a, 0xf70c, 0xf891], [0x0e4b, 0xf70d, 0xf894], [0x0e4c, 0xf70e, 0xf897],
+        [0x0e38, 0xf718, 0xf89b], [0x0e39, 0xf719, 0xf89c], [0x0e3a, 0xf71a, 0xf89d]],
+    [3]: [[0x0e48, 0xf705, 0xf88c], [0x0e49, 0xf706, 0xf88f], [0x0e4a, 0xf707, 0xf892], [0x0e4b, 0xf708, 0xf895], [0x0e4c, 0xf709, 0xf898]],
+    [2]: [[0x0e48, 0xf713, 0xf88a], [0x0e49, 0xf714, 0xf88d], [0x0e4a, 0xf715, 0xf890], [0x0e4b, 0xf716, 0xf893], [0x0e4c, 0xf717, 0xf896],
+        [0x0e31, 0xf710, 0xf884], [0x0e34, 0xf701, 0xf885], [0x0e35, 0xf702, 0xf886], [0x0e36, 0xf703, 0xf887], [0x0e37, 0xf704, 0xf888],
+        [0x0e47, 0xf712, 0xf889], [0x0e4d, 0xf711, 0xf899]],
+    [4]: [[0x0e0d, 0xf70f, 0xf89a], [0x0e10, 0xf700, 0xf89e]],
+};
+function puaShape(u, action, font) {
+    if (action === 0)
+        return u;
+    for (const [from, win, mac] of PUA[action])
+        if (from === u) {
+            if (font.hasGlyph(win))
+                return win;
+            if (font.hasGlyph(mac))
+                return mac;
+            break;
+        }
+    return u;
+}
+const ABOVE_START = [0, 1, 0, 0, 3];
+const ABOVE = [
+    [[0, 3], [0, 0], [1, 3]],
+    [[2, 2], [0, 1], [3, 2]],
+    [[0, 3], [0, 2], [2, 3]],
+    [[0, 3], [0, 3], [0, 3]],
+];
+const BELOW_START = [0, 0, 1, 2, 2];
+const BELOW = [
+    [[0, 0], [0, 2], [0, 0]],
+    [[0, 1], [4, 2], [0, 1]],
+    [[0, 2], [1, 2], [0, 2]],
+];
+function puaShaping(buffer, font) {
+    let above = ABOVE_START[4], below = BELOW_START[4], base = 0;
+    const info = buffer.info;
+    for (let i = 0; i < info.length; i++) {
+        const mt = markType(info[i].codepoint);
+        if (mt === 3) {
+            const ct = consonantType(info[i].codepoint);
+            above = ABOVE_START[ct];
+            below = BELOW_START[ct];
+            base = i;
+            continue;
+        }
+        const aboveEdge = ABOVE[above][mt], belowEdge = BELOW[below][mt];
+        above = aboveEdge[1];
+        below = belowEdge[1];
+        const action = aboveEdge[0] !== 0 ? aboveEdge[0] : belowEdge[0];
+        if (action === 4)
+            info[base].codepoint = puaShape(info[base].codepoint, action, font);
+        else
+            info[i].codepoint = puaShape(info[i].codepoint, action, font);
+    }
+}
+const isSaraAm = (u) => (u & ~0x80) === 0x0e33;
+const isAboveBaseMark = (u) => {
+    const v = u & ~0x80;
+    return v >= 0x0e34 && v <= 0x0e37 || v >= 0x0e47 && v <= 0x0e4e || v === 0x0e31 || v === 0x0e3b;
+};
+function preprocessText(plan, buffer, font) {
+    buffer.clearOutput();
+    const count = buffer.len;
+    for (buffer.idx = 0; buffer.idx < count;) {
+        const u = buffer.cur().codepoint;
+        if (!isSaraAm(u)) {
+            buffer.nextGlyph();
+            continue;
+        }
+        const nikhahit = buffer.outputGlyph(u - 0x0e33 + 0x0e4d);
+        buffer.hasContinuations = true;
+        nikhahit.unicodeProps |= 128;
+        buffer.replaceGlyph(u - 1);
+        const end = buffer.outLen;
+        setGeneralCategory(buffer.outInfo[end - 2], 12);
+        let start = end - 2;
+        while (start > 0 && isAboveBaseMark(buffer.outInfo[start - 1].codepoint))
+            start--;
+        if (start + 2 < end) {
+            buffer.mergeOutClusters(start, end);
+            const t = buffer.outInfo[end - 2];
+            for (let k = end - 2; k > start; k--)
+                buffer.outInfo[k] = buffer.outInfo[k - 1];
+            buffer.outInfo[start] = t;
+        }
+        if (start)
+            buffer.mergeOutClusters(start - 1, end);
+    }
+    buffer.sync();
+    if (plan.script === 'Thai' && !plan.map.foundScript[0])
+        puaShaping(buffer, font);
+}
+export const thaiShaper = {
+    preprocessText,
+    normalization: 4,
+    zeroWidthMarks: 2,
+    fallbackPosition: false,
+};