herb 0.10.4 → 0.11.0

data/sig/herb/engine/component_tags/partial_resolver.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/herb/engine/component_tags/partial_resolver.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ComponentTags
+      # Resolves a dot separated tag name to a partial path, so `<Users.ProfileCard />` becomes
+      # `render "users/profile_card"`.
+      #
+      # The tag name has to parse first, which needs the `dot_notation_tags` parser option.
+      class PartialResolver < Resolver
+        TAG_NAME: ::Regexp
+
+        # : (String) -> bool
+        def handles?: (String) -> bool
+
+        # : (String, Hash[String, String], block: bool) -> String
+        def render_code: (String, Hash[String, String], block: bool) -> String
+
+        private
+
+        # `Users.ProfileCard` -> `users/profile_card`
+        # : (String) -> String
+        def partial_path: (String) -> String
+
+        # : (String) -> String
+        def underscore: (String) -> String
+      end
+    end
+  end
+end

data/sig/herb/engine/component_tags/resolver.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/herb/engine/component_tags/resolver.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ComponentTags
+      # Decides what a tag renders to. A resolver claims a tag name through `handles?` and turns
+      # it into the Ruby source for a `render` call through `render_code`.
+      #
+      # Resolution is static: a resolver only ever sees the tag name and its attributes, never the
+      # application it compiles against.
+      class Resolver
+        # : (String) -> bool
+        def handles?: (String) -> bool
+
+        # : (String, Hash[String, String], block: bool) -> String
+        def render_code: (String, Hash[String, String], block: bool) -> String
+
+        private
+
+        # : (Hash[String, String]) -> String
+        def keyword_arguments: (Hash[String, String]) -> String
+      end
+    end
+  end
+end

data/sig/herb/engine/component_tags/visitor.rbs

@@ -0,0 +1,69 @@
+# Generated from lib/herb/engine/component_tags/visitor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module ComponentTags
+      class Visitor < Herb::Visitor
+        extend Herb::Visitor::Experimental
+
+        TAG_NAME_SEPARATOR: ::Regexp
+
+        KEYWORD_NAME: ::Regexp
+
+        ARRAY_PROPERTIES: untyped
+
+        NODE_PROPERTIES: untyped
+
+        # : (?resolvers: Array[Herb::Engine::ComponentTags::Resolver]) -> void
+        def initialize: (?resolvers: Array[Herb::Engine::ComponentTags::Resolver]) -> void
+
+        def visit_document_node: (untyped node) -> untyped
+
+        # : () -> String
+        def inspect: () -> String
+
+        private
+
+        def replace_component_nodes_recursive: (untyped node) -> untyped
+
+        # : (Herb::AST::Node?) -> bool
+        def component?: (Herb::AST::Node?) -> bool
+
+        def transform_to_erb_component: (untyped element_node) -> untyped
+
+        # : (String) -> Herb::Engine::ComponentTags::Resolver?
+        def resolver_for: (String) -> Herb::Engine::ComponentTags::Resolver?
+
+        # : (String?, Hash[String, String], block: bool) -> String?
+        def render_code: (String?, Hash[String, String], block: bool) -> String?
+
+        # : (Herb::AST::HTMLElementNode) -> Hash[String, String]
+        def extract_attributes_from_element: (Herb::AST::HTMLElementNode) -> Hash[String, String]
+
+        # : (Herb::AST::HTMLAttributeNode) -> String?
+        def attribute_name: (Herb::AST::HTMLAttributeNode) -> String?
+
+        # : (Herb::AST::HTMLAttributeNode, directive: bool) -> String
+        def attribute_value: (Herb::AST::HTMLAttributeNode, directive: bool) -> String
+
+        # : (Array[Herb::AST::Node]) -> String
+        def ruby_code_from: (Array[Herb::AST::Node]) -> String
+
+        # : (Array[Herb::AST::Node]) -> String
+        def string_literal_from: (Array[Herb::AST::Node]) -> String
+
+        # : (String) -> String
+        def escape: (String) -> String
+
+        # : (Herb::AST::HTMLElementNode, String) -> Herb::AST::ERBContentNode
+        def erb_content_node: (Herb::AST::HTMLElementNode, String) -> Herb::AST::ERBContentNode
+
+        # : (Herb::AST::HTMLElementNode, String, Array[Herb::AST::Node]) -> Herb::AST::ERBBlockNode
+        def erb_block_node: (Herb::AST::HTMLElementNode, String, Array[Herb::AST::Node]) -> Herb::AST::ERBBlockNode
+
+        # : (Herb::AST::HTMLElementNode) -> Herb::AST::ERBEndNode
+        def erb_end_node: (Herb::AST::HTMLElementNode) -> Herb::AST::ERBEndNode
+      end
+    end
+  end
+end

