raindown 0.13.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f795c35070ab8ae4f6b40e5a32595ab9ba6099b99f42aada8d0faafe2f56121d
-  data.tar.gz: a01426b3aab916e21b0e68f66fddd7f6b55d7e9c34ceb9665118a60b3ceae4b5
+  metadata.gz: 3d201e22c68a6326752cd504b5cca6674384031244b3b91cbe9e8da2e1034d8b
+  data.tar.gz: 6b3cf1bbc8e03c353c0eb0bade6a7c1f9546c99fc2dfabc260963f50e7ff3063
 SHA512:
-  metadata.gz: 052231532f48cc3a575388ebe95fa62b70bc3eba2121742142071c2ab256ced437de1f4c80f2e439599d579c2b5eea2d793b7cb05439601523bc72ff9c252dd6
-  data.tar.gz: 98ff7b646f8e380817bbf69efc06a0bf67b4945a233349c9702d3140458bb27e387ecd010498c80dbfa4a9d2e64872b4f7af75bcd12b28b992e8b82ac66f56c9
+  metadata.gz: cb8dba488c6c4ca2ddd49f8cd699a3d660f9a12fb00e756e6f5cd65e433b2ac04d4d4124e078a41b39fbe2707632f5cc1a78acf97e033dfdbe5715c01e50985b
+  data.tar.gz: 4d1d7f48804fcdc7ee6ce0343d2f34fa0f797566dc222a645dae1d3f4b79cc9f7841c6acbbfb83c93c0dde681bf110139f9ed51b4fd7ef7c37181db1052137fe

data/lib/elements.rb

@@ -6,28 +6,27 @@ module Raindown
   class Elements
     include Plugs
 
-    # Antlers' prop and slot directives, rendered as components in the template pass.
-    plug(:prop_component) do
+    # Write-in nodes, in <{ }>, like <{ Card }>, <{ :toc }> or <{ Card: }>...<{ :Card }>, rendered in the template pass.
+    plug(:write_in) do
       plug(:lexeme) do
-        require 'lexemes/prop_lexeme'
-        Antlers::PropLexeme
+        require_relative 'lexemes/node_lexeme'
+        NodeLexeme
       end
 
+      # A list: block loops over its files, so it comes before other nodes' blocks.
       plug(:node) do
-        require_relative 'nodes/component_nodes'
-        PropComponentNode
+        require_relative 'nodes/list_node'
+        ListNode
       end
-    end
 
-    plug(:slot_component) do
-      plug(:lexeme) do
-        require 'lexemes/slot_lexeme'
-        Antlers::SlotLexeme
+      plug(:node) do
+        require_relative 'nodes/write_in_node'
+        WriteInNode
       end
 
       plug(:node) do
-        require_relative 'nodes/component_nodes'
-        SlotComponentNode
+        require_relative 'nodes/write_in_node'
+        SoloWriteInNode
       end
     end
 
@@ -42,17 +41,5 @@ module Raindown
         EndpointNode
       end
     end
-
-    plug(:list) do
-      plug(:lexeme) do
-        require_relative 'lexemes/list_lexeme'
-        ListLexeme
-      end
-
-      plug(:node) do
-        require_relative 'nodes/list_node'
-        ListNode
-      end
-    end
   end
 end

data/lib/lexemes/node_lexeme.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'antlers/api'
+require_relative '../raindown/node_blocks'
+
+module Raindown
+  # A write-in node, in Antlers' delimiters, read with its props as Raindown reads them, like
+  # <{ :list folder: 'notes' }>. It opens a block with <{ Name: }>, and <{ :Name }> ends one, or else it's self-closing,
+  # as is <{ Card title='Hi' }>. Template directives, like if: and for:, aren't nodes, so they're left to their lexemes.
+  module NodeLexeme
+    include Antlers::Lexeme
+
+    module_function
+
+    DIRECTIVE = /\A(:)?([A-Za-z]\w*(?:::[A-Z]\w*)*)(:)?(?:\s+(.*))?\z/m
+
+    # A name with a colon is a node, like <{ :toc }> or <{ :app_name }>, while {:app_name} is a translation. One without
+    # is a node when it's capitalized, so <{ title }> is still a variable. The lexer gives no name to a directive that
+    # starts with another lexeme's keyword, like <{ if: draft }> or <{ :list }>, which it leaves to that lexeme.
+    def match?(segment:, name: nil, **)
+      _, close, node_name, open = segment.to_s.match(DIRECTIVE).to_a
+      return false if name.nil? || node_name.nil? || (close && open)
+      return true if close || open
+
+      node_name.match?(/\A[A-Z]/)
+    end
+
+    # <{ :Name }> ends a block of the name, or else is self-closing, while <{ Name }> is always self-closing.
+    def lexeme(segment:, **)
+      _, close, name, open, args = segment.match(DIRECTIVE).to_a
+      return { node_def: name, args: args.to_s } if open
+      return { node_end: name, args: args.to_s } if close
+
+      { node_solo: name, args: args.to_s }
+    end
+  end
+end

