metanorma-oiml 0.1.0

data/lib/metanorma/oiml/sts/html_renderer/templates/_element.html.liquid

@@ -0,0 +1 @@
+<{{ tag }}{% if id %} id="{{ id }}"{% endif %}{% if css %} class="{{ css }}"{% endif %}>{{ content }}</{{ tag }}>

data/lib/metanorma/oiml/sts/html_renderer/templates/_footer.html.liquid

@@ -0,0 +1,21 @@
+<div class="footer-grid">
+  <div class="footer-block">
+    <p class="footer-license">
+      {% if copyright %}{{ copyright | escape }} · {{ license | escape }}{% else %}{{ license | escape }}{% endif %}
+    </p>
+    <p class="footer-publisher">{{ publisher_name | escape }}</p>
+    <p class="footer-address">{{ publisher_address | escape }}</p>
+    <p class="footer-contact">
+      <a href="https://www.oiml.org">www.oiml.org</a> ·
+      <a href="mailto:biml@oiml.org">biml@oiml.org</a>
+    </p>
+  </div>
+  <div class="footer-block footer-meta">
+    <p><span class="footer-docid">{{ docid | escape }}</span></p>
+    <p class="footer-meta-line">{% if series != "" %}Series {{ series | escape }} · {% endif %}{% if year != "" %}{{ year | escape }} · {% endif %}EN</p>
+    <p class="footer-generated">
+      <span class="mn-icon brand-logo-light">{{ mn_icon_light }}</span><span class="mn-icon brand-logo-dark">{{ mn_icon_dark }}</span>
+      Generated by <a href="https://www.metanorma.org" title="Metanorma — aequitate verum">metanorma-oiml</a> {{ version | escape }}
+    </p>
+  </div>
+</div>

data/lib/metanorma/oiml/sts/html_renderer/templates/_hero.html.liquid

@@ -0,0 +1,9 @@
+<div class="hero">
+  <p class="hero-eyebrow">{{ eyebrow | escape }}</p>
+  <h1 class="hero-title">{{ title | escape }}</h1>
+  <p class="hero-chips">
+    {% for chip in chips %}
+    <span class="hero-chip{% if forloop.first %} hero-chip-primary{% endif %}">{{ chip | escape }}</span>
+    {% endfor %}
+  </p>
+</div>

data/lib/metanorma/oiml/sts/html_renderer/templates/_img.html.liquid

@@ -0,0 +1 @@
+<img src="{{ src }}" alt="{{ alt | escape }}"/>

data/lib/metanorma/oiml/sts/html_renderer/templates/_link.html.liquid

@@ -0,0 +1 @@
+<a href="{{ href | escape }}">{{ text }}</a>

data/lib/metanorma/oiml/sts/html_renderer/templates/_meta_header.html.liquid

@@ -0,0 +1 @@
+<header>{% if docid != "" %}<span class="doc-id">{{ docid }}</span>{% endif %}{% if title != "" %}<span class="title">{{ title }}</span>{% endif %}</header>