data/sig/herb/engine/css_inliner/inliner.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/herb/engine/css_inliner/inliner.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module CSSInliner
+      # Writes the CSS a template rendered into `style` attributes on the markup it applies to.
+      #
+      #     Herb::Engine::CSSInliner.inliner = Herb::Engine::CSSInliner::Inliner.new
+      #
+      # A template compiled with `CSSInliner::Visitor` hands everything it rendered to
+      # `CSSInliner.inline`, and this is what answers. Where the CSS came from is not something this
+      # has to know: a `<style>` block the template wrote, a block `ScopedStyle::Visitor` narrowed,
+      # and a stylesheet read at compile time all arrive the same way, and all of it is matched
+      # against the markup in the same buffer.
+      #
+      # Without an inliner installed, or if one fails, the markup is answered as it was rendered. The
+      # `<style>` blocks are still in it, so the CSS applies as it was written and the template is
+      # correct either way. Installing this is what turns a block into attributes, not what makes it
+      # work.
+      #
+      # The markup is wrapped in a `<template>` before it is parsed. A template renders a fragment,
+      # and a fragment is parsed in whatever context it is given: parsed as a body, a file whose
+      # roots are `<tr>` or `<td>` is not mangled but dropped, and `<tr><td>x</td></tr>` comes back
+      # as `x`. `<template>` is the one context that holds every element a file can start with.
+      #
+      # `keep` says whether the blocks the CSS came from are written out again, which they have to be
+      # when the CSS holds anything a `style` attribute cannot say. An inliner drops those rules
+      # instead of keeping them, so CSS holding `:hover` or `@media` is kept and says the rest twice.
+      # Which it is, is decided when the template is compiled.
+      #
+      # Anything answering `inline_fragment` with the markup and a stylesheet can stand in for
+      # `CSSInline::CSSInliner`, which is the only thing this needs it to be.
+      class Inliner
+        OPEN: String
+
+        CLOSE: String
+
+        # : (?keeping: untyped, ?dropping: untyped) -> void
+        def initialize: (?keeping: untyped, ?dropping: untyped) -> void
+
+        # : (String, ?String, ?keep: bool) -> String
+        def call: (String, ?String, ?keep: bool) -> String
+
+        # : () -> String
+        def inspect: () -> String
+
+        private
+
+        # : (bool) -> untyped
+        def build: (bool) -> untyped
+      end
+
+      attr_writer inliner: untyped
+
+      # : () -> untyped
+      def self.inliner: () -> untyped
+
+      # : (String, ?String, ?keep: bool) -> String
+      def self.inline: (String, ?String, ?keep: bool) -> String
+
+      # : () -> untyped
+      private def self.build: () -> untyped
+    end
+  end
+end

data/sig/herb/engine/css_inliner/visitor.rbs

