idml 0.1.0

data/lib/idml/elements.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Idml
+  # Typed models for IDML elements that appear inside parts. Every
+  # element class is generated from its `_Object` definition in the
+  # RNC schemas at `reference-docs/schemas/package/` via
+  # `scripts/rnc_to_lutaml.rb` + `scripts/assemble_element.rb`
+  # (or `scripts/generate_all_objects.rb` for bulk generation).
+  module Elements
+    autoload :AnchoredObjectDefault,
+             "idml/elements/pref_anchored_object_default"
+    autoload :AnchoredObjectSetting, "idml/elements/anchored_object_setting"
+    autoload :BaselineFrameGridOption,
+             "idml/elements/baseline_frame_grid_option"
+    autoload :BevelAndEmbossSetting, "idml/elements/bevel_and_emboss_setting"
+    autoload :BlendingSetting, "idml/elements/blending_setting"
+    autoload :ButtonPreference, "idml/elements/pref_button_preference"
+    autoload :CellStyle, "idml/elements/cell_style"
+    autoload :CellStyleGroup, "idml/elements/cell_style_group"
+    autoload :ChapterNumberPreference,
+             "idml/elements/pref_chapter_number_preference"
+    autoload :CharacterStyle, "idml/elements/character_style"
+    autoload :CharacterStyleGroup, "idml/elements/character_style_group"
+    autoload :CharacterStyleRange, "idml/elements/character_style_range"
+    autoload :CjkGridPreference, "idml/elements/pref_cjk_grid_preference"
+    autoload :Color, "idml/elements/color"
+    autoload :Content, "idml/elements/content"
+    autoload :ContentTransparencySetting,
+             "idml/elements/content_transparency_setting"
+    autoload :ContourOption, "idml/elements/contour_option"
+    autoload :DashedStrokeStyle, "idml/elements/dashed_stroke_style"
+    autoload :DataMerge, "idml/elements/pref_data_merge"
+    autoload :DataMergeField, "idml/elements/pref_data_merge_field"
+    autoload :DataMergeOption, "idml/elements/pref_data_merge_option"
+    autoload :DictionaryPreference, "idml/elements/pref_dictionary_preference"
+    autoload :DirectionalFeatherSetting,
+             "idml/elements/directional_feather_setting"
+    autoload :DocumentObject, "idml/elements/document_object"
+    autoload :DocumentPreference, "idml/elements/pref_document_preference"
+    autoload :DottedStrokeStyle, "idml/elements/dotted_stroke_style"
+    autoload :DropShadowSetting, "idml/elements/drop_shadow_setting"
+    autoload :EPubExportPreference, "idml/elements/pref_e_pub_export_preference"
+    autoload :EPubFixedLayoutExportPreference,
+             "idml/elements/pref_e_pub_fixed_layout_export_preference"
+    autoload :ExportForWebPreference,
+             "idml/elements/pref_export_for_web_preference"
+    autoload :FeatherSetting, "idml/elements/feather_setting"
+    autoload :FillTransparencySetting, "idml/elements/fill_transparency_setting"
+    autoload :FlexLayoutAttributeOption,
+             "idml/elements/flex_layout_attribute_option"
+    autoload :Font, "idml/elements/font"
+    autoload :FontFamily, "idml/elements/font_family"
+    autoload :FootnoteOption, "idml/elements/pref_footnote_option"
+    autoload :FrameFittingOption, "idml/elements/frame_fitting_option"
+    autoload :GraphicLine, "idml/elements/graphic_line"
+    autoload :Gradient, "idml/elements/gradient"
+    autoload :GradientFeatherSetting, "idml/elements/gradient_feather_setting"
+    autoload :GradientStop, "idml/elements/gradient_stop"
+    autoload :GridPreference, "idml/elements/pref_grid_preference"
+    autoload :Group, "idml/elements/group"
+    autoload :GuidePreference, "idml/elements/pref_guide_preference"
+    autoload :HTMLExportPreference, "idml/elements/pref_html_export_preference"
+    autoload :Image, "idml/elements/image"
+    autoload :IndexHeaderSetting, "idml/elements/pref_index_header_setting"
+    autoload :IndexOptions, "idml/elements/pref_index_options"
+    autoload :Ink, "idml/elements/ink"
+    autoload :InnerGlowSetting, "idml/elements/inner_glow_setting"
+    autoload :InnerShadowSetting, "idml/elements/inner_shadow_setting"
+    autoload :LayoutAdjustmentPreference,
+             "idml/elements/pref_layout_adjustment_preference"
+    autoload :LayoutGridDataInformation,
+             "idml/elements/pref_layout_grid_data_information"
+    autoload :Layer, "idml/elements/layer"
+    autoload :Link, "idml/elements/link"
+    autoload :MarginPreference, "idml/elements/pref_margin_preference"
+    autoload :MasterSpreadObject, "idml/elements/master_spread_object"
+    autoload :MixedInk, "idml/elements/mixed_ink"
+    autoload :MixedInkGroup, "idml/elements/mixed_ink_group"
+    autoload :MojikumiUiPreference, "idml/elements/pref_mojikumi_ui_preference"
+    autoload :ObjectExportOption, "idml/elements/object_export_option"
+    autoload :ObjectStyle, "idml/elements/object_style"
+    autoload :ObjectStyleContentEffectsCategorySettings,
+             "idml/elements/object_style_content_effects_category_settings"
+    autoload :ObjectStyleExportTagMap,
+             "idml/elements/object_style_export_tag_map"
+    autoload :ObjectStyleFillEffectsCategorySettings,
+             "idml/elements/object_style_fill_effects_category_settings"
+    autoload :ObjectStyleGroup, "idml/elements/object_style_group"
+    autoload :ObjectStyleObjectEffectsCategorySettings,
+             "idml/elements/object_style_object_effects_category_settings"
+    autoload :ObjectStyleStrokeEffectsCategorySettings,
+             "idml/elements/object_style_stroke_effects_category_settings"
+    autoload :OpacityGradientStop, "idml/elements/opacity_gradient_stop"
+    autoload :OuterGlowSetting, "idml/elements/outer_glow_setting"
+    autoload :PageItemDefault, "idml/elements/pref_page_item_default"
+    autoload :Page, "idml/elements/page"
+    autoload :ParagraphStyle, "idml/elements/paragraph_style"
+    autoload :ParagraphStyleGroup, "idml/elements/paragraph_style_group"
+    autoload :ParagraphStyleRange, "idml/elements/paragraph_style_range"
+    autoload :PasteboardPreference, "idml/elements/pref_pasteboard_preference"
+    autoload :PastedSmoothShade, "idml/elements/pasted_smooth_shade"
+    autoload :PathGeometry, "idml/elements/path_geometry"
+    autoload :PathPointArray, "idml/elements/path_point_array"
+    autoload :PathPointType, "idml/elements/path_point_type"
+    autoload :Polygon, "idml/elements/polygon"
+    autoload :PrintBookletOption, "idml/elements/pref_print_booklet_option"
+    autoload :PrintBookletPrintPreference,
+             "idml/elements/pref_print_booklet_print_preference"
+    autoload :PrintPreference, "idml/elements/pref_print_preference"
+    autoload :Properties, "idml/elements/properties"
+    autoload :GeometryPathType, "idml/elements/geometry_path_type"
+    autoload :Rectangle, "idml/elements/rectangle"
+    autoload :RootCellStyleGroup, "idml/elements/root_cell_style_group"
+    autoload :RootCharacterStyleGroup,
+             "idml/elements/root_character_style_group"
+    autoload :RootObjectStyleGroup, "idml/elements/root_object_style_group"
+    autoload :RootParagraphStyleGroup,
+             "idml/elements/root_paragraph_style_group"
+    autoload :RootTableStyleGroup, "idml/elements/root_table_style_group"
+    autoload :SatinSetting, "idml/elements/satin_setting"
+    autoload :SpreadObject, "idml/elements/spread_object"
+    autoload :StoryGridDataInformation,
+             "idml/elements/pref_story_grid_data_information"
+    autoload :StoryInner, "idml/elements/story_inner"
+    autoload :StoryPreference, "idml/elements/story_preference"
+    autoload :StripedStrokeStyle, "idml/elements/striped_stroke_style"
+    autoload :StrokeStyle, "idml/elements/stroke_style"
+    autoload :StrokeTransparencySetting,
+             "idml/elements/stroke_transparency_setting"
+    autoload :StyleExportTagMap, "idml/elements/style_export_tag_map"
+    autoload :Swatch, "idml/elements/swatch"
+    autoload :TOCStyle, "idml/elements/toc_style"
+    autoload :TOCStyleEntry, "idml/elements/toc_style_entry"
+    autoload :Table, "idml/elements/table"
+    autoload :TableCell, "idml/elements/table_cell"
+    autoload :TableRow, "idml/elements/table_row"
+    autoload :TableStyle, "idml/elements/table_style"
+    autoload :TableStyleGroup, "idml/elements/table_style_group"
+    autoload :TextDefault, "idml/elements/pref_text_default"
+    autoload :TextFrame, "idml/elements/text_frame"
+    autoload :TextFrameFootnoteOptionsObject,
+             "idml/elements/text_frame_footnote_options_object"
+    autoload :TextFramePreference, "idml/elements/text_frame_preference"
+    autoload :TextPreference, "idml/elements/pref_text_preference"
+    autoload :TextWrapPreference, "idml/elements/text_wrap_preference"
+    autoload :TinDocumentDataObject,
+             "idml/elements/pref_tin_document_data_object"
+    autoload :Tint, "idml/elements/tint"
+    autoload :TransformAttributeOption,
+             "idml/elements/transform_attribute_option"
+    autoload :TransparencyDefaultContainerObject,
+             "idml/elements/pref_transparency_default_container_object"
+    autoload :TransparencyPreference,
+             "idml/elements/pref_transparency_preference"
+    autoload :TransparencySetting, "idml/elements/transparency_setting"
+    autoload :TrapPreset, "idml/elements/trap_preset"
+    autoload :ViewPreference, "idml/elements/pref_view_preference"
+    autoload :XMLExportPreference, "idml/elements/pref_xml_export_preference"
+    autoload :XMLImportPreference, "idml/elements/pref_xml_import_preference"
+    autoload :XMLPreference, "idml/elements/pref_xml_preference"
+    autoload :XmlElement, "idml/elements/xml_element"
+    autoload :XmlExportMap, "idml/elements/xml_export_map"
+    autoload :XmlImportMap, "idml/elements/xml_import_map"
+    autoload :XmlStory, "idml/elements/xml_story"
+    autoload :XmlTag, "idml/elements/xml_tag"
+  end
+end

