idml 0.7.2 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6cc7058e67830e2dc6ea523ea6ca054f702ce29b51989a19deb023e5a840bee
-  data.tar.gz: 434b5af5ea49b9f2b48728b100b612ff0cd784079abfd6d419dbeb16554b3ebb
+  metadata.gz: 2f60e795f4325dcc4006a28915a18baf7069e21767694ca670c41f84db62d98d
+  data.tar.gz: 4f1f4846d41050b518c8add338ce431951b45ea58891b2c56154b47e59478bc7
 SHA512:
-  metadata.gz: a59cabfafa44138cb40ed8b6e493396c110ffe43728c0d0ea94d8ef4d8039efad635ba23660852b1040b58ce7141b6e301bf27ecb96599efd6d72069e6d81a95
-  data.tar.gz: d142ebcfc9eb6591827c72d3cd33303ee3a4c70637031b03622ea1355d453cac4aac1654f60ee7a3ee54a050755e88fb84c32c01df11df802c434442c0f9a4e2
+  metadata.gz: bbf7caac497ce2ab01a8c35af7bad78a24b7a706db6baa582b7d416cae1ce4995f18a3903379c4e994ab49ca1f28efd33e162821dead95250ae8248c041d16cd
+  data.tar.gz: ed5d2ae0abf40c0c6bf101d3c05ca35f59bc48aefed14366de7f5ac0f15979ff458ca7cf8493d012c4f6a78b0c1889815f987ea3dc9f24971f31ae34583f6fc4

data/TODO.pdf/103-drop-caps.md

@@ -1,6 +1,17 @@
 # TODO PDF 103: Drop caps (DropCapLines, DropCapCharacters)
 
-## Status: OPEN — gap identified in 2026-08-08 audit
+## Status: PARTIAL — `Render::DropCap` helper computes drop-cap
+geometry (font_size = base × lines, width via font_metrics.measure_text,
+height = leading × lines). TextFrameRenderer.emit_drop_cap emits the
+drop cap as an enlarged glyph at the paragraph's top-left when the
+paragraph declares DropCapLines/DropCapCharacters > 0 and is the
+chain's first paragraph.
+
+Wrap-around text is NOT yet implemented — the drop cap renders as an
+enlarged glyph; subsequent paragraph text flows normally and may
+overlap the drop cap. Real wrap-around (indent lines 1..M to the
+right of the drop cap) requires per-line wrap-width control in
+VerticalLayout, which is a bigger refactor. Tracked as follow-up.
 
 ## Problem
 

data/TODO.pdf/112-text-frame-vertical-justification.md

@@ -0,0 +1,53 @@
+# TODO PDF 112: TextFrame vertical justification (TopAlign / CenterAlign / BottomAlign / JustifyAlign)
+
+## Status: DONE for TopAlign / CenterAlign / BottomAlign. JustifyAlign
+defers to TopAlign (inter-paragraph space distribution not yet
+implemented). Content height is approximated by treating each run
+as one line — wrap may produce more lines, so slack is over-estimated;
+we'd rather under-offset than overflow.
+
+## Problem
+
+`Elements::TextFramePreference` carries `VerticalJustification`
+(attribute VerticalJustification on TextFramePreference_Object in
+Styles.rnc). Possible values: TopAlign, CenterAlign, BottomAlign,
+JustifyAlign.
+
+Today TextFrameRenderer always starts text at the top of the frame
+(`cursor_y = box[:y] + box[:height] - inset_top`). For
+`VerticalJustification="CenterAlign"` documents, the entire text
+block should be vertically centered within the frame's text area;
+for `BottomAlign`, text sits at the bottom.
+
+This is a common layout requirement — callouts, captions, footers,
+and sidebars often use bottom or center vertical justification.
+
+## What needs to happen
+
+1. `TextFrameRenderer#engine_render` reads
+   `frame.text_frame_preference.vertical_justification`.
+2. Compute the total content height (sum of all paragraph heights +
+   space_before/after).
+3. If VerticalJustification is CenterAlign: top-offset =
+   (frame_text_area_height - content_height) / 2.
+4. If BottomAlign: top-offset = (frame_text_area_height - content_height).
+5. Adjust the initial `cursor_y` by top-offset before laying out
+   the first paragraph.
+6. JustifyAlign: distribute extra vertical space between paragraphs
+   (more complex — defer).
+
+## Acceptance criteria
+
+- [ ] TextFrame with VerticalJustification="CenterAlign" centers
+      text vertically in the frame.
+- [ ] TextFrame with VerticalJustification="BottomAlign" aligns
+      text to the bottom.
+- [ ] TextFrame with VerticalJustification="TopAlign" (default)
+      renders as today.
+- [ ] Spec coverage per value.
+
+## Dependencies
+
+- TODO 108 (multi-frame story flow) — content_height calculation
+  needs to consider all paragraphs that will render, which the
+  chain state already tracks.

