emfsvg 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4334821604725312749ae532acdd4d729ec4bbdde73897e097d9aedf5404b20e
-  data.tar.gz: 077c491cd219b2f274036fb613353e0226ea150fa0cf70e0f544ae07f4b88598
+  metadata.gz: 5486d21c06edc95e8adcdd149befbac957e05eb18b3d4cb89a6ac556cf991f68
+  data.tar.gz: 423352d0507ab33950c3dbe22cfba957e76af5f48961dd77ab782b58714eaf75
 SHA512:
-  metadata.gz: d18d84ed9d2d156aee6e89fc946c4d6c53c00678b7b627c5c995cc7fb72f7bb52780dfeb27ecc14047e5aa3906502e1ca05d2609c6556201685dbacaee9fc3db
-  data.tar.gz: afb7470b2d7761102326ee7877cfa41c488966dadfde449abe91cdc332aead381b9f4a8bcef6a5bd582f7423d2336cbd982e1c213e5d210f38f336997ed2d720
+  metadata.gz: 2f2bdd7812cca71e2c160a8cba35a825c523678496db81176ba9f5f09aa0bbe5626e54d38aaaf8562b004c1a601c931a5a224a1c85a69d6ac770abbd617b9323
+  data.tar.gz: da3a81e8f1a56e7e213c25cb83621430c1f242b1b00edbf37d4c41c525ac5dc83b78342f095a2cafdca9fbc972c7625f983e9d4f07f55077eb0d2de9f79f58f6

data/README.adoc

@@ -1,24 +1,39 @@
-= emfsvg: pure-Ruby EMF to SVG transformer
+= emfsvg: pure-Ruby EMF ↔ SVG transformer
 