@@ -0,0 +1,87 @@
+# Generated from lib/herb/engine/css_inliner/visitor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module CSSInliner
+      # Writes the CSS a template rendered into `style` attributes on the markup it applies to.
+      #
+      #     Herb::Engine.new(source, filename: path, visitors: [
+      #       Herb::Engine::CSSInliner::Visitor.new(stylesheets: ["app/assets/email.css"])
+      #     ])
+      #
+      # A `style` attribute is the only way to say something an email client reads, and this is how a
+      # stylesheet gets there. The CSS is matched against the markup once the file has rendered, not
+      # when it is compiled, because that is the first moment the markup exists.
+      #
+      # Every `<style>` block the template rendered is inlined, whoever wrote it. A block the author
+      # wrote by hand, and a block `ScopedStyle::Visitor` narrowed, are both read out of the markup
+      # by the inliner itself. `stylesheets` are files read when the template is compiled and carried
+      # in the compiled template, so nothing reads a file to render one and the CSS a template was
+      # compiled against cannot change under it.
+      #
+      # Because it inlines every block it finds, this belongs in a stack that wants all of its CSS on
+      # the elements. That is what an email wants. A page that meant a `<style>` block to stay a
+      # `<style>` block does not.
+      #
+      # What a template holds when this runs is what it decides about, so it has to run after anything
+      # that rewrites the blocks, which the stack checks. A `ScopedStyle::Visitor` delivering anywhere
+      # other than `:inline` takes its block out of the markup, and reading a template before that
+      # happens is reading a block that will not be there to inline.
+      class Visitor < Herb::Visitor
+        extend Herb::Visitor::Experimental
+
+        include Herb::Visitor::ContextAware
+
+        include Herb::Visitor::Diagnostics
+
+        AT_RULES: Regexp
+
+        STATEFUL: Regexp
+
+        # : () -> bool
+        def self.reads_style_blocks?: () -> bool
+
+        # : (?stylesheets: Array[String]) -> void
+        def initialize: (?stylesheets: Array[String]) -> void
+
+        # : (Herb::AST::DocumentNode) -> void
+        def visit_document_node: (Herb::AST::DocumentNode) -> void
+
+        # : (Herb::AST::HTMLElementNode) -> void
+        def visit_html_element_node: (Herb::AST::HTMLElementNode) -> void
+
+        # : (Herb::AST::DocumentNode) -> void
+        def finish: (Herb::AST::DocumentNode) -> void
+
+        # : (String) -> String
+        def postamble: (String) -> String
+
+        # : () -> String
+        def inspect: () -> String
+
+        private
+
+        # : () -> void
+        def report_missing_inliner: () -> void
+
+        # : (Herb::AST::HTMLElementNode) -> String?
+        def block_css: (Herb::AST::HTMLElementNode) -> String?
+
+        # : () -> bool
+        def keeping?: () -> bool
+
+        # : (String) -> Herb::AST::LiteralNode
+        def literal_node: (String) -> Herb::AST::LiteralNode
+
+        # : () -> String?
+        def read_stylesheets: () -> String?
+
+        # : (String) -> String
+        def resolve: (String) -> String
+
+        # : (String) -> String?
+        def read_stylesheet: (String) -> String?
+      end
+    end
+  end
+end

data/sig/herb/engine/errors.rbs

@@ -0,0 +1,68 @@
+# Generated from lib/herb/engine/errors.rb with RBS::Inline
+
+module Herb
+  class Engine
+    class CompilationError < SyntaxError
+      attr_reader details: untyped
+
+      attr_reader diagnostics: untyped
+
+      attr_reader visitors: untyped
+
+      attr_reader parser_options: untyped
+
+      def initialize: (untyped message, ?details: untyped, ?diagnostics: untyped, ?visitors: untyped, ?parser_options: untyped) -> untyped
+
+      def detailed_message: (?highlight: untyped, **untyped) -> untyped
+
+      def formatted_errors: (?highlight: untyped) -> untyped
+    end
+
+    module LocatedError
+      attr_reader line: untyped
+
+      attr_reader column: untyped
+
+      attr_reader filename: untyped
+
+      attr_reader suggestion: untyped
+
+      def initialize: (untyped message, ?line: untyped, ?column: untyped, ?filename: untyped, ?suggestion: untyped) -> untyped
+
+      private
+
+      def build_error_message: (untyped message) -> untyped
+    end
+
+    class GeneratorTemplateError < CompilationError
+      include LocatedError
+    end
+
+    class InvalidRubyError < CompilationError
+      attr_reader compiled_source: untyped
+
+      def initialize: (untyped message, ?compiled_source: untyped) -> untyped
+    end
+
+    class SecurityError < StandardError
+      include LocatedError
+    end
+
+    class ParseError < CompilationError
+      CONTEXT_LINES: Integer
+
+      attr_reader source: String
+
+      attr_reader filename: String?
+
+      # : (String, diagnostics: Array[Herb::Diagnostic], source: String, ?filename: String?, ?visitors: Array[String], ?parser_options: Hash[Symbol, untyped], ?details: untyped) -> void
+      def initialize: (String, diagnostics: Array[Herb::Diagnostic], source: String, ?filename: String?, ?visitors: Array[String], ?parser_options: Hash[Symbol, untyped], ?details: untyped) -> void
+
+      # : () -> Integer?
+      def line_number: () -> Integer?
+
+      # : () -> Array[String]
+      def annotated_source_code: () -> Array[String]
+    end
+  end
+end