data/TODO.pdf/113-multi-column-text-frames.md

@@ -0,0 +1,48 @@
+# TODO PDF 113: Multi-column text frames (TextColumnCount, TextColumnGutter)
+
+## Status: OPEN — gap identified in 2026-08-10 audit
+
+## Problem
+
+`Elements::TextFramePreference` declares:
+- `TextColumnCount` — number of text columns in the frame (1-40)
+- `TextColumnGutter` — gap between columns (in points)
+- `TextColumnFixedWidth` — width of each column when uniform
+- `UseFixedColumnWidth` — boolean
+- `UseFlexibleColumnWidth` — boolean
+- `TextColumnMaxWidth` — max column width when flexible
+
+Real-world documents frequently use multi-column layouts
+(magazines, newspapers, technical reports, brochures). Today the
+renderer treats every text frame as a single column, ignoring
+TextColumnCount > 1.
+
+Effect: multi-column stories render as one wide column that over-
+laps adjacent content. The PDF is unreadable for multi-column docs.
+
+## What needs to happen
+
+1. `TextFrameRenderer` reads `text_frame_preference.text_column_count`.
+2. When > 1: split the frame's text area into N columns separated
+   by `text_column_gutter`.
+3. Render text column-by-column: column 1 fills top-to-bottom,
+   overflow continues at top of column 2, etc.
+4. StoryThreader chain state threads across columns WITHIN a frame
+   before crossing to the next frame.
+5. Optional: support TextColumnFixedWidth vs flexible-width
+   distribution.
+
+Architecture: this combines TODO 108 (chain flow) with column
+awareness. Each column acts like a mini-frame in the chain.
+
+## Acceptance criteria
+
+- [ ] TextFrame with TextColumnCount=2 renders two side-by-side columns.
+- [ ] Text overflows from column 1 → column 2 → next frame.
+- [ ] TextColumnGutter honored as the gap between columns.
+- [ ] Single-column frames render as today.
+
+## Dependencies
+
+- TODO 108 (multi-frame story flow) — column-to-column flow uses
+  the same chain state mechanism.

data/TODO.pdf/114-text-wrap-around-shapes.md

@@ -0,0 +1,50 @@
+# TODO PDF 114: Text wrap around shapes (TextWrapPreference)
+
+## Status: OPEN — gap identified in 2026-08-10 audit
+
+## Problem
+
+IDML page items (Rectangle, Polygon, GraphicLine, Group, Image, EPS)
+can declare a `<TextWrapPreference>` child that controls how text
+in neighboring TextFrames wraps around the item. Settings include:
+
+- WrapMode: None / Jump / Next / Bounding Box / Shape / Drop Cap
+- Contour: the wrap boundary (could differ from the visual shape)
+- Inverse: text wraps INSIDE the contour (rare)
+- OffsetTop/Left/Bottom/Right: additional margin around the contour
+
+Real documents wrap text around images and callout boxes constantly.
+Without text wrap support, overlapping items produce unreadable
+output — text from one frame runs over a graphic in another.
+
+Today TextFrameRenderer knows nothing about TextWrapPreference on
+other page items. It renders into the frame's full geometric
+rectangle regardless of overlapping wrap contours.
+
+## What needs to happen
+
+1. `Render::TextWrapResolver` reads TextWrapPreference from all
+   page items in the spread and indexes their contours by Self.
+2. Per TextFrame: compute the intersection of the frame's text area
+   with all wrap contours in the spread.
+3. TextFrameRenderer queries the resolver per text line; each line's
+   wrap width is reduced by the overlap on the left and right.
+4. Lines that fall entirely inside a wrap region are skipped.
+
+This is a substantial feature — wrap computation is non-trivial
+(geometry intersection, contour following). Most documents use a
+simple Bounding Box mode (rectangle subtract), which is tractable.
+
+## Acceptance criteria
+
+- [ ] TextWrapMode="BoundingBox" with an image inside the frame's
+      bounds reduces wrap width on affected lines.
+- [ ] TextWrapMode="None" (default) renders as today.
+- [ ] OffsetTop/Left/Bottom/Right honored (expands the contour by
+      the offsets).
+
+## Dependencies
+
+- TODO 108 (multi-frame story flow) — wrap-aware wrap width needs
+  to combine with chain-threaded line layout.
+- TODO 113 (multi-column) — wrap interacts with column boundaries.