-`emfsvg` converts Microsoft Enhanced Metafile (EMF) documents to SVG
-using the [`emf`](https://github.com/claricle/emf) gem's domain model.
-It is a clean-room Ruby replacement for the FFI wrapper around the
-GPLv2 `libemf2svg` C library.
+`emfsvg` converts between Microsoft Enhanced Metafile (EMF) and SVG
+in both directions. It is a clean-room Ruby replacement for the FFI
+wrapper around the GPLv2 `libemf2svg` C library.
+
+== Status
+
+* **EMF → SVG**: 208/208 fixtures (100%) semantically match libemf2svg.
+  Verified with the lossy `SvgMatcher` at 0.1px tolerance.
+  79/208 are byte-identical to libemf2svg's output.
+* **SVG → EMF**: functional for shapes, transforms, clips, text, and
+  images. Synthetic SVGs round-trip byte-equal through
+  `SVG → EMF → SVG`. The lossy matcher and golden-master tooling
+  are in place for iterative fidelity improvement.
 
 == Synopsis
 
   require "emfsvg"
 
+  # EMF → SVG
   svg = Emfsvg.from_file("image.emf")
   svg = Emfsvg.from_bytes(emf_bytes, width: 400, height: 300)
-  metafile = Emf.parse(emf_bytes)
-  svg = Emfsvg.to_svg(metafile, namespace: "svg")
+
+  # SVG → EMF
+  emf = Emfsvg.from_svg_file("drawing.svg")
+  emf = Emfsvg.from_svg(svg_string)
 
 == Command-line tool
 
   emfsvg convert INPUT.emf OUTPUT.svg [options]
+  emfsvg to-emf INPUT.svg OUTPUT.emf
+  emfsvg version
+  emfsvg help
 
-Options:
+Options (convert):
 
   -w, --width PIXELS      Override viewport width
   -h, --height PIXELS     Override viewport height
@@ -28,50 +43,50 @@ Options:
 
 == Architecture
 
-`emfsvg` adds a renderer layer on top of `emf`'s domain model:
-
-  Emf::Model::Metafile
-       v
-  Emfsvg::Renderer
-       v
-  Emfsvg::Visitors::EmrVisitor
-       v
-  Emfsvg::SvgBuilder (XML)
-       v
-  Emfsvg::DeviceContext (GDI state)
-       v
-  Emfsvg::ObjectTable (1-indexed pen/brush/font handles)
-
-The renderer walks the metafile's records, dispatching each to a
-`visit_<record_type>` method on the visitor. State changes (pen,
-brush, transform, clip) flow through the `DeviceContext`; persistent
-objects are stored in the `ObjectTable`.
-
-=== Handlers
-
-The visitor handles a useful subset of EMF records out of the box:
-
-* *Primitives*: `Rectangle`, `Ellipse`, `RoundRect`, `LineTo`,
-  `MoveToEx`, `Arc` (stub), `Polygon`, `Polyline` + 16-bit variants
-* *Paths*: `BeginPath`/`EndPath`/`CloseFigure`/`FillPath`/`StrokePath`/
-  `StrokeAndFillPath`/`AbortPath`
-* *State*: `SetTextColor`, `SetBkColor`, `SetBkMode`, `SetMapMode`,
-  `SetRop2`, `SetPolyFillMode`, `SetTextAlign`, `SetStretchBltMode`
-* *Transform*: `SetWorldTransform`, `ModifyWorldTransform`
-* *Objects*: `CreatePen`, `CreateBrushIndirect`, `SelectObject`,
-  `DeleteObject`, `SaveDc`, `RestoreDc`
-* *Misc*: `SetMiterLimit`, `SetWindowExtEx`, `SetViewportExtEx`
-
-Unsupported record types fall through silently (verbose mode logs
-them).
-
-=== Sparx/Wine Y-repair
-
-EMFs from Sparx Enterprise Architect under Wine have only the Y anchor
-negated. The detector (`rclBounds.top * rclBounds.bottom < 0`) and the
-per-coordinate repair live in `Emfsvg::Renderer` and
-`Emfsvg::Visitors::EmrVisitor#maybe_flip_y`, matching the behaviour
-of the C library.
+[cols="1,4"]
+|===
+| EMF → SVG | `Emf::Model::Metafile` → `Emfsvg::Renderer` → `Emfsvg::Visitors::EmrVisitor` → `Emfsvg::SvgBuilder`
+| SVG → EMF | SVG bytes → Nokogiri → `Emfsvg::Svg::Document` → `Emfsvg::Translation::EmfRenderer` → `Emf::Model::Metafile` → `Emf.serialize`
+|===
+
+Both directions share:
+
+* `Emfsvg::DeviceContext` / `ObjectTable` / `TransformStack` — GDI state
+* `Emf::*` — the `emf` gem's wire record classes + serializer
+* `Emfsvg::SvgMatcher` (spec/support) — lossy semantic SVG comparison
+
+=== SVG → EMF handler registry (OCP)
+
+Adding a new SVG element type means writing a handler class and
+registering it — no existing handler code changes:
+
+  # lib/emfsvg/translation/handlers/my_element_handler.rb
+  class MyElementHandler
+    include SharedGdi
+    def self.call(element, context)
+      # emit EMF records via context.emit(...)
+    end
+  end
+
+  # Register in EmfRenderer.register_default_handlers!
+  DEFAULT_REGISTRY.register(Svg::Elements::MyElement, Handlers::MyElementHandler)
+
+=== Lossy SVG matcher
+
+`Emfsvg::SvgMatcher` compares two SVG documents semantically:
+
+* Float tolerance (configurable, default 1.0px)
+* Auto-generated ID canonicalisation (`clip-N`, `img-N`)
+* libemf2svg typo normalisation (`0.00 00` → `0.0000`)
+* `<defs>` hoisting + multiset comparison
+* `<g transform><X/></g>` ≡ `<X transform/>` flattening
+
+Used by:
+
+* `spec/round_trip_spec.rb` — SVG→EMF→SVG round-trip verification
+* `spec/fidelity_regression_spec.rb` — EMF→SVG fidelity vs libemf2svg
+* `scripts/run_round_trip.rb` — full golden-master round-trip scan
+* `scripts/run_emf_svg_compare.rb` — full fidelity scan vs libemf2svg
 
 == Installation
 
@@ -92,12 +107,25 @@ Requires Ruby >= 3.1.
   bundle exec rspec
   bundle exec rubocop
 
-== Status
-
-EMF-to-SVG renders the common subset of records from the EMF
-fixtures. Bitmap records (StretchDIBits, AlphaBlend, etc.) and
-EMF+ drawing records are not yet rendered. Corrupted inputs are
-resilient through the `emf` parser's hardened error handling.
+=== Developer scripts
+
+[cols="1,3"]
+|===
+| `scripts/run_emf_svg_compare.rb [limit] [tolerance]` | EMF→SVG fidelity vs libemf2svg (208 fixtures, 100% pass at 0.1px)
+| `scripts/run_round_trip.rb [limit] [tolerance]` | SVG→EMF→SVG round-trip scan
+| `scripts/diff_fixture.rb <fixture.svg>` | Element-by-element diff between input and round-trip output
+| `scripts/diagnose_round_trip.rb [limit]` | Per-fixture failure reasons for round-trip scan
+| `scripts/regenerate_golden.rb` | Regenerate libemf2svg + emfsvg golden baselines
+| `scripts/run_compat_check.rb` | Legacy compat matrix vs libemf2svg
+|===
+
+== Dependencies
+
+* `emf` (~> 0.1) — EMF binary parser, domain model, and serializer
+* `nokogiri` (~> 1.16) — SVG parser
+* `fontisan` — cmap parsing for glyph-index text
+* `libpng` (~> 1.6) — PNG encode/decode for image round-trip
+* `base64`, `bigdecimal` — stdlib
 
 == License
 

data/exe/emfsvg

@@ -13,6 +13,7 @@ module EmfsvgCLI
     command = argv.shift
     case command
     when "convert" then convert(argv)
+    when "to-emf" then to_emf(argv)
     when "version", "-V", "--version"
       puts "emfsvg #{Emfsvg::VERSION}"
     when "help", "-h", "--help", nil
@@ -47,16 +48,34 @@ module EmfsvgCLI
     warn "Wrote #{output} (#{svg.bytesize} bytes)"
   end
 
+  def to_emf(argv)
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: emfsvg to-emf INPUT.svg OUTPUT.emf"
+    end
+
+    args = parser.parse(argv)
+    if args.length != 2
+      warn parser
+      exit 2
+    end
+
+    input, output = args
+    emf = Emfsvg.from_svg_file(input)
+    File.binwrite(output, emf)
+    warn "Wrote #{output} (#{emf.bytesize} bytes)"
+  end
+
   def print_help
     puts <<~HELP
-      emfsvg #{Emfsvg::VERSION} — EMF to SVG transformer
+      emfsvg #{Emfsvg::VERSION} — EMF <-> SVG transformer
 
       Usage:
         emfsvg convert INPUT.emf OUTPUT.svg [options]
+        emfsvg to-emf INPUT.svg OUTPUT.emf
         emfsvg version
         emfsvg help
 
-      Options:
+      Options (convert):
         -w, --width PIXELS      Override viewport width
         -h, --height PIXELS     Override viewport height
         -n, --namespace NAME    XML namespace prefix (e.g. svg)

data/lib/emfsvg/dib_encoder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  # Encode RGBA pixels + dimensions to Windows DIB (BITMAPINFOHEADER +
+  # pixel array) suitable for embedding in EMR_STRETCHDIBITS and
+  # related records. The inverse of emfsvg's DibDecoder.
+  #
+  # Output layout (BI_RGB, 32-bpp, bottom-up):
+  #   * BITMAPINFOHEADER (40 bytes)
+  #   * pixel array (BGRA per pixel, row-major from bottom to top)
+  module DibEncoder
+    BITMAPINFOHEADER_SIZE = 40
+    BI_RGB = 0
+
+    module_function
+
+    def encode(width, height, rgba_bytes)
+      return "" if width <= 0 || height <= 0
+      return "" if rgba_bytes.nil? || rgba_bytes.bytesize < (width * height * 4)
+
+      header = build_header(width, height)
+      pixels = bgra_pixel_array(width, height, rgba_bytes)
+      header + pixels
+    end
+
+    def build_header(width, height)
+      pixel_bytes = width * height * 4
+      [
+        BITMAPINFOHEADER_SIZE, # biSize  (uint32)
+        width,                            # biWidth (int32)
+        height,                           # biHeight (int32, positive = bottom-up)
+        1,                                # biPlanes (uint16)
+        32,                               # biBitCount (uint16)
+        BI_RGB,                           # biCompression (uint32)
+        pixel_bytes,                      # biSizeImage (uint32)
+        2835,                             # biXPelsPerMeter (~72 DPI)
+        2835,                             # biYPelsPerMeter
+        0,                                # biClrUsed
+        0                                 # biClrImportant
+      ].pack("Vl<l<vvVVVVVV")
+    end
+
+    # Convert RGBA → BGRA (the byte order DIB expects), keeping the
+    # bottom-up row order (rows reversed).
+    def bgra_pixel_array(width, height, rgba_bytes)
+      row_size = width * 4
+      out = String.new capacity: width * height * 4
+      (0...height).to_a.reverse_each do |src_row|
+        row_start = src_row * row_size
+        row_bytes = rgba_bytes.byteslice(row_start, row_size)
+        out << swap_rb_in_row(row_bytes)
+      end
+      out
+    end
+
+    def swap_rb_in_row(row_bytes)
+      bytes = row_bytes.dup
+      (0...bytes.bytesize).step(4).each do |i|
+        r = bytes.getbyte(i)
+        b = bytes.getbyte(i + 2)
+        bytes.setbyte(i, b)
+        bytes.setbyte(i + 2, r)
+      end
+      bytes
+    end
+  end
+end

data/lib/emfsvg/error.rb

@@ -5,5 +5,7 @@ module Emfsvg
 
   class FormatError < Error; end
 
+  class ParseError < Error; end
+
   class RenderError < Error; end
 end

data/lib/emfsvg/png_decoder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "libpng"
+
+module Emfsvg
+  # Decode PNG bytes to RGBA pixels. Wraps the libpng simplified API.
+  # Returns a Result with width, height, and a packed RGBA pixel buffer.
+  module PngDecoder
+    Result = Struct.new(:width, :height, :pixels, keyword_init: true)
+
+    module_function
+
+    def decode(png_bytes)
+      return nil if png_bytes.nil? || png_bytes.empty?
+
+      decoded = Libpng.decode(png_bytes, pixel_format: "RGBA")
+      Result.new(width: decoded.width, height: decoded.height,
+                 pixels: decoded.pixels)
+    rescue Libpng::Error
+      nil
+    end
+  end
+end

data/lib/emfsvg/svg/attribute_parser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Helpers for parsing common SVG attribute formats (numbers, points,
+    # path data). Used by Element subclasses.
+    module AttributeParser
+      module_function
+
+      def float(value, default: 0.0)
+        return default if value.nil? || value.strip.empty?
+
+        match = value.strip.match(/\A(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/)
+        match ? match[1].to_f : default
+      end
+
+      def integer(value, default: 0)
+        float(value, default: default.to_f).to_i
+      end
+
+      # Parse a points list like "1,2 3,4 5,6" into an array of [x, y]
+      # pairs.
+      def points(value)
+        return [] if value.nil? || value.strip.empty?
+
+        nums = value.strip.split(/[\s,]+/).map(&:to_f)
+        nums.each_slice(2).to_a
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/clip_path_registry.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Resolves `clip-path="url(#X)"` references to ClipPath value
+    # objects. Built once per Svg::Document by walking the <defs>
+    # section; queried by the translation layer when emitting clip
+    # records for a shape.
+    class ClipPathRegistry
+      URL_RE = /\Aurl\(\s*#([^)\s]+)\s*\)\z/
+
+      def initialize
+        @clip_paths = {}
+      end
+
+      def register(clip_path)
+        @clip_paths[clip_path.id] = clip_path
+      end
+
+      def lookup(clip_path_attr)
+        return nil if clip_path_attr.nil?
+
+        match = clip_path_attr.match(URL_RE)
+        return nil unless match
+
+        @clip_paths[match[1]]
+      end
+
+      def self.from_document(document)
+        registry = new
+        collect_clip_paths(document.root_element, registry)
+        registry
+      end
+
+      def self.collect_clip_paths(element, registry)
+        return unless element
+
+        registry.register(element) if element.is_a?(Elements::ClipPath)
+        element.children.each { |c| collect_clip_paths(c, registry) }
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/color.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # SVG color value object. Holds an RGB triplet (0..255 each) or
+    # represents a "null" color (fill="none" / stroke="none").
+    #
+    # Parses CSS color syntax:
+    #   * #RGB / #RRGGBB hex
+    #   * rgb(r, g, b) functional
+    #   * CSS Level 1+2 named colors (17 basic)
+    #
+    # Anything else raises Emfsvg::FormatError. The translation layer
+    # relies on a normalized RGB triplet — no transparency, no currentColor.
+    class Color
+      attr_reader :red, :green, :blue
+
+      def initialize(red:, green:, blue:)
+        @red = clamp(red)
+        @green = clamp(green)
+        @blue = clamp(blue)
+      end
+
+      def null?
+        false
+      end
+
+      def to_emf_wire
+        Emf::Model::Geometry::Color.new(red: red, green: green, blue: blue)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && red == other.red && green == other.green && blue == other.blue
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, red, green, blue].hash
+      end
+
+      NULL = NullColor = Class.new do
+        def null? = true
+        def red = 0
+        def green = 0
+        def blue = 0
+        def to_emf_wire = Emf::Model::Geometry::Color.new(red: 0, green: 0, blue: 0)
+        def ==(other) = other.is_a?(self.class)
+        alias_method :eql?, :==
+        def hash = NullColor.hash
+      end.new.freeze
+
+      NAMED_COLORS = {
+        "black" => [0x00, 0x00, 0x00],
+        "silver" => [0xC0, 0xC0, 0xC0],
+        "gray" => [0x80, 0x80, 0x80],
+        "grey" => [0x80, 0x80, 0x80],
+        "white" => [0xFF, 0xFF, 0xFF],
+        "maroon" => [0x80, 0x00, 0x00],
+        "red" => [0xFF, 0x00, 0x00],
+        "purple" => [0x80, 0x00, 0x80],
+        "fuchsia" => [0xFF, 0x00, 0xFF],
+        "magenta" => [0xFF, 0x00, 0xFF],
+        "green" => [0x00, 0x80, 0x00],
+        "lime" => [0x00, 0xFF, 0x00],
+        "olive" => [0x80, 0x80, 0x00],
+        "yellow" => [0xFF, 0xFF, 0x00],
+        "navy" => [0x00, 0x00, 0x80],
+        "blue" => [0x00, 0x00, 0xFF],
+        "teal" => [0x00, 0x80, 0x80],
+        "aqua" => [0x00, 0xFF, 0xFF],
+        "cyan" => [0x00, 0xFF, 0xFF]
+      }.freeze
+
+      def self.parse(value)
+        return NULL if value.nil? || value.strip == "none" || value.strip.empty?
+
+        v = value.strip
+        if (m = v.match(/\A#([0-9a-fA-F]{3})\z/))
+          expand_short_hex(m[1])
+        elsif (m = v.match(/\A#([0-9a-fA-F]{6})\z/))
+          new(red: m[1][0, 2].to_i(16), green: m[1][2, 2].to_i(16), blue: m[1][4, 2].to_i(16))
+        elsif (m = v.match(/\Argb\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*\)\z/i))
+          new(red: m[1].to_i, green: m[2].to_i, blue: m[3].to_i)
+        elsif NAMED_COLORS.key?(v.downcase)
+          r, g, b = NAMED_COLORS[v.downcase]
+          new(red: r, green: g, blue: b)
+        else
+          raise FormatError, "unsupported SVG color: #{value.inspect}"
+        end
+      end
+
+      def self.expand_short_hex(digits)
+        new(red: (digits[0] * 2).to_i(16),
+            green: (digits[1] * 2).to_i(16),
+            blue: (digits[2] * 2).to_i(16))
+      end
+
+      private
+
+      def clamp(byte)
+        byte.to_i.clamp(0, 255)
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/document.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Root of a parsed SVG document. Carries the viewport geometry from
+    # the outer <svg width height viewBox> element plus the (lazily
+    # parsed) child element tree.
+    #
+    # emfsvg's EMF→SVG renderer always wraps content in
+    # `<g transform="translate(-bounds.left, -bounds.top)">`. For
+    # byte-clean round-trip, the SVG→EMF side detects this "header
+    # translate group" and uses it to recover the EMF bounds origin
+    # instead of emitting a redundant SetWorldTransform.
+    class Document
+      def initialize(width:, height:, root_element:, view_box: nil)
+        @width = width
+        @height = height
+        @view_box = view_box
+        @root_element = root_element
+      end
+
+      attr_reader :width, :height, :view_box, :root_element
+
+      # The Group that represents the emfsvg-emitted header translate,
+      # or nil if no such group is present. This group's contents are
+      # dispatched directly (without the wrapping translate); the
+      # translate feeds the EMF header bounds instead.
+      def header_translate_group
+        candidate = first_child
+        return nil unless candidate.is_a?(Elements::Group)
+
+        matrix = candidate.transform_matrix
+        return nil unless matrix
+        return nil unless translate_only?(matrix)
+
+        candidate
+      end
+
+      # A matrix equivalent to a pure translate: identity 2×2 portion
+      # (modulo floating-point rounding).
+      IDENTITY_TOLERANCE = 1e-9
+
+      def translate_only?(matrix)
+        (matrix.m11 - 1.0).abs < IDENTITY_TOLERANCE &&
+          (matrix.m22 - 1.0).abs < IDENTITY_TOLERANCE &&
+          matrix.m12.abs < IDENTITY_TOLERANCE &&
+          matrix.m21.abs < IDENTITY_TOLERANCE
+      end
+
+      # [min_x, min_y, w, h] for the EMF bounds.
+      def bounds
+        return view_box if view_box
+
+        group = header_translate_group
+        if group
+          matrix = group.transform_matrix
+          return [-matrix.dx, -matrix.dy, width, height]
+        end
+
+        [0, 0, width, height]
+      end
+
+      private
+
+      def first_child
+        root_element.is_a?(Element) ? root_element.children.first : nil
+      end
+    end
+  end
+end

data/lib/emfsvg/svg/element.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Emfsvg
+  module Svg
+    # Base value object for an SVG element. Subclasses (Svg::Elements::*)
+    # carry typed semantic fields; the base provides a uniform interface
+    # for the translation layer's dispatch.
+    #
+    # Element instances are immutable: built once from a Nokogiri node
+    # via the .from_node factory. The node is not retained.
+    class Element
+      ELEMENT_NAME = "abstract"
+
+      def element_name
+        self.class::ELEMENT_NAME
+      end
+
+      def children
+        []
+      end
+
+      # All elements expose `clip_path` (nil by default) so the SharedGdi
+      # module can treat every element uniformly. Subclasses with the
+      # attribute override via attr_reader.
+      def clip_path
+        nil
+      end
+
+      # Registry: SVG element name -> Element subclass. OCP: register
+      # new subclasses via Element.register("rect", Elements::Rect)
+      # instead of editing a switch.
+      @registry = {}
+
+      class << self
+        attr_reader :registry
+
+        def register(element_name, subclass)
+          @registry[element_name] = subclass
+        end
+
+        def from_node(node)
+          subclass = @registry[node.name]
+          return subclass.from_node(node) if subclass
+
+          OpenElement.new(name: node.name, children: node.element_children.map do |c|
+            from_node(c)
+          end)
+        end
+      end
+    end
+
+    # Fallback for unknown SVG element types. Carries the element name
+    # so handlers can skip it or warn; carries children so traversal
+    # still descends into known subtrees.
+    class OpenElement < Element
+      ELEMENT_NAME = "open"
+
+      attr_reader :name, :children
+
+      def initialize(name:, children: [])
+        @name = name
+        @children = children.freeze
+      end
+    end
+  end
+end