data/sig/herb/engine/helpers.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/herb/engine/helpers.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Helpers
+      # : (String) -> bool
+      def self.comment?: (String) -> bool
+
+      # : (String) -> String
+      def self.without_trailing_spaces: (String) -> String
+
+      # : (String) -> bool
+      def self.ends_on_heredoc_terminator?: (String) -> bool
+
+      # : (String) -> bool
+      def self.heredoc?: (String) -> bool
+
+      # : (String) -> Array[untyped]?
+      def self.heredoc_tokens: (String) -> Array[untyped]?
+
+      # : (String) -> String
+      def self.strip_trailing_comment: (String) -> String
+
+      # : () -> bool
+      def self.prism_available?: () -> bool
+    end
+  end
+end

data/sig/herb/engine/inline_render/inliner.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/herb/engine/inline_render/inliner.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module InlineRender
+      class Inliner
+        VIRTUAL_PATH_DEPENDENT: ::Regexp
+
+        STRICT_LOCALS: ::Regexp
+
+        attr_reader filename: untyped
+
+        def initialize: (?untyped options) -> untyped
+
+        def can_inline?: (untyped node, ?shadowed: untyped) -> untyped
+
+        def can_inline_collection?: (untyped node, ?shadowed: untyped) -> untyped
+
+        def collection?: (untyped node) -> untyped
+
+        def collection_expression: (untyped node) -> untyped
+
+        def collection_item_name: (untyped node) -> untyped
+
+        def resolve_path: (untyped node) -> untyped
+
+        def own_locals: (untyped source) -> untyped
+
+        def local_assignments: (untyped node) -> untyped
+
+        private
+
+        def safe_to_inline?: (untyped file_path, ?item: untyped, ?shadowed: untyped) -> untyped
+
+        def find_format: () -> untyped
+      end
+    end
+  end
+end

data/sig/herb/engine/inline_render/visitor.rbs

