plurimath 0.11.11 → 0.11.13

data/lib/plurimath/math/function.rb

@@ -105,6 +105,7 @@ module Plurimath
       autoload :Underbrace, "#{__dir__}/function/ubrace"
       autoload :Underline, "#{__dir__}/function/ul"
       autoload :UnaryFunction, "#{__dir__}/function/unary_function"
+      autoload :Uncertainty, "#{__dir__}/function/uncertainty"
       autoload :Underover, "#{__dir__}/function/underover"
       autoload :Underset, "#{__dir__}/function/underset"
       autoload :Unitsml, "#{__dir__}/function/unitsml"

data/lib/plurimath/math/renderer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    # Internal bridge to the optional `lasem` gem, which renders MathML to
+    # SVG/PNG/PDF/PostScript through a native extension.
+    #
+    # This is NOT part of the public API: reach rendering via Plurimath::Math.render
+    # or Plurimath::Math::Formula#render. Renderer is the single place `lasem`
+    # (native, Opal-incompatible) is required, so the rest of the library stays
+    # decoupled from it. Opal excludes the guarded native require when compiling
+    # this autoloaded bridge, and available? is always false under Opal.
+    #
+    # Not thread-safe: the underlying Lasem native render keeps static parser
+    # state and the +@load_error+ diagnostic is shared module state, so callers
+    # should not render concurrently.
+    module Renderer
+      # Output image formats accepted by lasem.
+      OUTPUT_FORMATS = %i[svg png pdf ps].freeze
+
+      # Keyword options forwarded to Formula#to_mathml (the serialization step).
+      MATHML_OPTIONS = %i[
+        intent formatter unitsml split_on_linebreak display_style
+        unary_function_spacing
+      ].freeze
+
+      # Geometry options forwarded straight to Lasem.render. The names match
+      # lasem's own kwargs; nil values are dropped so lasem applies its defaults.
+      LASEM_OPTIONS = %i[ppi zoom width height offset_x offset_y].freeze
+
+      module_function
+
+      # Render a MathML document to a binary image string. Raises a
+      # Plurimath::Errors rendering error (UnsupportedRenderFormat,
+      # RenderingUnavailable, or RenderingFailed) on any problem.
+      def render(mathml, format:, **opts)
+        format = normalize_format(format)
+        ensure_available!
+        render_with_backend(mathml, format, opts)
+      end
+
+      # Only the backend call is wrapped here, so the UnsupportedRenderFormat /
+      # RenderingUnavailable errors raised above are not re-wrapped.
+      def render_with_backend(mathml, format, opts)
+        Lasem.render(
+          mathml,
+          input: :mathml,
+          output: format,
+          **opts.slice(*LASEM_OPTIONS).compact,
+        )
+      rescue StandardError => e
+        # Catches Lasem::RenderError/DependencyError AND Lasem::OptionError, which
+        # is an ArgumentError living OUTSIDE Lasem::Error (lasem-ruby errmodel-1),
+        # so we deliberately rescue StandardError rather than Lasem::Error.
+        raise Errors::RenderingFailed.new(format, e)
+      end
+      private_class_method :render_with_backend
+
+      # True only when this is a non-Opal runtime, the `lasem` gem loads, and its
+      # native extension reports itself available. Never raises.
+      def available?
+        return false if RUBY_ENGINE == "opal"
+
+        @load_error = nil
+        load_lasem && Lasem.native_available?
+      rescue StandardError => e
+        @load_error = e
+        false
+      end
+
+      def normalize_format(format)
+        symbol = format.to_s.downcase.to_sym
+        return symbol if OUTPUT_FORMATS.include?(symbol)
+
+        raise Errors::UnsupportedRenderFormat.new(format, OUTPUT_FORMATS)
+      end
+
+      def ensure_available!
+        return if available?
+
+        raise Errors::RenderingUnavailable.new(@load_error)
+      end
+
+      # Lazily require the optional gem. Only ever reached on the non-Opal path.
+      # Returns true on success, false on LoadError (recorded for diagnostics).
+      def load_lasem
+        require "lasem" unless RUBY_ENGINE == "opal"
+        true
+      rescue LoadError => e
+        @load_error = e
+        false
+      end
+    end
+  end
+end