data/lib/nodes/list_node.rb

@@ -1,46 +1,43 @@
 # frozen_string_literal: true
 
 require 'antlers/api'
+require_relative '../raindown/context'
+require_relative '../raindown/node_blocks'
+require_relative '../raindown/nodes'
+require_relative 'write_in_node'
 
 module Raindown
+  # <{ list: page folder: 'notes' }> ... <{ :list }>, which renders its template for each file the list: node lists,
+  # with the file as page. Without a block, <{ :list folder: 'notes' }> renders the node's links, as a WriteInNode.
   class ListNode < Antlers::BranchNode
-    include Antlers::Props
-    include Antlers::Variables
+    DEF_KEY = :node_def
+    END_KEY = :node_end
 
-    DEF_KEY = :list_def
-    END_KEY = :list_end
+    def initialize(name:, args:)
+      super(name:)
 
-    def initialize(value:, folder:, props: [], children: [])
-      super(name: :toc, props:, children:)
-
-      @value = value.delete("'").delete('"')
-      @folder = folder.delete("'").delete('"')
+      @variable, @tags = args.split(/\s+/, 2)
     end
 
-    def render(current_binding: nil, parent_binding: nil, slot_node: nil, metadata: {})
-      output = ''
-
-      list = metadata.list(folder: @folder)
-
-      list.each do |value|
-        # TODO: Parallelize by creating new bindings and ensuring children have any args they need via RenderEvent.
-        current_binding.local_variable_set(@value, value)
-
-        @children.each do |child|
-          output += child.render(current_binding:, parent_binding:, slot_node:, metadata:) || ''
-        end
-      end
+    def render(current_binding: nil, context: Context.new, **)
+      tags = NodeBlocks.props(@tags.to_s, BoundVariables.new(current_binding))
+      Nodes.instance(Nodes.node_class('list'), tags).files(metadata: context.metadata).map do |file|
+        current_binding.local_variable_set(@variable, file)
+        super
+      end.join
+    end
 
-      output
+    def end_name
+      'list'
     end
 
     class << self
       def match?(segment:)
-        segment[DEF_KEY]
+        segment[DEF_KEY] == 'list'
       end
 
       def build(segment:, **)
-        new(value: segment[:list_def], folder: segment[:folder])
+        new(name: :list, args: segment[:args])
       end
     end
   end