data/TODO.pdf/115-bullet-numbered-lists.md

@@ -0,0 +1,49 @@
+# TODO PDF 115: Bullet and numbered list rendering
+
+## Status: DONE for inline marker emission. Hanging-indent layout
+(bullet in a left gutter with wrapped lines indented to align with
+text after marker) is a follow-up — currently the marker sits inline
+before the first run's text.
+
+## Problem
+
+`Elements::ParagraphStyleRange` carries a large set of bullets and
+numbering attributes (BulletsAndNumberingListType, NumberingExpression,
+BulletsTextAfter, NumberingLevel, NumberingContinue, NumberingStartAt,
+BulletsAlignment, NumberingAlignment, BulletCharacterType,
+BulletCharacterValue, RestartPolicy, LowerLevel, UpperLevel).
+
+The renderer ignores all of these. Lists appear in the PDF as plain
+paragraphs without bullet markers or numbering.
+
+Real documents (technical specs, tutorials, procedures, contracts)
+use lists extensively.
+
+## What needs to happen
+
+1. Read BulletsAndNumberingListType from PSR:
+   - "BulletList" → emit a bullet glyph at the paragraph's start
+   - "NumberedList" → emit a number/letter at the paragraph's start
+2. Apply BulletsAlignment (left/center/right) within a hanging-indent
+   gutter.
+3. Auto-increment numbering per NumberingLevel +
+   NumberingContinue + NumberingStartAt rules.
+4. Honor RestartPolicy for sub-list restart behavior.
+5. BulletCharacterValue picks the glyph (Unicode codepoint).
+
+Architecture: list markers prepend the paragraph's first run; the
+renderer needs an in-memory counter per numbering chain (similar
+to StoryChainController).
+
+## Acceptance criteria
+
+- [ ] PSR with BulletsAndNumberingListType="BulletList" renders a
+      bullet glyph before the paragraph's first character.
+- [ ] PSR with BulletsAndNumberingListType="NumberedList" renders
+      a sequential number, auto-incremented per chain.
+- [ ] BulletsTextAfter (e.g., ". ", ") ") honored as the marker's
+      suffix.
+
+## Dependencies
+
+- None — independent feature work on PSR.

data/lib/idml/render/drop_cap.rb

@@ -0,0 +1,83 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Computes drop-cap geometry for a paragraph. IDML's DropCapLines
+    # (M) and DropCapCharacters (N) declare that the first N
+    # characters of the paragraph should render at M-lines-tall and
+    # the next M text lines should wrap to the right of the drop cap.
+    #
+    # The helper returns a `DropCapLayout` struct with the drop cap
+    # text, font size, width (for wrap offset), and total height.
+    # Returns nil when the paragraph doesn't declare drop caps.
+    module DropCap
+      DropCapLayout = Struct.new(
+        :text, :width, :height, :font_size, :wrap_offset, :lines,
+        keyword_init: true
+      )
+
+      # Returns a DropCapLayout for the paragraph, or nil when drop
+      # caps aren't declared. `font_metrics` measures the drop-cap
+      # text's natural width. `base_size` is the paragraph's normal
+      # font size (drop cap is enlarged relative to it).
+      def self.layout(paragraph, font_metrics:, base_size:, leading:)
+        return nil unless active?(paragraph)
+        return nil unless font_metrics
+
+        chars = paragraph.drop_cap_characters.to_i
+        lines = paragraph.drop_cap_lines.to_i
+        return nil if chars <= 0 || lines <= 0
+
+        build_layout(paragraph, font_metrics, base_size, leading, chars, lines)
+      end
+
+      # True when the paragraph declares an active drop cap
+      # (both DropCapLines and DropCapCharacters are positive integers).
+      def self.active?(paragraph)
+        return false unless paragraph
+        return false unless paragraph.drop_cap_lines.to_i.positive?
+
+        paragraph.drop_cap_characters.to_i.positive?
+      end
+
+      # Pulls the first N characters from the paragraph's first run.
+      # If the first run is shorter than N, takes from subsequent runs
+      # until N chars are accumulated (rare — drop caps typically use
+      # 1-2 chars).
+      def self.extract_drop_cap_text(paragraph, n)
+        runs = paragraph.runs
+        return nil if runs.empty?
+
+        collected = +""
+        runs.each do |run|
+          needed = n - collected.length
+          break if needed <= 0
+
+          collected << run.text[0, needed]
+          break if collected.length >= n
+        end
+        collected
+      end
+
+      def self.build_layout(paragraph, font_metrics, base_size, leading,
+                            chars, lines)
+        text = extract_drop_cap_text(paragraph, chars)
+        return nil if text.nil? || text.empty?
+
+        font_size = base_size * lines
+        width = font_metrics.measure_text(text, font_size).to_f
+        return nil unless width&.positive?
+
+        DropCapLayout.new(
+          text: text,
+          width: width,
+          height: leading * lines,
+          font_size: font_size,
+          wrap_offset: width,
+          lines: lines,
+        )
+      end
+      private_class_method :build_layout
+    end
+  end
+end