data/lib/plurimath/math/semantic_tree.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module Plurimath
+  module Math
+    # Builds a transient display view using the evaluator's precedence parser.
+    # It never evaluates operands or replaces the Formula's stored model.
+    class SemanticTree
+      View = Struct.new(:label, :children, :source)
+      private_constant :View
+
+      LANGUAGES = %i[omml latex mathml asciimath unicodemath].freeze
+      private_constant :LANGUAGES
+
+      RELATIONS = %w[Equal Less Greater Lt Gt Le Ge Leq Geq Ne Neq].freeze
+      APPLICATIONS = %w[
+        Sin Cos Tan Cot Sec Csc Sinh Cosh Tanh Coth Sech Csch
+        Arcsin Arccos Arctan Arccot Arcsec Arccsc Arcsinh Arccosh Arctanh
+        Ln Exp Abs Sgn Det Min Max Gcd Lcm
+      ].freeze
+      private_constant :RELATIONS, :APPLICATIONS
+
+      def initialize(language, options)
+        unsupported("label language #{language.inspect}") unless LANGUAGES.include?(language)
+        @language = language
+        @options = options
+      end
+
+      def render(formula)
+        @label_context = formula.cloned_objects
+        root = evaluate_node(formula)
+        (["|_ Semantic tree", "   |_ expression #{label(root.source)}"] + lines(root, 2)).join("\n")
+      end
+
+      # Normalize only the symbolic backend's input. Some source parsers store
+      # Unicode minus and function application as generic Symbol instances.
+      def normalize_tokens(tokens)
+        normalized = []
+        index = 0
+        while index < tokens.length
+          node = tokens[index]
+          if node.instance_of?(Symbols::Symbol) && ["−", "&#x2212;"].include?(node.value)
+            node = Symbols::Minus.new
+          elsif unbound_application?(node)
+            offset = application_marker?(tokens[index + 1]) ? 2 : 1
+            argument = tokens[index + offset]
+            valid_argument!(argument)
+            node = bind_application(node, argument)
+            index += offset
+          end
+          normalized << node
+          index += 1
+        end
+        normalized
+      end
+
+      def relation_operator?(node)
+        return false unless node.is_a?(Symbols::Symbol)
+
+        RELATIONS.include?(node.class.name.split("::").last) ||
+          (node.instance_of?(Symbols::Symbol) && %w[= < > <= >= != ≤ ≥ ≠].include?(node.value))
+      end
+
+      def relation(operator, left, right)
+        view("relation #{label(operator)}", left, right,
+             source: sequence(left, operator, right))
+      end
+
+      def add(left, right)
+        view("add #{label(Symbols::Plus.new)}", left, right,
+             source: sequence(left, Symbols::Plus.new, right))
+      end
+
+      def subtract(left, right)
+        view("subtract #{label(Symbols::Minus.new)}", left, right,
+             source: sequence(left, Symbols::Minus.new, right))
+      end
+
+      def multiply(left, right, implicit:)
+        view(implicit ? "implicit multiply" : "multiply", left, right,
+             source: sequence(left, implicit ? nil : Symbols::Times.new, right))
+      end
+
+      def divide(left, right)
+        view("divide", left, right,
+             source: sequence(left, Symbols::Symbol.new("/"), right))
+      end
+
+      def power(left, right)
+        composite("power", Function::Power.new(left.source, right.source),
+                  role("base", left), role("script", right))
+      end
+
+      def positive(value)
+        view("positive", value, source: Formula.new([Symbols::Plus.new, value.source]))
+      end
+
+      def negate(value)
+        view("negative", value, source: Formula.new([Symbols::Minus.new, value.source]))
+      end
+
+      def negated_mod(node)
+        left = negate(evaluate_node(node.parameter_one))
+        right = evaluate_node(node.parameter_two)
+        composite("mod", Function::Mod.new(left.source, right.source), left, right)
+      end
+
+      def group(value)
+        source = Function::Fenced.new(Symbols::Paren::Lround.new, [value.source], Symbols::Paren::Rround.new)
+        composite("group", source, value)
+      end
+
+      def nary_function?(node)
+        node.is_a?(Function::Int) || node.is_a?(Function::Sum) || node.is_a?(Function::Prod)
+      end
+
+      def log_argument(node, argument)
+        argument = evaluate_node(argument)
+        children = []
+        children << view("function name #{label(Function::Log.new)}")
+        children << role("base", evaluate_node(node.parameter_one)) if node.parameter_one
+        children << role("argument", argument)
+        function = node.dup
+        function.parameter_two = nil
+        result = composite("apply", Formula.new([function, argument.source]), *children)
+        node.parameter_two ? power(result, evaluate_node(node.parameter_two)) : result
+      end
+
+      def evaluate_node(node)
+        case node
+        when Formula
+          Evaluation::ExpressionParser.new(self, node.value).parse
+        when Array
+          Evaluation::ExpressionParser.new(self, node).parse
+        when Number
+          view("number #{label(node)}", source: node)
+        when Symbols::Symbol
+          symbol(node)
+        when Function::Fenced
+          fenced(node)
+        when Function::Frac
+          numerator = evaluate_node(node.parameter_one)
+          denominator = evaluate_node(node.parameter_two)
+          composite("fraction", with_parameters(node, numerator, denominator),
+                    role("numerator", numerator), role("denominator", denominator))
+        when Function::Sqrt
+          radicand = evaluate_node(node.parameter_one)
+          composite("square root", with_parameters(node, radicand),
+                    view('degree "⬚"'), role("radicand", radicand))
+        when Function::Root
+          index = evaluate_node(node.parameter_one)
+          radicand = evaluate_node(node.parameter_two)
+          composite("root", with_parameters(node, index, radicand),
+                    role("index", index), role("radicand", radicand))
+        when Function::Power
+          power(evaluate_node(node.parameter_one), evaluate_node(node.parameter_two))
+        when Function::Base
+          base = evaluate_node(node.parameter_one)
+          script = evaluate_node(node.parameter_two)
+          composite("subscript", with_parameters(node, base, script),
+                    role("base", base), role("script", script))
+        when Function::PowerBase
+          base = evaluate_node(node.parameter_one)
+          subscript = evaluate_node(node.parameter_two)
+          superscript = evaluate_node(node.parameter_three)
+          composite("subsup", with_parameters(node, base, subscript, superscript),
+                    role("base", base), role("subscript", subscript), role("superscript", superscript))
+        when Function::Int, Function::Sum, Function::Prod
+          nary(node)
+        when Function::Mod
+          left = evaluate_node(node.parameter_one)
+          right = evaluate_node(node.parameter_two)
+          composite("mod", with_parameters(node, left, right), left, right)
+        when Function::FontStyle
+          styled_symbol(node)
+        when Function::UnaryFunction
+          unsupported(node) unless application_function?(node)
+          argument = evaluate_node(node.parameter_one)
+          composite("apply", with_parameters(node, argument),
+                    view("function name #{label(node.class.new, function_name: true)}"),
+                    role("argument", argument))
+        else
+          unsupported(node || "missing operand")
+        end
+      end
+
+      def unsupported(construct)
+        name = construct.is_a?(String) ? construct : construct.class.name.sub(/^Plurimath::Math::/, "")
+        raise Errors::UnsupportedSemanticTreeError, name
+      end
+
+      private
+
+      def view(label, *children, source: nil)
+        View.new(label, children, source)
+      end
+
+      def composite(name, source, *children)
+        view("#{name} #{label(source)}", *children, source: source)
+      end
+
+      def role(name, child)
+        composite(name, child.source, child)
+      end
+
+      def sequence(left, operator, right)
+        Formula.new([left.source, operator, right.source].compact)
+      end
+
+      def with_parameters(node, *children)
+        copy = node.dup
+        children.each_with_index do |child, index|
+          copy.public_send("#{Core::ALL_PARAMETERS.fetch(index)}=", child.source)
+        end
+        copy
+      end
+
+      def lines(node, depth)
+        ["#{'   ' * depth}|_ #{node.label}"] +
+          node.children.flat_map { |child| lines(child, depth + 1) }
+      end
+
+      # Use the existing language writers for labels. A copy isolates writer
+      # caches from the stored leaf; composite labels are never reparsed.
+      def label(node, function_name: false)
+        copy = node.cloned_objects
+        options = @options.dup
+        options[:formula] = @label_context
+        text = case @language
+               when :mathml
+                 copy.dump_mathml(copy, false, options: options)
+               when :omml
+                 copy.dump_omml(copy, true, options: options)
+               else
+                 copy.public_send("to_#{@language}", options: options)
+               end
+        text = text.to_s
+        text = text.delete("⁡") if function_name
+        text.inspect
+      end
+
+      def symbol(node)
+        if node.operator? || node.open? || node.close? || relation_operator?(node) || application_marker?(node)
+          unsupported(node)
+        end
+        # Punctuation, separators and unclassified operators cannot safely be
+        # treated as operands. Named mathematical letters remain symbol leaves.
+        glyph = Utility.html_entity_to_unicode(node.to_unicodemath(options: @options.dup).to_s)
+        unsupported(node) unless glyph.match?(/\A[\p{L}\p{N}]+\z/) || %w[∞ ∅].include?(glyph)
+
+        view("symbol #{label(node)}", source: node)
+      end
+
+      def fenced(node)
+        left = node.parameter_one
+        right = node.parameter_three
+        unless left.nil? == right.nil? &&
+            (left.nil? || left.is_a?(Symbols::Paren::Lround)) &&
+            (right.nil? || right.is_a?(Symbols::Paren::Rround))
+          unsupported("Function::Fenced (non-round or unmatched delimiters)")
+        end
+        group(evaluate_node(node.parameter_two))
+      end
+
+      def styled_symbol(node)
+        child = node.parameter_one
+        if child.is_a?(Function::Text) && child.parameter_one.to_s.match?(/\A\p{L}\z/)
+          copy = node.dup
+          copy.parameter_one = child.dup
+          view("symbol #{label(copy)}", source: copy)
+        elsif child.is_a?(Symbols::Symbol) || child.is_a?(Number)
+          symbol(child) if child.is_a?(Symbols::Symbol)
+          copy = node.dup
+          copy.parameter_one = child.dup
+          view("symbol #{label(copy)}", source: copy)
+        else
+          unsupported("#{node.class.name.sub(/^Plurimath::Math::/, '')} (non-atomic font style)")
+        end
+      end
+
+      def nary(node)
+        children = []
+        lower = evaluate_node(node.parameter_one) if node.parameter_one
+        upper = evaluate_node(node.parameter_two) if node.parameter_two
+        body = evaluate_node(node.parameter_three)
+        children << role("lower limit", lower) if lower
+        children << role("upper limit", upper) if upper
+        children << role(node.is_a?(Function::Int) ? "integrand" : "body", body)
+        source = node.dup
+        source.parameter_one = lower&.source
+        source.parameter_two = upper&.source
+        source.parameter_three = body.source
+        composite(node.class::FUNCTION.fetch(:name), source, *children)
+      end
+
+      def application_function?(node)
+        node.is_a?(Function::UnaryFunction) && APPLICATIONS.include?(node.class.name.split("::").last)
+      end
+
+      # A function power such as sin^2 carries the exponent on an unbound
+      # function node. Bind its following operand inside the power, so the
+      # result is (sin x)^2, while retaining the shared parser's precedence.
+      def unbound_application?(node)
+        return unbound_application?(node.parameter_one) if node.is_a?(Function::Power)
+
+        application_function?(node) &&
+          (node.parameter_one.nil? || application_marker?(node.parameter_one))
+      end
+
+      def bind_application(node, argument)
+        copy = node.dup
+        copy.parameter_one = if node.is_a?(Function::Power)
+                               bind_application(node.parameter_one, argument)
+                             else
+                               argument
+                             end
+        copy
+      end
+
+      def application_marker?(node)
+        node.is_a?(Symbols::Funcapply) ||
+          (node.instance_of?(Symbols::Symbol) && ["⁡", "&#x2061;"].include?(node.value))
+      end
+
+      def valid_argument!(node)
+        if !node.is_a?(Core) || node.operator? || node.open? || node.close? || relation_operator?(node)
+          unsupported("function application (missing or ambiguous argument)")
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/math/symbols/symbol.rb