data/lib/nodes/write_in_node.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'antlers/api'
+require 'nodes/html_node'
+require_relative '../raindown/context'
+require_relative '../raindown/fragments'
+require_relative '../raindown/node_blocks'
+require_relative '../raindown/nodes'
+
+module Raindown
+  # A write-in node, in <{ }>, which Antlers renders where it is in the template, so its props see loop variables, like
+  # <{ Card name=p.name }> in a for: loop. It only renders, with its render, never its rewrite, and the Markdown
+  # between its tags, <{ Card: }> to <{ :Card }>, is its slot, rendered to HTML in its scope first.
+  # One with a class template, like Raindeer's .rbx components, renders its template, with that HTML as its slot.
+  class WriteInNode < Antlers::BranchNode
+    DEF_KEY = :node_def
+    END_KEY = :node_end
+
+    def initialize(name:, args: '', **)
+      super(name:)
+
+      @args = args
+    end
+
+    def render(current_binding: nil, context: Context.new, **)
+      slot = Raindown.commonmark(super) unless @children.empty?
+      props, args = NodeBlocks.args(@args, BoundVariables.new(current_binding))
+      node = Nodes.instance(node_class, props, args || [])
+      return Fragments.add(template_html(node, props, slot.to_s, current_binding)) if Nodes.template?(node.class)
+
+      Nodes.rendered(node, context, slot: slot.to_s)
+    end
+
+    def end_name
+      @name
+    end
+
+    private
+
+    # A render-only component, like Card, isn't a node Nodes finds, as it has no rewrite, so it's any class of the name.
+    def node_class
+      klass = Nodes.node_class(@name)
+      return klass if klass
+      raise NameError, "No node is named #{@name}, for <{ :#{@name} }>" unless @name.match?(/\A[A-Z]/)
+
+      Object.const_get(@name)
+    end
+
+    # The node's class template, whose slot is the HTML in place of its children.
+    def template_html(node, props, slot, parent_binding)
+      children = @children
+      @children = [Antlers::HTMLNode.new(html: slot)]
+      node.render_template(parent_binding:, slot_node: self, props:)
+    ensure
+      @children = children
+    end
+
+    class << self
+      def match?(segment:)
+        segment[DEF_KEY]
+      end
+
+      def build(segment:, **)
+        new(name: segment[DEF_KEY], args: segment[:args])
+      end
+    end
+  end
+
+  # <{ Card }>, or <{ :Card }> when it doesn't end a block, which a lowercase name needs, like <{ :toc }>.
+  class SoloWriteInNode < WriteInNode
+    END_KEY = nil
+
+    def self.match?(segment:)
+      segment[:node_solo] || segment[:node_end]
+    end
+
+    def self.build(segment:, **)
+      new(name: segment[:node_solo] || segment[:node_end], args: segment[:args])
+    end
+  end
+
+  # The variables where Antlers renders a node, like a loop's, and then the front matter's, as its props read them.
+  class BoundVariables < BasicObject
+    def initialize(binding)
+      @binding = binding
+    end
+
+    # A name that can't be a local, like a-b, is only looked for in the front matter.
+    def send(name)
+      return @binding.local_variable_get(name) if name.match?(/\A[a-z_]\w*\z/) && @binding.local_variable_defined?(name)
+
+      @binding.receiver.send(name)
+    end
+  end
+end

data/lib/raindown/bare_directives.rb

@@ -8,7 +8,7 @@ require_relative 'front_matter'
 module Raindown
   # Raindown files (.rd/.raindown) can write a content directive, which writes its output back, bare on its own line,
   # like endpoint: or toc:, which shows in bold in the HTML. Markdown files opt in with "raindown: true" in their front
-  # matter, or with the --bare flag. Nodes like toc: and files: are handled by NodeBlocks, before the rest.
+  # matter, or with the --bare flag. Nodes like toc: and list: are handled by NodeBlocks, before the rest.
   # Template directives, like if: and for:, are always in Antlers' delimiters, so they're never bare.
   #
   # A bare schema: shows in bold, with its fields in a code block below it.

data/lib/raindown/chart/chart.rb

@@ -32,7 +32,7 @@ module Raindown
     end
 
     # The data is read every time, so the chart follows changes to its file.
-    def replace(metadata: NoMetadata)
+    def rewrite(metadata: NoMetadata)
       points = points(metadata:)
       return '' if points.empty?
 

data/lib/raindown/cli.rb

@@ -76,6 +76,8 @@ module Raindown
     end
 
     def self.run(argv)
+      # Markdown is UTF-8 whatever the locale, as an app opened from the Dock, like Obsidian, starts Raindown without one.
+      Encoding.default_external = Encoding::UTF_8
       return if command(argv)
 
       # Without a path, like "raindown", "raindown -x" or "raindown watch", it's the current directory.

data/lib/raindown/context.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'front_matter'
+require_relative 'variables'
+
+module Raindown
+  # The document being rendered, its metadata, like a site's pages, and whether its directives can be bare: the keywords
+  # a node's rewrite and render can take. Antlers passes it down to Raindown's own Antlers nodes.
+  Context = Data.define(:document, :metadata, :bare) do
+    def initialize(document: '', metadata: NoMetadata, bare: false)
+      super
+    end
+
+    # The document's front matter, as variables, like {title}.
+    def variables
+      Variables.new(FrontMatter.parse(document).first)
+    end
+  end
+end

