imagescript 3.2.1 → 3.4.0

package/dist/render/font.js

@@ -1,3 +1,4 @@
+const MAX_COMMANDS = 100000;
 export class Font {
     data;
     view;
@@ -13,7 +14,8 @@ export class Font {
     cff = null;
     cmap;
     outlineCache;
-    kerning;
+    kernTable;
+    variation;
     constructor(data) {
         this.data = data;
         this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
@@ -53,11 +55,14 @@ export class Font {
         }
         else if (this.tables.CFF2)
             throw new Error('Font: CFF2 outlines are not supported');
+        else if (this.tables.CBDT && this.tables.CBLC || this.tables.sbix)
+            this.outlines = 'none';
         else
             throw new Error('Font: no supported glyph outlines');
         this.cmap = parseCmap(this, this.tables.cmap.offset);
         this.outlineCache = new Map();
-        this.kerning = (this.tables.GPOS && parseGPOSKerning(this, this.tables.GPOS.offset)) || (this.tables.kern && parseKern(this, this.tables.kern.offset)) || null;
+        this.kernTable = this.tables.kern && parseKern(this, this.tables.kern.offset) || null;
+        this.variation = parseVariations(this, this.tables.cmap.offset);
     }
     u8(o) { return this.data[o]; }
     i8(o) { return this.view.getInt8(o); }
@@ -73,6 +78,28 @@ export class Font {
         const index = Math.min(glyph, this.numberOfHMetrics - 1);
         return this.u16(hmtx + index * 4);
     }
+    variationGlyph(codepoint, selector) {
+        const glyph = this.variation ? this.variation(codepoint, selector) : 0;
+        return glyph < 0 ? this.glyphIndex(codepoint) : glyph;
+    }
+    extents(glyph) {
+        if (this.outlines === 'glyf' && glyph < this.numGlyphs) {
+            const o = this.glyfOffset(glyph);
+            if (o < 0)
+                return { xMin: 0, yMin: 0, xMax: 0, yMax: 0 };
+            return { xMin: this.i16(o + 2), yMin: this.i16(o + 4), xMax: this.i16(o + 6), yMax: this.i16(o + 8) };
+        }
+        let xMin = Infinity, yMin = Infinity, xMax = -Infinity, yMax = -Infinity;
+        for (const command of this.outline(glyph))
+            for (let i = 1; i < command.length; i += 2) {
+                const x = command[i], y = command[i + 1];
+                xMin = Math.min(xMin, x);
+                xMax = Math.max(xMax, x);
+                yMin = Math.min(yMin, y);
+                yMax = Math.max(yMax, y);
+            }
+        return xMax >= xMin ? { xMin, yMin, xMax, yMax } : { xMin: 0, yMin: 0, xMax: 0, yMax: 0 };
+    }
     leftSideBearing(glyph) {
         const hmtx = this.tables.hmtx.offset;
         if (glyph < this.numberOfHMetrics)
@@ -82,63 +109,42 @@ export class Font {
     glyfPoints(glyph) {
         if (this.outlines !== 'glyf' || glyph >= this.numGlyphs)
             return null;
-        const loca = this.tables.loca.offset;
-        const start = this.indexToLocFormat ? this.u32(loca + glyph * 4) : this.u16(loca + glyph * 2) * 2;
-        const end = this.indexToLocFormat ? this.u32(loca + glyph * 4 + 4) : this.u16(loca + glyph * 2 + 2) * 2;
-        if (end <= start)
+        const offset = this.glyfOffset(glyph);
+        if (offset < 0)
             return null;
-        const offset = this.tables.glyf.offset + start;
         const contourCount = this.i16(offset);
         const xMin = this.i16(offset + 2);
         if (contourCount < 0) {
-            const components = [];
-            let p = offset + 10, flags = 0;
-            do {
-                flags = this.u16(p);
-                const component = this.u16(p + 2);
-                p += 4;
-                let arg1, arg2;
-                if (flags & 1) {
-                    arg1 = flags & 2 ? this.i16(p) : this.u16(p);
-                    arg2 = flags & 2 ? this.i16(p + 2) : this.u16(p + 2);
-                    p += 4;
-                }
-                else {
-                    arg1 = flags & 2 ? this.i8(p) : this.u8(p);
-                    arg2 = flags & 2 ? this.i8(p + 1) : this.u8(p + 1);
-                    p += 2;
-                }
-                let matrix = [1, 0, 0, 1];
-                const f2dot14 = (o) => this.i16(o) / 16384;
-                if (flags & 8) {
-                    const s = f2dot14(p);
-                    matrix = [s, 0, 0, s];
-                    p += 2;
-                }
-                else if (flags & 0x40) {
-                    matrix = [f2dot14(p), 0, 0, f2dot14(p + 2)];
-                    p += 4;
-                }
-                else if (flags & 0x80) {
-                    matrix = [f2dot14(p), f2dot14(p + 2), f2dot14(p + 4), f2dot14(p + 6)];
-                    p += 8;
-                }
-                components.push({
-                    glyph: component,
-                    dx: flags & 2 ? arg1 : 0,
-                    dy: flags & 2 ? arg2 : 0,
-                    matrix,
-                    round: (flags & 4) !== 0,
-                    match: flags & 2 ? null : [arg1, arg2],
-                    useMetrics: (flags & 0x200) !== 0
-                });
-            } while (flags & 0x20);
-            const instructions = flags & 0x100 ? this.data.subarray(p + 2, p + 2 + this.u16(p)) : new Uint8Array(0);
-            return { xs: [], ys: [], on: [], ends: [], instructions, xMin, components };
+            const { components, end } = this.components(offset);
+            const instructions = components[components.length - 1].flags & 0x100 ? this.data.subarray(end + 2, end + 2 + this.u16(end)) : new Uint8Array(0);
+            return {
+                xs: [], ys: [], on: [], ends: [], instructions, xMin,
+                components: components.map(({ glyph, flags, arg1, arg2, matrix }) => ({
+                    glyph, dx: flags & 2 ? arg1 : 0, dy: flags & 2 ? arg2 : 0, matrix,
+                    round: (flags & 4) !== 0, match: flags & 2 ? null : [arg1, arg2], useMetrics: (flags & 0x200) !== 0,
+                })),
+            };
         }
+        const points = this.simplePoints(offset, contourCount);
+        if (!points)
+            return null;
+        const { xs, ys, flags, ends, instructions } = points;
+        return { xs: Array.from(xs), ys: Array.from(ys), on: Array.from(flags, f => (f & 1) === 1), ends, instructions, xMin, components: null };
+    }
+    glyfOffset(glyph) {
+        const loca = this.tables.loca.offset;
+        const start = this.indexToLocFormat ? this.u32(loca + glyph * 4) : this.u16(loca + glyph * 2) * 2;
+        const end = this.indexToLocFormat ? this.u32(loca + glyph * 4 + 4) : this.u16(loca + glyph * 2 + 2) * 2;
+        return end > start ? this.tables.glyf.offset + start : -1;
+    }
+    simplePoints(offset, contourCount) {
         const ends = [];
-        for (let i = 0; i < contourCount; i++)
-            ends.push(this.u16(offset + 10 + i * 2));
+        for (let i = 0; i < contourCount; i++) {
+            const end = this.u16(offset + 10 + i * 2);
+            if (i && end <= ends[i - 1])
+                return null;
+            ends.push(end);
+        }
         const pointCount = contourCount ? ends[contourCount - 1] + 1 : 0;
         let p = offset + 10 + contourCount * 2;
         const instructionLength = this.u16(p);
@@ -152,7 +158,7 @@ export class Font {
                 for (let repeat = this.u8(p++); repeat > 0 && i < pointCount; repeat--)
                     flags[i++] = flag;
         }
-        const xs = [], ys = [];
+        const xs = new Int32Array(pointCount), ys = new Int32Array(pointCount);
         for (const [coords, short, same] of [[xs, 2, 16], [ys, 4, 32]]) {
             let value = 0;
             for (let i = 0; i < pointCount; i++) {
@@ -165,113 +171,92 @@ export class Font {
                     value += this.i16(p);
                     p += 2;
                 }
-                coords.push(value);
+                coords[i] = value;
             }
         }
-        return { xs, ys, on: Array.from(flags, f => (f & 1) === 1), ends, instructions, xMin, components: null };
+        return { xs, ys, flags, ends, instructions };
+    }
+    components(offset) {
+        const components = [];
+        const f2dot14 = (o) => this.i16(o) / 16384;
+        let p = offset + 10, flags = 0;
+        do {
+            flags = this.u16(p);
+            const glyph = this.u16(p + 2);
+            p += 4;
+            let arg1, arg2;
+            if (flags & 1) {
+                arg1 = flags & 2 ? this.i16(p) : this.u16(p);
+                arg2 = flags & 2 ? this.i16(p + 2) : this.u16(p + 2);
+                p += 4;
+            }
+            else {
+                arg1 = flags & 2 ? this.i8(p) : this.u8(p);
+                arg2 = flags & 2 ? this.i8(p + 1) : this.u8(p + 1);
+                p += 2;
+            }
+            let matrix = [1, 0, 0, 1];
+            if (flags & 8) {
+                const scale = f2dot14(p);
+                matrix = [scale, 0, 0, scale];
+                p += 2;
+            }
+            else if (flags & 0x40) {
+                matrix = [f2dot14(p), 0, 0, f2dot14(p + 2)];
+                p += 4;
+            }
+            else if (flags & 0x80) {
+                matrix = [f2dot14(p), f2dot14(p + 2), f2dot14(p + 4), f2dot14(p + 6)];
+                p += 8;
+            }
+            components.push({ glyph, flags, arg1, arg2, matrix });
+        } while (flags & 0x20);
+        return { components, end: p };
     }
     outline(glyph) {
         if (glyph >= this.numGlyphs)
             glyph = 0;
         let path = this.outlineCache.get(glyph);
         if (!path) {
-            path = this.outlines === 'glyf' ? this.glyfOutline(glyph, 0) : this.cffOutline(glyph);
+            path = this.outlines === 'glyf' ? this.glyfOutline(glyph, { expanding: new Set(), budget: MAX_COMMANDS }) : this.outlines === 'cff' ? this.cffOutline(glyph) : [];
             this.outlineCache.set(glyph, path);
         }
         return path;
     }
-    glyfOutline(glyph, depth) {
-        if (depth > 8)
+    glyfOutline(glyph, expanding) {
+        if (expanding.expanding.has(glyph) || expanding.expanding.size > 8 || expanding.budget <= 0)
             return [];
-        const loca = this.tables.loca.offset;
-        const start = this.indexToLocFormat ? this.u32(loca + glyph * 4) : this.u16(loca + glyph * 2) * 2;
-        const end = this.indexToLocFormat ? this.u32(loca + glyph * 4 + 4) : this.u16(loca + glyph * 2 + 2) * 2;
-        if (end <= start)
+        const offset = this.glyfOffset(glyph);
+        if (offset < 0)
             return [];
-        const offset = this.tables.glyf.offset + start;
         const contours = this.i16(offset);
-        return contours >= 0 ? this.simpleGlyph(offset, contours) : this.compositeGlyph(offset, depth);
+        if (contours >= 0) {
+            const path = this.simpleGlyph(offset, contours);
+            expanding.budget -= path.length;
+            return expanding.budget >= 0 ? path : [];
+        }
+        expanding.expanding.add(glyph);
+        const path = this.compositeGlyph(offset, expanding);
+        expanding.expanding.delete(glyph);
+        return path;
     }
     simpleGlyph(offset, contourCount) {
-        const endPoints = [];
-        for (let i = 0; i < contourCount; i++)
-            endPoints.push(this.u16(offset + 10 + i * 2));
-        const pointCount = contourCount ? endPoints[contourCount - 1] + 1 : 0;
-        let p = offset + 10 + contourCount * 2;
-        p += 2 + this.u16(p);
-        const flags = new Uint8Array(pointCount);
-        for (let i = 0; i < pointCount;) {
-            const flag = this.u8(p++);
-            flags[i++] = flag;
-            if (flag & 8) {
-                for (let repeat = this.u8(p++); repeat > 0 && i < pointCount; repeat--)
-                    flags[i++] = flag;
-            }
-        }
-        const xs = new Int32Array(pointCount);
-        const ys = new Int32Array(pointCount);
-        for (const [coords, short, same] of [[xs, 2, 16], [ys, 4, 32]]) {
-            let value = 0;
-            for (let i = 0; i < pointCount; i++) {
-                const flag = flags[i];
-                if (flag & short) {
-                    const delta = this.u8(p++);
-                    value += flag & same ? delta : -delta;
-                }
-                else if (!(flag & same)) {
-                    value += this.i16(p);
-                    p += 2;
-                }
-                coords[i] = value;
-            }
-        }
+        const points = this.simplePoints(offset, contourCount);
+        if (!points)
+            return [];
         const path = [];
         let first = 0;
-        for (const last of endPoints) {
-            contourToPath(path, xs, ys, flags, first, last);
+        for (const last of points.ends) {
+            contourToPath(path, points.xs, points.ys, points.flags, first, last);
             first = last + 1;
         }
         return path;
     }
-    compositeGlyph(offset, depth) {
+    compositeGlyph(offset, expanding) {
         const path = [];
-        let p = offset + 10;
-        for (let more = true; more;) {
-            const flags = this.u16(p);
-            const glyph = this.u16(p + 2);
-            p += 4;
-            let dx, dy;
-            if (flags & 1) {
-                dx = flags & 2 ? this.i16(p) : this.u16(p);
-                dy = flags & 2 ? this.i16(p + 2) : this.u16(p + 2);
-                p += 4;
-            }
-            else {
-                dx = flags & 2 ? this.i8(p) : this.u8(p);
-                dy = flags & 2 ? this.i8(p + 1) : this.u8(p + 1);
-                p += 2;
-            }
-            if (!(flags & 2))
-                dx = dy = 0;
-            let a = 1, b = 0, c = 0, d = 1;
-            const f2dot14 = (o) => this.i16(o) / 16384;
-            if (flags & 8) {
-                a = d = f2dot14(p);
-                p += 2;
-            }
-            else if (flags & 0x40) {
-                a = f2dot14(p);
-                d = f2dot14(p + 2);
-                p += 4;
-            }
-            else if (flags & 0x80) {
-                a = f2dot14(p);
-                b = f2dot14(p + 2);
-                c = f2dot14(p + 4);
-                d = f2dot14(p + 6);
-                p += 8;
-            }
-            for (const command of this.glyfOutline(glyph, depth + 1)) {
+        for (const { glyph, flags, arg1, arg2, matrix: [a, b, c, d] } of this.components(offset).components) {
+            const dx = flags & 2 ? arg1 : 0, dy = flags & 2 ? arg2 : 0;
+            for (const command of this.glyfOutline(glyph, expanding)) {
                 const transformed = [command[0]];
                 for (let i = 1; i < command.length; i += 2) {
                     const x = command[i], y = command[i + 1];
@@ -279,7 +264,6 @@ export class Font {
                 }
                 path.push(transformed);
             }
-            more = !!(flags & 0x20);
         }
         return path;
     }
@@ -424,115 +408,63 @@ function parseCmap(font, offset) {
     }
     return symbol ? (c) => lookup(c) || (c < 256 ? lookup(0xf000 + c) : 0) : lookup;
 }
-function parseGPOSKerning(font, gpos) {
-    const featureList = gpos + font.u16(gpos + 6);
-    const lookupList = gpos + font.u16(gpos + 8);
-    const lookups = new Set();
-    for (let i = 0, count = font.u16(featureList); i < count; i++) {
-        const record = featureList + 2 + i * 6;
-        if (font.u32(record) !== 0x6b65726e)
-            continue;
-        const feature = featureList + font.u16(record + 4);
-        for (let j = 0, n = font.u16(feature + 2); j < n; j++)
-            lookups.add(font.u16(feature + 4 + j * 2));
-    }
-    const pairLookups = [];
-    for (const index of [...lookups].sort((a, b) => a - b)) {
-        if (index >= font.u16(lookupList))
-            continue;
-        const lookup = lookupList + font.u16(lookupList + 2 + index * 2);
-        const type = font.u16(lookup);
-        const subtables = [];
-        for (let i = 0, count = font.u16(lookup + 4); i < count; i++) {
-            let subtable = lookup + font.u16(lookup + 6 + i * 2);
-            if (type === 9) {
-                if (font.u16(subtable + 2) !== 2)
-                    continue;
-                subtable += font.u32(subtable + 4);
-            }
-            else if (type !== 2)
-                continue;
-            const pair = parsePairPos(font, subtable);
-            if (pair)
-                subtables.push(pair);
+function parseVariations(font, offset) {
+    let table = -1;
+    for (let i = 0, count = font.u16(offset + 2); i < count; i++) {
+        const record = offset + 4 + i * 8;
+        if (font.u16(record) === 0 && font.u16(record + 2) === 5) {
+            const t = offset + font.u32(record + 4);
+            if (font.u16(t) === 14)
+                table = t;
         }
-        if (subtables.length)
-            pairLookups.push(subtables);
     }
-    if (!pairLookups.length)
+    if (table < 0)
         return null;
-    return (left, right) => {
-        let total = 0;
-        for (const subtables of pairLookups) {
-            for (const subtable of subtables) {
-                const value = subtable(left, right);
-                if (value === undefined)
-                    continue;
-                total += value;
-                break;
+    const u24 = (o) => font.u8(o) << 16 | font.u16(o + 1);
+    const records = font.u32(table + 6);
+    return (codepoint, selector) => {
+        let lo = 0, hi = records - 1;
+        while (lo <= hi) {
+            const mid = lo + hi >> 1, record = table + 10 + mid * 11, vs = u24(record);
+            if (vs < selector)
+                lo = mid + 1;
+            else if (vs > selector)
+                hi = mid - 1;
+            else {
+                const defaults = font.u32(record + 3), others = font.u32(record + 7);
+                if (others) {
+                    const o = table + others;
+                    let l = 0, h = font.u32(o) - 1;
+                    while (l <= h) {
+                        const m = l + h >> 1, u = u24(o + 4 + m * 5);
+                        if (u < codepoint)
+                            l = m + 1;
+                        else if (u > codepoint)
+                            h = m - 1;
+                        else
+                            return font.u16(o + 4 + m * 5 + 3);
+                    }
+                }
+                if (defaults) {
+                    const o = table + defaults;
+                    let l = 0, h = font.u32(o) - 1;
+                    while (l <= h) {
+                        const m = l + h >> 1, start = u24(o + 4 + m * 4);
+                        if (codepoint < start)
+                            h = m - 1;
+                        else if (codepoint > start + font.u8(o + 4 + m * 4 + 3))
+                            l = m + 1;
+                        else
+                            return -1;
+                    }
+                }
+                return 0;
             }
         }
-        return total;
+        return 0;
     };
 }
-function valueRecord(format) {
-    let size = 0, xAdvance = -1;
-    for (let bit = 0; bit < 8; bit++) {
-        if (!(format & 1 << bit))
-            continue;
-        if (bit === 2)
-            xAdvance = size;
-        size += 2;
-    }
-    return { size, xAdvance };
-}
-function parsePairPos(font, table) {
-    const format = font.u16(table);
-    const coverage = parseCoverage(font, table + font.u16(table + 2));
-    const first = valueRecord(font.u16(table + 4));
-    const second = valueRecord(font.u16(table + 6));
-    if (first.xAdvance === -1)
-        return null;
-    if (format === 1) {
-        const sets = font.u16(table + 8);
-        const recordSize = 2 + first.size + second.size;
-        return (left, right) => {
-            const index = coverage(left);
-            if (index === -1 || index >= sets)
-                return undefined;
-            const set = table + font.u16(table + 10 + index * 2);
-            let lo = 0, hi = font.u16(set) - 1;
-            while (lo <= hi) {
-                const mid = lo + hi >> 1;
-                const record = set + 2 + mid * recordSize;
-                const glyph = font.u16(record);
-                if (glyph < right)
-                    lo = mid + 1;
-                else if (glyph > right)
-                    hi = mid - 1;
-                else
-                    return font.i16(record + 2 + first.xAdvance);
-            }
-            return undefined;
-        };
-    }
-    if (format === 2) {
-        const classes1 = parseClassDef(font, table + font.u16(table + 8));
-        const classes2 = parseClassDef(font, table + font.u16(table + 10));
-        const class1Count = font.u16(table + 12), class2Count = font.u16(table + 14);
-        const recordSize = first.size + second.size;
-        return (left, right) => {
-            if (coverage(left) === -1)
-                return undefined;
-            const c1 = classes1(left), c2 = classes2(right);
-            if (c1 >= class1Count || c2 >= class2Count)
-                return undefined;
-            return font.i16(table + 16 + (c1 * class2Count + c2) * recordSize + first.xAdvance);
-        };
-    }
-    return null;
-}
-function parseCoverage(font, table) {
+export function parseCoverage(font, table) {
     const format = font.u16(table), count = font.u16(table + 2);
     return glyph => {
         let lo = 0, hi = count - 1;
@@ -560,7 +492,7 @@ function parseCoverage(font, table) {
         return -1;
     };
 }
-function parseClassDef(font, table) {
+export function parseClassDef(font, table) {
     const format = font.u16(table);
     if (format === 1) {
         const start = font.u16(table + 2), count = font.u16(table + 4);

package/dist/render/hinting.js

@@ -12,6 +12,12 @@ class SkipInstruction extends Error {
 }
 const roundHalfAway = (v) => v < 0 ? -Math.round(-v) : Math.round(v);
 const mulFix = (a, b) => roundHalfAway(a * b / 65536);
+const mulDiv = (a, b, c) => {
+    if (!c)
+        return a * b < 0 ? -0x7fffffff : 0x7fffffff;
+    const d = Math.floor((Math.abs(a * b) + Math.abs(c) / 2) / Math.abs(c));
+    return a * b * c < 0 ? -d : d;
+};
 const divFix = (a, b) => b === 0 ? 0 : roundHalfAway(a * 65536 / b);
 const ROUND_GRID = { period: 64, phase: 0, threshold: 32 };
 const defaultState = () => ({
@@ -28,6 +34,7 @@ function makeZone(count) {
     };
 }
 const MAX_INSTRUCTIONS = 1_000_000;
+const MAX_POINTS = 65536;
 export class Hinter {
     font;
     fpgm;
@@ -38,6 +45,8 @@ export class Hinter {
     maxTwilight;
     sizes = new Map();
     scaleFixed = 0;
+    loading = new Set();
+    points = 0;
     constructor(font) {
         this.font = font;
         const table = (tag) => {
@@ -98,6 +107,8 @@ export class Hinter {
         if (state.broken)
             return null;
         try {
+            this.loading.clear();
+            this.points = 0;
             const outline = this.load(glyph, state, 0);
             if (!outline)
                 return { path: [], advance: Math.round(this.font.advance(glyph) * state.scale / 64) };
@@ -125,19 +136,23 @@ export class Hinter {
     load(glyph, size, depth) {
         if (depth > 8)
             throw new HintError('composite glyphs nested too deep');
+        if (this.loading.has(glyph))
+            throw new HintError('composite glyph containing itself');
         const font = this.font;
         const data = font.glyfPoints(glyph);
         if (!data)
             return null;
+        this.points += data.xs.length;
+        if (this.points > MAX_POINTS)
+            throw new HintError('too many points');
         const scale = size.scale, scaleFixed = this.scaleFixed = size.scaleFixed;
         const lsb = font.leftSideBearing(glyph), advance = font.advance(glyph);
         let count, zone;
         if (data.components) {
-            const parts = [];
-            const placed = [];
             let total = 0;
             const xsAll = [], ysAll = [], on = [], ends = [];
             let useMetrics = null;
+            this.loading.add(glyph);
             for (const component of data.components) {
                 const part = this.load(component.glyph, size, depth + 1);
                 if (!part)
@@ -161,7 +176,6 @@ export class Hinter {
                         dy = Math.round(dy / 64) * 64;
                     }
                 }
-                placed.push({ dx, dy });
                 for (let i = 0; i < part.count; i++) {
                     const x = part.zone.curX[i], y = part.zone.curY[i];
                     xsAll.push(transformed ? a * x + c * y + dx : x + dx);
@@ -171,10 +185,10 @@ export class Hinter {
                 for (const end of part.zone.ends)
                     ends.push(end + total);
                 total += part.count;
-                parts.push(part);
                 if (component.useMetrics)
                     useMetrics = part;
             }
+            this.loading.delete(glyph);
             count = total;
             zone = makeZone(count + 4);
             zone.ends = ends;
@@ -339,10 +353,10 @@ class Execution {
     }
     lineVector(p1, p2, perpendicular, original) {
         const z1 = this.zone(this.gs.zp1), z2 = this.zone(this.gs.zp2);
-        this.point(z1, p2);
-        this.point(z2, p1);
-        let x = (original ? z1.orgX[p2] - z2.orgX[p1] : z1.curX[p2] - z2.curX[p1]);
-        let y = (original ? z1.orgY[p2] - z2.orgY[p1] : z1.curY[p2] - z2.curY[p1]);
+        this.point(z1, p1);
+        this.point(z2, p2);
+        let x = (original ? z1.orgX[p1] - z2.orgX[p2] : z1.curX[p1] - z2.curX[p2]);
+        let y = (original ? z1.orgY[p1] - z2.orgY[p2] : z1.curY[p1] - z2.curY[p2]);
         if (x === 0 && y === 0) {
             x = 1;
             y = 0;
@@ -467,18 +481,19 @@ class Execution {
                         [a0, a1].forEach(i => this.point(za, i));
                         [b0, b1].forEach(i => this.point(zb, i));
                         this.point(z, p);
-                        const ax0 = za.curX[a0], ay0 = za.curY[a0], ax1 = za.curX[a1], ay1 = za.curY[a1];
-                        const bx0 = zb.curX[b0], by0 = zb.curY[b0], bx1 = zb.curX[b1], by1 = zb.curY[b1];
+                        const ax0 = Math.round(za.curX[a0]), ay0 = Math.round(za.curY[a0]), ax1 = Math.round(za.curX[a1]), ay1 = Math.round(za.curY[a1]);
+                        const bx0 = Math.round(zb.curX[b0]), by0 = Math.round(zb.curY[b0]), bx1 = Math.round(zb.curX[b1]), by1 = Math.round(zb.curY[b1]);
                         const dax = ax1 - ax0, day = ay1 - ay0, dbx = bx1 - bx0, dby = by1 - by0;
-                        const det = dax * dby - day * dbx;
-                        if (Math.abs(det) < 1e-9) {
-                            z.curX[p] = (ax0 + ax1 + bx0 + bx1) / 4;
-                            z.curY[p] = (ay0 + ay1 + by0 + by1) / 4;
+                        const discriminant = mulDiv(dax, -dby, 64) + mulDiv(day, dbx, 64);
+                        const dotProduct = mulDiv(dax, dbx, 64) + mulDiv(day, dby, 64);
+                        if (19 * Math.abs(discriminant) > Math.abs(dotProduct)) {
+                            const v = mulDiv(bx0 - ax0, -dby, 64) + mulDiv(by0 - ay0, dbx, 64);
+                            z.curX[p] = ax0 + mulDiv(v, dax, discriminant);
+                            z.curY[p] = ay0 + mulDiv(v, day, discriminant);
                         }
                         else {
-                            const t = ((bx0 - ax0) * dby - (by0 - ay0) * dbx) / det;
-                            z.curX[p] = ax0 + t * dax;
-                            z.curY[p] = ay0 + t * day;
+                            z.curX[p] = Math.trunc((ax0 + ax1 + bx0 + bx1) / 4);
+                            z.curY[p] = Math.trunc((ay0 + ay1 + by0 + by1) / 4);
                         }
                         z.touchX[p] = z.touchY[p] = 1;
                         break;
@@ -532,11 +547,12 @@ class Execution {
                     case 0x76:
                     case 0x77: {
                         const n = this.pop();
-                        const grid = op === 0x76 ? 64 : 64 / Math.SQRT2;
-                        const period = [grid / 2, grid, grid * 2, grid][n >> 6 & 3];
-                        const phase = [0, period / 4, period / 2, period * 3 / 4][n >> 4 & 3];
+                        const grid = op === 0x76 ? 0x4000 : 0x2d41;
+                        const period = [grid >> 1, grid, grid * 2, grid][n >> 6 & 3];
+                        const phase = [0, period >> 2, period >> 1, Math.trunc(period * 3 / 4)][n >> 4 & 3];
                         const t = n & 15;
-                        gs.round = { period, phase, threshold: t === 0 ? period - 1 : (t - 4) * period / 8 };
+                        const threshold = t === 0 ? period - 1 : Math.trunc((t - 4) * period / 8);
+                        gs.round = { period: period >> 8, phase: phase >> 8, threshold: threshold >> 8 };
                         break;
                     }
                     case 0x1a:
@@ -1016,7 +1032,7 @@ class Execution {
                         const z0 = this.zone(gs.zp0), z1 = this.zone(gs.zp1);
                         this.point(z0, p2);
                         this.point(z1, p1);
-                        const d = this.project(z0.curX[p2] - z1.curX[p1], z0.curY[p2] - z1.curY[p1]) / 2;
+                        const d = Math.trunc(Math.round(this.project(z0.curX[p2] - z1.curX[p1], z0.curY[p2] - z1.curY[p1])) / 2);
                         this.move(z1, p1, d);
                         this.move(z0, p2, -d);
                         break;