qr_reader 0.0.1 → 0.0.2

data/lib/qr_reader/formats/pdf/font_tables.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+# Generated by script/generate_font_tables.py from fontTools (MIT); do not edit.
+module QrReader
+  module Formats
+    module PDF
+      # Glyph name tables for PDF fonts: Adobe's standard encodings, the CFF
+      # standard strings and the Unicode values of the glyph names in them.
+      module FontTables
+        # SID -> name for SIDs 0..390 of CFF fonts.
+        CFF_STANDARD_STRINGS = [
+          nil, "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand",
+          "quoteright", "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period",
+          "slash", "zero", "one", "two", "three", "four", "five", "six",
+          "seven", "eight", "nine", "colon", "semicolon", "less", "equal", "greater",
+          "question", "at", "A", "B", "C", "D", "E", "F",
+          "G", "H", "I", "J", "K", "L", "M", "N",
+          "O", "P", "Q", "R", "S", "T", "U", "V",
+          "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum",
+          "underscore", "quoteleft", "a", "b", "c", "d", "e", "f",
+          "g", "h", "i", "j", "k", "l", "m", "n",
+          "o", "p", "q", "r", "s", "t", "u", "v",
+          "w", "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde",
+          "exclamdown", "cent", "sterling", "fraction", "yen", "florin", "section", "currency",
+          "quotesingle", "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi", "fl", "endash",
+          "dagger", "daggerdbl", "periodcentered", "paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright",
+          "guillemotright", "ellipsis", "perthousand", "questiondown", "grave", "acute", "circumflex", "tilde",
+          "macron", "breve", "dotaccent", "dieresis", "ring", "cedilla", "hungarumlaut", "ogonek",
+          "caron", "emdash", "AE", "ordfeminine", "Lslash", "Oslash", "OE", "ordmasculine",
+          "ae", "dotlessi", "lslash", "oslash", "oe", "germandbls", "onesuperior", "logicalnot",
+          "mu", "trademark", "Eth", "onehalf", "plusminus", "Thorn", "onequarter", "divide",
+          "brokenbar", "degree", "thorn", "threequarters", "twosuperior", "registered", "minus", "eth",
+          "multiply", "threesuperior", "copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave", "Aring",
+          "Atilde", "Ccedilla", "Eacute", "Ecircumflex", "Edieresis", "Egrave", "Iacute", "Icircumflex",
+          "Idieresis", "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis", "Ograve", "Otilde",
+          "Scaron", "Uacute", "Ucircumflex", "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron",
+          "aacute", "acircumflex", "adieresis", "agrave", "aring", "atilde", "ccedilla", "eacute",
+          "ecircumflex", "edieresis", "egrave", "iacute", "icircumflex", "idieresis", "igrave", "ntilde",
+          "oacute", "ocircumflex", "odieresis", "ograve", "otilde", "scaron", "uacute", "ucircumflex",
+          "udieresis", "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall", "Hungarumlautsmall", "dollaroldstyle",
+          "dollarsuperior", "ampersandsmall", "Acutesmall", "parenleftsuperior", "parenrightsuperior", "twodotenleader", "onedotenleader", "zerooldstyle",
+          "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle", "fiveoldstyle", "sixoldstyle", "sevenoldstyle", "eightoldstyle",
+          "nineoldstyle", "commasuperior", "threequartersemdash", "periodsuperior", "questionsmall", "asuperior", "bsuperior", "centsuperior",
+          "dsuperior", "esuperior", "isuperior", "lsuperior", "msuperior", "nsuperior", "osuperior", "rsuperior",
+          "ssuperior", "tsuperior", "ff", "ffi", "ffl", "parenleftinferior", "parenrightinferior", "Circumflexsmall",
+          "hyphensuperior", "Gravesmall", "Asmall", "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall",
+          "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall", "Lsmall", "Msmall", "Nsmall",
+          "Osmall", "Psmall", "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall", "Vsmall",
+          "Wsmall", "Xsmall", "Ysmall", "Zsmall", "colonmonetary", "onefitted", "rupiah", "Tildesmall",
+          "exclamdownsmall", "centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall", "Dieresissmall", "Brevesmall", "Caronsmall",
+          "Dotaccentsmall", "Macronsmall", "figuredash", "hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall", "questiondownsmall",
+          "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird", "twothirds", "zerosuperior", "foursuperior",
+          "fivesuperior", "sixsuperior", "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior", "oneinferior", "twoinferior",
+          "threeinferior", "fourinferior", "fiveinferior", "sixinferior", "seveninferior", "eightinferior", "nineinferior", "centinferior",
+          "dollarinferior", "periodinferior", "commainferior", "Agravesmall", "Aacutesmall", "Acircumflexsmall", "Atildesmall", "Adieresissmall",
+          "Aringsmall", "AEsmall", "Ccedillasmall", "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall", "Igravesmall",
+          "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall", "Ntildesmall", "Ogravesmall", "Oacutesmall", "Ocircumflexsmall",
+          "Otildesmall", "Odieresissmall", "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall", "Ucircumflexsmall", "Udieresissmall",
+          "Yacutesmall", "Thornsmall", "Ydieresissmall", "001.000", "001.001", "001.002", "001.003", "Black",
+          "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold",
+        ].freeze
+
+        # Code -> glyph name (nil: .notdef).
+        STANDARD_ENCODING = [
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quoteright",
+          "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash",
+          "zero", "one", "two", "three", "four", "five", "six", "seven",
+          "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question",
+          "at", "A", "B", "C", "D", "E", "F", "G",
+          "H", "I", "J", "K", "L", "M", "N", "O",
+          "P", "Q", "R", "S", "T", "U", "V", "W",
+          "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore",
+          "quoteleft", "a", "b", "c", "d", "e", "f", "g",
+          "h", "i", "j", "k", "l", "m", "n", "o",
+          "p", "q", "r", "s", "t", "u", "v", "w",
+          "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, "exclamdown", "cent", "sterling", "fraction", "yen", "florin", "section",
+          "currency", "quotesingle", "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi", "fl",
+          nil, "endash", "dagger", "daggerdbl", "periodcentered", nil, "paragraph", "bullet",
+          "quotesinglbase", "quotedblbase", "quotedblright", "guillemotright", "ellipsis", "perthousand", nil, "questiondown",
+          nil, "grave", "acute", "circumflex", "tilde", "macron", "breve", "dotaccent",
+          "dieresis", nil, "ring", "cedilla", nil, "hungarumlaut", "ogonek", "caron",
+          "emdash", nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, "AE", nil, "ordfeminine", nil, nil, nil, nil,
+          "Lslash", "Oslash", "OE", "ordmasculine", nil, nil, nil, nil,
+          nil, "ae", nil, nil, nil, "dotlessi", nil, nil,
+          "lslash", "oslash", "oe", "germandbls", nil, nil, nil, nil,
+        ].freeze
+
+        MAC_ROMAN_ENCODING = [
+          "NUL", "Eth", "eth", "Lslash", "lslash", "Scaron", "scaron", "Yacute",
+          "yacute", "HT", "LF", "Thorn", "thorn", "CR", "Zcaron", "zcaron",
+          "DLE", "DC1", "DC2", "DC3", "DC4", "onehalf", "onequarter", "onesuperior",
+          "threequarters", "threesuperior", "twosuperior", "brokenbar", "minus", "multiply", "RS", "US",
+          "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quotesingle",
+          "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash",
+          "zero", "one", "two", "three", "four", "five", "six", "seven",
+          "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question",
+          "at", "A", "B", "C", "D", "E", "F", "G",
+          "H", "I", "J", "K", "L", "M", "N", "O",
+          "P", "Q", "R", "S", "T", "U", "V", "W",
+          "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore",
+          "grave", "a", "b", "c", "d", "e", "f", "g",
+          "h", "i", "j", "k", "l", "m", "n", "o",
+          "p", "q", "r", "s", "t", "u", "v", "w",
+          "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "DEL",
+          "Adieresis", "Aring", "Ccedilla", "Eacute", "Ntilde", "Odieresis", "Udieresis", "aacute",
+          "agrave", "acircumflex", "adieresis", "atilde", "aring", "ccedilla", "eacute", "egrave",
+          "ecircumflex", "edieresis", "iacute", "igrave", "icircumflex", "idieresis", "ntilde", "oacute",
+          "ograve", "ocircumflex", "odieresis", "otilde", "uacute", "ugrave", "ucircumflex", "udieresis",
+          "dagger", "degree", "cent", "sterling", "section", "bullet", "paragraph", "germandbls",
+          "registered", "copyright", "trademark", "acute", "dieresis", "notequal", "AE", "Oslash",
+          "infinity", "plusminus", "lessequal", "greaterequal", "yen", "mu", "partialdiff", "summation",
+          "product", "pi", "integral", "ordfeminine", "ordmasculine", "Omega", "ae", "oslash",
+          "questiondown", "exclamdown", "logicalnot", "radical", "florin", "approxequal", "Delta", "guillemotleft",
+          "guillemotright", "ellipsis", "nbspace", "Agrave", "Atilde", "Otilde", "OE", "oe",
+          "endash", "emdash", "quotedblleft", "quotedblright", "quoteleft", "quoteright", "divide", "lozenge",
+          "ydieresis", "Ydieresis", "fraction", "currency", "guilsinglleft", "guilsinglright", "fi", "fl",
+          "daggerdbl", "periodcentered", "quotesinglbase", "quotedblbase", "perthousand", "Acircumflex", "Ecircumflex", "Aacute",
+          "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex",
+          "apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave", "dotlessi", "circumflex", "tilde",
+          "macron", "breve", "dotaccent", "ring", "cedilla", "hungarumlaut", "ogonek", "caron",
+        ].freeze
+
+        WIN_ANSI_ENCODING = [
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          nil, nil, nil, nil, nil, nil, nil, nil,
+          "space", "exclam", "quotedbl", "numbersign", "dollar", "percent", "ampersand", "quotesingle",
+          "parenleft", "parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash",
+          "zero", "one", "two", "three", "four", "five", "six", "seven",
+          "eight", "nine", "colon", "semicolon", "less", "equal", "greater", "question",
+          "at", "A", "B", "C", "D", "E", "F", "G",
+          "H", "I", "J", "K", "L", "M", "N", "O",
+          "P", "Q", "R", "S", "T", "U", "V", "W",
+          "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum", "underscore",
+          "grave", "a", "b", "c", "d", "e", "f", "g",
+          "h", "i", "j", "k", "l", "m", "n", "o",
+          "p", "q", "r", "s", "t", "u", "v", "w",
+          "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "bullet",
+          "Euro", "bullet", "quotesinglbase", "florin", "quotedblbase", "ellipsis", "dagger", "daggerdbl",
+          "circumflex", "perthousand", "Scaron", "guilsinglleft", "OE", "bullet", "Zcaron", "bullet",
+          "bullet", "quoteleft", "quoteright", "quotedblleft", "quotedblright", "bullet", "endash", "emdash",
+          "tilde", "trademark", "scaron", "guilsinglright", "oe", "bullet", "zcaron", "Ydieresis",
+          "space", "exclamdown", "cent", "sterling", "currency", "yen", "brokenbar", "section",
+          "dieresis", "copyright", "ordfeminine", "guillemotleft", "logicalnot", "hyphen", "registered", "macron",
+          "degree", "plusminus", "uni00B2", "uni00B3", "acute", "mu", "paragraph", "periodcentered",
+          "cedilla", "uni00B9", "ordmasculine", "guillemotright", "onequarter", "onehalf", "threequarters", "questiondown",
+          "Agrave", "Aacute", "Acircumflex", "Atilde", "Adieresis", "Aring", "AE", "Ccedilla",
+          "Egrave", "Eacute", "Ecircumflex", "Edieresis", "Igrave", "Iacute", "Icircumflex", "Idieresis",
+          "Eth", "Ntilde", "Ograve", "Oacute", "Ocircumflex", "Otilde", "Odieresis", "multiply",
+          "Oslash", "Ugrave", "Uacute", "Ucircumflex", "Udieresis", "Yacute", "Thorn", "germandbls",
+          "agrave", "aacute", "acircumflex", "atilde", "adieresis", "aring", "ae", "ccedilla",
+          "egrave", "eacute", "ecircumflex", "edieresis", "igrave", "iacute", "icircumflex", "idieresis",
+          "eth", "ntilde", "ograve", "oacute", "ocircumflex", "otilde", "odieresis", "divide",
+          "oslash", "ugrave", "uacute", "ucircumflex", "udieresis", "yacute", "thorn", "ydieresis",
+        ].freeze
+
+        # Glyph name -> Unicode code point (Adobe Glyph List).
+        UNICODE = {
+          "A" => 0x0041, "AE" => 0x00C6, "Aacute" => 0x00C1, "Acircumflex" => 0x00C2, "Adieresis" => 0x00C4,
+          "Agrave" => 0x00C0, "Aring" => 0x00C5, "Atilde" => 0x00C3, "B" => 0x0042, "C" => 0x0043,
+          "Ccedilla" => 0x00C7, "D" => 0x0044, "Delta" => 0x2206, "E" => 0x0045, "Eacute" => 0x00C9,
+          "Ecircumflex" => 0x00CA, "Edieresis" => 0x00CB, "Egrave" => 0x00C8, "Eth" => 0x00D0, "Euro" => 0x20AC,
+          "F" => 0x0046, "G" => 0x0047, "H" => 0x0048, "I" => 0x0049, "Iacute" => 0x00CD,
+          "Icircumflex" => 0x00CE, "Idieresis" => 0x00CF, "Igrave" => 0x00CC, "J" => 0x004A, "K" => 0x004B,
+          "L" => 0x004C, "Lslash" => 0x0141, "M" => 0x004D, "N" => 0x004E, "Ntilde" => 0x00D1,
+          "O" => 0x004F, "OE" => 0x0152, "Oacute" => 0x00D3, "Ocircumflex" => 0x00D4, "Odieresis" => 0x00D6,
+          "Ograve" => 0x00D2, "Omega" => 0x2126, "Oslash" => 0x00D8, "Otilde" => 0x00D5, "P" => 0x0050,
+          "Q" => 0x0051, "R" => 0x0052, "S" => 0x0053, "Scaron" => 0x0160, "T" => 0x0054,
+          "Thorn" => 0x00DE, "U" => 0x0055, "Uacute" => 0x00DA, "Ucircumflex" => 0x00DB, "Udieresis" => 0x00DC,
+          "Ugrave" => 0x00D9, "V" => 0x0056, "W" => 0x0057, "X" => 0x0058, "Y" => 0x0059,
+          "Yacute" => 0x00DD, "Ydieresis" => 0x0178, "Z" => 0x005A, "Zcaron" => 0x017D, "a" => 0x0061,
+          "aacute" => 0x00E1, "acircumflex" => 0x00E2, "acute" => 0x00B4, "adieresis" => 0x00E4, "ae" => 0x00E6,
+          "agrave" => 0x00E0, "ampersand" => 0x0026, "approxequal" => 0x2248, "aring" => 0x00E5, "asciicircum" => 0x005E,
+          "asciitilde" => 0x007E, "asterisk" => 0x002A, "at" => 0x0040, "atilde" => 0x00E3, "b" => 0x0062,
+          "backslash" => 0x005C, "bar" => 0x007C, "braceleft" => 0x007B, "braceright" => 0x007D, "bracketleft" => 0x005B,
+          "bracketright" => 0x005D, "breve" => 0x02D8, "brokenbar" => 0x00A6, "bullet" => 0x2022, "c" => 0x0063,
+          "caron" => 0x02C7, "ccedilla" => 0x00E7, "cedilla" => 0x00B8, "cent" => 0x00A2, "circumflex" => 0x02C6,
+          "colon" => 0x003A, "comma" => 0x002C, "copyright" => 0x00A9, "currency" => 0x00A4, "d" => 0x0064,
+          "dagger" => 0x2020, "daggerdbl" => 0x2021, "degree" => 0x00B0, "dieresis" => 0x00A8, "divide" => 0x00F7,
+          "dollar" => 0x0024, "dotaccent" => 0x02D9, "dotlessi" => 0x0131, "e" => 0x0065, "eacute" => 0x00E9,
+          "ecircumflex" => 0x00EA, "edieresis" => 0x00EB, "egrave" => 0x00E8, "eight" => 0x0038, "ellipsis" => 0x2026,
+          "emdash" => 0x2014, "endash" => 0x2013, "equal" => 0x003D, "eth" => 0x00F0, "exclam" => 0x0021,
+          "exclamdown" => 0x00A1, "f" => 0x0066, "five" => 0x0035, "florin" => 0x0192, "four" => 0x0034,
+          "fraction" => 0x2044, "g" => 0x0067, "germandbls" => 0x00DF, "grave" => 0x0060, "greater" => 0x003E,
+          "greaterequal" => 0x2265, "guillemotleft" => 0x00AB, "guillemotright" => 0x00BB, "guilsinglleft" => 0x2039, "guilsinglright" => 0x203A,
+          "h" => 0x0068, "hungarumlaut" => 0x02DD, "hyphen" => 0x002D, "i" => 0x0069, "iacute" => 0x00ED,
+          "icircumflex" => 0x00EE, "idieresis" => 0x00EF, "igrave" => 0x00EC, "infinity" => 0x221E, "integral" => 0x222B,
+          "j" => 0x006A, "k" => 0x006B, "l" => 0x006C, "less" => 0x003C, "lessequal" => 0x2264,
+          "logicalnot" => 0x00AC, "lozenge" => 0x25CA, "lslash" => 0x0142, "m" => 0x006D, "macron" => 0x00AF,
+          "minus" => 0x2212, "mu" => 0x00B5, "multiply" => 0x00D7, "n" => 0x006E, "nine" => 0x0039,
+          "notequal" => 0x2260, "ntilde" => 0x00F1, "numbersign" => 0x0023, "o" => 0x006F, "oacute" => 0x00F3,
+          "ocircumflex" => 0x00F4, "odieresis" => 0x00F6, "oe" => 0x0153, "ogonek" => 0x02DB, "ograve" => 0x00F2,
+          "one" => 0x0031, "onehalf" => 0x00BD, "onequarter" => 0x00BC, "ordfeminine" => 0x00AA, "ordmasculine" => 0x00BA,
+          "oslash" => 0x00F8, "otilde" => 0x00F5, "p" => 0x0070, "paragraph" => 0x00B6, "parenleft" => 0x0028,
+          "parenright" => 0x0029, "partialdiff" => 0x2202, "percent" => 0x0025, "period" => 0x002E, "periodcentered" => 0x00B7,
+          "perthousand" => 0x2030, "pi" => 0x03C0, "plus" => 0x002B, "plusminus" => 0x00B1, "product" => 0x220F,
+          "q" => 0x0071, "question" => 0x003F, "questiondown" => 0x00BF, "quotedbl" => 0x0022, "quotedblbase" => 0x201E,
+          "quotedblleft" => 0x201C, "quotedblright" => 0x201D, "quoteleft" => 0x2018, "quoteright" => 0x2019, "quotesinglbase" => 0x201A,
+          "quotesingle" => 0x0027, "r" => 0x0072, "radical" => 0x221A, "registered" => 0x00AE, "ring" => 0x02DA,
+          "s" => 0x0073, "scaron" => 0x0161, "section" => 0x00A7, "semicolon" => 0x003B, "seven" => 0x0037,
+          "six" => 0x0036, "slash" => 0x002F, "space" => 0x0020, "sterling" => 0x00A3, "summation" => 0x2211,
+          "t" => 0x0074, "thorn" => 0x00FE, "three" => 0x0033, "threequarters" => 0x00BE, "tilde" => 0x02DC,
+          "trademark" => 0x2122, "two" => 0x0032, "u" => 0x0075, "uacute" => 0x00FA, "ucircumflex" => 0x00FB,
+          "udieresis" => 0x00FC, "ugrave" => 0x00F9, "underscore" => 0x005F, "uni00B2" => 0x00B2, "uni00B3" => 0x00B3,
+          "uni00B9" => 0x00B9, "v" => 0x0076, "w" => 0x0077, "x" => 0x0078, "y" => 0x0079,
+          "yacute" => 0x00FD, "ydieresis" => 0x00FF, "yen" => 0x00A5, "z" => 0x007A, "zcaron" => 0x017E,
+          "zero" => 0x0030,
+        }.freeze
+      end
+    end
+  end
+end