data/lib/metanorma/oiml/sts/html_renderer/templates/document.html.liquid

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="{{ lang }}">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>{{ title | escape }}</title>
+<script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
+<style type="text/tailwindcss">
+{{ css }}
+</style>
+</head>
+<body class="bg-paper text-ink font-body text-[16px] leading-relaxed m-0">
+<header class="site-nav sticky top-0 z-40 flex items-center gap-3 min-h-[56px] px-5 py-2 bg-nav-bg border-b border-nav-border text-nav-text shadow-sm">
+  <span class="brand-logo-light shrink-0 [&>svg]:h-[34px] [&>svg]:w-auto [&>svg]:block">{{ logo_light }}</span>
+  <span class="brand-logo-dark shrink-0 [&>svg]:h-[34px] [&>svg]:w-auto [&>svg]:block">{{ logo_dark }}</span>
+  <span class="nav-doc-title font-semibold text-nav-text truncate min-w-0">{{ title | escape }}</span>
+  <nav class="breadcrumb hidden md:flex items-baseline gap-2 min-w-0 text-sm whitespace-nowrap overflow-hidden ml-auto" aria-label="Breadcrumb">
+    <span class="crumb-doc font-mono text-xs font-bold tracking-wider uppercase text-accent">{{ docid | escape }}</span><span class="crumb-sep text-ink-faint" aria-hidden="true">›</span><span class="crumb-current overflow-hidden text-ellipsis text-ink-faint" id="crumb-current"></span>
+  </nav>
+  <span class="nav-actions ml-auto md:ml-0 flex gap-2">
+    <button id="theme-toggle" class="nav-btn inline-flex items-center justify-center w-9 h-9 rounded-md border border-nav-btn-border bg-nav-btn-bg text-nav-text hover:border-accent hover:text-accent transition-colors cursor-pointer" aria-label="Toggle light and dark mode" title="Toggle light / dark mode">
+      <svg class="icon-sun hidden dark:block" viewBox="0 0 16 16" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"><circle cx="8" cy="8" r="3"/><line x1="8" y1="1" x2="8" y2="3"/><line x1="8" y1="13" x2="8" y2="15"/><line x1="1" y1="8" x2="3" y2="8"/><line x1="13" y1="8" x2="15" y2="8"/><line x1="3.05" y1="3.05" x2="4.46" y2="4.46"/><line x1="11.54" y1="3.05" x2="12.95" y2="4.46"/><line x1="3.05" y1="12.95" x2="4.46" y2="11.54"/><line x1="11.54" y1="12.95" x2="12.95" y2="11.54"/></svg>
+      <svg class="icon-moon dark:hidden" viewBox="0 0 16 16" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M13.5 9.5A5.5 5.5 0 0 1 6.5 2.5 5.5 5.5 0 1 0 13.5 9.5z"/></svg>
+    </button>
+    <button id="toc-toggle" class="nav-btn hidden max-lg:inline-flex items-center justify-center w-9 h-9 rounded-md border border-nav-btn-border bg-nav-btn-bg text-nav-text hover:border-accent hover:text-accent transition-colors cursor-pointer" aria-label="Show contents" aria-expanded="false" aria-controls="toc" title="Contents">☰</button>
+  </span>
+</header>
+{{ hero }}
+<div class="page grid max-lg:grid-cols-1 lg:grid-cols-[300px_minmax(0,1fr)] gap-10 max-w-[1200px] mx-auto px-6 pt-7 pb-8 max-lg:px-4">
+  {{ toc }}
+  <div class="page-body min-w-0">
+    {{ content }}
+  </div>
+</div>
+<button id="back-to-top" class="back-to-top fixed right-6 bottom-6 z-40 w-10 h-10 rounded-full bg-accent text-white text-lg cursor-pointer shadow-lg opacity-0 translate-y-2 pointer-events-none transition-all hover:brightness-110" aria-label="Back to top" title="Back to top">↑</button>
+<footer class="site-footer px-6 py-6 text-xs text-ink-faint border-t border-line">
+  {{ footer }}
+</footer>
+<script>
+{{ js }}
+</script>
+</body>
+</html>