data/lib/idml/render/list_marker.rb

@@ -0,0 +1,63 @@
+# frozen_string: true
+
+module Idml
+  module Render
+    # Produces a list-marker string for a paragraph (bullet glyph or
+    # numbered-list expression). IDML stores the resolved marker
+    # directly on the PSR (BulletCharacterValue as a Unicode codepoint,
+    # NumberingExpression as the rendered text), so the renderer
+    # doesn't need to maintain its own counter.
+    #
+    # Used by `StyleResolver` to prepend the marker to the paragraph's
+    # first run's text. The marker becomes part of the run's natural
+    # text flow — no special positioning needed for MVP.
+    #
+    # Hanging-indent layout (bullet aligned in a left gutter with
+    # wrapped lines indented to align with text after the marker) is
+    # a follow-up; for now the marker sits inline before the text.
+    module ListMarker
+      DEFAULT_BULLET = "•".freeze # BULLET
+      DEFAULT_TEXT_AFTER = "\t".freeze
+
+      # Returns the marker string for the paragraph, or nil when the
+      # paragraph isn't part of a list.
+      def self.marker_for(paragraph)
+        return nil unless paragraph
+
+        case paragraph.bullets_and_numbering_list_type
+        when "BulletList" then bullet_marker(paragraph)
+        when "NumberedList" then numbered_marker(paragraph)
+        end
+      end
+
+      def self.bullet_marker(paragraph)
+        bullet = bullet_char(paragraph)
+        suffix = text_after(paragraph)
+        "#{bullet}#{suffix}"
+      end
+      private_class_method :bullet_marker
+
+      def self.numbered_marker(paragraph)
+        expr = paragraph.numbering_expression
+        return nil if expr.nil? || expr.empty?
+
+        suffix = text_after(paragraph)
+        "#{expr}#{suffix}"
+      end
+      private_class_method :numbered_marker
+
+      def self.bullet_char(paragraph)
+        codepoint = paragraph.bullet_character_value
+        return DEFAULT_BULLET unless codepoint&.positive?
+
+        [codepoint].pack("U")
+      end
+      private_class_method :bullet_char
+
+      def self.text_after(paragraph)
+        paragraph.bullets_text_after || DEFAULT_TEXT_AFTER
+      end
+      private_class_method :text_after
+    end
+  end
+end

data/lib/idml/render/renderers/text_frame_renderer.rb

@@ -157,8 +157,9 @@ module Idml
         # next frame in the chain.
         def self.engine_render(canvas, state, context, box, font)
           layout_frame = layout_frame(context.item, box)
-          cursor_y = box[:y] + box[:height] - (layout_frame.inset_top || 0)
+          top_y = box[:y] + box[:height] - (layout_frame.inset_top || 0)
           bottom_limit = TextEngine::VerticalLayout.bottom_limit(layout_frame)
+          cursor_y = vertical_justify_top(top_y, bottom_limit, state, context)
           char_cursor = state.char_cursor
 
           if state.current_paragraph
@@ -174,6 +175,77 @@ module Idml
         end
         private_class_method :engine_render
 