@@ -0,0 +1,104 @@
+# Generated from lib/herb/engine/inline_render/visitor.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module InlineRender
+      # Replaces a `render` of a static partial with the partial itself, so the rendered page costs
+      # no partial lookup at run time.
+      #
+      #     require "herb/engine/inline_render/visitor"
+      #
+      #     Herb::Engine.new(source, visitors: [Herb::Engine::InlineRender::Visitor.new])
+      #
+      # It has to run first, and the engine refuses a stack that puts it anywhere else. Everything
+      # after it sees the partial's markup as part of the template it landed in, which is what holds
+      # a partial to whatever the template around it is held to: a validator that refuses markup in a
+      # template refuses it in a partial, and a transform that rewrites a tag rewrites it wherever it
+      # was written. Were it to run last, moving markup into a partial would be a way of turning
+      # those off.
+      #
+      # What it moves is recorded on `Herb::Visitor::Context::Origin`, because a tree alone cannot say that a
+      # node was written somewhere else or that nobody wrote it at all. That is what lets a position
+      # reported from inside an inlined partial name the partial rather than the template it landed
+      # in, and leaves the wrapper written here attributed to nobody.
+      #
+      # A partial is inlined only when the file it names is knowable and the copy would mean what the
+      # original did. Some of what a partial means is answered by where it is rather than by what it
+      # says, and none of that survives being copied, so `Inliner` reads the partial and leaves it
+      # alone when it finds any of it. Anything left alone stays the `render` call it was written as.
+      class Visitor < Herb::Visitor
+        extend Herb::Visitor::Experimental
+
+        include Herb::Visitor::ContextAware
+
+        ARRAY_PROPERTIES: Array[Symbol]
+
+        NODE_PROPERTIES: Array[Symbol]
+
+        ASSIGNMENT_NODES: Array[Symbol]
+
+        # : () -> bool
+        def self.inlines_renders?: () -> bool
+
+        # : (Herb::AST::DocumentNode) -> void
+        def visit_document_node: (Herb::AST::DocumentNode) -> void
+
+        # : () -> String
+        def inspect: () -> String
+
+        private
+
+        # : (Herb::AST::Node) -> void
+        def inline: (Herb::AST::Node) -> void
+
+        # : (Array[Herb::AST::Node]) -> void
+        def expand: (Array[Herb::AST::Node]) -> void
+
+        # : (Herb::AST::Node) -> bool
+        def inlinable?: (Herb::AST::Node) -> bool
+
+        # : (Herb::AST::Node) -> Array[String]
+        def shadowed: (Herb::AST::Node) -> Array[String]
+
+        # : (Herb::AST::Node, ?Array[String]) -> Array[String]
+        def assigned_locals: (Herb::AST::Node, ?Array[String]) -> Array[String]
+
+        # : (Herb::AST::Node) -> String?
+        def assigned_name: (Herb::AST::Node) -> String?
+
+        # : (Herb::AST::Node) -> bool
+        def outputs?: (Herb::AST::Node) -> bool
+
+        # : (Herb::AST::Node) -> Array[Herb::AST::Node]
+        def spliced: (Herb::AST::Node) -> Array[Herb::AST::Node]
+
+        # : (Pathname) -> String
+        def relative: (Pathname) -> String
+
+        # : (Array[Herb::AST::Node]) -> void
+        def inline_nested: (Array[Herb::AST::Node]) -> void
+
+        # : (String) -> Herb::AST::DocumentNode?
+        def parse: (String) -> Herb::AST::DocumentNode?
+
+        # : (Herb::AST::Node, Array[String]) -> String
+        def opening_for: (Herb::AST::Node, Array[String]) -> String
+
+        # : (Array[String], Array[String]) -> String
+        def block_locals: (Array[String], Array[String]) -> String
+
+        # : (Herb::AST::Node) -> String
+        def closing_for_code: (Herb::AST::Node) -> String
+
+        # : (Herb::AST::Node, Array[Herb::AST::Node], Pathname, Array[String]) -> Herb::AST::ERBBlockNode
+        def block: (Herb::AST::Node, Array[Herb::AST::Node], Pathname, Array[String]) -> Herb::AST::ERBBlockNode
+
+        # : (Herb::AST::Node) -> Herb::AST::ERBEndNode
+        def closing_for: (Herb::AST::Node) -> Herb::AST::ERBEndNode
+
+        # : () -> untyped
+        def inliner: () -> untyped
+      end
+    end
+  end
+end

data/sig/herb/engine/runtime/entry.rbs

@@ -0,0 +1,43 @@
+# Generated from lib/herb/engine/runtime/entry.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Runtime
+      # What was observed at one position in one template while it rendered.
+      #
+      # A collector puts things here by name, so several can share a position without knowing about
+      # each other: a query count and a render time sit side by side under different keys.
+      class Entry
+        attr_reader template: String?
+
+        attr_reader line: Integer
+
+        attr_reader column: Integer
+
+        attr_reader end_line: Integer?
+
+        attr_reader end_column: Integer?
+
+        attr_reader observations: Hash[Symbol, Array[untyped]]
+
+        # : (String?, Integer, Integer, ?Integer?, ?Integer?) -> void
+        def initialize: (String?, Integer, Integer, ?Integer?, ?Integer?) -> void
+
+        # : (Symbol, untyped) -> void
+        def observe: (Symbol, untyped) -> void
+
+        # : (Symbol) -> Array[untyped]
+        def []: (Symbol) -> Array[untyped]
+
+        # : () -> bool
+        def empty?: () -> bool
+
+        # : () -> Herb::Location
+        def location: () -> Herb::Location
+
+        # : () -> String
+        def to_s: () -> String
+      end
+    end
+  end
+end

data/sig/herb/engine/runtime/error_page.rbs

