fontisan 0.2.12 → 0.2.13

data/lib/fontisan/font_loader.rb

@@ -60,7 +60,7 @@ module Fontisan
 
       # Check for Type 1 format first (PFB/PFA have different signatures)
       if type1_font?(path)
-        return Type1Font.from_file(path)
+        return Type1Font.from_file(path, mode: resolved_mode)
       end
 
       File.open(path, "rb") do |io|

data/lib/fontisan/hints/hint_converter.rb

@@ -274,7 +274,10 @@ module Fontisan
                      end
 
         # Merge all extracted hints (prep_hints and fpgm_hints override stem widths if present)
-        hints.merge!(prep_hints).merge!(fpgm_hints).merge!(blue_zones)
+        # Note: fpgm_hints contains metadata (fpgm_size, has_functions, complexity)
+        # which we must filter out before merging into PostScript dict hints
+        fpgm_dict_hints = fpgm_hints.reject { |k, _| %i[fpgm_size has_functions complexity].include?(k) }
+        hints.merge!(prep_hints).merge!(fpgm_dict_hints).merge!(blue_zones)
 
         # Provide default blue_values if none were detected
         # These are standard values that work for most Latin fonts

data/lib/fontisan/type1/cff_to_type1_converter.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # Converter for CFF CharStrings to Type 1 CharStrings
+    #
+    # [`CffToType1Converter`](lib/fontisan/type1/cff_to_type1_converter.rb) converts
+    # CFF (Compact Font Format) Type 2 CharStrings to Type 1 CharStrings.
+    #
+    # CFF and Type 1 use similar stack-based languages but have different operator
+    # codes and some structural differences:
+    # - Operator codes differ between formats
+    # - Type 1 uses hsbw/sbw for width selection; CFF uses initial operand
+    # - Hint operators need to be preserved with code translation
+    #
+    # @example Convert a CFF CharString to Type 1
+    #   converter = Fontisan::Type1::CffToType1Converter.new
+    #   type1_charstring = converter.convert(cff_charstring)
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+    # @see https://www.microsoft.com/typography/otspec/cff.htm
+    class CffToType1Converter
+      # CFF to Type 1 operator mapping
+      #
+      # Maps CFF operator codes to Type 1 operator codes.
+      # Most operators are the same, but some differ.
+      CFF_TO_TYPE1 = {
+        # Path construction operators
+        hmoveto: 22,      # CFF: 22, Type 1: 22
+        vmoveto: 4,       # CFF: 4, Type 1: 4
+        rlineto: 5,       # CFF: 5, Type 1: 5
+        hlineto: 6,       # CFF: 6, Type 1: 6
+        vlineto: 7,       # CFF: 7, Type 1: 7
+        rrcurveto: 8,     # CFF: 8, Type 1: 8
+        hhcurveto: 27,    # CFF: 27, Type 1: 27
+        hvcurveto: 31,    # CFF: 31, Type 1: 31
+        vhcurveto: 30,    # CFF: 30, Type 1: 30
+        rcurveline: 24,   # CFF: 24, Type 1: 24
+        rlinecurve: 25,   # CFF: 25, Type 1: 25
+
+        # Hint operators
+        hstem: 1,         # CFF: 1, Type 1: 1
+        vstem: 3,         # CFF: 3, Type 1: 3
+        hstemhm: 18,      # CFF: 18, Type 1: 18
+        vstemhm: 23,      # CFF: 23, Type 1: 23
+
+        # Hint substitution (preserve for compatibility)
+        hintmask: 19,     # CFF: 19, Type 1: Not supported (skip)
+        cntrmask: 20,     # CFF: 20, Type 1: Not supported (skip)
+
+        # End char
+        endchar: 14,      # CFF: 14, Type 1: 14
+
+        # Miscellaneous
+        callsubr: 10,     # CFF: 10, Type 1: 10
+        return: 11,       # CFF: 11, Type 1: 11
+        rmoveto: 21,      # CFF: 21, Type 1: 21
+      }.freeze
+
+      # Escape code for two-byte operators
+      ESCAPE_BYTE = 12
+
+      # Initialize a new CffToType1Converter
+      #
+      # @param nominal_width [Integer] Nominal width from CFF Private dict (default: 0)
+      # @param default_width [Integer] Default width from CFF Private dict (default: 0)
+      def initialize(nominal_width: 0, default_width: 0)
+        @nominal_width = nominal_width
+        @default_width = default_width
+      end
+
+      # Convert CFF CharString to Type 1 CharString
+      #
+      # Takes binary CFF CharString data and converts it to Type 1 format.
+      #
+      # @param cff_charstring [String] CFF CharString bytecode
+      # @param private_dict [Hash] CFF Private dict for context (optional)
+      # @return [String] Type 1 CharString bytecode
+      #
+      # @example Convert a CharString
+      #   converter = Fontisan::Type1::CffToType1Converter.new
+      #   type1_bytes = converter.convert(cff_bytes)
+      def convert(cff_charstring, private_dict: {})
+        # Parse CFF CharString into operations
+        parser = Tables::Cff::CharStringParser.new(cff_charstring,
+                                                       stem_count: private_dict[:stem_count]&.to_i || 0)
+        operations = parser.parse
+
+        # Extract width from operations (CFF spec: odd stack before first move = width)
+        width = extract_width(operations)
+
+        # Convert operations to Type 1 format
+        convert_operations(operations, width)
+      end
+
+      # Extract width from CFF operations
+      #
+      # In CFF, if there's an odd number of arguments before the first move
+      # operator (rmoveto, hmoveto, vmoveto, rcurveline, rrcurveline, vvcurveto,
+      # hhcurveto), the first argument is the width.
+      #
+      # @param operations [Array<Hash>] Parsed CFF operations
+      # @return [Integer, nil] Width value or nil if using default
+      def extract_width(operations)
+        return @default_width if operations.empty?
+
+        # Find first move operator
+        first_move_idx = operations.index do |op|
+          %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto hhcurveto].include?(op[:name])
+        end
+
+        return @default_width unless first_move_idx
+
+        # Count operands before first move
+        operand_count = operations[0...first_move_idx].sum(0) do |op|
+          op[:operands]&.length || 0
+        end
+
+        # If odd, first operand of first move is width
+        if operand_count.odd?
+          first_move = operations[first_move_idx]
+          if first_move[:operands] && !first_move[:operands].empty?
+            return first_move[:operands].first
+          end
+        end
+
+        @default_width
+      end
+
+      # Convert parsed CFF operations to Type 1 CharString
+      #
+      # @param operations [Array<Hash>] Parsed CFF operations
+      # @param width [Integer, nil] Glyph width from CFF CharString
+      # @return [String] Type 1 CharString bytecode
+      def convert_operations(operations, width = nil)
+        result = String.new(encoding: Encoding::ASCII_8BIT)
+
+        # Determine width: use provided width or default/nominal
+        glyph_width = width || @default_width
+
+        # Add hsbw (horizontal sidebearing and width) at start
+        # This is the standard width operator for horizontal fonts
+        result << encode_number(0)  # left sidebearing (usually 0 for CFF)
+        result << encode_number(glyph_width)
+        result << ESCAPE_BYTE
+        result << 34  # hsbw operator (two-byte: 12 34)
+
+        x = 0
+        y = 0
+        first_move = true
+        skip_first_operand = false
+
+        # Check if width was extracted (odd stack before first move)
+        if width && operations.any?
+          # Count operands before first move to determine if width was in stack
+          first_move_idx = operations.index do |op|
+            %i[rmoveto hmoveto vmoveto rcurveline rrcurveline vvcurveto hhcurveto].include?(op[:name])
+          end
+
+          if first_move_idx
+            operand_count = operations[0...first_move_idx].sum(0) do |op|
+              op[:operands]&.length || 0
+            end
+
+            skip_first_operand = operand_count.odd?
+          end
+        end
+
+        operations.each do |op|
+          case op[:name]
+          when :hstem, :vstem, :hstemhm, :vstemhm
+            # Hint operators - preserve
+            op[:operands].each { |val| result << encode_number(val) }
+            result << CFF_TO_TYPE1[op[:name]]
+          when :rmoveto
+            # rmoveto dx dy (or width dx dy if first move with odd stack)
+            operands = op[:operands]
+            if first_move && skip_first_operand && !operands.empty?
+              # Skip first operand (it was the width)
+              operands = operands[1..]
+              skip_first_operand = false
+            end
+
+            if operands.length >= 2
+              dx, dy = operands[0], operands[1]
+              x += dx
+              y += dy
+              result << encode_number(dx)
+              result << encode_number(dy)
+              result << 21  # rmoveto
+            elsif operands.length == 1
+              # Only dy (hmoveto/vmoveto style)
+              result << encode_number(operands.first)
+              result << 4  # vmoveto (closest approximation)
+            end
+            first_move = false
+          when :hmoveto
+            # hmoveto dx (or width dx if first move)
+            operands = op[:operands]
+            if first_move && skip_first_operand && !operands.empty?
+              operands = [operands[0]] if operands.length > 1
+              skip_first_operand = false
+            end
+
+            dx = operands.first
+            x += dx if dx
+            result << encode_number(dx)
+            result << 22  # hmoveto
+            first_move = false
+          when :vmoveto
+            # vmoveto dy
+            dy = op[:operands].first
+            y += dy if dy
+            result << encode_number(dy)
+            result << 4  # vmoveto
+            first_move = false
+          when :rlineto
+            # rlineto dx dy
+            dx, dy = op[:operands]
+            x += dx
+            y += dy
+            result << encode_number(dx)
+            result << encode_number(dy)
+            result << 5  # rlineto
+            first_move = false
+          when :hlineto
+            # hlineto dx
+            dx = op[:operands].first
+            x += dx
+            result << encode_number(dx)
+            result << 6  # hlineto
+            first_move = false
+          when :vlineto
+            # vlineto dy
+            dy = op[:operands].first
+            y += dy
+            result << encode_number(dy)
+            result << 7  # vlineto
+            first_move = false
+          when :rrcurveto
+            # rrcurveto dx1 dy1 dx2 dy2 dx3 dy3
+            dx1, dy1, dx2, dy2, dx3, dy3 = op[:operands]
+            x += dx1 + dx2 + dx3
+            y += dy1 + dy2 + dy3
+            [dx1, dy1, dx2, dy2, dx3, dy3].each { |val| result << encode_number(val) }
+            result << 8  # rrcurveto
+            first_move = false
+          when :hhcurveto, :hvcurveto, :vhcurveto
+            # Flexible curve operators
+            op[:operands].each { |val| result << encode_number(val) }
+            result << CFF_TO_TYPE1[op[:name]]
+            first_move = false
+          when :rcurveline, :rlinecurve
+            # Flexible curve operators
+            op[:operands].each { |val| result << encode_number(val) }
+            result << CFF_TO_TYPE1[op[:name]]
+            first_move = false
+          when :callsubr, :return, :endchar
+            # Control operators
+            result << CFF_TO_TYPE1[op[:name]]
+            first_move = false
+          when :hintmask, :cntrmask
+            # Hint mask operators - Type 1 doesn't support these
+            # Skip them
+            first_move = false
+          when :shortint
+            # Short integer push - handled by operand encoding
+            first_move = false
+          else
+            # Unknown operator - skip
+            first_move = false
+          end
+        end
+
+        # Add endchar
+        result << 14
+
+        result
+      end
+
+      private
+
+      # Encode integer for Type 1 CharString
+      #
+      # Type 1 CharStrings use a variable-length integer encoding:
+      # - Numbers from -107 to 107: single byte (byte + 139)
+      # - Larger numbers: escaped with 255, then 2-byte value
+      #
+      # @param num [Integer] Number to encode
+      # @return [String] Encoded bytes
+      def encode_number(num)
+        if num >= -107 && num <= 107
+          [num + 139].pack("C")
+        else
+          # Use escape sequence (255) followed by 2-byte signed integer
+          num += 32768 if num < 0
+          [255, num % 256, num >> 8].pack("C*")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/type1/font_dictionary.rb