data/lib/idml/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Idml
+  module Errors
+    class Error < StandardError; end
+    class PackageNotFound < Error; end
+    class InvalidPackage < Error; end
+    class PartNotFound < Error; end
+  end
+end

data/lib/idml/geometry.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Idml
+  # Coordinate-transform helpers for composition operations. The IDML
+  # coordinate system has its origin at the bottom-left of the spread,
+  # y increasing upward; page item coordinates are spread-relative.
+  # When composing two packages, source coordinates must be translated
+  # into the destination's coordinate space.
+  module Geometry
+    Point = Struct.new(:x, :y)
+
+    # 2D affine transform: [a, b, c, d, e, f] representing
+    #   x' = a*x + c*y + e
+    #   y' = b*x + d*y + f
+    Transform = Struct.new(:a, :b, :c, :d, :e, :f)
+
+    module_function
+
+    # Parse an ItemTransform string "a b c d e f" into a Transform.
+    def parse_transform(str)
+      return nil unless str
+
+      parts = str.split(/\s+/).map(&:to_f)
+      return nil unless parts.length == 6
+
+      Transform.new(*parts)
+    end
+
+    # Apply a Transform to a point [x, y], returning [x', y'].
+    def apply_transform(transform, x, y)
+      return [x, y] unless transform
+
+      [(transform.a * x) + (transform.c * y) + transform.e,
+       (transform.b * x) + (transform.d * y) + transform.f]
+    end
+
+    # Combine (multiply) two transforms: result = outer ∘ inner.
+    def combine_transforms(outer, inner)
+      return inner unless outer
+      return outer unless inner
+
+      Transform.new(
+        (outer.a * inner.a) + (outer.c * inner.b),
+        (outer.b * inner.a) + (outer.d * inner.b),
+        (outer.a * inner.c) + (outer.c * inner.d),
+        (outer.b * inner.c) + (outer.d * inner.d),
+        (outer.a * inner.e) + (outer.c * inner.f) + outer.e,
+        (outer.b * inner.e) + (outer.d * inner.f) + outer.f,
+      )
+    end
+
+    # Transform IDML geometric_bounds [y1, x1, y2, x2] by applying
+    # an optional ItemTransform. Returns new [y1, x1, y2, x2].
+    def transform_bounds(bounds, transform = nil)
+      return bounds unless transform && bounds
+
+      y1, x1, y2, x2 = bounds
+      x1p, y1p = apply_transform(transform, x1, y1)
+      x2p, y2p = apply_transform(transform, x2, y2)
+      xs = [x1p, x2p]
+      ys = [y1p, y2p]
+      [ys.min, xs.min, ys.max, xs.max]
+    end
+
+    # Convert IDML bounds + ItemTransform string to a PDF rect
+    # with Y-axis flip. Single entry point for all renderers.
+    def placement_rect(bounds, item_transform_str, page_height)
+      transform = parse_transform(item_transform_str)
+      transformed = transform_bounds(bounds, transform)
+      bounds_to_pdf_rect(transformed, page_height)
+    end
+
+    # Convert IDML bounds [y1, x1, y2, x2] to a PDF rectangle
+    # { x:, y:, width:, height: } with Y-axis flipped.
+    def bounds_to_pdf_rect(bounds, page_height)
+      return nil unless bounds && bounds.length == 4
+
+      y1, x1, y2, x2 = bounds
+      {
+        x: x1,
+        y: page_height - y2,
+        width: (x2 - x1).abs,
+        height: (y2 - y1).abs,
+      }
+    end
+
+    def translate(point, by: offset(x: 0, y: 0))
+      Point.new(point.x + by.x, point.y + by.y)
+    end
+
+    def scale(point, by: offset(x: 1, y: 1))
+      Point.new(point.x * by.x, point.y * by.y)
+    end
+
+    # Rotate `point` counterclockwise by `angle_degrees` around `around`.
+    def rotate(point, angle_degrees:, around: offset(x: 0, y: 0))
+      rad = angle_degrees * Math::PI / 180
+      cos = Math.cos(rad)
+      sin = Math.sin(rad)
+      dx = point.x - around.x
+      dy = point.y - around.y
+      Point.new(around.x + ((dx * cos) - (dy * sin)),
+                around.y + ((dx * sin) + (dy * cos)))
+    end
+
+    def offset(x:, y:)
+      Point.new(x, y)
+    end
+  end
+end

