imagescript 3.2.1 → 3.4.0

package/dist/render/shapers/use.js

@@ -0,0 +1,235 @@
+/*!
+ * The Universal Shaping Engine, ported from HarfBuzz (hb-ot-shaper-use.cc, hb-ot-shaper-use-machine.rl)
+ * Copyright © 2015 Mozilla Foundation, © 2015 Google, Inc., Old MIT license (see THIRD_PARTY_NOTICES.md and
+ * licenses/HarfBuzz.txt)
+ */
+import { isLigated, isSubstituted, ligComp, isUnicodeMark, isMark } from "../buffer.js";
+import { compose, unicodeCategory } from "../shape.js";
+import { useCategory } from "../unicode-data.js";
+import { value } from "../unicode.js";
+import { lazyScanner, cat, seq, alt, opt, star, plus, any } from "./machine.js";
+import { forEachSyllable, insertDottedCircles, vowelConstraintsPreprocess } from "./syllabic.js";
+import { dataCreate as arabicDataCreate, setupMasksArabic } from "./arabic.js";
+const CATEGORIES = {
+    O: 0, B: 1, N: 4, GB: 5, CGJ: 6, SUB: 11, H: 12, HN: 13, ZWNJ: 14, WJ: 16, R: 18, CS: 43, IS: 44, Sk: 48, G: 49,
+    J: 50, SB: 51, SE: 52, HVM: 53, HM: 54, HR: 55, RK: 56, FAbv: 24, FBlw: 25, FPst: 26, MAbv: 27, MBlw: 28,
+    MPst: 29, MPre: 30, CMAbv: 31, CMBlw: 32, VAbv: 33, VBlw: 34, VPst: 35, VPre: 22, VMAbv: 37, VMBlw: 38,
+    VMPst: 39, VMPre: 23, SMAbv: 41, SMBlw: 42, FMAbv: 45, FMBlw: 46, FMPst: 47,
+};
+const findSyllables = lazyScanner(() => {
+    const s = (...c) => star(cat(...c));
+    const h = cat(12, 53, 44, 48);
+    const consonantModifiers = seq(s(31), s(32), star(alt(seq(h, cat(1)), cat(11)), s(31), s(32)));
+    const medialConsonants = seq(opt(cat(30)), opt(cat(27)), opt(cat(28)), opt(cat(29)));
+    const dependentVowels = alt(seq(s(22), s(33), s(34), s(35)), cat(12));
+    const vowelModifiers = seq(opt(cat(53)), s(23), s(37), s(38), s(39));
+    const finalConsonants = seq(s(24), s(25), s(26));
+    const finalModifiers = alt(seq(s(45), s(46)), opt(cat(47)));
+    const complexSyllableStart = seq(opt(cat(18, 43)), cat(1, 5));
+    const complexSyllableMiddle = seq(consonantModifiers, medialConsonants, dependentVowels, vowelModifiers, star(cat(48), cat(1)));
+    const complexSyllableTail = seq(complexSyllableMiddle, finalConsonants, finalModifiers);
+    const numberJoinerTerminatedClusterTail = seq(star(cat(13), cat(4)), cat(13));
+    const numeralClusterTail = plus(cat(13), cat(4));
+    const symbolClusterTail = alt(seq(plus(cat(41)), s(42)), plus(cat(42)));
+    const viramaTerminatedClusterTail = seq(consonantModifiers, cat(44, 56));
+    const viramaTerminatedCluster = seq(complexSyllableStart, viramaTerminatedClusterTail);
+    const sakotTerminatedClusterTail = seq(complexSyllableMiddle, cat(48));
+    const sakotTerminatedCluster = seq(complexSyllableStart, sakotTerminatedClusterTail);
+    const standardCluster = seq(complexSyllableStart, complexSyllableTail);
+    const tail = alt(complexSyllableTail, sakotTerminatedClusterTail, symbolClusterTail, viramaTerminatedClusterTail);
+    const brokenCluster = seq(opt(cat(18)), alt(tail, numberJoinerTerminatedClusterTail, numeralClusterTail));
+    const numberJoinerTerminatedCluster = seq(cat(4), numberJoinerTerminatedClusterTail);
+    const numeralCluster = seq(cat(4), opt(numeralClusterTail));
+    const symbolCluster = seq(cat(0, 5, 51), opt(tail));
+    const g = seq(cat(49), opt(cat(55)), opt(cat(54)), s(52));
+    const hieroglyphCluster = seq(s(51), g, star(cat(50), s(51), opt(g)));
+    const zwnj = opt(cat(14));
+    return [
+        [seq(viramaTerminatedCluster, zwnj), 0],
+        [seq(sakotTerminatedCluster, zwnj), 1],
+        [seq(standardCluster, zwnj), 2],
+        [seq(numberJoinerTerminatedCluster, zwnj), 3],
+        [seq(numeralCluster, zwnj), 4],
+        [seq(symbolCluster, zwnj), 5],
+        [seq(hieroglyphCluster, zwnj), 6],
+        [cat(47), 8],
+        [seq(brokenCluster, zwnj), 7],
+        [any, 8],
+    ];
+});
+function setupSyllables(plan, _font, buffer) {
+    const info = buffer.info, kept = [];
+    for (let i = 0; i < info.length; i++) {
+        if (info[i].category === 6)
+            continue;
+        if (info[i].category === 14) {
+            let j = i + 1;
+            while (j < info.length && info[j].category === 6)
+                j++;
+            if (j < info.length && isUnicodeMark(info[j]))
+                continue;
+        }
+        kept.push(i);
+    }
+    let serial = 1;
+    for (const [start, end, type] of findSyllables(kept.map(i => info[i].category))) {
+        const from = kept[start], to = end < kept.length ? kept[end] : info.length;
+        for (let i = from; i < to; i++)
+            info[i].syllable = serial << 4 | type;
+        if (type === 7)
+            buffer.hasBrokenSyllable = true;
+        if (++serial === 16)
+            serial = 1;
+    }
+    setupRphfMask(plan, buffer);
+    setupTopographicalMasks(plan, buffer);
+}
+function setupRphfMask(plan, buffer) {
+    const mask = plan.data.rphfMask;
+    if (!mask)
+        return;
+    const info = buffer.info;
+    forEachSyllable(buffer, (start, end) => {
+        const limit = info[start].category === 18 ? 1 : Math.min(3, end - start);
+        for (let i = start; i < start + limit; i++)
+            info[i].mask |= mask;
+    });
+}
+const TOPOGRAPHICAL = ['isol', 'init', 'medi', 'fina'];
+function setupTopographicalMasks(plan, buffer) {
+    if (plan.data.arabic)
+        return;
+    const masks = TOPOGRAPHICAL.map(tag => {
+        const m = plan.map.get1Mask(tag);
+        return m === plan.map.globalMask ? 0 : m;
+    });
+    const all = masks.reduce((a, b) => a | b, 0);
+    if (!all)
+        return;
+    const others = ~all, info = buffer.info;
+    let lastStart = 0, lastForm = 4;
+    forEachSyllable(buffer, (start, end) => {
+        const type = info[start].syllable & 0x0f;
+        if (type === 6 || type === 8)
+            lastForm = 4;
+        else {
+            const join = lastForm === 3 || lastForm === 0;
+            if (join) {
+                lastForm = lastForm === 3 ? 2 : 1;
+                for (let i = lastStart; i < start; i++)
+                    info[i].mask = info[i].mask & others | masks[lastForm];
+            }
+            lastForm = join ? 3 : 0;
+            for (let i = start; i < end; i++)
+                info[i].mask = info[i].mask & others | masks[lastForm];
+        }
+        lastStart = start;
+    });
+}
+function clearSubstitutionFlags(_plan, _font, buffer) {
+    for (const info of buffer.info)
+        info.glyphProps &= ~16;
+}
+function recordRphf(plan, _font, buffer) {
+    const mask = plan.data.rphfMask;
+    if (!mask)
+        return;
+    const info = buffer.info;
+    forEachSyllable(buffer, (start, end) => {
+        for (let i = start; i < end && info[i].mask & mask; i++)
+            if (isSubstituted(info[i])) {
+                info[i].category = 18;
+                break;
+            }
+    });
+}
+function recordPref(_plan, _font, buffer) {
+    const info = buffer.info;
+    forEachSyllable(buffer, (start, end) => {
+        for (let i = start; i < end; i++)
+            if (isSubstituted(info[i])) {
+                info[i].category = 22;
+                break;
+            }
+    });
+}
+const isHalant = (info) => (info.category === 12 || info.category === 53 || info.category === 44) && !isLigated(info);
+const POST_BASE = new Set([24, 25, 26, 45, 46, 47, 27, 28, 29, 30, 33, 34, 35, 22, 37,
+    38, 39, 23]);
+const REORDERED = new Set([0, 1, 2, 5, 7]);
+function reorderSyllable(buffer, start, end) {
+    const info = buffer.info;
+    if (!REORDERED.has(info[start].syllable & 0x0f))
+        return;
+    if (info[start].category === 18 && end - start > 1)
+        for (let i = start + 1; i < end; i++) {
+            const postBase = POST_BASE.has(info[i].category) || isHalant(info[i]);
+            if (postBase || i === end - 1) {
+                if (postBase)
+                    i--;
+                buffer.mergeClusters(start, i + 1);
+                const t = info[start];
+                for (let k = start; k < i; k++)
+                    info[k] = info[k + 1];
+                info[i] = t;
+                break;
+            }
+        }
+    let j = start;
+    for (let i = start; i < end; i++) {
+        const category = info[i].category;
+        if (isHalant(info[i]))
+            j = i + 1;
+        else if ((category === 22 || category === 23) && ligComp(info[i]) === 0 && j < i) {
+            buffer.mergeClusters(j, i + 1);
+            const t = info[i];
+            for (let k = i; k > j; k--)
+                info[k] = info[k - 1];
+            info[j] = t;
+        }
+    }
+}
+function reorder(_plan, font, buffer) {
+    insertDottedCircles(font, buffer, 7, 1, 18, -1);
+    forEachSyllable(buffer, (start, end) => reorderSyllable(buffer, start, end));
+}
+function collectFeatures(planner) {
+    const map = planner.map;
+    map.addGsubPause(setupSyllables);
+    map.enableFeature('locl', 64);
+    map.enableFeature('ccmp', 64);
+    map.enableFeature('nukt', 64);
+    map.enableFeature('akhn', 8 | 64);
+    map.addGsubPause(clearSubstitutionFlags);
+    map.addFeature('rphf', 8 | 64);
+    map.addGsubPause(recordRphf);
+    map.addGsubPause(clearSubstitutionFlags);
+    map.enableFeature('pref', 8 | 64);
+    map.addGsubPause(recordPref);
+    for (const tag of ['rkrf', 'abvf', 'blwf', 'half', 'pstf', 'vatu', 'cjct'])
+        map.enableFeature(tag, 8 | 64);
+    map.addGsubPause(reorder);
+    map.addGsubPause(null);
+    for (const tag of TOPOGRAPHICAL)
+        map.addFeature(tag);
+    map.addGsubPause(null);
+    for (const tag of ['abvs', 'blws', 'haln', 'pres', 'psts'])
+        map.enableFeature(tag, 8);
+}
+const ARABIC_JOINING = new Set(['Adlm', 'Arab', 'Chrs', 'Rohg', 'Mand', 'Mani', 'Mong', 'Nkoo', 'Ougr', 'Phag', 'Phlp', 'Sogd', 'Syrc']);
+export const useShaper = {
+    collectFeatures,
+    dataCreate: (plan) => ({ rphfMask: plan.map.get1Mask('rphf'), arabic: ARABIC_JOINING.has(plan.script) ? arabicDataCreate(plan) : null }),
+    preprocessText: (_plan, buffer) => vowelConstraintsPreprocess(buffer),
+    compose: (_c, a, b) => isMark(unicodeCategory(a)) ? 0 : compose(a, b),
+    setupMasks: (plan, buffer) => {
+        const use = plan.data;
+        if (use.arabic)
+            setupMasksArabic(use.arabic, buffer, plan.script);
+        for (const info of buffer.info)
+            info.category = CATEGORIES[value(useCategory, info.codepoint)];
+    },
+    normalization: 3,
+    zeroWidthMarks: 1,
+    fallbackPosition: false,
+};