@@ -4,6 +4,8 @@ module Plurimath
   module Math
     module Symbols
       class Symbol < Core
+        extend SymbolDocumentation
+
         attr_accessor :value, :slashed, :mini_sub_sized, :mini_sup_sized,
                       :options
 
@@ -46,11 +48,16 @@ module Plurimath
           if value&.include?("&#x2147;")
             attributes[:intent] = Utility.html_entity_to_unicode(value)
           end
-          attributes[:rspace] = @options[:rspace] if @options&.key?(:rspace)
-          mi_tag = ox_element("mi", attributes: attributes)
-          return mi_tag if ["{:", ":}"].include?(value)
-
-          value ? mi_tag << value : mi_tag
+          # `rspace` is an operator attribute: MathML 4 allows it on `mo` (and
+          # `mpadded`), never on `mi`. A generic token that carries one must
+          # therefore serialize as `mo`, whatever produced it.
+          rspace = @options&.[](:rspace)
+          attributes[:rspace] = rspace unless rspace.nil?
+          tag_name = rspace.nil? ? "mi" : "mo"
+          token_tag = ox_element(tag_name, attributes: attributes)
+          return token_tag if ["{:", ":}"].include?(value)
+
+          value ? token_tag << value : token_tag
         end
 
         def to_latex(**)