+        # Computes the starting cursor_y for vertical justification.
+        # IDML's TextFramePreference.VerticalJustification can be:
+        # - TopAlign (default): start at frame top, no offset
+        # - CenterAlign: center the content block vertically
+        # - BottomAlign: align content to the frame bottom
+        # - JustifyAlign: distribute extra space between paragraphs
+        #   (deferred — falls back to TopAlign behavior)
+        #
+        # Content height is estimated by walking paragraphs and
+        # summing leading × lines + space_before/after. Without
+        # shaping/wrapping we can't know exact line count, so we
+        # approximate by treating each run as one line.
+        def self.vertical_justify_top(top_y, bottom_limit, state, context)
+          justification = text_frame_vertical_justification(context)
+          return top_y unless %w[CenterAlign BottomAlign].include?(justification)
+
+          content_height = estimate_content_height(state)
+          available = top_y - bottom_limit
+          slack = [available - content_height, 0].max
+          return top_y if slack.zero?
+
+          case justification
+          when "CenterAlign" then top_y - (slack / 2)
+          when "BottomAlign" then top_y - slack
+          else top_y
+          end
+        end
+        private_class_method :vertical_justify_top
+
+        def self.text_frame_vertical_justification(context)
+          pref = context.item&.text_frame_preference&.first
+          pref&.vertical_justification
+        end
+        private_class_method :text_frame_vertical_justification
+
+        # Estimates total renderable content height for vertical
+        # justification. Walks paragraphs and runs, summing leading
+        # per run plus paragraph space_before/after. Approximation:
+        # treats each run as one line (wrap may produce more lines,
+        # which would over-estimate slack; acceptable for
+        # justification since we'd rather under-offset than overflow).
+        def self.estimate_content_height(state)
+          paragraphs = paragraphs_for_estimate(state)
+          return 0 if paragraphs.empty?
+
+          paragraphs.sum do |paragraph|
+            paragraph_height(paragraph)
+          end
+        end
+        private_class_method :estimate_content_height
+
+        def self.paragraphs_for_estimate(state)
+          result = []
+          result << state.current_paragraph if state.current_paragraph
+          result + state.paragraphs
+        end
+        private_class_method :paragraphs_for_estimate
+
+        def self.paragraph_height(paragraph)
+          size = paragraph.runs.first&.point_size || DEFAULT_SIZE
+          leading = leading_for(paragraph, size)
+          line_count = [paragraph.runs.length, 1].max
+          (leading * line_count) + space_before_after(paragraph)
+        end
+        private_class_method :paragraph_height
+
+        def self.space_before_after(paragraph)
+          (paragraph.space_before || 0) + (paragraph.space_after || 0)
+        end
+        private_class_method :space_before_after
+
         def self.resume_paragraph(canvas, state, context, layout_frame, font,
                                   cursor_y, bottom_limit, char_cursor)
           paragraph = state.current_paragraph
@@ -233,6 +305,8 @@ module Idml
 
           emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
                                   frame_left, frame_right, first_paragraph)
+          emit_drop_cap(canvas, paragraph, context, frame_left, cursor_y,
+                        first_paragraph)
 
           rendered_count = 0
           runs.each do |run|
@@ -260,6 +334,33 @@ module Idml
         end
         private_class_method :render_runs_for_paragraph
 
+        # Renders the drop cap for a paragraph (when declared and the
+        # first paragraph of the chain). Wrap-around text is not yet
+        # implemented — the drop cap renders as an enlarged glyph at
+        # the paragraph's top-left; subsequent text may overlap it.
+        # Marked as a follow-up in TODO 103.
+        def self.emit_drop_cap(canvas, paragraph, context, frame_left,
+                               cursor_y, first_paragraph)
+          return nil unless first_paragraph
+          return nil unless DropCap.active?(paragraph)
+
+          base_size = paragraph.runs.first&.point_size || DEFAULT_SIZE
+          leading = leading_for(paragraph, base_size)
+          drop_cap = DropCap.layout(paragraph,
+                                    font_metrics: context.font_metrics,
+                                    base_size: base_size, leading: leading)
+          return nil unless drop_cap
+
+          drop_at_y = cursor_y - drop_cap.font_size + (base_size * 0.25)
+          canvas.text(
+            drop_cap.text,
+            at: [frame_left, drop_at_y],
+            font: font_for_run(paragraph.runs.first, context),
+            size: drop_cap.font_size,
+          )
+        end
+        private_class_method :emit_drop_cap
+
         def self.emit_paragraph_top_rule(canvas, paragraph, context, cursor_y,
                                          frame_left, frame_right,
                                          first_paragraph)

data/lib/idml/render/style_resolver.rb

@@ -54,6 +54,12 @@ module Idml
         :left_indent,
         :right_indent,
         :auto_leading,