data/lib/idml/namespace.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Idml
+  # The IDML packaging namespace, used on every part's root wrapper
+  # element (idPkg:Spread, idPkg:Story, idPkg:Fonts, etc.). The actual
+  # content elements inside (Spread, Story, FontFamily) are NOT in this
+  # namespace — the wrapper just declares the prefix for idPkg-scoped
+  # children.
+  class PackagingNamespace < Lutaml::Xml::Namespace
+    uri "http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging"
+    prefix_default "idPkg"
+  end
+end

data/lib/idml/package.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Idml
+  # Read/write access to an IDML package's ZIP container. A Package
+  # holds a path; ZIP and part reads are lazy. Typed part access goes
+  # through `#part(name)` which dispatches via `Idml::Parts.class_for`.
+  #
+  # @example Open a package and read the designmap
+  #   pkg = Idml::Package.new("path/to/file.idml")
+  #   dm = pkg.designmap
+  #   puts dm.dom_version
+  #
+  # @example Write a new package
+  #   parts = { "mimetype" => "...", "designmap.xml" => "..." }
+  #   Idml::Package.write(parts: parts, to: "out.idml")
+  class Package
+    # The IDML UCF container's mimetype entry name. Per the IDML spec, this
+    # entry must appear first in the archive and be stored uncompressed.
+    MIMETYPE_ENTRY = "mimetype"
+    private_constant :MIMETYPE_ENTRY
+
+    def initialize(path)
+      raise Errors::PackageNotFound, path.to_s unless File.exist?(path)
+
+      @path = File.expand_path(path)
+    end
+
+    attr_reader :path
+
+    def designmap
+      @designmap ||= part("designmap.xml")
+    end
+
+    def backing_story
+      @backing_story ||= part("XML/BackingStory.xml")
+    end
+
+    def spreads
+      @spreads ||= part_names.grep(%r{\ASpreads/}).map { |n| part(n) }
+    end
+
+    def master_spreads
+      @master_spreads ||= part_names.grep(%r{\AMasterSpreads/}).map do |n|
+        part(n)
+      end
+    end
+
+    def stories
+      @stories ||= part_names.grep(%r{\AStories/}).map { |n| part(n) }
+    end
+
+    def story_by_id(story_id)
+      return nil unless story_id
+
+      name = "Stories/Story_#{story_id}.xml"
+      return nil unless has_part?(name)
+
+      part(name)
+    end
+
+    def master_spread_by_id(master_id)
+      return nil unless master_id
+
+      name = "MasterSpreads/MasterSpread_#{master_id}.xml"
+      return nil unless has_part?(name)
+
+      part(name)
+    end
+
+    def fonts
+      return unless has_part?("Resources/Fonts.xml")
+
+      @fonts ||= part("Resources/Fonts.xml")
+    end
+
+    def graphic
+      return unless has_part?("Resources/Graphic.xml")
+
+      @graphic ||= part("Resources/Graphic.xml")
+    end
+
+    def style
+      return unless has_part?("Resources/Styles.xml")
+
+      @style ||= part("Resources/Styles.xml")
+    end
+
+    def style_mapping
+      if has_part?("Resources/StyleMapping.xml")
+        @style_mapping ||=
+          part("Resources/StyleMapping.xml")
+      end
+    end
+
+    def preferences
+      if has_part?("Resources/Preferences.xml")
+        @preferences ||=
+          part("Resources/Preferences.xml")
+      end
+    end
+
+    def tags
+      @tags ||= part("XML/Tags.xml") if has_part?("XML/Tags.xml")
+    end
+
+    def mapping
+      @mapping ||= part("XML/Mapping.xml") if has_part?("XML/Mapping.xml")
+    end
+
+    def dom_version
+      designmap&.dom_version
+    end
+
+    def part_names
+      @part_names ||= with_zip do |zip_file|
+        names = []
+        zip_file.each do |entry|
+          names << entry.name if entry.name && !entry.name.empty?
+        end
+        names.sort
+      end
+    end
+
+    def has_part?(name)
+      part_names.include?(name)
+    end
+
+    def read_part(name)
+      raise Errors::PartNotFound, name unless has_part?(name)
+
+      with_zip { |zip_file| zip_file.read(name) }
+    end
+
+    # Returns a typed part instance for `name` when a class is registered
+    # for that file pattern (e.g. Designmap for designmap.xml). Falls
+    # back to Parts::Raw — a lossless XML wrapper — for unmodeled parts.
+    def part(name)
+      xml = read_part(name)
+      klass = Idml::Parts.class_for(name)
+      return Idml::Parts::Raw.from_xml(xml) unless klass
+
+      klass.from_xml(xml)
+    end
+
+    def each_part
+      return enum_for(:each_part) unless block_given?
+
+      with_zip do |zip_file|
+        zip_file.each do |entry|
+          next if entry.directory?
+
+          yield entry.name, entry.get_input_stream.read
+        end
+      end
+    end
+
+    def self.write(parts:, to:)
+      raise Errors::InvalidPackage, "no parts given" if parts.empty?
+
+      output_path = File.expand_path(to)
+      FileUtils.mkdir_p(File.dirname(output_path))
+      write_to_zip(parts, output_path)
+      new(output_path)
+    end
+
+    private
+
+    def with_zip(&)
+      Zip::File.open(@path, &)
+    rescue Errno::ENOENT => e
+      raise Errors::PackageNotFound, e.message
+    rescue Zip::Error => e
+      raise Errors::InvalidPackage, e.message
+    end
+
+    def self.write_to_zip(parts, output_path)
+      with_mimetype_tempfile(parts[MIMETYPE_ENTRY]) do |mimetype_path|
+        Zip::File.open(output_path, Zip::File::CREATE) do |zip_file|
+          write_mimetype(zip_file, mimetype_path)
+          write_remaining_parts(zip_file, parts)
+        end
+      end
+    end
+    private_class_method :write_to_zip
+
+    def self.write_mimetype(zip_file, mimetype_path)
+      return unless mimetype_path
+
+      zip_file.add_stored(MIMETYPE_ENTRY, mimetype_path)
+    end
+    private_class_method :write_mimetype
+
+    def self.write_remaining_parts(zip_file, parts)
+      parts.each do |name, content|
+        next if name == MIMETYPE_ENTRY
+
+        zip_file.get_output_stream(name) { |stream| stream.write(content) }
+      end
+    end
+    private_class_method :write_remaining_parts
+
+    def self.with_mimetype_tempfile(content)
+      return yield(nil) unless content
+
+      Tempfile.create("idml-mimetype") do |tmp|
+        tmp.write(content)
+        tmp.close
+        yield tmp.path
+      end
+    end
+    private_class_method :with_mimetype_tempfile
+  end
+end

