class ActionDispatch::Journey::Path::Pattern

def build_formatter
  Visitors::FormatBuilder.new.accept(spec)
end

def eager_load!
  required_names
  offsets
  to_regexp
  @ast = nil
end

def initialize(ast, requirements, separators, anchored)
  @ast          = ast
  @spec         = ast.root
  @requirements = requirements
  @separators   = separators
  @anchored     = anchored
  @names          = ast.names
  @optional_names = nil
  @required_names = nil
  @re             = nil
  @offsets        = nil
end

def match: (String other) -> ActionDispatch::Journey::Path::Pattern::MatchData?

def match(other)
  return unless match = to_regexp.match(other)
  MatchData.new(names, offsets, match)
end

def match?: (String other) -> bool

def match?(other)
  to_regexp.match?(other)
end

def offsets: () -> (Integer | Integer | Integer | Integer | Integer)

def offsets
  return @offsets if @offsets
  @offsets = [0]
  spec.find_all(&:symbol?).each do |node|
    node = node.to_sym
    if @requirements.key?(node)
      re = /#{Regexp.union(@requirements[node])}|/
      @offsets.push((re.match("").length - 1) + @offsets.last)
    else
      @offsets << @offsets.last
    end
  end
  @offsets
end

def optional_names: () -> untyped

def optional_names
  @optional_names ||= spec.find_all(&:group?).flat_map { |group|
    group.find_all(&:symbol?)
  }.map(&:name).uniq
end

def regexp_visitor: () -> Class

def regexp_visitor
  @anchored ? AnchoredRegexp : UnanchoredRegexp
end

def required_names: () -> untyped

def required_names
  @required_names ||= names - optional_names
end

def requirements_anchored?
  # each required param must not be surrounded by a literal, otherwise it isn't simple to chunk-match the url piecemeal
  terminals = ast.terminals
  terminals.each_with_index { |s, index|
    next if index < 1
    next if s.type == :DOT || s.type == :SLASH
    back = terminals[index - 1]
    fwd = terminals[index + 1]
    # we also don't support this yet, constraints must be regexps
    return false if s.symbol? && s.regexp.is_a?(Array)
    return false if back.literal?
    return false if !fwd.nil? && fwd.literal?
  }
  true
end

def requirements_for_missing_keys_check: () -> version | Regexp

def requirements_for_missing_keys_check
  @requirements_for_missing_keys_check ||= requirements.transform_values do |regex|
    /\A#{regex}\Z/
  end
end

def source
  to_regexp.source
end

def to_regexp: () -> Regexp

def to_regexp
  @re ||= regexp_visitor.new(@separators, @requirements).accept spec
end