+        :drop_cap_lines,
+        :bullets_and_numbering_list_type,
+        :bullet_character_value,
+        :bullets_text_after,
+        :numbering_expression,
+        :drop_cap_characters,
         # RuleAbove / RuleBelow — paragraph rules (horizontal lines
         # above/below the paragraph block). Driven by PSR attributes.
         :rule_above,
@@ -113,7 +119,7 @@ module Idml
           runs = csr_runs(psr, condition_filter: condition_filter)
           next if runs.empty?
 
-          Paragraph.new(
+          paragraph = Paragraph.new(
             runs: runs,
             alignment: runs.first.alignment,
             space_before: psr.space_before,
@@ -122,6 +128,12 @@ module Idml
             left_indent: psr.left_indent,
             right_indent: psr.right_indent,
             auto_leading: psr.auto_leading,
+            drop_cap_lines: psr.drop_cap_lines,
+            drop_cap_characters: psr.drop_cap_characters,
+            bullets_and_numbering_list_type: psr.bullets_and_numbering_list_type,
+            bullet_character_value: psr.bullet_character_value,
+            bullets_text_after: psr.bullets_text_after,
+            numbering_expression: psr.numbering_expression,
             rule_above: psr.rule_above,
             rule_above_line_weight: psr.rule_above_line_weight,
             rule_above_color: psr.stroke_color,
@@ -139,6 +151,8 @@ module Idml
             rule_below_right_indent: psr.rule_below_right_indent,
             rule_below_width: psr.rule_below_width,
           )
+          prepend_list_marker(paragraph)
+          paragraph
         end
       end
 
@@ -189,6 +203,19 @@ module Idml
       end
       private_class_method :alignment_for
 
+      # Prepends the list marker (bullet glyph or numbered expression)
+      # to the paragraph's first run when the paragraph is part of
+      # a list. Mutates the first run's text in place.
+      def self.prepend_list_marker(paragraph)
+        marker = ListMarker.marker_for(paragraph)
+        return unless marker
+        return if paragraph.runs.empty?
+
+        first_run = paragraph.runs.first
+        first_run.text = "#{marker}#{first_run.text}"
+      end
+      private_class_method :prepend_list_marker
+
       # Concatenate runs into a single block. Used when the renderer
       # can't handle per-run styling (e.g., no font metrics available).
       def self.concatenate(runs)

data/lib/idml/render.rb

@@ -15,6 +15,8 @@ module Idml
     autoload :StrokeStyle,         "#{__dir__}/render/stroke_style"
     autoload :CharacterStyle,      "#{__dir__}/render/character_style"
     autoload :ParagraphRules,      "#{__dir__}/render/paragraph_rules"
+    autoload :DropCap,             "#{__dir__}/render/drop_cap"
+    autoload :ListMarker,          "#{__dir__}/render/list_marker"
     autoload :StoryChainController, "#{__dir__}/render/story_chain_controller"
     autoload :LayerFilter,         "#{__dir__}/render/layer_filter"
     autoload :ConditionFilter,     "#{__dir__}/render/condition_filter"

data/lib/idml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Idml
-  VERSION = "0.7.2"
+  VERSION = "0.7.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: idml
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.4
 platform: ruby
 authors:
 - Ribose
@@ -168,6 +168,10 @@ files:
 - TODO.pdf/11-font-embedding.md
 - TODO.pdf/110-conditional-text.md
 - TODO.pdf/111-footnote-support.md
+- TODO.pdf/112-text-frame-vertical-justification.md
+- TODO.pdf/113-multi-column-text-frames.md
+- TODO.pdf/114-text-wrap-around-shapes.md
+- TODO.pdf/115-bullet-numbered-lists.md
 - TODO.pdf/12-idml-to-pdf-pipeline.md
 - TODO.pdf/13-cjk-text-layout.md
 - TODO.pdf/14-page-item-element-models.md
@@ -430,6 +434,7 @@ files:
 - lib/idml/render/color_helper.rb
 - lib/idml/render/color_resolver.rb
 - lib/idml/render/condition_filter.rb
+- lib/idml/render/drop_cap.rb
 - lib/idml/render/font_reference_resolver.rb
 - lib/idml/render/font_setup.rb
 - lib/idml/render/gradient_resolver.rb
@@ -439,6 +444,7 @@ files:
 - lib/idml/render/image.rb
 - lib/idml/render/image_collector.rb
 - lib/idml/render/layer_filter.rb
+- lib/idml/render/list_marker.rb
 - lib/idml/render/metadata_builder.rb
 - lib/idml/render/page_item_renderer.rb
 - lib/idml/render/paragraph_rules.rb