data/lib/idml/part.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Idml
+  # Mixin for every part class (typed or raw). Provides the `part_file`
+  # class-level macro that registers the class against a filename pattern
+  # in Idml::Parts. New part classes self-register; nothing else in the
+  # codebase needs to change when adding one (open/closed).
+  module Part
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def part_file(pattern)
+        reg = pattern.is_a?(Regexp) ? pattern : /\A#{Regexp.escape(pattern)}\z/
+        Idml::Parts.register(reg, self)
+      end
+    end
+  end
+end

data/lib/idml/parts/backing_story.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Idml
+  module Parts
+    # Typed model for `XML/BackingStory.xml`. BackingStory is the root
+    # of the document's logical XML structure. Root is
+    # `<idPkg:BackingStory>`; the inner `<XmlStory>` carries the
+    # structure tree. XmlStory declares every attribute from
+    # `XmlStory_Object` in
+    # `reference-docs/schemas/package/XML/BackingStory.rnc`.
+    class BackingStory < Lutaml::Model::Serializable
+      include Idml::Part
+
+      part_file "XML/BackingStory.xml"
+
+      attribute :dom_version, :string
+      attribute :xml_story, Idml::Elements::XmlStory, collection: true
+
+      xml do
+        root "BackingStory"
+        namespace Idml::PackagingNamespace
+        map_attribute "DOMVersion", to: :dom_version
+        map_element "XmlStory", to: :xml_story
+      end
+    end
+  end
+end

