' . $html . '
'); + + return array_values(unpack('N*', mb_convert_encoding($mpdf->drawnText[0], 'UTF-32BE', 'UTF-8'))); + } + + public function dataRuns() + { + return [ + 'a word ending in a mark, where the lookahead runs out' => [ + [self::BEH, self::BEH, self::FATHA], + [self::FATHA, self::BEH, self::BEH], + ], + 'a word starting with a mark, where the backtrack runs out' => [ + [self::FATHA, self::BEH, self::BEH], + [self::BEH, self::BEH, self::FATHA], + ], + 'the lookahead met past the mark' => [ + [self::BEH, self::BEH, self::FATHA, self::LOW_ALEF], + [self::LOW_ALEF, self::FATHA, self::DOTLESS_BEH_FINAL, self::BEH], + ], + 'the backtrack met past the mark' => [ + [self::LOW_ALEF, self::FATHA, self::BEH, self::BEH], + [self::BEH, self::DOTLESS_BEH_INITIAL, self::FATHA, self::LOW_ALEF], + ], + ]; + } + + /** + * @dataProvider dataRuns + */ + public function testAFormsContextIsMatchedUpToTheEdgeOfTheRun($codepoints, $expected) + { + $this->assertSame($expected, $this->drawn($codepoints)); + } + +} diff --git a/tests/Mpdf/Fixtures/arabic-shape.php b/tests/Mpdf/Fixtures/arabic-shape.php new file mode 100644 index 000000000..4d267e322 --- /dev/null +++ b/tests/Mpdf/Fixtures/arabic-shape.php @@ -0,0 +1,34 @@ + + */ + +require __DIR__ . '/../../../vendor/autoload.php'; + +set_time_limit(5); +error_reporting(E_ERROR); + +list($runs, $usetags, $marks) = json_decode(base64_decode($argv[1]), true); + +$forms = []; +foreach ($runs as $name => $run) { + list($hexes, $glyphs) = $run; + + $info = []; + foreach ($hexes as $hex) { + $info[] = ['hex' => $hex, 'uni' => hexdec($hex)]; + } + + \Mpdf\Shaper\Arabic::shape($info, $glyphs, $marks, $usetags, 'arab'); + + foreach ($info as $char) { + $forms[$name][] = [$char['hex'], $char['form']]; + } +} + +echo json_encode($forms); diff --git a/tests/Mpdf/Fonts/GlyphStringTest.php b/tests/Mpdf/Fonts/GlyphStringTest.php index db15d7432..97021a7c5 100644 --- a/tests/Mpdf/Fonts/GlyphStringTest.php +++ b/tests/Mpdf/Fonts/GlyphStringTest.php @@ -33,6 +33,48 @@ public function codepointProvider() ]; } + /** + * A six-digit glyph holds two five-digit ones: U+100300 is 10030 followed by a 0, and a 1 followed + * by 00300. Neither is in a class that names only U+100300. + * + * @dataProvider listProvider + */ + public function testAGlyphIsInAListOnlyWhereTheListNamesIt($glyphs, $glyph, $expected) + { + $set = GlyphString::set($glyphs); + + $this->assertSame($expected, isset($set[$glyph]), 'set()'); + $this->assertSame($expected, GlyphString::inList($glyphs, $glyph), 'inList()'); + } + + public function listProvider() + { + return [ + 'plane 16, itself' => [' 100300', '100300', true], + 'a BMP glyph its hex ends with' => [' 100300', '00300', false], + 'a plane 1 glyph its hex begins with' => [' 100300', '10030', false], + 'a plane 16 glyph whose hex ends with a BMP one in the list' => [' 00300', '100300', false], + 'the first of several' => [' 00300| 100300| 00302', '00300', true], + 'the last of several' => [' 00300| 100300| 00302', '00302', true], + 'between two that hold it' => [' 100300| 00300| 003001', '00300', true], + 'several, none of them it' => [' 00301| 100300| 00302', '00300', false], + 'an empty class' => ['', '00300', false], + 'a Coverage table, without the spaces' => ['00041|100300', '00300', false], + ]; + } + + /** + * inList() reads whatever separates the glyphs, since the lists it is asked about are not all + * GDEF's shape + */ + public function testAListMaySeparateItsGlyphsWithAnythingButAHexDigit() + { + $this->assertTrue(GlyphString::inList('0FE8E 0FE94 ', '0FE94')); + $this->assertFalse(GlyphString::inList('0FE8E 10FE94 ', '0FE94')); + $this->assertTrue(GlyphString::inList('((?:(?: 00300| 00301))*)', '00301')); + $this->assertFalse(GlyphString::inList('((?:(?: 100300| 100301))*)', '00301')); + } + /** * \Mpdf\unicode_hex() has been a public function of the Mpdf namespace since 5.7.1 and upstream * declares it in the same place, so anything outside the library that calls it has to keep diff --git a/tests/Mpdf/Fonts/Table/LookupFlagTest.php b/tests/Mpdf/Fonts/Table/LookupFlagTest.php index 91b8d31b1..41ec1527e 100644 --- a/tests/Mpdf/Fonts/Table/LookupFlagTest.php +++ b/tests/Mpdf/Fonts/Table/LookupFlagTest.php @@ -2,6 +2,8 @@ namespace Mpdf\Fonts\Table; +use Mpdf\Fonts\GlyphString; + class LookupFlagTest extends \Yoast\PHPUnitPolyfills\TestCases\TestCase { @@ -109,6 +111,27 @@ public function testAnUndefinedMarkFilteringSetIsRefused() $this->lookupFlag->skips(0x0018, '00041', 3); } + /** + * GlyphString::of() writes a plane 16 glyph six digits wide, and the five-digit glyph its hex ends + * with is not skipped with it + */ + public function testAGlyphWhoseHexEndsAPlaneSixteenMarksIsNotSkippedWithIt() + { + $marks = ' ' . implode('| ', [GlyphString::of(0x100300)]); + $flag = new LookupFlag('demo', [ + 'GlyphClassBases' => '', + 'GlyphClassMarks' => $marks, + 'GlyphClassLigatures' => '', + 'GlyphClassComponents' => '', + 'MarkGlyphSets' => [], + 'MarkAttachmentType' => [], + ]); + + $this->assertFalse($flag->skips(LookupFlag::IGNORE_MARKS, GlyphString::of(0x0300), '')); + $this->assertFalse($flag->skips(LookupFlag::IGNORE_MARKS, GlyphString::of(0x0301), '')); + $this->assertTrue($flag->skips(LookupFlag::IGNORE_MARKS, GlyphString::of(0x100300), '')); + } + /** * An empty class adds no separator of its own, but one it follows still gets its "|" - which is * how the ignore strings in the cached GSUB data have always read diff --git a/tests/Mpdf/GdefClassMembershipTest.php b/tests/Mpdf/GdefClassMembershipTest.php new file mode 100644 index 000000000..be061d391 --- /dev/null +++ b/tests/Mpdf/GdefClassMembershipTest.php @@ -0,0 +1,134 @@ +mpdf = new Mpdf([ + 'mode' => 'utf-8', + 'tempDir' => $tempDir, + 'fontDir' => [__DIR__ . '/../data/ttf'], + 'fontdata' => [self::FONTKEY => [ + 'R' => 'NotoSans-PlaneSixteenMark-Synthetic.ttf', + 'useOTL' => 0xFF, + ]], + 'default_font' => self::FONTKEY, + ]); + + $this->otl = new Otl($this->mpdf, new FontCache(new Cache($tempDir . '/mpdf/ttfontdata'))); + } + + protected function tear_down() + { + $this->mpdf->cleanup(); + + parent::tear_down(); + } + + public function testTheParserClassesThePlaneSixteenMarkAsThePrivateUseCharacterItMapsItTo() + { + $this->shape([0x41]); + + $this->assertSame(' 00301| 0E001', $this->otl->GDEFdata[self::FONTKEY]['GlyphClassMarks']); + } + + public function dataRuns() + { + return [ + 'IgnoreMarks does not skip U+0300, whose hex U+100300 ends with' => [ + [0x41, 0x0300], + [[0x41, 'C', null], [0x60, 'C', null]], + ], + 'a mark attaches to U+10030, whose hex U+100300 begins with' => [ + [0x10030, 0x0301], + [[0x10030, 'C', null], [0x0301, 'M', ['BaseWidth' => 639, 'XPlacement' => 300, 'YPlacement' => 0]]], + ], + ]; + } + + /** + * @dataProvider dataRuns + */ + public function testAGlyphIsNotTakenForTheMarkItsHexIsPartOf($codepoints, $expected) + { + // Before the shaper first reads GDEF, which it then keeps for the font + $this->otl->GDEFdata[self::FONTKEY] = [ + 'GlyphClassBases' => ' 00020| 00041| 00060| 0007E| 00300| 10030', + 'GlyphClassMarks' => ' 00301| 100300', + 'GlyphClassLigatures' => '', + 'GlyphClassComponents' => '', + 'MarkGlyphSets' => [], + 'MarkAttachmentType' => [], + ]; + + $this->assertSame($expected, $this->shape($codepoints)); + } + + /** + * @param int[] $codepoints + * + * @return array[] The codepoint, the group and the positioning of each glyph of the run + */ + private function shape($codepoints) + { + $text = ''; + foreach ($codepoints as $codepoint) { + $text .= UtfString::code2utf($codepoint); + } + $this->otl->applyOTL($text, 0xFF); + + $run = []; + foreach ($this->otl->OTLdata['char_data'] as $i => $character) { + $run[] = [ + $character['uni'], + $this->otl->OTLdata['group'][$i], + isset($this->otl->OTLdata['GPOSinfo'][$i]) ? $this->otl->OTLdata['GPOSinfo'][$i] : null, + ]; + } + + return $run; + } + +} diff --git a/tests/Mpdf/Shaper/ArabicTest.php b/tests/Mpdf/Shaper/ArabicTest.php index 17da48a0d..097cad861 100644 --- a/tests/Mpdf/Shaper/ArabicTest.php +++ b/tests/Mpdf/Shaper/ArabicTest.php @@ -479,17 +479,137 @@ public function testEveryJoiningTableEntryIsFiledUnderItsOwnCodepoint() } } + /** + * A form a chained rule gives is drawn where the text holds the glyphs the rule names, and a glyph + * whose hex is only part of one of theirs is not one of them: 00628 is inside 100628, and 0064E + * inside 10064E. + * + * @dataProvider dataContextNamingAPlaneSixteenGlyph + */ + public function testAFormsContextIsNotMetByAGlyphWhoseHexIsPartOfOneItNames($prel, $ignore, $hexes, $expected) + { + $glyphs = $this->glyphs(); + $glyphs[self::DAL] = ['D_ISOL', 'D_FINA', 'prel' => [1 => [$prel]], 'ignore' => [1 => $ignore]]; + + $this->assertSame($expected, $this->shape($hexes, self::ALL_FORMS, 'arab', self::FATHA, $glyphs)); + } + + public function dataContextNamingAPlaneSixteenGlyph() + { + return [ + 'the backtrack' => [ + '1' . self::BEH, + '()', + [self::BEH, self::DAL], + [['B_INIT', 2], [self::DAL, 0]], + ], + 'the glyphs the lookup skips' => [ + self::BEH, + '((?:(?: 1' . self::FATHA . '))*)', + [self::BEH, self::FATHA, self::DAL], + [['B_INIT', 2], [self::FATHA, 0], [self::DAL, 0]], + ], + ]; + } + + /** + * The walk over the glyphs a chained rule's lookup ignores read past the edge of the run: a notice + * for each glyph on PHP 7, and from PHP 8 a walk that never returned (#204). Here the notice is what + * fails, so a regression cannot hang the suite. + * + * @dataProvider dataContextWalkedToTheEdgeOfTheRun + */ + public function testAFormsContextWalkReadsNothingPastTheEdgeOfTheRun($hexes, $glyphs, $expected) + { + set_error_handler(function ($number, $message, $file, $line) { + throw new \ErrorException($message, 0, $number, $file, $line); + }); + + try { + $forms = $this->shape($hexes, self::ALL_FORMS, 'arab', self::FATHA, $glyphs); + } finally { + restore_error_handler(); + } + + $this->assertSame($expected, $forms); + } + + /** + * The same cases, all in one child process under a time limit, for a regression that reads past the + * edge without a notice. The limit is the child's own rather than a `timeout` around it, so it holds + * on Windows too, and the child reports nothing short of a fatal error, so a walk warning on every + * step cannot fill the stderr pipe and leave it blocked instead of timed out. + */ + public function testAFormsContextWalkReturnsAtTheEdgeOfTheRun() + { + $runs = []; + $expected = []; + foreach ($this->dataContextWalkedToTheEdgeOfTheRun() as $name => $case) { + $runs[$name] = [$case[0], $case[1]]; + $expected[$name] = $case[2]; + } + + // base64, because Windows argument quoting does not survive the JSON's double quotes + $arg = base64_encode(json_encode([$runs, self::ALL_FORMS, ' ' . self::FATHA])); + $command = escapeshellarg(PHP_BINARY) . ' -d display_errors=stderr ' + . escapeshellarg(__DIR__ . '/../Fixtures/arabic-shape.php') . ' ' . $arg; + + $process = proc_open($command, [1 => ['pipe', 'w'], 2 => ['pipe', 'w']], $pipes, null, null, ['bypass_shell' => true]); + $output = stream_get_contents($pipes[1]); + $errors = stream_get_contents($pipes[2]); + fclose($pipes[1]); + fclose($pipes[2]); + $this->assertSame(0, proc_close($process), $errors); + + $this->assertSame($expected, json_decode($output, true)); + } + + public function dataContextWalkedToTheEdgeOfTheRun() + { + // The forms are the presentation forms rather than names, because the run is left holding them + // and shape() reads each back as hex + $ignoreFatha = '((?:(?: ' . self::FATHA . '))*)'; + + return [ + 'a backtrack that runs out at the start of the run' => [ + [self::FATHA, self::DAL], + [self::DAL => ['0FEA9', '0FEAA', 'prel' => [0 => [self::BEH]], 'ignore' => [0 => $ignoreFatha]]], + [[self::FATHA, 0], [self::DAL, 0]], + ], + 'a lookahead that runs out at the end of the run' => [ + [self::BEH, self::FATHA], + [self::BEH => ['0FE8F', 'postl' => [0 => [self::DAL]], 'ignore' => [0 => $ignoreFatha]]], + [[self::BEH, 0], [self::FATHA, 0]], + ], + 'a lookahead whose second position runs out after the first is met' => [ + [self::BEH, self::FATHA, self::DAL, self::FATHA], + [self::BEH => ['0FE8F', '0FE90', '0FE91', 'postl' => [2 => [self::DAL, self::DAL]], 'ignore' => [2 => $ignoreFatha]]], + [[self::BEH, 0], [self::FATHA, 0], [self::DAL, 0], [self::FATHA, 0]], + ], + 'a backtrack met past the ignored glyphs' => [ + [self::BEH, self::FATHA, self::DAL], + [self::DAL => ['0FEA9', '0FEAA', 'prel' => [1 => [self::BEH]], 'ignore' => [1 => $ignoreFatha]]], + [[self::BEH, 0], [self::FATHA, 0], ['0FEAA', 1]], + ], + 'a lookahead met past the ignored glyphs' => [ + [self::BEH, self::FATHA, self::DAL], + [self::BEH => ['0FE8F', '0FE90', '0FE91', 'postl' => [2 => [self::DAL]], 'ignore' => [2 => $ignoreFatha]]], + [['0FE91', 2], [self::FATHA, 0], [self::DAL, 0]], + ], + ]; + } + /** * @return array one [hex, form] pair per character, in logical order */ - private function shape($hexes, $usetags = self::ALL_FORMS, $scriptTag = 'arab', $glyphClassMarks = self::FATHA) + private function shape($hexes, $usetags = self::ALL_FORMS, $scriptTag = 'arab', $glyphClassMarks = self::FATHA, $glyphs = null) { $info = []; foreach ($hexes as $hex) { $info[] = ['hex' => $hex, 'uni' => hexdec($hex)]; } - Arabic::shape($info, $this->glyphs(), ' ' . $glyphClassMarks, $usetags, $scriptTag); + Arabic::shape($info, $glyphs === null ? $this->glyphs() : $glyphs, ' ' . $glyphClassMarks, $usetags, $scriptTag); $forms = []; foreach ($info as $char) { diff --git a/tests/Mpdf/Shaper/LineBreakingTest.php b/tests/Mpdf/Shaper/LineBreakingTest.php index 53a365cd3..630f7e9d0 100644 --- a/tests/Mpdf/Shaper/LineBreakingTest.php +++ b/tests/Mpdf/Shaper/LineBreakingTest.php @@ -54,6 +54,18 @@ public function testAWordInTheDictionaryEndsAWord() $this->assertSame([1], $this->southEastAsian($dict, [0x0E17, 0x0E14, 0x0E2A, 0x0E2D])); } + /** + * A word does not end before a mark GDEF classes, and a character whose hex is only part of a + * mark's is not one: 00E2A is inside 100E2A + */ + public function testAWordDoesNotEndBeforeAMark() + { + $dict = $this->linear([0x17, 0x14]) . chr(0x04); + + $this->assertSame([], $this->southEastAsian($dict, [0x0E17, 0x0E14, 0x0E2A, 0x0E2D], GlyphString::set(' 00E2A'))); + $this->assertSame([1], $this->southEastAsian($dict, [0x0E17, 0x0E14, 0x0E2A, 0x0E2D], GlyphString::set(' 100E2A'))); + } + public function testTextThatIsNotInTheDictionaryEndsNoWord() { $dict = $this->linear([0x17, 0x14]) . chr(0x04); @@ -105,10 +117,10 @@ private function tibetan($unicode) /** * @return array the indexes marked as ending a word */ - private function southEastAsian($dict, $unicode) + private function southEastAsian($dict, $unicode, $marks = []) { $info = $this->info($unicode); - LineBreaking::southEastAsian($info, $dict, ''); + LineBreaking::southEastAsian($info, $dict, $marks); return $this->wordEnds($info); } diff --git a/tests/data/fontcache/NotoSans-PlaneSixteenMark-Synthetic.json b/tests/data/fontcache/NotoSans-PlaneSixteenMark-Synthetic.json new file mode 100644 index 000000000..2d48db0c9 --- /dev/null +++ b/tests/data/fontcache/NotoSans-PlaneSixteenMark-Synthetic.json @@ -0,0 +1,98 @@ +{ + "_": "Generated by composer fontcache:update. See tests/Mpdf/Fonts/ParserGoldenMaster.php.", + "fullName": "NotoSans-PlaneSixteenMark-Synthetic", + "mtx": { + "GSUBScriptLang": { + "DFLT": "DFLT ", + "latn": "DFLT " + }, + "GSUBFeatures": { + "DFLT": { + "DFLT": { + "ccmp": [ + 0 + ] + } + }, + "latn": { + "DFLT": { + "ccmp": [ + 0 + ] + } + } + }, + "GSUBLookups": [ + { + "Type": 1, + "Flag": 8, + "SubtableCount": 1, + "Subtables": [ + 62 + ], + "MarkFilteringSet": "" + } + ], + "GPOSScriptLang": { + "DFLT": "DFLT ", + "latn": "DFLT " + }, + "GPOSFeatures": { + "DFLT": { + "DFLT": { + "mark": [ + 0 + ] + } + }, + "latn": { + "DFLT": { + "mark": [ + 0 + ] + } + } + }, + "GPOSLookups": [ + { + "Type": 4, + "Flag": 0, + "SubtableCount": 1, + "Subtables": [ + 62 + ], + "MarkFilteringSet": "" + } + ], + "MarkGlyphSets": [], + "rtlPUAstr": "", + "haskernGPOS": false, + "hassmallcapsGSUB": false + }, + "cache": { + "GDEFdata.json": { + "GlyphClassBases": " 00020| 00041| 00060| 0007E| 00300| 10030", + "GlyphClassMarks": " 00301| 0E001", + "GlyphClassLigatures": "", + "GlyphClassComponents": "", + "MarkGlyphSets": [], + "MarkAttachmentType": [] + }, + "GPOS.dat": "108 bytes, sha256 c1668d8fb37c2532bd19f2435d2f11a6b4bf397ec03e2511fa4b0f2d2616cf87", + "GPOSdata.json": [ + [ + { + "769": 0 + } + ] + ], + "GSUB.dat": "74 bytes, sha256 7cf15c4f04eae9517b326ff0aedf14c27e790d0304901cdde3da390ffb0da577", + "GSUBdata.json": [ + [ + { + "768": 0 + } + ] + ] + } +} diff --git a/tests/data/fontcache/NotoSansArabic-ContextEdge-Synthetic.json b/tests/data/fontcache/NotoSansArabic-ContextEdge-Synthetic.json new file mode 100644 index 000000000..07d46f738 --- /dev/null +++ b/tests/data/fontcache/NotoSansArabic-ContextEdge-Synthetic.json @@ -0,0 +1,319 @@ +{ + "_": "Generated by composer fontcache:update. See tests/Mpdf/Fonts/ParserGoldenMaster.php.", + "fullName": "NotoSansArabicContextEdgeSynthetic-Regular", + "mtx": { + "GSUBScriptLang": { + "DFLT": "DFLT ", + "arab": "DFLT ", + "cyrl": "DFLT ", + "dev2": "DFLT ", + "grek": "DFLT ", + "latn": "DFLT " + }, + "GSUBFeatures": { + "DFLT": { + "DFLT": { + "init": [ + 0 + ], + "medi": [ + 1 + ], + "fina": [ + 2 + ] + } + }, + "arab": { + "DFLT": { + "init": [ + 0 + ], + "medi": [ + 1 + ], + "fina": [ + 2 + ] + } + }, + "cyrl": { + "DFLT": { + "init": [ + 0 + ], + "medi": [ + 1 + ], + "fina": [ + 2 + ] + } + }, + "dev2": { + "DFLT": { + "init": [ + 0 + ], + "medi": [ + 1 + ], + "fina": [ + 2 + ] + } + }, + "grek": { + "DFLT": { + "init": [ + 0 + ], + "medi": [ + 1 + ], + "fina": [ + 2 + ] + } + }, + "latn": { + "DFLT": { + "init": [ + 0 + ], + "medi": [ + 1 + ], + "fina": [ + 2 + ] + } + } + }, + "GSUBLookups": [ + { + "Type": 6, + "Flag": 8, + "SubtableCount": 1, + "Subtables": [ + 122 + ], + "MarkFilteringSet": "" + }, + { + "Type": 1, + "Flag": 0, + "SubtableCount": 1, + "Subtables": [ + 148 + ], + "MarkFilteringSet": "" + }, + { + "Type": 6, + "Flag": 8, + "SubtableCount": 1, + "Subtables": [ + 162 + ], + "MarkFilteringSet": "" + }, + { + "Type": 1, + "Flag": 0, + "SubtableCount": 1, + "Subtables": [ + 194 + ], + "MarkFilteringSet": "" + }, + { + "Type": 1, + "Flag": 0, + "SubtableCount": 1, + "Subtables": [ + 208 + ], + "MarkFilteringSet": "" + } + ], + "GPOSScriptLang": { + "DFLT": "DFLT ", + "arab": "DFLT ", + "cyrl": "DFLT ", + "dev2": "DFLT ", + "grek": "DFLT ", + "latn": "DFLT " + }, + "GPOSFeatures": { + "DFLT": { + "DFLT": { + "mark": [ + 0 + ], + "mkmk": [ + 1 + ] + } + }, + "arab": { + "DFLT": { + "mark": [ + 0 + ], + "mkmk": [ + 1 + ] + } + }, + "cyrl": { + "DFLT": { + "mark": [ + 0 + ], + "mkmk": [ + 1 + ] + } + }, + "dev2": { + "DFLT": { + "mark": [ + 0 + ], + "mkmk": [ + 1 + ] + } + }, + "grek": { + "DFLT": { + "mark": [ + 0 + ], + "mkmk": [ + 1 + ] + } + }, + "latn": { + "DFLT": { + "mark": [ + 0 + ], + "mkmk": [ + 1 + ] + } + } + }, + "GPOSLookups": [ + { + "Type": 4, + "Flag": 0, + "SubtableCount": 1, + "Subtables": [ + 102 + ], + "MarkFilteringSet": "" + }, + { + "Type": 6, + "Flag": 16, + "SubtableCount": 1, + "Subtables": [ + 194 + ], + "MarkFilteringSet": 0 + } + ], + "MarkGlyphSets": [ + " 0E005" + ], + "rtlPUAstr": "\\x{0E002}-\\x{0E004}", + "haskernGPOS": false, + "hassmallcapsGSUB": false + }, + "cache": { + "GDEFdata.json": { + "GlyphClassBases": " 00020| 00627| 008AD| 0E000| 0E001| 0E002| 0E003| 0E004", + "GlyphClassMarks": " 0064E| 0E005", + "GlyphClassLigatures": "", + "GlyphClassComponents": "", + "MarkGlyphSets": [ + " 0E005" + ], + "MarkAttachmentType": [] + }, + "GPOS.dat": "234 bytes, sha256 0f363351c5ea276d72ca75127977045024304d1f2b19b04e8cfded715c737a13", + "GPOSdata.json": [ + [ + { + "57349": 0 + } + ], + [ + { + "57349": 0 + } + ] + ], + "GSUB.arab.DFLT.json": { + "rtlSUB": { + "00628": { + "2": "0E004", + "prel": { + "2": [ + "008AD" + ] + }, + "ignore": { + "2": "((?:(?: 0064E| 0E005))*)", + "1": "((?:(?: 0064E| 0E005))*)" + }, + "3": "0E003", + "1": "0E002", + "postl": { + "1": [ + "008AD" + ] + } + } + }, + "finals": "0E002 ", + "rphf": [], + "half": [], + "pref": [], + "blwf": [], + "pstf": [] + }, + "GSUB.dat": "220 bytes, sha256 3ac7cb0c04aead3a9fc0c5f6c607b54931c16a81c5d5edb41654ceb5d58d593e", + "GSUBdata.json": [ + [ + { + "1576": 0 + } + ], + [ + { + "1576": 0 + } + ], + [ + { + "1576": 0 + } + ], + [ + { + "1576": 0 + } + ], + [ + { + "1576": 0 + } + ] + ] + } +} diff --git a/tests/data/otldump/NotoSans-PlaneSixteenMark-Synthetic.txt b/tests/data/otldump/NotoSans-PlaneSixteenMark-Synthetic.txt new file mode 100644 index 000000000..a73861ad4 --- /dev/null +++ b/tests/data/otldump/NotoSans-PlaneSixteenMark-Synthetic.txt @@ -0,0 +1,24 @@ +