package/dist/render/svg.js

@@ -173,16 +173,76 @@ function parseXML(text) {
     }
     return root;
 }
+function urlReference(value) {
+    let close = -1;
+    for (let open = value.indexOf('url('); open >= 0; open = value.indexOf('url(', open + 4)) {
+        if (close < open && (close = value.indexOf(')', open)) < 0)
+            return null;
+        let inner = value.slice(open + 4, close).trim();
+        if (inner.startsWith('"') || inner.startsWith("'"))
+            inner = inner.slice(1);
+        if (inner.endsWith('"') || inner.endsWith("'"))
+            inner = inner.slice(0, -1);
+        inner = inner.trim();
+        if (/^#[^'"\s]+$/.test(inner))
+            return inner.slice(1);
+    }
+    return null;
+}
+function stripComments(text) {
+    let out = '';
+    for (let i = 0;;) {
+        const start = text.indexOf('/*', i);
+        if (start < 0)
+            return out + text.slice(i);
+        out += text.slice(i, start);
+        const end = text.indexOf('*/', start + 2);
+        if (end < 0)
+            return out;
+        i = end + 2;
+    }
+}
+function blockEnd(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i++) {
+        if (text[i] === '{')
+            depth++;
+        else if (text[i] === '}' && !--depth)
+            return i;
+    }
+    return text.length;
+}
 function parseStyleSheet(text) {
     const rules = [];
-    text = text.replace(/\/\*[\s\S]*?\*\//g, '');
+    text = stripComments(text);
+    const cache = {};
+    const next = (char, i) => {
+        const cached = cache[char];
+        if (cached === undefined || cached !== -1 && cached < i)
+            cache[char] = text.indexOf(char, i);
+        return cache[char];
+    };
     let order = 0;
-    const blocks = /([^{}@]+)\{([^{}]*)\}|@[^{;]*(\{(?:[^{}]*\{[^{}]*\})*[^{}]*\}|;)/g;
-    for (const [, selectors, body] of text.matchAll(blocks)) {
-        if (selectors === undefined)
+    for (let i = 0; i < text.length;) {
+        const start = i, open = next('{', i), close = next('}', i), at = next('@', i);
+        if (open < 0)
+            break;
+        if (close >= 0 && close < open) {
+            i = close + 1;
+            continue;
+        }
+        if (at >= 0 && at < open) {
+            const semicolon = next(';', at);
+            i = semicolon >= 0 && semicolon < open ? semicolon + 1 : blockEnd(text, open) + 1;
+            continue;
+        }
+        const end = blockEnd(text, open);
+        const body = text.slice(open + 1, end);
+        i = end + 1;
+        if (body.includes('{'))
             continue;
         const declarations = parseDeclarations(body);
-        for (const selector of selectors.split(',')) {
+        for (const selector of text.slice(start, open).split(',')) {
             const parsed = parseSelector(selector.trim());
             if (parsed)
                 rules.push({ ...parsed, order: order++, declarations });
@@ -279,7 +339,7 @@ function parseSelector(selector) {
 }
 function parseDeclarations(text) {
     const declarations = { normal: {}, important: {} };
-    text = text.replace(/\/\*[\s\S]*?\*\//g, '');
+    text = stripComments(text);
     for (const part of text.split(';')) {
         const colon = part.indexOf(':');
         if (colon === -1)
@@ -312,7 +372,10 @@ function validProperty(name, value) {
             return true;
     }
 }
+const MAX_INSTANCES = 100000;
+const MAX_DASHES = 1000000;
 class Document {
+    instances;
     ids;
     active;
     root;
@@ -320,26 +383,28 @@ class Document {
     constructor(root) {
         this.ids = new Map();
         this.active = new Set();
+        this.instances = 0;
         const styles = [];
-        const walk = (node) => {
+        const stack = [root];
+        while (stack.length) {
+            const node = stack.pop();
             if (node.attrs.id && !this.ids.has(node.attrs.id))
                 this.ids.set(node.attrs.id, node);
             if (node.name === 'style' && node.svg && (!node.attrs.type || node.attrs.type === 'text/css'))
                 styles.push(node.text);
-            for (const child of node.children) {
-                child.parent = node;
-                walk(child);
+            for (let i = node.children.length - 1; i >= 0; i--) {
+                node.children[i].parent = node;
+                stack.push(node.children[i]);
             }
-        };
-        walk(root);
+        }
         this.root = root;
         this.rules = parseStyleSheet(styles.join('\n'));
     }
     reference(value) {
         if (!value)
             return null;
-        const match = /url\(\s*['"]?\s*#([^)'"]+?)\s*['"]?\s*\)/.exec(value) || /^\s*#(.+?)\s*$/.exec(value);
-        return match ? this.ids.get(match[1]) || null : null;
+        const id = urlReference(value) ?? (value.trim().startsWith('#') ? value.trim().slice(1) : null);
+        return id ? this.ids.get(id) || null : null;
     }
     href(node) {
         return node.attrs.href || node.attrs['xlink:href'];
@@ -356,7 +421,7 @@ class Document {
         const presentation = {};
         for (const name in node.attrs)
             if (PROPERTIES.has(name))
-                presentation[name] = node.attrs[name];
+                presentation[name] = node.attrs[name].trim();
         apply(presentation);
         const rules = this.rules.filter(rule => rule.match(node));
         const inline = node.attrs.style ? parseDeclarations(node.attrs.style) : null;
@@ -406,6 +471,8 @@ class Document {
     renderNode(node, context, root = false) {
         if (!node.svg || UNSUPPORTED.has(node.name) || context.depth > 32 || !this.passesConditions(node))
             return;
+        if (context.instanced && ++this.instances > MAX_INSTANCES)
+            throw new Error(`SVG: more than ${MAX_INSTANCES} elements rendered through <use> references`);
         const style = this.computeStyle(node, context.style);
         if (style.display === 'none')
             return;
@@ -513,7 +580,7 @@ class Document {
                 outer = multiply(outer, [1, 0, 0, 1, parseLength(target.attrs.x, ctx.viewport, 16, 'x'), parseLength(target.attrs.y, ctx.viewport, 16, 'y')]);
             const inner = viewBox ? multiply(outer, viewBoxTransform(viewBox, width, height, target.attrs.preserveAspectRatio)) : outer;
             const opacity = clamp01(parseNumber(style.opacity, 1));
-            const innerContext = { ...ctx, matrix: inner, style, viewport: viewBox ? { width: viewBox[2], height: viewBox[3] } : { width, height } };
+            const innerContext = { ...ctx, matrix: inner, style, viewport: viewBox ? { width: viewBox[2], height: viewBox[3] } : { width, height }, instanced: true };
             const draw = (layer) => /^(visible|auto)$/.test(target.attrs.overflow || '')
                 ? this.renderChildren(target, { ...innerContext, layer })
                 : this.clipped({ ...ctx, matrix: outer, layer }, 0, 0, width, height, inner => this.renderChildren(target, { ...innerContext, layer: inner }));
@@ -526,7 +593,7 @@ class Document {
         }
         const computed = target.computed, computedParent = target.computedParent;
         target.computed = null;
-        this.renderNode(target, { ...ctx, matrix });
+        this.renderNode(target, { ...ctx, matrix, instanced: true });
         target.computed = computed;
         target.computedParent = computedParent;
     }
@@ -1142,9 +1209,8 @@ function shapePath(node, viewport, fontSize) {
 }
 function parsePath(d) {
     const path = [];
-    const tokens = /([MmZzLlHhVvCcSsQqTtAa])|([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)/g;
     const items = [];
-    for (const m of d.matchAll(tokens))
+    for (const m of d.matchAll(PATH_TOKENS))
         items.push(m[1] ? { command: m[1] } : m[2]);
     let i = 0;
     let command = null;
@@ -1398,6 +1464,14 @@ function transformPoints(points, m) {
 function dash(subpaths, pattern, offset) {
     const total = pattern.reduce((a, b) => a + b, 0);
     const result = [];
+    let length = 0;
+    for (const { points, closed } of subpaths) {
+        const pts = closed ? [...points, points[0], points[1]] : points;
+        for (let i = 0; i + 3 < pts.length; i += 2)
+            length += Math.hypot(pts[i + 2] - pts[i], pts[i + 3] - pts[i + 1]);
+    }
+    if (!(length / total * pattern.length <= MAX_DASHES))
+        return subpaths;
     for (const { points, closed } of subpaths) {
         const pts = closed ? [...points, points[0], points[1]] : points;
         let index = 0;
@@ -1620,10 +1694,15 @@ function viewBoxTransform([vx, vy, vw, vh], width, height, preserve = 'xMidYMid
     return [sx, 0, 0, sy, tx, ty];
 }
 const UNITS = { px: 1, pt: 4 / 3, pc: 16, mm: 96 / 25.4, cm: 96 / 2.54, in: 96 };
+const NUMBER = String.raw `[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?`;
+const LENGTH = new RegExp(`^(${NUMBER})\\s*(px|pt|pc|mm|cm|in|em|ex|%)?$`);
+const NUMBER_OR_PERCENTAGE = new RegExp(`^(${NUMBER})\\s*(%?)$`);
+const NUMBERS = new RegExp(NUMBER, 'g');
+const PATH_TOKENS = new RegExp(`([MmZzLlHhVvCcSsQqTtAa])|(${NUMBER})`, 'g');
 function parseLength(value, viewport, fontSize = 16, axis = 'x') {
     if (value === undefined || value === null)
         return 0;
-    const match = /^\s*([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)\s*(px|pt|pc|mm|cm|in|em|ex|%)?\s*$/.exec(String(value));
+    const match = LENGTH.exec(String(value).trim());
     if (!match)
         return 0;
     const number = parseFloat(match[1]);
@@ -1650,13 +1729,13 @@ function parseNumber(value, fallback) {
 function parseStrictNumber(value) {
     if (value === undefined || value === null)
         return null;
-    const match = /^\s*([-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)\s*(%?)\s*$/.exec(String(value));
+    const match = NUMBER_OR_PERCENTAGE.exec(String(value).trim());
     if (!match)
         return null;
     return match[2] ? parseFloat(match[1]) / 100 : parseFloat(match[1]);
 }
 function parseNumberList(value) {
-    return [...String(value).matchAll(/[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/g)].map(m => parseFloat(m[0]));
+    return [...String(value).matchAll(NUMBERS)].map(m => parseFloat(m[0]));
 }
 function parseDashArray(value, viewport, fontSize) {
     if (!value || value === 'none')
@@ -1686,7 +1765,7 @@ function parseColor(value) {
             return [0, 2, 4, 6].slice(0, hex.length / 2).map(i => parseInt(hex.slice(i, i + 2), 16) / 255).concat(hex.length === 6 ? [1] : []);
         return null;
     }
-    match = /^(rgba?|hsla?)\(\s*([^)]*)\)$/.exec(value);
+    match = /^(rgba?|hsla?)\(([^)]*)\)$/.exec(value);
     if (match) {
         const parts = match[2].split(/\s*[,/]\s*|\s+/).filter(Boolean);
         if (parts.length < 3)