data/lib/idml/parts/designmap.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Idml
+  module Parts
+    # Typed model for the package's `designmap.xml` part. The file's
+    # root is `<Document>` directly (no `<idPkg:Document>` wrapper
+    # unlike other parts). Every attribute from `Document_Object` in
+    # `reference-docs/schemas/package/designmap.rnc` is declared,
+    # generated by `scripts/rnc_to_lutaml.rb`.
+    class Designmap < Lutaml::Model::Serializable
+      include Idml::Part
+
+      part_file "designmap.xml"
+
+      attribute :dom_version, :string
+      attribute :self_attr, :string
+      attribute :story_list, :string
+      attribute :full_name, :string
+      attribute :visible, :boolean
+      attribute :file_path, :string
+      attribute :modified, :boolean
+      attribute :saved, :boolean
+      attribute :name, :string
+      attribute :zero_point, :string
+      attribute :active_layer, :string
+      attribute :unused_swatches, :string
+      attribute :converted, :boolean
+      attribute :recovered, :boolean
+      attribute :read_only, :boolean
+      attribute :id_attr, :integer
+      attribute :cmyk_profile_list, :string
+      attribute :rgb_profile_list, :string
+      attribute :cmyk_profile, :string
+      attribute :rgb_profile, :string
+      attribute :solid_color_intent, :string
+      attribute :after_blending_intent, :string
+      attribute :default_image_intent, :string
+      attribute :rgb_policy, :string
+      attribute :cmyk_policy, :string
+      attribute :accurate_lab_spots, :boolean
+      attribute :selected_page_items, :string
+      attribute :transparency_attribute_default_property, :string
+      attribute :applied_math_ml_font_size, :float
+      attribute :applied_math_ml_rgb_color, :string
+      attribute :tint_value, :float
+      attribute :prefer_math_ml_in_epub_export, :boolean
+      attribute :active_process, :string
+
+      attribute :layer, Idml::Elements::Layer, collection: true
+
+      xml do
+        root "Document"
+        map_attribute "DOMVersion", to: :dom_version
+        map_attribute "Self", to: :self_attr
+        map_attribute "StoryList", to: :story_list
+        map_attribute "FullName", to: :full_name
+        map_attribute "Visible", to: :visible
+        map_attribute "FilePath", to: :file_path
+        map_attribute "Modified", to: :modified
+        map_attribute "Saved", to: :saved
+        map_attribute "Name", to: :name
+        map_attribute "ZeroPoint", to: :zero_point
+        map_attribute "ActiveLayer", to: :active_layer
+        map_attribute "UnusedSwatches", to: :unused_swatches
+        map_attribute "Converted", to: :converted
+        map_attribute "Recovered", to: :recovered
+        map_attribute "ReadOnly", to: :read_only
+        map_attribute "Id", to: :id_attr
+        map_attribute "CMYKProfileList", to: :cmyk_profile_list
+        map_attribute "RGBProfileList", to: :rgb_profile_list
+        map_attribute "CMYKProfile", to: :cmyk_profile
+        map_attribute "RGBProfile", to: :rgb_profile
+        map_attribute "SolidColorIntent", to: :solid_color_intent
+        map_attribute "AfterBlendingIntent", to: :after_blending_intent
+        map_attribute "DefaultImageIntent", to: :default_image_intent
+        map_attribute "RGBPolicy", to: :rgb_policy
+        map_attribute "CMYKPolicy", to: :cmyk_policy
+        map_attribute "AccurateLABSpots", to: :accurate_lab_spots
+        map_attribute "SelectedPageItems", to: :selected_page_items
+        map_attribute "TransparencyAttributeDefaultProperty",
+                      to: :transparency_attribute_default_property
+        map_attribute "AppliedMathMLFontSize", to: :applied_math_ml_font_size
+        map_attribute "AppliedMathMLRgbColor", to: :applied_math_ml_rgb_color
+        map_attribute "TintValue", to: :tint_value
+        map_attribute "PreferMathMLInEpubExport", to: :prefer_math_ml_in_epub_export
+        map_attribute "ActiveProcess", to: :active_process
+        map_element "Layer", to: :layer
+      end
+    end
+  end
+end

data/lib/idml/parts/fonts.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Idml
+  module Parts
+    # Typed model for `Resources/Fonts.xml`. Root is `<idPkg:Fonts>`;
+    # children are `<FontFamily>` elements (each containing `<Font>`
+    # children). FontFamily and Font declare every attribute from
+    # their respective `_Object` definitions in
+    # `reference-docs/schemas/package/Resources/Fonts.rnc`.
+    class Fonts < Lutaml::Model::Serializable
+      include Idml::Part
+
+      part_file "Resources/Fonts.xml"
+
+      attribute :dom_version, :string
+      attribute :font_family, Idml::Elements::FontFamily, collection: true
+
+      xml do
+        root "Fonts"
+        namespace Idml::PackagingNamespace
+        map_attribute "DOMVersion", to: :dom_version
+        map_element "FontFamily", to: :font_family
+      end
+    end
+  end
+end