data/lib/raindown/directives.rb

@@ -19,7 +19,7 @@ module Raindown
 
     module_function
 
-    # A directive's line without its delimiters, like "files: folder: 'notes'" for <!-- files: folder: 'notes' -->.
+    # A directive's line without its delimiters, like "list: folder: 'notes'" for <!-- list: folder: 'notes' -->.
     def text(line)
       line = line.strip
       [COMMENT, DELIMITERS].each do |open, close|

data/lib/raindown/fragments.rb

@@ -18,8 +18,13 @@ module Raindown
     end
 
     def add(html)
+      "<!-- raindown:fragment #{store(html)} -->"
+    end
+
+    # Keeps the HTML for this render, returning its index in the list.
+    def store(html)
       list << html
-      "<!-- raindown:fragment #{list.length - 1} -->"
+      list.length - 1
     end
 
     # Fills each placeholder, again and again, since a fragment can hold others, like a component in a slot.

data/lib/raindown/js/host.mjs

@@ -16,13 +16,13 @@ const classes = {}
 const nodes = {}
 
 const requests = {
-  // Every exported class with replace is a node, named by its export, or by its class for a default export.
+  // Every exported class with rewrite is a node, named by its export, or by its class for a default export.
   async load({ folder }) {
     for (const file of readdirSync(folder).filter((file) => /\.m?js$/.test(file))) {
       const exports = await import(pathToFileURL(join(folder, file)).href)
 
       for (const [name, value] of Object.entries(exports)) {
-        if (typeof value?.prototype?.replace === 'function') classes[name === 'default' ? value.name : name] = value
+        if (typeof value?.prototype?.rewrite === 'function') classes[name === 'default' ? value.name : name] = value
       }
     }
 

data/lib/raindown/js/js_nodes.rb

@@ -6,7 +6,7 @@ require 'open3'
 require_relative '../node'
 
 module Raindown
-  # JavaScript Components, the .js and .mjs files in a project's .raindown folder, which export classes with replace and
+  # JavaScript Components, the .js and .mjs files in a project's .raindown folder, which export classes with rewrite and
   # optionally render, like Ruby nodes. They run in a NodeJS process of Raindown's own, started when a folder has them,
   # so only projects with JavaScript Components need NodeJS.
   module JSNodes
@@ -57,7 +57,7 @@ module Raindown
     end
   end
 
-  # A JavaScript Component, made in the NodeJS process with its props, where its replace and render are sent.
+  # A JavaScript Component, made in the NodeJS process with its props, where its rewrite and render are sent.
   class JSNode < Node
     # A class for each JavaScript Component, which renders its own HTML when the component has render.
     def self.for(name:, render:)
@@ -72,8 +72,8 @@ module Raindown
       JSNodes.host.request(op: 'new', id: object_id, name: self.class.name, args:, props:)
     end
 
-    def replace(**context)
-      js_output(:replace, context)
+    def rewrite(**context)
+      js_output(:rewrite, context)
     end
 
     private

data/lib/raindown/list.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Raindown
+  # The node behind list:, the files the metadata has for its props, like list: folder: 'notes'. Bare or in comments it
+  # writes a link to each, and in <{ list: page folder: 'notes' }> ... <{ :list }> it renders its template for each,
+  # with the file as page, the name before its props, which is its argument. A project can change how files are listed
+  # with its own List node in .raindown, like "class List < Raindown::List".
+  class List < Node
+    # Order is the metadata to sort by, like order: :created_at, rather than a tag to list by.
+    def initialize(_name = nil, order: nil, **tags)
+      @order = order
+      @tags = tags
+    end
+
+    # Each file has its front matter, its path and its content. Sorted by an order, files without it come last, and ones
+    # with the same value stay in the order they're listed.
+    def files(metadata: NoMetadata)
+      files = metadata.list(**@tags)
+      return files unless @order
+
+      sorted, unsorted = files.partition { it[@order] }
+      sorted.sort_by.with_index { |file, index| [file[@order], index] } + unsorted
+    end
+
+    def rewrite(metadata: NoMetadata)
+      files(metadata:).map { |file| "- [#{file.title || file.path}](#{file.path})" }.join("\n")
+    end
+  end
+end

data/lib/raindown/markdown_nodes.rb

@@ -57,10 +57,11 @@ module Raindown
 
     # Braces that the template pass hid, in its code or its props' values, are written back as braces.
     # The template pass loads here, as it loads nodes itself.
-    def replace(metadata: NoMetadata, bare: false)
+    def rewrite(document: '', metadata: NoMetadata, bare: false)
       require_relative 'pre_renderer'
       defaults, template = FrontMatter.parse(File.read(self.class.path))
-      markdown = PreRenderer.render(template, variables: Variables.new(defaults.merge(@props)), metadata:, bare:)
+      context = Context.new(document:, metadata:, bare:)
+      markdown = PreRenderer.render(template, variables: Variables.new(defaults.merge(@props)), context:)
       Variables.unwrap(markdown.sub(/\A(?:[ \t]*\n)+/, '').rstrip)
     end
   end

data/lib/raindown/node.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
 module Raindown
-  # The base class of Raindown's own nodes, like TOC and Files.
+  # The base class of Raindown's own nodes, like TOC and List.
   # A project's nodes are LowNodes, or subclasses of these.
-  class Node; end
+  class Node
+    # Write-in, in <{ }>, a node renders its Markdown as HTML. One whose rewrite takes written:, what it wrote last
+    # time, can write edits back to its source, like Table to its file, so it needs its own render, which never does.
+    def render(**context)
+      raise Nodes::NoRender, "#{self.class.name} writes edits back, so it needs a render" if Nodes.takes?(self, :rewrite, :written)
+
+      Raindown.commonmark(Nodes.call(self, :rewrite, **context).to_s)
+    end
+  end
 end

data/lib/raindown/node_blocks.rb

@@ -16,9 +16,10 @@ module Raindown
   #   - **1.2.0** Bare directives
   #
   #   <!-- :Changelog -->
-  # In Antlers' delimiters, <{ Changelog: }> to <{ :Changelog }>, or a self-closing <{ :Changelog }> or bare
-  # :Changelog, it renders the node without writing it. toc: and files: are Raindown's own nodes. A name only starts
-  # a block when it's a loaded node, so other text like "Note:" is left alone.
+  # A bare :Changelog is write-in: it only renders, with its render, never its rewrite. In Antlers' delimiters, like
+  # <{ Changelog }>, it's write-in too, and the template pass renders it, as a WriteInNode, so it's only found here
+  # for a document's outline. toc: and list: are Raindown's own nodes. A name only starts a block when it's a loaded
+  # node, so other text like "Note:" is left alone.
   module NodeBlocks
     class MissingEndTag < StandardError; end
     class BrokenText < StandardError; end
@@ -27,7 +28,8 @@ module Raindown
     OPEN = /\A( {0,3})<\{\s*(#{NAME}):(?:\s+(.*?))?\s*\}>[ \t]*$/
     COMMENT_OPEN = /\A( {0,3})<!--\s*(#{NAME}):(?:\s+(.*?))?\s*-->[ \t]*$/
     BARE_OPEN = /\A( {0,3})(#{NAME}):(?:[ \t]+(.*?))?[ \t]*$/
-    SELF_CLOSING = /\A( {0,3})<\{\s*:(#{NAME})(?:\s+(.*?))?\s*\}>[ \t]*$/
+    # <{ Card }>, or <{ :Card }>, which a lowercase name like toc needs, as <{ toc }> is a variable.
+    SELF_CLOSING = /\A( {0,3})<\{\s*(?::|(?=[A-Z]))(#{NAME})(?:\s+(.*?))?\s*\}>[ \t]*$/
     BARE_SELF_CLOSING = /\A( {0,3}):(#{NAME})(?:[ \t]+(.*?))?[ \t]*$/
     # Unquoted text after name:, like YAML's, runs up to the next prop, so title: Hello world limit: 3 has two.
     UNQUOTED = /.+?(?=[ \t]+\w+(?:=|:[ \t])|[ \t]*\z)/
@@ -40,12 +42,15 @@ module Raindown
     module_function
 
     # Each block outside code and front matter as { open:, close:, last:, writes:, node: }, where close is nil for a
-    # bare block, and writes is whether its output's written into the file. A self-closing node is a block of one line
-    # with self_closing: true.
+    # bare block, and writes is whether its output's written into the file. A self-closing node is a block of one line.
     def find(lines, front_matter: {}, bare: false)
+      with_nodes(spans(lines, bare:), front_matter)
+    end
+
+    def with_nodes(spans, front_matter)
       variables = Variables.new(front_matter)
 
-      spans(lines, bare:).map do |span|
+      spans.map do |span|
         node = Nodes.instance(span[:class], *args(span[:args], variables, antlers: span[:antlers]))
         span.except(:name, :class, :args, :antlers).merge(node:)
       end
@@ -71,28 +76,29 @@ module Raindown
       spans
     end
 
-    # Swaps each block for its node's HTML, through a placeholder, or for its Markdown when it has no HTML of its own.
-    # The directive and end tag become Directives markers, which also keep the node's output from joining
-    # the Markdown around it, like two lists becoming one.
-    def to_rendered(markdown, metadata: NoMetadata, bare: false)
-      lines = markdown.lines
-      find(lines, front_matter: FrontMatter.parse(markdown).first, bare:).reverse_each do |block|
-        lines[block[:open]..block[:last]] = rendered_lines(lines, block, markdown:, metadata:, bare:)
+    # Swaps each bare block or block in comments for its node's Markdown, or its HTML when it has its own, or only renders,
+    # as a fragment or a placeholder. The directive and end tag become Directives markers, which also keep the node's
+    # output from joining the Markdown around it, like two lists becoming one. Ones in <{ }> are left to Antlers.
+    def to_rendered(context)
+      lines = context.document.dup.force_encoding('UTF-8').lines
+      spans = spans(lines, bare: context.bare).reject { it[:antlers] }
+      with_nodes(spans, FrontMatter.parse(context.document).first).reverse_each do |block|
+        lines[block[:open]..block[:last]] = rendered_lines(lines, block, context)
       end
       lines.join
     end
 
-    def rendered_lines(lines, block, markdown:, metadata:, bare:)
-      output = node_markdown(block[:node], markdown:, metadata:, bare:).chomp
+    def rendered_lines(lines, block, context)
+      output = node_markdown(block, context).chomp
       close = marker(lines[block[:close]]) if block[:close]
 
       [marker(lines[block[:open]]), *("#{output}\n".lines unless output.empty?), *close]
     end
 
-    def node_markdown(node, markdown:, metadata:, bare:)
-      return Nodes.placeholder(node) if Nodes.html?(node)
+    def node_markdown(block, context)
+      return Nodes.rendered(block[:node], context) if !block[:writes] || Nodes.html?(block[:node])
 
-      Nodes.call(node, :replace, document: markdown, metadata:, bare:).to_s
+      Nodes.call(block[:node], :rewrite, **context.to_h).to_s
     end
 
     def marker(line)
@@ -109,7 +115,7 @@ module Raindown
         end_tag(lines, index, found[2], comment: pattern == :comment_open)
           .then { |close| { open: index, close:, last: close, writes: pattern == :comment_open, **span } }
       when :bare_open then { **bare_block(lines, index), writes: true, **span }
-      else { open: index, close: nil, last: index, writes: false, self_closing: true, **span }
+      else { open: index, close: nil, last: index, writes: false, **span }
       end
     end
 
@@ -156,7 +162,7 @@ module Raindown
     end
 
     # A value, like 'text', 3, true, nil or :draft, or else a variable. In Antlers' delimiters a word is a variable, like
-    # author.name, while bare or in a comment, which read like Markdown, it's text, like notes in files: folder: notes,
+    # author.name, while bare or in a comment, which read like Markdown, it's text, like notes in list: folder: notes,
     # and only one in braces is a variable, like {author.name}.
     def value(value, variables, antlers: true)
       Lowkey::ValueParser.parse(value) do

data/lib/raindown/node_injector.rb

@@ -36,7 +36,7 @@ module Raindown
 
     def block_lines(lines, block)
       context = { document: @content, metadata: @metadata, bare: @bare, written: written_lines(lines, block) }
-      markdown = Nodes.call(block[:node], :replace, **context).to_s.chomp
+      markdown = Nodes.call(block[:node], :rewrite, **context).to_s.chomp
       written = markdown.empty? ? [] : "#{markdown}\n".lines
       return [line(lines[block[:open]]), *bare(written, block)] unless block[:close]