data/lib/qr_reader/formats/pdf/fonts.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+module QrReader
+  module Formats
+    module PDF
+      # A PDF font as drawing text in a barcode font needs it: the codes of
+      # a string, their widths, and the outline of each glyph (from the
+      # embedded font program) or its glyph procedure (Type 3). Fonts that
+      # are not embedded draw nothing.
+      #
+      # Only glyphs whose outlines are all right-angled polygons (see
+      # VectorRenderer.rectilinear?), as in barcode fonts, are returned by
+      # #glyph: ordinary text (with curves) never becomes part of a rendered
+      # code and costs only a lookup.
+      class Font
+        # Largest font program decoded.
+        PROGRAM_LIMIT = 1 << 24
+        # Most glyphs (outlines or procedures) prepared per font.
+        MAX_GLYPHS = 4096
+        IDENTITY = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0].freeze
+
+        # The Font of font dictionary +value+, or nil.
+        def self.load(doc, value)
+          dict = doc.dict_value(value)
+          dict ? new(doc, dict) : nil
+        rescue Error, *INTERNAL_ERRORS
+          nil
+        end
+
+        # Glyph space -> text space (Type 3: the FontMatrix).
+        attr_reader :matrix
+        # Resources of a Type 3 font's glyph procedures (nil: the page's).
+        attr_reader :resources
+
+        def initialize(doc, dict)
+          @doc = doc
+          @glyphs = {}
+          @matrix = IDENTITY
+          @widths = {}
+          @default_width = 0.0
+          @code_bytes = 1
+          case doc.resolve(dict[:Subtype])
+          when :Type3 then init_type3(dict)
+          when :Type0 then init_type0(dict)
+          else init_simple(dict)
+          end
+        end
+
+        def type3?
+          !@procs.nil?
+        end
+
+        # Yields code, width (text space, before the font size) and whether
+        # word spacing applies, for each character code of +string+.
+        def each_code(string)
+          if @ranges
+            pos = 0
+            while pos < string.bytesize
+              code, length = split(string, pos)
+              yield code, width(code), length == 1 && code == 32
+              pos += length
+            end
+          elsif @code_bytes == 2
+            pos = 0
+            while pos + 1 < string.bytesize
+              code = (string.getbyte(pos) << 8) | string.getbyte(pos + 1)
+              yield code, width(code), false
+              pos += 2
+            end
+          else
+            string.each_byte { |code| yield code, width(code), code == 32 }
+          end
+        end
+
+        # Outline of +code+ in text space (closed flat polygons) when it is
+        # made of module-like shapes, else nil.
+        def glyph(code)
+          return @glyphs[code] if @glyphs.key?(code)
+          return nil if @glyphs.size >= MAX_GLYPHS
+
+          @glyphs[code] = begin
+            polys = outline(code)
+            if polys && !polys.empty? && polys.all? { |p| VectorRenderer.rectilinear?(p) }
+              a, b, c, d, e, f = @matrix
+              polys.map do |p|
+                q = Array.new(p.size)
+                i = 0
+                while i < p.size
+                  x = p[i]
+                  y = p[i + 1]
+                  q[i] = a * x + c * y + e
+                  q[i + 1] = b * x + d * y + f
+                  i += 2
+                end
+                q
+              end
+            end
+          rescue Error, *INTERNAL_ERRORS
+            nil
+          end
+        end
+
+        # Decoded content of the Type 3 glyph procedure of +code+, or nil.
+        def procedure(code)
+          return nil unless @procs
+          return @glyphs[code] if @glyphs.key?(code)
+          return nil if @glyphs.size >= MAX_GLYPHS
+
+          name = @names[code]
+          stream = name && @doc.resolve(@procs[name])
+          @glyphs[code] = stream.is_a?(Stream) ? @doc.content(stream) : nil
+        end
+
+        private
+
+        def value(dict, key)
+          @doc.resolve(dict[key])
+        end
+
+        def number(v)
+          Util.number(@doc.resolve(v))
+        end
+
+        # Widths of composite fonts are by CID.
+        def width(code)
+          @widths.fetch(@cids ? cid_for(code) : code, @default_width)
+        end
+
+        # --- Simple fonts (Type1, MMType1, TrueType) ------------------------
+
+        def init_simple(dict)
+          descriptor = @doc.dict_value(dict[:FontDescriptor]) || {}
+          @program, @kind = program(descriptor)
+          @names = encoding(dict)
+          @symbolic = ((Util.int(value(descriptor, :Flags)) || 0) & 4) != 0
+          read_simple_widths(dict, descriptor, 0.001)
+          @matrix = program_matrix
+        end
+
+        def read_simple_widths(dict, descriptor, scale)
+          first = Util.int(value(dict, :FirstChar)) || 0
+          widths = value(dict, :Widths)
+          if widths.is_a?(Array)
+            widths.first(256).each_with_index do |w, i|
+              w = number(w)
+              @widths[first + i] = w * scale if w
+            end
+          end
+          missing = number(value(descriptor, :MissingWidth))
+          @default_width = missing ? missing * scale : 0.0
+        end
+
+        # [program, kind] from a FontDescriptor (nil when not embedded).
+        def program(descriptor)
+          %i[FontFile FontFile2 FontFile3].each do |key|
+            stream = value(descriptor, key)
+            next unless stream.is_a?(Stream)
+
+            data = @doc.decode_stream(stream, PROGRAM_LIMIT)
+            return parse_program(data, stream.dict)
+          end
+          [nil, nil]
+        rescue Error, *INTERNAL_ERRORS
+          [nil, nil]
+        end
+
+        def parse_program(data, dict)
+          head = data.byteslice(0, 4)
+          if ["\x00\x01\x00\x00".b, "true", "OTTO"].include?(head)
+            [FontPrograms::TrueType.new(data), :truetype]
+          elsif data.start_with?("%!") || data.getbyte(0) == 0x80
+            data, clear = pfb(data)
+            [FontPrograms::Type1.new(data, clear || Util.int(@doc.resolve(dict[:Length1]))), :type1]
+          else
+            [FontPrograms::CFF.new(data), :cff]
+          end
+        end
+
+        # PFB segments joined; [data, length of the clear-text part].
+        def pfb(data)
+          return [data, nil] unless data.getbyte(0) == 0x80
+
+          out = String.new(encoding: Encoding::BINARY)
+          clear = nil
+          pos = 0
+          while data.getbyte(pos) == 0x80 && [1, 2].include?(data.getbyte(pos + 1))
+            length = data.byteslice(pos + 2, 4).unpack1("V")
+            out << data.byteslice(pos + 6, length).to_s
+            clear ||= out.bytesize
+            pos += 6 + length
+          end
+          [out, clear]
+        end
+
+        def program_matrix
+          upem = @program.respond_to?(:units_per_em) && !@program.cff ? @program.units_per_em : nil
+          return [1.0 / upem, 0.0, 0.0, 1.0 / upem, 0.0, 0.0] if upem
+
+          cff = @program.respond_to?(:cff) ? @program.cff : @program
+          m = cff.respond_to?(:font_matrix) ? cff.font_matrix : nil
+          m.is_a?(Array) && m.size == 6 && m.all?(Numeric) ? m.map(&:to_f) : [0.001, 0.0, 0.0, 0.001, 0.0, 0.0]
+        end
+
+        # code -> glyph name from /Encoding (Differences over a base
+        # encoding over the font program's own).
+        def encoding(dict)
+          names = Array.new(256)
+          builtin = @program.is_a?(FontPrograms::Type1) ? @program.encoding : nil
+          case builtin
+          when :standard then FontTables::STANDARD_ENCODING.each_with_index { |name, code| names[code] = name }
+          when Hash then builtin.each { |code, name| names[code] = name if code < 256 }
+          end
+          enc = value(dict, :Encoding)
+          base = enc.is_a?(Hash) ? value(enc, :BaseEncoding) : enc
+          if (table = base_table(base))
+            table.each_with_index { |name, code| names[code] = name if name }
+          end
+          if enc.is_a?(Hash) && (diffs = value(enc, :Differences)).is_a?(Array)
+            code = 0
+            diffs.each do |item|
+              item = @doc.resolve(item)
+              case item
+              when Integer then code = item
+              when Symbol
+                names[code] = item.to_s if code.between?(0, 255)
+                code += 1
+              end
+            end
+          end
+          names
+        end
+
+        def base_table(name)
+          case name
+          when :WinAnsiEncoding then FontTables::WIN_ANSI_ENCODING
+          when :MacRomanEncoding then FontTables::MAC_ROMAN_ENCODING
+          when :StandardEncoding then FontTables::STANDARD_ENCODING
+          end
+        end
+
+        # Glyph outline of +code+ in glyph space.
+        def outline(code)
+          return nil unless @program
+
+          if @cid_font
+            gid = cid_gid(cid_for(code)) or return nil
+            return @program.outline(gid)
+          end
+          name = @names[code]
+          case @kind
+          when :type1
+            @program.outline(name) if name
+          when :cff
+            gid = (name && @program.gid_for_name(name)) || @program.gid_for_code(code)
+            gid ? @program.outline(gid) : nil
+          when :truetype
+            gid = truetype_gid(code, name) or return nil
+            @program.outline(gid)
+          end
+        end
+
+        def truetype_gid(code, name)
+          tt = @program
+          if @symbolic || !name
+            [code, 0xF000 | code, 0xF100 | code, 0xF200 | code].each do |c|
+              gid = tt.lookup(3, 0, c) and return gid
+            end
+            gid = tt.lookup(1, 0, code) and return gid
+          end
+          if name
+            unicode = FontTables::UNICODE[name] || name[/\Auni(\h{4})\z/, 1]&.hex || name[/\Au(\h{4,6})\z/, 1]&.hex
+            gid = unicode && tt.lookup(3, 1, unicode) and return gid
+            gid = tt.cff&.gid_for_name(name) and return gid
+          end
+          gid = tt.lookup(3, 1, code) and return gid
+          code.positive? && code < tt.glyph_count ? code : nil
+        end
+
+        # --- Type 3 ---------------------------------------------------------
+
+        def init_type3(dict)
+          m = value(dict, :FontMatrix)
+          m = m.map { |v| number(v) } if m.is_a?(Array)
+          @matrix = m.is_a?(Array) && m.size == 6 && m.none?(&:nil?) ? m : [0.001, 0.0, 0.0, 0.001, 0.0, 0.0]
+          @procs = @doc.dict_value(dict[:CharProcs]) || {}
+          @resources = dict[:Resources]
+          @names = Array.new(256)
+          enc = @doc.dict_value(dict[:Encoding])
+          if enc && (diffs = value(enc, :Differences)).is_a?(Array)
+            code = 0
+            diffs.each do |item|
+              item = @doc.resolve(item)
+              case item
+              when Integer then code = item
+              when Symbol
+                @names[code] = item if code.between?(0, 255)
+                code += 1
+              end
+            end
+          end
+          # Widths are in glyph space.
+          read_simple_widths(dict, {}, @matrix[0])
+        end
+
+        # --- Type 0 (composite) ---------------------------------------------
+
+        def init_type0(dict)
+          descendant = value(dict, :DescendantFonts)
+          cid = @doc.dict_value(descendant.is_a?(Array) ? descendant.first : descendant) || {}
+          descriptor = @doc.dict_value(cid[:FontDescriptor]) || {}
+          @program, @kind = program(descriptor)
+          @cid_font = true
+          @matrix = @program ? program_matrix : IDENTITY
+          read_cmap(value(dict, :Encoding))
+          map = value(cid, :CIDToGIDMap)
+          @cid_to_gid = map.is_a?(Stream) ? @doc.decode_stream(map, 1 << 18) : nil
+          read_cid_widths(cid)
+        end
+
+        # Identity-H/V and other predefined CMaps: 2-byte codes, CID = code;
+        # embedded CMaps: their code space and CID ranges.
+        def read_cmap(enc)
+          @code_bytes = 2
+          return unless enc.is_a?(Stream)
+
+          text = @doc.decode_stream(enc, 1 << 20)
+          @ranges = []
+          text.scan(/begincodespacerange(.*?)endcodespacerange/m) do |(body)|
+            body.scan(/<(\h+)>\s*<(\h+)>/) { |lo, hi| @ranges << [lo.size / 2, lo.hex, hi.hex] if lo.size == hi.size }
+          end
+          @ranges = nil if @ranges.empty?
+          @cids = []
+          text.scan(/begincidrange(.*?)endcidrange/m) do |(body)|
+            body.scan(/<(\h+)>\s*<(\h+)>\s*(\d+)/) { |lo, hi, cid| @cids << [lo.hex, hi.hex, cid.to_i] }
+          end
+          text.scan(/begincidchar(.*?)endcidchar/m) do |(body)|
+            body.scan(/<(\h+)>\s*(\d+)/) { |c, cid| @cids << [c.hex, c.hex, cid.to_i] }
+          end
+          @cids = nil if @cids.empty?
+        end
+
+        # [code, length] of the code at +pos+ (code space ranges).
+        def split(string, pos)
+          (1..4).each do |n|
+            break if pos + n > string.bytesize
+
+            code = 0
+            n.times { |i| code = (code << 8) | string.getbyte(pos + i) }
+            return [code, n] if @ranges.any? { |len, lo, hi| len == n && code.between?(lo, hi) }
+          end
+          [string.getbyte(pos), 1]
+        end
+
+        def cid_for(code)
+          return code unless @cids
+
+          @cids.each { |lo, hi, cid| return cid + code - lo if code.between?(lo, hi) }
+          0
+        end
+
+        def cid_gid(cid)
+          if @cid_to_gid
+            return nil if 2 * cid + 1 >= @cid_to_gid.bytesize
+
+            return (@cid_to_gid.getbyte(2 * cid) << 8) | @cid_to_gid.getbyte(2 * cid + 1)
+          end
+          if @kind == :cff && @program.cid?
+            @program.gid_for_cid(cid)
+          elsif @program.is_a?(FontPrograms::TrueType) && @program.cff&.cid?
+            @program.cff.gid_for_cid(cid)
+          else
+            cid
+          end
+        end
+
+        def read_cid_widths(cid)
+          dw = number(value(cid, :DW))
+          @default_width = (dw || 1000.0) * 0.001
+          w = value(cid, :W)
+          return unless w.is_a?(Array)
+
+          i = 0
+          entries = 0
+          while i < w.size && entries < 65_536
+            first = Util.int(@doc.resolve(w[i]))
+            nxt = @doc.resolve(w[i + 1])
+            break unless first
+
+            if nxt.is_a?(Array)
+              nxt.each_with_index do |v, j|
+                v = number(v)
+                @widths[first + j] = v * 0.001 if v
+                entries += 1
+              end
+              i += 2
+            else
+              last = Util.int(nxt)
+              v = number(w[i + 2])
+              break unless last && v
+
+              (first..[last, first + 65_536].min).each { |c| @widths[c] = v * 0.001 }
+              entries += last - first + 1
+              i += 3
+            end
+          end
+        end
+      end
+
+      private_constant :Font, :FontPrograms, :FontTables
+    end
+  end
+end