@@ -137,6 +137,34 @@ module Fontisan
         @raw_data[key]
       end
 
+      # Convert FontDictionary to Type 1 text format
+      #
+      # Generates the PostScript code for the Font Dictionary section
+      # of a Type 1 font.
+      #
+      # @return [String] Type 1 Font Dictionary text
+      #
+      # @example Generate Type 1 format
+      #   dict = FontDictionary.new
+      #   puts dict.to_type1_format
+      def to_type1_format
+        result = []
+        result << "% Type 1 Font Dictionary"
+        result << "12 dict begin"
+        result << ""
+        result << "/FontType 1 def"
+        result << "/PaintType #{@paint_type} def"
+        result << font_matrix_to_type1
+        result << font_bbox_to_type1
+        result << ""
+        result << font_info_to_type1
+        result << ""
+        result << "currentdict end"
+        result << "/FontName #{@font_name} def"
+
+        result.join("\n")
+      end
+
       private
 
       # Extract font dictionary from data
@@ -270,6 +298,40 @@ module Fontisan
         @font_type = @raw_data[:font_type] || 1
       end
 
+      # Format FontMatrix for Type 1 output
+      #
+      # @return [String] Formatted FontMatrix definition
+      def font_matrix_to_type1
+        "/FontMatrix [#{@font_matrix.join(' ')}] def"
+      end
+
+      # Format FontBBox for Type 1 output
+      #
+      # @return [String] Formatted FontBBox definition
+      def font_bbox_to_type1
+        "/FontBBox {#{@font_b_box.join(' ')}} def"
+      end
+
+      # Format FontInfo for Type 1 output
+      #
+      # @return [String] Formatted FontInfo definitions
+      def font_info_to_type1
+        info = @font_info
+        result = []
+        result << "/FullName (#{info.full_name || 'Untitled'}) readonly def" if info.full_name
+        result << "/FamilyName (#{info.family_name || 'Untitled'}) readonly def" if info.family_name
+        result << "/version (#{info.version || '001.000'}) readonly def" if info.version
+        result << "/Copyright (#{info.copyright || ''}) readonly def" if info.copyright
+        result << "/Notice (#{info.notice || ''}) readonly def" if info.notice
+        result << "/Weight (#{info.weight || 'Medium'}) readonly def" if info.weight
+        result << "/isFixedPitch #{info.is_fixed_pitch || false} def" if info.is_fixed_pitch
+        result << "/UnderlinePosition #{info.underline_position || -100} def" if info.underline_position
+        result << "/UnderlineThickness #{info.underline_thickness || 50} def" if info.underline_thickness
+        result << "/ItalicAngle #{info.italic_angle || 0} def" if info.italic_angle
+
+        result.join("\n")
+      end
+
       # FontInfo sub-dictionary
       #
       # Contains font metadata such as FullName, FamilyName, version, etc.