@@ -0,0 +1,115 @@
+# Generated from lib/herb/engine/runtime/error_page.rb with RBS::Inline
+
+module Herb
+  class Engine
+    module Runtime
+      # Serves a page the dev tools can boot into when a template refused to compile.
+      #
+      #     config.middleware.use Herb::Engine::Runtime::ErrorPage, dev_tools: "/assets/herb-dev-tools.js"
+      #
+      # A template that fails to compile takes the whole response with it, so there is no page left
+      # for `Middleware` to inject into and nothing for the dev tools to attach to. This serves a
+      # document of its own carrying the same diagnostics payload, which the panel reads on start and
+      # shows as a blocking overlay.
+      #
+      # Action View wraps the failure in its own error, so what arrives here is an
+      # `ActionView::Template::Error` whose `cause` is the Herb one. The chain is walked rather than
+      # rescued by class for that reason.
+      #
+      # A link in that chain can also be a delegator standing in for the real error. Action View
+      # hands a template syntax error to `ActiveSupport::SyntaxErrorProxy`, which answers `is_a?`
+      # for itself and `cause` for the error it wraps, so the walk steps through `__getobj__`
+      # whenever a link has one.
+      #
+      # The page says what is wrong without any JavaScript at all. The dev tools are an enhancement
+      # on top of that, so a missing or misconfigured bundle costs the overlay and not the message.
+      class ErrorPage
+        HTML_REQUEST: Regexp
+
+        MAX_CAUSES: Integer
+
+        CONTEXT_LINES: Integer
+
+        ORIGIN: String
+
+        UNKNOWN_TEMPLATE: String
+
+        STYLES: String
+
+        # : (untyped, ?dev_tools: (String | ^() -> String?)?, ?dev_server_port: (Integer | String | ^() -> untyped)?, ?enabled: bool) -> void
+        def initialize: (untyped, ?dev_tools: (String | ^() -> String?)?, ?dev_server_port: (Integer | String | ^() -> untyped)?, ?enabled: bool) -> void
+
+        # : (untyped) -> untyped
+        def call: (untyped) -> untyped
+
+        private
+
+        # : (Exception) -> Herb::Engine::CompilationError?
+        def compilation_error: (Exception) -> Herb::Engine::CompilationError?
+
+        # : (untyped) -> Exception?
+        def delegated: (untyped) -> Exception?
+
+        # : (untyped) -> bool
+        def wants_html?: (untyped) -> bool
+
+        # : (Herb::Engine::CompilationError) -> untyped
+        def respond: (Herb::Engine::CompilationError) -> untyped
+
+        # : (Herb::Engine::CompilationError) -> Herb::Engine::Runtime::Report
+        def report_for: (Herb::Engine::CompilationError) -> Herb::Engine::Runtime::Report
+
+        # : (Herb::Engine::Runtime::Report, Herb::Engine::CompilationError) -> void
+        def note_source: (Herb::Engine::Runtime::Report, Herb::Engine::CompilationError) -> void
+
+        # : (Herb::Engine::Runtime::Report, Herb::Engine::CompilationError) -> void
+        def note_provenance: (Herb::Engine::Runtime::Report, Herb::Engine::CompilationError) -> void
+
+        # : (Herb::Engine::CompilationError) -> Array[Herb::Diagnostic]
+        def diagnostics_for: (Herb::Engine::CompilationError) -> Array[Herb::Diagnostic]
+
+        # : (Herb::Diagnostic) -> Herb::Diagnostic
+        def blocking: (Herb::Diagnostic) -> Herb::Diagnostic
+
+        # : (Herb::Engine::CompilationError) -> String?
+        def template_for: (Herb::Engine::CompilationError) -> String?
+
+        # : (Herb::Engine::CompilationError) -> String
+        def page: (Herb::Engine::CompilationError) -> String
+
+        # : (Array[Herb::Diagnostic]) -> String
+        def title: (Array[Herb::Diagnostic]) -> String
+
+        # : () -> String
+        def script_tag: () -> String
+
+        # : () -> String?
+        def dev_tools_path: () -> String?
+
+        # : () -> String
+        def dev_server_port_meta_tag: () -> String
+
+        # : (untyped) -> untyped
+        def resolved: (untyped) -> untyped
+
+        # : (Hash[Symbol, untyped]) -> String
+        def provenance: (Hash[Symbol, untyped]) -> String
+
+        # : (Array[Herb::Diagnostic], Hash[String, String], String) -> String
+        def fallback: (Array[Herb::Diagnostic], Hash[String, String], String) -> String
+
+        # : (Herb::Diagnostic, String?) -> String
+        def section: (Herb::Diagnostic, String?) -> String
+
+        # : (String?, Integer?) -> String
+        def excerpt: (String?, Integer?) -> String
+
+        # : (String) -> String
+        def escape: (String) -> String
+
+        # : (String) -> String
+        def escape_attribute: (String) -> String
+      end
+    end
+  end
+end