data/lib/metanorma/oiml/sts/html_renderer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      # HTML rendering for OIML STS XML (Liquid-based; see
+      # html_renderer/ruby.rb).
+      module HtmlRenderer
+        autoload :Ruby, "#{__dir__}/html_renderer/ruby"
+
+        module_function
+
+        def render(sts_xml, **)
+          Ruby.new.render(sts_xml, **)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/mathml_builder.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# MathML passthrough helper.
+#
+# Design note: previously this module extracted plain text from MathML via
+# regex symbol rules, subscript/superscript rewriting, and asciimath
+# conversion. That approach was wrong — mnconvert (the production
+# Metanorma→STS converter) copies MathML verbatim into <inline-formula>.
+# We do the same via Mml::V3::Math.from_xml + Sts::NisoSts::InlineFormula.
+#
+# The text-extraction methods (asciimath_to_plain_text, mathml_to_plain_text,
+# apply_symbol_rules, apply_subscript_rules, apply_superscript_rules) were
+# removed. No code should reach back into this module for math rendering —
+# inline/dispatched formulas pass MathML through structurally.
+module Metanorma
+  module Oiml
+    module Sts
+      module MathmlBuilder
+        module_function
+
+        MATHML_NS = "http://www.w3.org/1998/Math/MathML"
+
+        def wrap_math_content(content)
+          "<math xmlns='#{MATHML_NS}'>#{content}</math>"
+        end
+
+        # The Math model class nominally paired with a formula wrapper
+        # class. sts >= 0.6.0 unified all MathML on Mml::V3::Math across
+        # IsoSts, NisoSts, and TbxIsoTml, so this is always Mml::V3::Math
+        # regardless of the formula wrapper's namespace. Kept as a
+        # method (not a constant) so callers don't hard-code the class.
+        def math_klass_for(_formula_klass)
+          Mml::V3::Math
+        end
+
+        # Builds a math model instance from a stem-bearing typed model node.
+        # Handles StemInlineElement (.math), StemBlockElement (.math),
+        # and FmtStemElement (.semx[].math). Returns nil when the node
+        # carries no parseable MathML — callers should silently drop
+        # the formula in that case (mnconvert's behavior).
+        #
+        # `klass:` selects which typed Math model to instantiate.
+        # Defaults to Mml::V3::Math — the canonical MathML model used
+        # by sts >= 0.6.0 across IsoSts, NisoSts, and TbxIsoTml.
+        def math_from_stem(stem_node, klass: Mml::V3::Math)
+          math_el = first_math_element(stem_node)
+          return nil unless math_el
+
+          # The stem's `math` attribute already carries a typed MML model
+          # (SemanticMathElement inherits Mml::V3::Math). Passing it
+          # straight through avoids the earlier stringify-and-reparse
+          # roundtrip — which depended on `math_el.content` and broke
+          # when the typed model changed shape.
+          return math_el if math_el.is_a?(klass)
+
+          # Fallback for any future stem shape that isn't already an
+          # Mml::V3::Math subclass: build from its serialized XML.
+          string = math_el.to_s
+          return nil if string.empty?
+
+          klass.from_xml(wrap_math_content(string))
+        rescue StandardError
+          nil
+        end
+
+        # Wraps the stem's MathML in an InlineFormula for
+        # use inside paragraphs and table cells. Returns nil if the
+        # stem carries no parseable MathML.
+        #
+        # Always uses Mml::V3::Math — the canonical MathML model,
+        # unified across all STS namespaces in sts >= 0.6.0.
+        def inline_formula_from_stem(stem_node, klass: ::Sts::NisoSts::InlineFormula)
+          math = math_from_stem(stem_node, klass: Mml::V3::Math)
+          return nil unless math
+
+          klass.new(math: math)
+        end
+
+        # SemanticMathElement is a subclass of Mml::V3::Math — already
+        # a fully-typed Math model. The earlier stringify/re-parse path
+        # broke because SemanticMathElement doesn't expose a `.content`
+        # accessor at the Lutaml level.
+        def first_math_element(stem_node)
+          if stem_node.is_a?(Metanorma::Document::Components::Inline::FmtStemElement)
+            Array(stem_node.semx).flat_map { |semx| Array(semx.math) }.first
+          elsif stem_node.class.method_defined?(:math)
+            Array(stem_node.math).first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/parity_validator/normaliser.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module ParityValidator
+        # Text normalisation shared by all comparison logic.
+        class Normaliser
+          CHROME_SELECTORS = %w[
+            script style head nav
+            .title-section .prefatory-section
+            .toc #toc
+            .coverpage_docnumber .coverpage_techcommittee
+            .coverpage_docstage .coverpage_warning
+            .doctitle-fr .doc-title
+            .btn .collapse-button .collapse-group
+            .anchor .h-anchor
+          ].freeze
+
+          # MN wraps heading text in `<a class="header">…</a>`. Removing
+          # the node would discard the title text; unwrap it instead so
+          # the content survives but the link chrome is gone.
+          UNWRAP_SELECTORS = %w[.header].freeze
+
+          BLOCK_BOUNDARY_ELEMENTS =
+            %w[p div td th li h1 h2 h3 h4 h5 h6 section table tr
+               ul ol dl dt dd].freeze
+
+          def self.strip_chrome(html, selectors: CHROME_SELECTORS)
+            doc = Nokogiri::HTML(html)
+            UNWRAP_SELECTORS.each do |sel|
+              doc.css(sel).each { |node| node.replace(node.children) }
+            end
+            selectors.each { |sel| doc.css(sel).remove }
+            doc.css("body").first&.to_html || doc.to_html
+          end
+
+          def self.normalise(text)
+            new_text = text.to_s
+            new_text = unify_block_boundaries(new_text)
+            # Collapse non-breaking spaces (U+00A0) and regular whitespace.
+            new_text = new_text.gsub(/[⁡⁢⁣⁤]/, "")
+            new_text = new_text.gsub(/[ \s]+/, " ")
+            new_text = unify_dashes(new_text)
+            new_text = new_text.gsub(/\s+/, " ").strip.downcase
+            new_text
+          end
+
+          def self.unify_block_boundaries(text)
+            regex = /(<\/(?:#{BLOCK_BOUNDARY_ELEMENTS.join("|")})>)/i
+            text.gsub(regex, " \\1")
+          end
+
+          def self.unify_dashes(text)
+            text.gsub(/[–—−]/, "-")
+          end
+
+          def self.strip_section_number(text)
+            text.to_s.gsub(/\A\s*\d+(\.\d+)*[\s ]+/, "")
+          end
+
+          # Annex headings carry an obligation marker on one side only:
+          # "Annex A (Informative) Examples" vs "Annex A Examples".
+          # Whitespace handling is intentionally separate from the
+          # marker match — the previous combined regex was flagged by
+          # CodeQL for polynomial backtracking on adversarial whitespace.
+          def self.strip_annex_obligation(text)
+            stripped = text.to_s.gsub(/\((?:in|nor)formative\)/i, " ")
+            stripped.squeeze(" ")
+          end
+
+          def self.strip_anchor_brackets(text)
+            text.to_s.gsub(/\[([A-Z0-9][A-Z0-9_]*)\]/, '\1')
+          end
+
+          def self.heading_text(text)
+            # Normalise FIRST: the number/title delimiter is often a
+            # non-breaking space, which only the normaliser collapses.
+            normalise(strip_annex_obligation(strip_section_number(normalise(text))))
+          end
+
+          def self.paragraph_text(text)
+            normalise(strip_anchor_brackets(text))
+          end
+
+          # List-item markers ("—", "•", "1.") are rendered as literal
+          # text on one side and CSS on the other; compare the content.
+          def self.list_item_text(text)
+            normalise(text.to_s.sub(/\A\s*[-–—•‒]\s*/, ""))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/parity_validator/report.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Metanorma
+  module Oiml
+    module Sts
+      module ParityValidator
+        # Result of a parity check. Reports which MN HTML elements are
+        # missing from the STS HTML.
+        class Report
+          attr_reader :missing_headings, :missing_paragraphs,
+                      :missing_table_cells, :missing_list_items,
+                      :missing_images, :missing_notes,
+                      :word_coverage_percent, :paragraph_coverage_percent
+
+          def initialize(mn_html:, sts_html:)
+            @mn_html = Normaliser.strip_chrome(mn_html)
+            # The STS side gets a lighter strip: its own heading anchors
+            # (.h-anchor) and non-content elements. The TOC/nav/footer
+            # stay — the MN side keeps its equivalents too, and removing
+            # them on one side only would manufacture mismatches.
+            @sts_html = Normaliser.strip_chrome(sts_html, selectors: STS_CHROME_SELECTORS)
+            compute_missing_sets
+            compute_coverage
+          end
+
+          STS_CHROME_SELECTORS = %w[script style head .h-anchor .li-label].freeze
+
+          def pass?
+            [
+              @missing_headings, @missing_paragraphs,
+              @missing_table_cells, @missing_list_items,
+              @missing_images, @missing_notes
+            ].all?(&:empty?)
+          end
+
+          def to_h
+            {
+              pass: pass?,
+              missing_headings: @missing_headings.to_a,
+              missing_paragraphs: @missing_paragraphs.to_a,
+              missing_table_cells: @missing_table_cells.to_a,
+              missing_list_items: @missing_list_items.to_a,
+              missing_images: @missing_images.to_a,
+              missing_notes: @missing_notes.to_a,
+              word_coverage_percent: @word_coverage_percent,
+              paragraph_coverage_percent: @paragraph_coverage_percent
+            }
+          end
+
+          private
+
+          def compute_missing_sets
+            mn = extract_elements(@mn_html)
+            sts = extract_elements(@sts_html)
+
+            @missing_headings = mn[:headings] - sts[:headings]
+            @missing_paragraphs = mn[:paragraphs] - sts[:paragraphs]
+            @missing_table_cells = mn[:table_cells] - sts[:table_cells]
+            @missing_list_items = mn[:list_items] - sts[:list_items]
+            @missing_images = mn[:images] - sts[:images]
+            @missing_notes = mn[:notes] - sts[:notes]
+          end
+
+          def extract_elements(html)
+            doc = Nokogiri::HTML(html)
+            {
+              headings: extract_set(doc, "//h1 | //h2 | //h3 | //h4 | //h5 | //h6",
+                                    method(:heading_normalised)),
+              paragraphs: extract_set(doc, "//p", method(:paragraph_normalised)),
+              # Cells that only carry a table note (class table-notes)
+              # compare in the notes set, not here.
+              table_cells: extract_set(doc, "//td[not(contains(@class,'table-notes'))] | //th",
+                                       method(:Normaliser_paragraph)),
+              list_items: extract_set(doc, "//li", method(:list_item_normalised)),
+              images: doc.xpath("//img/@src").map(&:value).to_set,
+              # Note bodies wherever they live (section flow or tfoot
+              # table-notes cells); the kind label is included by both
+              # renderers ("NOTE …").
+              notes: extract_set(doc, "//div[contains(@class,'note')] | //td[contains(@class,'table-notes')]",
+                                 method(:Normaliser_paragraph))
+            }
+          end
+
+          def extract_set(doc, xpath, normaliser_method)
+            doc.xpath(xpath).map do |node|
+              normaliser_method.call(node.text)
+            end.reject(&:empty?).to_set
+          end
+
+          def heading_normalised(text)
+            Normaliser.heading_text(text)
+          end
+
+          def paragraph_normalised(text)
+            Normaliser.paragraph_text(text)
+          end
+
+          def list_item_normalised(text)
+            Normaliser.list_item_text(text)
+          end
+
+          def Normaliser_paragraph(text)
+            Normaliser.normalise(text)
+          end
+
+          def compute_coverage
+            mn_text = Normaliser.normalise(Nokogiri::HTML(@mn_html).text)
+            sts_text = Normaliser.normalise(Nokogiri::HTML(@sts_html).text)
+            mn_words = mn_text.split.to_set
+            sts_words = sts_text.split.to_set
+            covered = mn_words.count { |w| sts_words.include?(w) }
+            @word_coverage_percent = if mn_words.empty?
+                                       100.0
+                                     else
+                                       (covered.to_f * 100.0 / mn_words.size).round(2)
+                                     end
+
+            mn_paras = Nokogiri::HTML(@mn_html).css("p").map do |p|
+              Normaliser.normalise(p.text)
+            end.reject(&:empty?).reject { |t| t.length < 30 }.to_set
+            sts_paras = Nokogiri::HTML(@sts_html).css("p").map do |p|
+              Normaliser.normalise(p.text)
+            end.reject(&:empty?).to_set
+            pcovered = mn_paras.count { |p| sts_paras.include?(p) }
+            @paragraph_coverage_percent = if mn_paras.empty?
+                                            100.0
+                                          else
+                                            (pcovered.to_f * 100.0 / mn_paras.size).round(2)
+                                          end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/parity_validator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "set"
+
+module Metanorma
+  module Oiml
+    module Sts
+      # Validates that the STS-rendered HTML contains 100% of the
+      # semantic content present in the Metanorma HTML output.
+      module ParityValidator
+        autoload :Report, "metanorma/oiml/sts/parity_validator/report"
+        autoload :Normaliser, "metanorma/oiml/sts/parity_validator/normaliser"
+
+        module_function
+
+        def validate(mn_html:, sts_html:)
+          Report.new(mn_html: mn_html, sts_html: sts_html)
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/transformer/back_transformer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class BackTransformer < Base
+          def transform(source)
+            app_group = build_app_group(source)
+            ref_lists = build_bibliography(source)
+            ModelBuilder.back(app_group: app_group, ref_list: ref_lists)
+          end
+
+          private
+
+          def build_app_group(source)
+            return nil if source.annexes.empty?
+
+            apps = source.annexes.map do |annex|
+              sec = section_transformer.transform(annex)
+              attrs = {}
+              APP_CONTENT_ATTRS.each do |attr|
+                next unless sec.class.method_defined?(attr)
+
+                value = sec.public_send(attr)
+                next if value.nil? || (value.is_a?(Array) && value.empty?)
+
+                # Section stores body paragraphs as `paragraphs` (plural);
+                # App stores them as `paragraph` (singular). Map across
+                # the boundary so the annex intro paragraphs survive.
+                key = (attr == :paragraphs) ? :paragraph : attr
+                attrs[key] = value
+              end
+              ::Sts::NisoSts::App.new(attrs)
+            end
+            ModelBuilder.app_group(app: apps)
+          end
+
+          # Everything SectionTransformer can produce: dropping any of
+          # these at the app boundary silently loses annex-level content
+          # (e.g. the Element map annex's table — or the annex letter
+          # label, "Annex A").
+          APP_CONTENT_ATTRS = %i[
+            id label title paragraphs list fig table_wrap def_list disp_formula
+            non_normative_note non_normative_example ref_list sec preformat
+          ].freeze
+
+          def build_bibliography(source)
+            return [] if source.bibliography.empty?
+            source.bibliography.map { |rs| reference_transformer.transform_section(rs) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/transformer/base.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class Base
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          protected
+
+          def source
+            context.source
+          end
+
+          def dispatcher
+            @dispatcher ||= BlockDispatcher.new(context)
+          end
+
+          def paragraph_transformer
+            @paragraph_transformer ||= ParagraphTransformer.new(context)
+          end
+
+          def list_transformer
+            @list_transformer ||= ListTransformer.new(context)
+          end
+
+          def table_transformer
+            @table_transformer ||= TableTransformer.new(context)
+          end
+
+          def figure_transformer
+            @figure_transformer ||= FigureTransformer.new(context)
+          end
+
+          def formula_transformer
+            @formula_transformer ||= FormulaTransformer.new(context)
+          end
+
+          def note_transformer
+            @note_transformer ||= NoteTransformer.new(context)
+          end
+
+          def reference_transformer
+            @reference_transformer ||= ReferenceTransformer.new(context)
+          end
+
+          def section_transformer
+            @section_transformer ||= SectionTransformer.new(context)
+          end
+
+          def term_transformer
+            @term_transformer ||= TermTransformer.new(context)
+          end
+
+          def dl_transformer
+            @dl_transformer ||= DlTransformer.new(context)
+          end
+
+          def front_transformer
+            @front_transformer ||= FrontTransformer.new(context)
+          end
+        end
+      end
+    end
+  end
+end