handle endchar command with seac parameters (standard encoding accented characters)

src/tables/cff.js

@@ -824,7 +824,52 @@ function parseCFFCharstring(font, glyph, code, version) {
                         break;
                     }
 
-                    if (stack.length > 0 && !haveWidth) {
+                    if (stack.length >= 4) {
+                        // Type 2 Charstring Format Appendix C
+                        // treat like Type 1 seac command (standard encoding accented character)
+                        const acharName = cffStandardEncoding[stack.pop()];
+                        const bcharName = cffStandardEncoding[stack.pop()];
+                        const ady = stack.pop();
+                        const adx = stack.pop();
+                        // const asb = stack.pop(); // ignored for Type 2
+                        if ( acharName && bcharName ) {
+                            glyph.isComposite = true;
+                            glyph.components = [];
+
+                            const acharGlyphIndex = font.cffEncoding.charset.indexOf(acharName);
+                            const bcharGlyphIndex = font.cffEncoding.charset.indexOf(bcharName);
+
+                            glyph.components.push({
+                                glyphIndex: bcharGlyphIndex,
+                                dx: 0,
+                                dy: 0
+                            });
+                            glyph.components.push({
+                                glyphIndex: acharGlyphIndex,
+                                dx: adx,
+                                dy: ady
+                            });
+                            p.extend(font.glyphs.get(bcharGlyphIndex).path);
+                            const acharGlyph = font.glyphs.get(acharGlyphIndex);
+                            const shiftedCommands = JSON.parse(JSON.stringify(acharGlyph.path.commands)); // make a deep clone
+                            for (let i = 0; i < shiftedCommands.length; i += 1) {
+                                const cmd = shiftedCommands[i];
+                                if (cmd.type !== 'Z') {
+                                    cmd.x += adx;
+                                    cmd.y += ady;
+                                }
+                                if ( cmd.type === 'Q' || cmd.type === 'C' ) {
+                                    cmd.x1 += adx;
+                                    cmd.y1 += ady;
+                                }
+                                if ( cmd.type === 'C' ) {
+                                    cmd.x2 += adx;
+                                    cmd.y2 += ady;
+                                }
+                            }
+                            p.extend(shiftedCommands);
+                        }
+                    } else if (stack.length > 0 && !haveWidth) {
                         width = stack.shift() + nominalWidthX;
                         haveWidth = true;
                     }

test/fonts/LICENSE

@@ -1,3 +1,8 @@
+AbrilFatface-Regular.otf
+    Copyright (c) 2011, Copyright (c) 2011, TypeTogether (www.type-together.com [email protected]), with Reserved Font Names “Abril” and “Abril Fatface”
+    SIL Open Font License, Version 1.1.
+    https://www.fontsquirrel.com/license/abril-fatface
+
 Changa-Regular.ttf
     Copyright 2011 Eduardo Tunni (www.tipo.net.ar)
     SIL Open Font License, Version 1.1.

test/tables/cff.js

@@ -138,4 +138,17 @@ describe('tables/cff.js', function () {
             { type: 'L', x: 50, y: 500 }
         ] );
     });
+
+    it('can handle standard encoding accented characters via endchar', function() {
+        const font = loadSync('./test/fonts/AbrilFatface-Regular.otf', { lowMemory: true });
+        const glyph13 = font.glyphs.get(13); // the semicolon is combined of comma and period
+        const commands = glyph13.path.commands;
+        assert.equal(glyph13.isComposite, true);
+        assert.equal(commands.length, 15);
+        assert.deepEqual(commands[0], { type: 'M', x: 86, y: -156 });
+        assert.deepEqual(commands[7], { type: 'C', x: 74, y: -141, x1: 174, y1: -35, x2: 162, y2: -66 });
+        assert.deepEqual(commands[9], { type: 'M', x: 36, y: 407 });
+        assert.deepEqual(commands[13], { type: 'C', x: 36, y: 407, x1: 66, y1: 495, x2: 36, y2: 456 });
+        assert.deepEqual(commands[14], { type: 'Z' });
+    });
 });