data/lib/plurimath/math.rb

@@ -4,13 +4,18 @@ module Plurimath
   module Math
     autoload :Core, "#{__dir__}/math/core"
     autoload :Evaluation, "#{__dir__}/math/evaluation"
+    autoload :SemanticTree, "#{__dir__}/math/semantic_tree"
     autoload :Formula, "#{__dir__}/math/formula"
     autoload :ModelHelper, "#{__dir__}/math/model_helper"
     autoload :Function, "#{__dir__}/math/function"
     autoload :InvalidTypeError, "#{__dir__}/errors/invalid_type_error"
+    autoload :MissingDependencyError,
+             "#{__dir__}/errors/missing_dependency_error"
     autoload :Number, "#{__dir__}/math/number"
     autoload :ParseOptionError, "#{__dir__}/errors/parse_option_error"
     autoload :ParseError, "#{__dir__}/errors/parse_error"
+    autoload :Renderer, "#{__dir__}/math/renderer"
+    autoload :AmbiguousDecimalError, "#{__dir__}/errors/ambiguous_decimal_error"
     autoload :Symbols, "#{__dir__}/math/symbols"
 
     VALID_TYPES = {
@@ -50,6 +55,27 @@ module Plurimath
       end
     end
 
+    # Parse +text+ of +type+ and render the resulting formula to a binary image
+    # (one of :svg, :png, :pdf, :ps) via the optional `lasem` gem. Parse options
+    # (e.g. :locale) are routed to .parse; the rest go to Formula#render. Raises a
+    # Plurimath::Errors rendering error (RenderingUnavailable, UnsupportedRenderFormat,
+    # or RenderingFailed) when lasem/its native extension is unavailable, the format
+    # is unsupported, or rendering fails, and Plurimath::Math::ParseError when +text+
+    # cannot be parsed (raised during parsing, before rendering).
+    def render(text, type, format: :svg, **options)
+      parse_options = options.slice(*SUPPORTED_PARSE_OPTIONS)
+      render_options = options.except(*SUPPORTED_PARSE_OPTIONS)
+      parse(text, type, **parse_options).render(format: format, **render_options)
+    end
+
+    # True when image rendering is available (the `lasem` gem and its native
+    # extension are present; always false under Opal). Never raises.
+    def render_available?
+      return false if RUBY_ENGINE == "opal"
+
+      Renderer.available?
+    end
+
     def parse_with_configuration(text, type, options)
       return parse_formula(text, type) unless options.key?(:locale)
 

data/lib/plurimath/mathml/translator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mml"
+require_relative "uncertainty_marker"
 
 module Plurimath
   class Mathml
@@ -91,6 +92,8 @@ module Plurimath
 
       # MathML element: <mrow>
       def mrow_to_mrow(mrow)
+        return mrow_to_uncertainty(mrow) if uncertainty_mrow?(mrow)
+
         children = ordered_children(mrow)
         formula_values = children.filter_map do |child|
           mml_to_plurimath(child)
@@ -115,6 +118,35 @@ module Plurimath
         Plurimath::Math::Formula.new(mrow_obj.value)
       end
 
+      # An mrow whose intent is an uncertainty marker (plurimath#493). The
+      # marker is authoritative; the visible children are regenerated on
+      # output, so only the child marked arg="unit" is read.
+      def uncertainty_mrow?(mrow)
+        mrow.respond_to?(:intent) && UncertaintyMarker.marker?(mrow.intent)
+      end
+
+      def mrow_to_uncertainty(mrow)
+        UncertaintyMarker.build(mrow.intent) { uncertainty_unit(mrow) }
+      end
+
+      def uncertainty_unit(mrow)
+        units = ordered_children(mrow).select do |child|
+          child.respond_to?(:arg) && child.arg == "unit"
+        end
+        return if units.empty?
+
+        if units.length > 1
+          raise Plurimath::Errors::InvalidUncertainty.new(
+            "intent #{mrow.intent.inspect}: more than one arg=\"unit\" child",
+          )
+        end
+
+        unit = mml_to_plurimath(units.first)
+        return if unit.nil?
+
+        unit.is_a?(Plurimath::Math::Formula) ? unit : Plurimath::Math::Formula.new([unit])
+      end
+
       # MathML element: <mover> base overscript
       # Note: Overset convention is parameter_one=overscript, parameter_two=base
       # (reversed from MathML document order) to match rendering methods

data/lib/plurimath/mathml/uncertainty_marker.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Mathml
+    # Reads the measurement-uncertainty marker (plurimath#493) shared by the
+    # MathML, OMML and UnicodeMath readers: the MathML `intent` of an mrow,
+    # the text of the hidden OMML phantom, and the UnicodeMath ⓘ("...")
+    # string. See docs/uncertainty.adoc.
+    #
+    #   standard-uncertainty(1.230,0.004)
+    #   standard-uncertainty:concise(1.230,0.004)
+    #   expanded-uncertainty(10.0,0.3,2[,0.95][,$unit])
+    #   coverage-interval[:shortest|:probabilistically-symmetric](y,lo,hi,p[,$unit])
+    #
+    # A string that starts with one of the three concept names is a marker.
+    # A marker that does not have exactly this shape raises
+    # Errors::InvalidUncertainty; it is never read as ordinary content.
+    module UncertaintyMarker
+      UNIT_REFERENCE = "$unit"
+
+      ARGUMENT_FIELDS = {
+        standard: [%i[magnitude]],
+        expanded: [%i[magnitude coverage_factor],
+                   %i[magnitude coverage_factor coverage_probability]],
+        coverage_interval: [%i[lower upper coverage_probability]],
+      }.freeze
+
+      module_function
+
+      def names
+        Math::Function::Uncertainty::MARKER_NAMES
+      end
+
+      def name_pattern
+        @name_pattern ||= begin
+          alternatives = names.values.map { |name| Regexp.escape(name) }
+          /\A\s*(#{alternatives.join('|')})(?![\w-])/
+        end
+      end
+
+      # True when the text uses one of the three concept names, whether or
+      # not the rest of the marker is well formed.
+      def marker?(text)
+        text.is_a?(String) && name_pattern.match?(text)
+      end
+
+      # Builds the Uncertainty node described by the marker. `unit` is
+      # called only when the marker refers to `$unit`, and must return the
+      # unit content read from the markup.
+      def build(text, &unit)
+        fields = parse(text)
+        options = fields[:options]
+        if fields[:unit]
+          unit_value = unit&.call
+          invalid!(text, "it refers to $unit but no unit content was found") unless unit_value
+
+          options[:unit] = unit_value
+        end
+        Math::Function::Uncertainty.new(fields[:value], **options)
+      end
+
+      def parse(text)
+        match = marker_match(text)
+        category = names.key(match[:name])
+        arguments = match[:arguments].split(",", -1).map(&:strip)
+        unit = arguments.last == UNIT_REFERENCE
+        arguments.pop if unit
+        if arguments.any? { |argument| argument.empty? || argument.start_with?("$") }
+          invalid!(text, "arguments must be numbers, with $unit only as the last one")
+        end
+
+        value, *rest = arguments
+        fields = ARGUMENT_FIELDS[category].find { |list| list.length == rest.length }
+        invalid!(text, "wrong number of arguments for #{match[:name]}") unless fields
+
+        options = { category: category }
+        fields.zip(rest).each { |field, number| options[field] = Math::Number.new(number) }
+        options.merge!(property_options(category, match[:property], text))
+        { value: Math::Number.new(value), options: options, unit: unit }
+      end
+
+      # Whitespace follows the MathML 4 intent grammar (section 5.1):
+      #
+      #   application := expression '(' arguments? S ')'
+      #   expression  := S ( term property* ) S
+      #   property    := S ':' NCName
+      #
+      # so whitespace may come before a property's ':' and between the head
+      # (with its property) and '(', and around each argument, but not
+      # between ':' and the property name.
+      def marker_match(text)
+        name = Regexp.union(names.values)
+        pattern = /\A\s*(?<name>#{name})(?:\s*:(?<property>[^():,\s]+))?\s*\((?<arguments>[^()]*)\)\s*\z/
+        pattern.match(text) || invalid!(text, "it is not of the form name[:property](arguments)")
+      end
+
+      def property_options(category, property, text)
+        case category
+        when :standard
+          return { notation: :absolute } if property.nil?
+          return { notation: :concise } if property == "concise"
+        when :expanded
+          return {} if property.nil?
+        when :coverage_interval
+          return {} if property.nil?
+
+          kind = Math::Function::Uncertainty::INTERVAL_KIND_NAMES.key(property)
+          return { interval_kind: kind } if kind
+        end
+        invalid!(text, "unknown property :#{property}")
+      end
+
+      def invalid!(text, detail)
+        raise Errors::InvalidUncertainty.new("marker #{text.inspect}: #{detail}")
+      end
+    end
+  end
+end