data/lib/fontisan/type1/pfa_generator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "pfb_generator"
+require_relative "decryptor"
 
 module Fontisan
   module Type1
@@ -220,17 +221,20 @@ module Fontisan
                         generate_simple_charstrings
                       end
 
-        # Combine all charstrings
-        binary_data = charstrings.values.join
+        # Build CharStrings dictionary text
+        charstrings_dict = build_charstrings_dict_text(charstrings)
 
-        # Convert to hex representation
+        # Encrypt with eexec
+        encrypted_data = Decryptor.eexec_encrypt(charstrings_dict)
+
+        # Convert encrypted data to hex representation
         hex_lines = []
 
         # Start hex section marker
         hex_lines << "00" # Start binary data marker
 
-        # Encode binary data as hex with line breaks
-        hex_string = binary_data.bytes.map { |b| format("%02x", b) }.join
+        # Encode encrypted data as hex with line breaks
+        hex_string = encrypted_data.bytes.map { |b| format("%02x", b) }.join
 
         # Split into lines of HEX_LINE_LENGTH characters
         hex_string.scan(/.{#{HEX_LINE_LENGTH}}/o) do |line|
@@ -243,6 +247,28 @@ module Fontisan
         hex_lines
       end
 
+      # Build CharStrings dictionary text for eexec encryption
+      #
+      # @param charstrings [Hash] Glyph ID to CharString mapping
+      # @return [String] CharStrings dictionary text
+      def build_charstrings_dict_text(charstrings)
+        lines = []
+        lines << "dup /FontName get exch definefont pop"
+        lines << "begin"
+        lines << "/CharStrings #{charstrings.size} dict dup begin"
+
+        charstrings.each do |gid, charstring|
+          # Convert charstring bytes to hex representation for PostScript
+          hex_data = charstring.unpack1("H*")
+          lines << "#{gid} #{charstring.bytesize} #{hex_data} RD"
+        end
+
+        lines << "end"
+        lines << "end"
+        lines << "put"
+        lines.join("\n")
+      end
+
       # Generate simple CharStrings (without curve conversion)
       #
       # @return [Hash<Integer, String>] Glyph ID to CharString mapping

data/lib/fontisan/type1/pfa_parser.rb

@@ -36,12 +36,18 @@ module Fontisan
       # @return [String] Encrypted portion as hex string
       attr_reader :encrypted_hex
 
+      # @return [String] Encrypted portion as binary data
+      attr_reader :encrypted_binary
+
       # @return [String] Trailing text after zeros (if any)
       attr_reader :trailing_text
 
       # Parse PFA format data
       #
-      # @param data [String] ASCII PFA data
+      # Handles both standard PFA (hex-encoded encrypted data with zero marker)
+      # and .t1 format (binary encrypted data without zero marker).
+      #
+      # @param data [String] ASCII PFA data or .t1 format data
       # @return [PFAParser] Self for method chaining
       # @raise [ArgumentError] If data is nil or empty
       # @raise [Fontisan::Error] If PFA format is invalid
@@ -58,6 +64,7 @@ module Fontisan
           # No eexec marker - entire file is clear text
           @clear_text = data
           @encrypted_hex = ""
+          @encrypted_binary = ""
           @trailing_text = ""
           return self
         end
@@ -72,25 +79,31 @@ module Fontisan
         encrypted_start = skip_whitespace(after_eexec, 0)
         encrypted_data = after_eexec[encrypted_start..]
 
-        # Find zero marker
+        # Find zero marker (optional for .t1 format)
         zero_index = encrypted_data.index(ZERO_MARKER)
-        if zero_index.nil?
-          raise Fontisan::Error,
-                "Invalid PFA: cannot find zero marker after eexec"
-        end
 
-        # Extract encrypted hex data (before zeros)
-        @encrypted_hex = encrypted_data[0...zero_index].strip
-
-        # Extract trailing text (after zeros)
-        trailing_start = zero_index + ZERO_MARKER.length
-        trailing_start = skip_whitespace(encrypted_data, trailing_start)
-
-        @trailing_text = if trailing_start < encrypted_data.length
-                           encrypted_data[trailing_start..]
-                         else
-                           ""
-                         end
+        if zero_index
+          # Standard PFA format with zero marker
+          # Extract encrypted hex data (before zeros)
+          @encrypted_hex = encrypted_data[0...zero_index].strip
+          @encrypted_binary = [@encrypted_hex.gsub(/\s/, "")].pack("H*")
+
+          # Extract trailing text (after zeros)
+          trailing_start = zero_index + ZERO_MARKER.length
+          trailing_start = skip_whitespace(encrypted_data, trailing_start)
+
+          @trailing_text = if trailing_start < encrypted_data.length
+                             encrypted_data[trailing_start..]
+                           else
+                             ""
+                           end
+        else
+          # .t1 format - binary encrypted data without zero marker
+          # Treat everything after eexec as binary encrypted data
+          @encrypted_binary = encrypted_data.lstrip
+          @encrypted_hex = @encrypted_binary.unpack1("H*")
+          @trailing_text = ""
+        end
 
         self
       end
@@ -120,18 +133,6 @@ module Fontisan
           data.include?("%!PS-Adobe-3.0 Resource-Font")
       end
 
-      # Get encrypted hex as binary data
-      #
-      # Decodes the hexadecimal encrypted portion to binary.
-      #
-      # @return [String] Binary encrypted data
-      def encrypted_binary
-        return "" if @encrypted_hex.nil? || @encrypted_hex.empty?
-
-        # Convert hex string to binary
-        [@encrypted_hex.gsub(/\s/, "")].pack("H*")
-      end
-
       private
 
       # Normalize line endings to LF

data/lib/fontisan/type1/pfb_generator.rb

@@ -2,6 +2,7 @@
 
 require_relative "upm_scaler"
 require_relative "ttf_to_type1_converter"
+require_relative "decryptor"
 require_relative "../tables/name"
 
 module Fontisan
@@ -197,9 +198,31 @@ module Fontisan
         "/CharStrings #{@charstrings&.size || 0} dict dup begin\nend"
       end
 
+      # Build CharStrings dictionary text for eexec encryption
+      #
+      # @param charstrings [Hash] Glyph ID to CharString mapping
+      # @return [String] CharStrings dictionary text
+      def build_charstrings_dict_text(charstrings)
+        lines = []
+        lines << "dup /FontName get exch definefont pop"
+        lines << "begin"
+        lines << "/CharStrings #{charstrings.size} dict dup begin"
+
+        charstrings.each do |gid, charstring|
+          # Convert charstring bytes to hex representation for PostScript
+          hex_data = charstring.unpack1("H*")
+          lines << "#{gid} #{charstring.bytesize} #{hex_data} RD"
+        end
+
+        lines << "end"
+        lines << "end"
+        lines << "put"
+        lines.join("\n")
+      end
+
       # Build binary segment (CharStrings)
       #
-      # @return [String] Binary CharString data
+      # @return [String] Binary CharString data (encrypted with eexec)
       def build_binary_segment
         # Convert glyphs to Type 1 CharStrings
         charstrings = if @convert_curves
@@ -209,11 +232,11 @@ module Fontisan
                         generate_simple_charstrings
                       end
 
-        # Encode charstrings to eexec format (encrypted)
-        # For now, we'll use plain format (not encrypted)
-        # TODO: Implement eexec encryption
+        # Build CharStrings dictionary text
+        charstrings_dict = build_charstrings_dict_text(charstrings)
 
-        charstrings.values.join
+        # Encrypt with eexec
+        Decryptor.eexec_encrypt(charstrings_dict)
       end
 
       # Generate simple CharStrings (without curve conversion)

data/lib/fontisan/type1/private_dict.rb

@@ -163,6 +163,63 @@ module Fontisan
           !@stem_snap_h.empty? || !@stem_snap_v.empty?
       end
 
+      # Convert PrivateDict to Type 1 text format
+      #
+      # Generates the PostScript code for the Private dictionary section
+      # of a Type 1 font.
+      #
+      # @return [String] Type 1 Private dictionary text
+      #
+      # @example Generate Type 1 format
+      #   priv = PrivateDict.new
+      #   priv.blue_values = [-10, 0, 470, 480]
+      #   puts priv.to_type1_format
+      def to_type1_format
+        result = []
+        result << array_to_type1(:BlueValues, @blue_values) unless @blue_values.empty?
+        result << array_to_type1(:OtherBlues, @other_blues) unless @other_blues.empty?
+        result << array_to_type1(:FamilyBlues, @family_blues) unless @family_blues.empty?
+        result << array_to_type1(:FamilyOtherBlues, @family_other_blues) unless @family_other_blues.empty?
+        result << scalar_to_type1(:BlueScale, @blue_scale)
+        result << scalar_to_type1(:BlueShift, @blue_shift)
+        result << scalar_to_type1(:BlueFuzz, @blue_fuzz)
+        result << array_to_type1(:StdHW, @std_hw) unless @std_hw.empty?
+        result << array_to_type1(:StdVW, @std_vw) unless @std_vw.empty?
+        result << array_to_type1(:StemSnapH, @stem_snap_h) unless @stem_snap_h.empty?
+        result << array_to_type1(:StemSnapV, @stem_snap_v) unless @stem_snap_v.empty?
+        result << boolean_to_type1(:ForceBold, @force_bold) unless @force_bold == false
+        result << scalar_to_type1(:lenIV, @len_iv)
+
+        result.join("\n")
+      end
+
+      # Format an array value for Type 1 output
+      #
+      # @param name [Symbol] Array name
+      # @param value [Array] Array value
+      # @return [String] Formatted Type 1 array definition
+      def array_to_type1(name, value)
+        "/#{name} [#{value.join(' ')}] def"
+      end
+
+      # Format a scalar value for Type 1 output
+      #
+      # @param name [Symbol] Value name
+      # @param value [Numeric] Numeric value
+      # @return [String] Formatted Type 1 scalar definition
+      def scalar_to_type1(name, value)
+        "/#{name} #{value} def"
+      end
+
+      # Format a boolean value for Type 1 output
+      #
+      # @param name [Symbol] Value name
+      # @param value [Boolean] Boolean value
+      # @return [String] Formatted Type 1 boolean definition
+      def boolean_to_type1(name, value)
+        "/#{name} #{value} def"
+      end
+
       private
 
       # Extract private dictionary from data