mdom 0.3.0 → 0.4.0

data/lib/mdom/inline_parser.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "prism"
+require "strscan"
 
 require_relative "node/inline_nodes"
 
@@ -15,6 +16,17 @@ module MDOM
   # 产出的是**未求值**的节点：`#{}` 只保存表达式原文，公式只保存 TeX 原文。
   # 块级结构（围栏、块级公式、透明 Ruby……）不属于本类。
   #
+  # === 扫描方式
+  #
+  # 扫描由 +StringScanner+（strscan，Ruby 自带）驱动：主循环用一条正则把**整段
+  # 普通字面**一次收下，只在遇到标记字符时才逐字符分派；查找类操作（找配对反引号、
+  # 找闭定界符、找 `]` ……）同样交给 +StringScanner+ 的正则搜索，而不是 Ruby 层的
+  # 逐字符 +while+ 循环。这样 +String#[]+ 与 +String#<<+ 的调用次数从「每字符一次」
+  # 降到「每段一次」。
+  #
+  # 注意 +StringScanner+ 的位置是**字节**偏移，所以本类内部一律按字节定位，需要
+  # 单个字符时用 +String#byteslice+ 取出（+char_before+ 负责向前跨过一个多字节字符）。
+  #
   #   MDOM::InlineParser.parse("**粗** 与 *斜* 与 `code`")
   class InlineParser
     # 可以被 `\` 转义的字符（CommonMark 的 ASCII 标点，外加 CSM 用到的 `$`、`@`）。
@@ -32,7 +44,9 @@ module MDOM
       |[\u2026\u00B7\u30FB]
     /x
 
-    MENTION_RE = /\A@([A-Za-z0-9_][\w-]*)(?::([A-Za-z0-9_][\w-]*))?/
+    # 提及的名字部分：前导 `@` 已由主循环消费，所以这里不再带 `@`（也不用 `\A`
+    # 锚定——+StringScanner#scan+ 就是从当前位置匹配）。
+    MENTION_SCAN_RE = /[A-Za-z0-9_][\w-]*(?::[A-Za-z0-9_][\w-]*)?/
     AUTOLINK_RE = /\A(?:[A-Za-z][A-Za-z0-9+.-]*:[^\s<>]*|[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+)\z/
     DESTINATION_RE = /\A(\S*?)(?:\s+"([^"]*)")?\z/
     RATIO_RE = %r{\A(\S+?)/(\S+)\z}
@@ -49,6 +63,47 @@ module MDOM
       ["*", "*", Node::Emphasis]
     ].freeze
 
+    # -- 扫描用正则 ----------------------------------------------------------
+    #
+    # 主循环先用 +LITERAL_RUN+ 整段收下普通字面；匹配不上时当前字符必是标记
+    # （两者互补），于是交给 +handle+ 逐字符分派。
+
+    LITERAL_RUN = /[^\\`*~\[!<$#@\n]+/
+    ANY_CHAR = /./m
+
+    # 预筛的最低文本长度：更短的文本即使退化也只是常数级，不值得为它建索引
+    # （见 maybe_closes?）。
+    PREFILTER_MIN_BYTES = 4096
+
+    TICKS = /`+/
+    STARS = /\*+/
+    TILDES = /~~/
+    INS_CLOSE = /\+~/
+    DOLLAR = /\$/
+    WIKI_CLOSE = /\]\]/
+
+    # 查找类操作的「跳板」：只停在这些字符上，其余整段跳过。
+    EMPHASIS_JUMP = /[\\`\[!*]/
+    BRACKET_JUMP = /[\\`\[\]]/
+    PAREN_JUMP = /[\\()"']/
+    CLOSE_BRACKET = /\]/
+    CLOSE_ANGLE = />/
+    # 「转义对或目标字符」：找目标字符时用它一次跳过普通字符（见 last_unescaped）。
+    ESCAPE_OR_SQUARE = /\\|\]/
+    ESCAPE_OR_PAREN = /\\|\)/
+
+    # 分派要比较的 ASCII 码（扫描位置是字节偏移，用整数比较省掉一次字符串分配）。
+    BACKSLASH = "\\".ord
+    BACKTICK = "`".ord
+    STAR = "*".ord
+    OPEN_SQUARE = "[".ord
+    CLOSE_SQUARE = "]".ord
+    OPEN_PAREN = "(".ord
+    CLOSE_PAREN = ")".ord
+    EXCLAMATION = "!".ord
+    DQUOTE = '"'.ord
+    SQUOTE = "'".ord
+
     # 解析行内文本，返回行内节点数组。
     #
     # * +styles:+ 为 +false+ 时不再识别样式标签（`*` `**` `~~` `~+`）——样式不得
@@ -65,17 +120,24 @@ module MDOM
     end
 
     def parse(text)
-      @text = text.to_s
-      @pos = 0
+      @scan = StringScanner.new(text.to_s)
       @nodes = []
       buffer = +""
+      @has_close_square = nil
+      @has_close_paren = nil
+      @close_square_ready = false
+      @close_paren_ready = false
+      @link_closer_ready = false
+
+      until @scan.eos?
+        run = @scan.scan(LITERAL_RUN)
+        if run
+          buffer << run
+          next
+        end
 
-      while @pos < @text.length
-        char = @text[@pos]
-        next if handle(char, buffer)
-
-        buffer << char
-        @pos += 1
+        char = @scan.getch
+        buffer << char unless handle(char, buffer)
       end
 
       flush(buffer)
@@ -84,7 +146,10 @@ module MDOM
 
     private
 
-    # 按当前模式分派一个字符，返回是否已消费。
+    # 按当前模式分派一个字符（该字符**已经被消费**），返回是否已处理。
+    #
+    # 契约：处理函数返回 +false+ 时，扫描位置必须与进入时相同——调用方会把
+    # +char+ 按字面收下。失败路径统一走 +rewind+。
     def handle(char, buffer)
       return literal_char(char, buffer) if @literal
 
@@ -114,40 +179,40 @@ module MDOM
 
     # 行内文本里的 `\`：行尾是硬换行，否则按 Markdown 转义语义（CSM §3.11）。
     def escape(buffer)
-      following = @text[@pos + 1]
+      following = @scan.check(ANY_CHAR)
       return false if following.nil?
 
       if following == "\n"
-        @pos += 2
+        @scan.skip(ANY_CHAR)
         emit(buffer, Node::HardBreak.new)
         return true
       end
 
       return false unless ESCAPABLE.include?(following)
 
+      @scan.skip(ANY_CHAR)
       buffer << following
-      @pos += 2
       true
     end
 
     # 软换行折叠（CSM §1.1）：前一个字符是 CJK 标点则直接相连，否则折叠为一个空格。
     def line_break(buffer)
-      previous = @pos.zero? ? nil : @text[@pos - 1]
-      @pos += 1
-      buffer << " " unless cjk_punctuation?(previous)
+      buffer << " " unless cjk_punctuation?(char_before(@scan.pos, 1))
       true
     end
 
     # `` `代码` `` / ``` ``代码`` ```（CSM §1.5）。内容按字面处理。
     def code_span(buffer)
-      ticks = run_length("`")
-      return false if ticks > MAX_CODE_TICKS
+      start = @scan.pos
+      ticks = 1 + @scan.skip(TICKS).to_i
+      return rewind(start) if ticks > MAX_CODE_TICKS
 
-      after = skip_code_span(@pos, ticks)
-      return false if after.nil?
+      closing = find_run(TICKS, ticks)
+      return rewind(start) if closing.nil?
 
-      code = @text[(@pos + ticks)...(after - ticks)]
-      @pos = after
+      body_start = start + ticks - 1
+      code = @scan.string.byteslice(body_start, closing - body_start)
+      @scan.pos = closing + ticks
       emit(buffer, Node::CodeSpan.new(code))
       true
     end
@@ -158,23 +223,26 @@ module MDOM
     # 闭 `*` 的左边都是非空白、且强调不嵌套（内部不再识别 `*`）。任一不满足就把
     # 整个定界符串按字面收下，不退化成更短的定界符。
     def emphasis(buffer)
-      count = run_length("*")
-      return literal_emphasis(buffer, count) unless @styles && count <= 2
-      return literal_emphasis(buffer, count) if blank?(@text[@pos + count])
+      count = 1 + @scan.skip(STARS).to_i
+      # 查找会移动扫描位置，失败路径要回到这里，所以先把内容起点定住。
+      body_start = @scan.pos
+      return literal_emphasis(buffer, count, body_start) unless @styles && count <= 2
+      return literal_emphasis(buffer, count, body_start) if blank?(@scan.check(ANY_CHAR))
 
-      closing = find_emphasis_close(count)
-      return literal_emphasis(buffer, count) if closing.nil?
+      closing = find_emphasis_close(count, body_start)
+      return literal_emphasis(buffer, count, body_start) if closing.nil?
 
-      inner = @text[(@pos + count)...closing]
-      @pos = closing + count
+      inner = @scan.string.byteslice(body_start, closing - body_start)
+      @scan.pos = closing + count
       klass = count == 2 ? Node::Strong : Node::Emphasis
       emit(buffer, klass.new(children: InlineParser.parse(inner, styles: false)))
       true
     end
 
-    def literal_emphasis(buffer, count)
-      buffer << @text[@pos, count]
-      @pos += count
+    # 定界符不成立，整串按字面收下（CSM §1.7 不作退化），扫描位置回到 +from+。
+    def literal_emphasis(buffer, count, from)
+      @scan.pos = from
+      buffer << ("*" * count)
       true
     end
 
@@ -182,20 +250,25 @@ module MDOM
     def tilde_mark(buffer)
       return false unless @styles
 
-      if @text[@pos, 2] == "~~"
-        closing = find_sequence("~~", @pos + 2)
-        return false if closing.nil?
+      start = @scan.pos
+      if @scan.check(/~/)
+        @scan.skip(/~/)
+        body_start = @scan.pos
+        closing = find_sequence(TILDES, body_start)
+        return rewind(start) if closing.nil?
 
-        inner = @text[(@pos + 2)...closing]
-        @pos = closing + 2
+        inner = @scan.string.byteslice(body_start, closing - body_start)
+        @scan.pos = closing + 2
         emit(buffer, Node::Del.new(children: InlineParser.parse(inner)))
         true
-      elsif @text[@pos, 2] == "~+"
-        closing = find_sequence("+~", @pos + 2)
-        return false if closing.nil?
-
-        inner = @text[(@pos + 2)...closing]
-        @pos = closing + 2
+      elsif @scan.check(/\+/)
+        @scan.skip(/\+/)
+        body_start = @scan.pos
+        closing = find_sequence(INS_CLOSE, body_start)
+        return rewind(start) if closing.nil?
+
+        inner = @scan.string.byteslice(body_start, closing - body_start)
+        @scan.pos = closing + 2
         emit(buffer, Node::Ins.new(children: InlineParser.parse(inner)))
         true
       else
@@ -203,25 +276,31 @@ module MDOM
       end
     end
 
-    # `[` 家族：WikiLink、进度条、度量、链接/行内引用。
+    # `[` 家族：WikiLink、进度条、度量、链接/行内引用。整族共用同一个失败回退点——
+    # 失败时只消费掉的那个 `[` 由调用方按字面收下。
     def bracket(buffer)
-      if @text[@pos, 2] == "[["
-        wiki_link(buffer)
-      elsif @text[@pos, 3] == "[->"
-        bar(buffer, Node::Progress)
-      elsif @text[@pos, 2] == "[="
-        bar(buffer, Node::Meter)
+      start = @scan.pos
+      if @scan.check(/\[/)
+        @scan.skip(/\[/)
+        wiki_link(buffer, start)
+      elsif @scan.check(/->/)
+        @scan.skip(/->/)
+        bar(buffer, Node::Progress, start)
+      elsif @scan.check(/=/)
+        @scan.skip(/=/)
+        bar(buffer, Node::Meter, start)
       else
         link(buffer)
       end
     end
 
-    def wiki_link(buffer)
-      closing = find_sequence("]]", @pos + 2)
-      return false if closing.nil?
+    def wiki_link(buffer, start)
+      body_start = @scan.pos
+      closing = find_sequence(WIKI_CLOSE, body_start)
+      return rewind(start) if closing.nil?
 
-      inner = @text[(@pos + 2)...closing]
-      @pos = closing + 2
+      inner = @scan.string.byteslice(body_start, closing - body_start)
+      @scan.pos = closing + 2
       target, _, label = inner.partition("|")
       label = nil if label.empty?
       # label 的策略与一般链接的文本相同：最多一个紧邻的样式标签，其余按字面
@@ -231,79 +310,88 @@ module MDOM
     end
 
     # `[=m/n]` → `<meter>`，`[->m/n]` → `<progress>`（CSM §1.10）。
-    def bar(buffer, klass)
-      offset = klass == Node::Meter ? 2 : 3
-      closing = @text.index("]", @pos + offset)
-      return false if closing.nil?
+    def bar(buffer, klass, start)
+      found = @scan.scan_until(CLOSE_BRACKET)
+      return rewind(start) if found.nil?
 
-      ratio = @text[(@pos + offset)...closing]
+      ratio = found.byteslice(0, found.bytesize - 1)
       match = RATIO_RE.match(ratio)
-      return false if match.nil?
+      return rewind(start) if match.nil?
 
-      @pos = closing + 1
       emit(buffer, klass.new(match[1], match[2], children: literal_nodes(ratio)))
       true
     end
 
     # `[文本](uri "title")` → `<a>`；`[文本](@uri)` → `<q>`（CSM §1.9、§2.3）。
     def link(buffer)
-      closing = matching_bracket(@pos)
-      return false if closing.nil?
-      return false unless @text[closing + 1] == "("
+      start = @scan.pos
+      return rewind(start) unless maybe_link?(start - 1)
+
+      closing = matching_bracket(start - 1)
+      return rewind(start) if closing.nil?
+      return rewind(start) unless @scan.string.getbyte(closing + 1) == OPEN_PAREN
 
       paren = matching_paren(closing + 1)
-      return false if paren.nil?
+      return rewind(start) if paren.nil?
 
-      label = @text[(@pos + 1)...closing]
-      destination = @text[(closing + 2)...paren]
-      @pos = paren + 1
+      string = @scan.string
+      label = string.byteslice(start, closing - start)
+      destination = string.byteslice(closing + 2, paren - closing - 2)
+      @scan.pos = paren + 1
       emit(buffer, build_link(destination, label))
       true
     end
 
     # `![alt](uri "title")` → `<img>`（CSM §2.3）。
     def image(buffer)
-      return false unless @text[@pos + 1] == "["
+      start = @scan.pos
+      return rewind(start) unless @scan.check(/\[/)
 
-      closing = matching_bracket(@pos + 1)
-      return false if closing.nil?
-      return false unless @text[closing + 1] == "("
+      @scan.skip(/\[/)
+      open = @scan.pos - 1
+      return rewind(start) unless maybe_link?(open)
+
+      closing = matching_bracket(open)
+      return rewind(start) if closing.nil?
+      return rewind(start) unless @scan.string.getbyte(closing + 1) == OPEN_PAREN
 
       paren = matching_paren(closing + 1)
-      return false if paren.nil?
+      return rewind(start) if paren.nil?
 
-      alt = @text[(@pos + 2)...closing]
-      destination = @text[(closing + 2)...paren]
+      string = @scan.string
+      alt = string.byteslice(open + 1, closing - open - 1)
+      destination = string.byteslice(closing + 2, paren - closing - 2)
       uri, title = split_destination(destination)
-      @pos = paren + 1
+      @scan.pos = paren + 1
       emit(buffer, Node::Image.new(uri, alt: alt, title: title, children: literal_nodes(alt)))
       true
     end
 
     # `<uri>` / `<mailto:a@b.c>` → `<a>`（CSM §2.3）。
     def autolink(buffer)
-      closing = @text.index(">", @pos + 1)
-      return false if closing.nil?
+      start = @scan.pos
+      found = @scan.scan_until(CLOSE_ANGLE)
+      return rewind(start) if found.nil?
 
-      inner = @text[(@pos + 1)...closing]
-      return false if inner.empty? || !AUTOLINK_RE.match?(inner)
+      inner = found.byteslice(0, found.bytesize - 1)
+      return rewind(start) if inner.empty? || !AUTOLINK_RE.match?(inner)
 
-      @pos = closing + 1
       emit(buffer, Node::Link.new(inner, children: literal_nodes(inner)))
       true
     end
 
     # `$\TeX$` → 行内 `<span class="math">`（CSM §1.11）。`$$` 属于块级公式，这里按字面处理。
     def math(buffer)
-      return false if @text[@pos + 1] == "$"
+      start = @scan.pos
+      return rewind(start) if @scan.check(DOLLAR)
 
-      closing = find_sequence("$", @pos + 1)
-      return false if closing.nil?
+      closing = find_sequence(DOLLAR, start)
+      return rewind(start) if closing.nil?
 
-      tex = @text[(@pos + 1)...closing]
-      return false if tex.empty?
+      tex = @scan.string.byteslice(start, closing - start)
+      return rewind(start) if tex.empty?
 
-      @pos = closing + 1
+      @scan.pos = closing + 1
       emit(buffer, Node::Math.new(tex, children: literal_nodes(tex)))
       true
     end
@@ -313,29 +401,33 @@ module MDOM
     # 边界交给 Prism 判定：把从 `#{` 起的剩余文本包进一个双引号字符串字面量，
     # Prism 给出的插值节点 location 就是 `#{}` 的范围。嵌套 `{}`、字符串与注释
     # 里的 `}` 由 Ruby 自己的词法处理，不需要自研扫描器（CSM §3.12）。
+    #
+    # 位置算式（`start` 是 `{` 的字节位置，`length` 是 `#{expr}` 的字节长度）：
+    # `#{expr}` 的起点是 `start - 1`，表达式是它去掉 `#{` 与 `}` 的中间段。
     def interpolation(buffer)
-      return false unless @text[@pos + 1] == "{"
+      start = @scan.pos
+      return rewind(start) unless @scan.check(/\{/)
 
-      closing = interpolation_end
-      return false if closing.nil?
+      length = interpolation_end(@scan.rest)
+      return rewind(start) if length.nil?
 
-      expr = @text[(@pos + 2)...closing]
-      @pos = closing + 1
+      expr = @scan.string.byteslice(start + 1, length - 3)
+      @scan.pos = start + length - 1
       emit(buffer, Node::Interpolation.new(expr))
       true
     end
 
     # `@user` / `@project:x` / `@tag:kw`（CSM §2.2）。`:` 前是作用域，其后是名字。
+    #
+    # 前一个字符是词字符时不算提及（`a@b` 里的 `@` 只是文本）。
     def mention(buffer)
-      return false if @pos.positive? && @text[@pos - 1].match?(/\w/)
+      return false if char_before(@scan.pos, 1)&.match?(/\w/)
 
-      match = MENTION_RE.match(@text[@pos..])
-      return false if match.nil?
+      matched = @scan.scan(MENTION_SCAN_RE)
+      return false if matched.nil?
 
-      @pos += match[0].length
-      scope = match[1]
-      name = match[2]
-      emit(buffer, Node::Mention.new(name || scope, kind: name ? scope : nil))
+      scope, _, name = matched.partition(":")
+      emit(buffer, Node::Mention.new(name.empty? ? scope : name, kind: name.empty? ? nil : scope))
       true
     end
 
@@ -418,131 +510,268 @@ module MDOM
       @nodes << node
     end
 
-    # 从 +@pos+ 起连续 +char+ 的个数。
-    def run_length(char)
-      run_length_at(@pos, char)
+    # -- 扫描器辅助 ----------------------------------------------------------
+
+    # 让扫描位置回到 +position+ 并返回 +false+：处理函数的统一失败出口。
+    def rewind(position)
+      @scan.pos = position
+      false
+    end
+
+    # 把扫描位置向前推进到 +position+，越界时停在文末——`\` 正好是最后一个字符时，
+    # 「跳过转义对」的 +2 会多出一格（+StringScanner#pos=+ 对越界值直接抛
+    # +RangeError+）。
+    def advance_to(position)
+      size = @scan.string.bytesize
+      @scan.pos = position > size ? size : position
+    end
+
+    # 两级预筛的第一个问题：整段文本里到底有没有 `]`（C 层的 +include?+，一次，极廉）。
+    def any_close_square?
+      @has_close_square = @scan.string.include?("]") if @has_close_square.nil?
+      @has_close_square
+    end
+
+    # 同上，问的是 `)`。
+    def any_close_paren?
+      @has_close_paren = @scan.string.include?(")") if @has_close_paren.nil?
+      @has_close_paren
+    end
+
+    # +open+ 之后是否**可能**存在配对的闭定界符。
+    #
+    # 两级：先排除「整段根本没有该字符」；只有 +PREFILTER_MIN_BYTES+ 以上的文本才
+    # 进一步查「最后一个位置」——收集位置是 Ruby 层循环，短文本（绝大多数行内段）
+    # 哪怕退化也只是常数级，不值得付这个固定成本。
+    def maybe_closes?(has_any, last_position, open)
+      return false unless has_any
+      return true if @scan.string.bytesize < PREFILTER_MIN_BYTES
+
+      last = last_position
+      !last.nil? && last > open
+    end
+
+    # 链接/图片的乐观预筛：+open+（`[` 的位置）之后必须存在「未被转义、且后面紧跟
+    # `(`」的 `]`——否则既不可能是链接也不可能是图片。
+    #
+    # 少了这一步，`"[(" * 2000 + ")]" * 2000` 这类输入仍会退化：预筛只看「有没有 `]`」
+    # 是拦不住的（`]` 很多），而 `matching_bracket` 仍要一个个扫。
+    def maybe_link?(open)
+      return false unless any_close_square?
+      return true if @scan.string.bytesize < PREFILTER_MIN_BYTES
+
+      last = last_link_closer
+      !last.nil? && last > open
+    end
+
+    # 未被转义的、后面紧跟 `(` 的最后一个 `]` 的位置（没有则 +nil+）。
+    def last_link_closer
+      unless @link_closer_ready
+        @last_link_closer = last_unescaped(CLOSE_SQUARE, ESCAPE_OR_SQUARE) do |position|
+          @scan.string.getbyte(position + 1) == OPEN_PAREN
+        end
+        @link_closer_ready = true
+      end
+      @last_link_closer
     end
 
-    def run_length_at(pos, char)
-      cursor = pos
-      cursor += 1 while cursor < @text.length && @text[cursor] == char
-      cursor - pos
+    # 未被转义的最后一个 `]` 的字节位置（没有则 +nil+），供 +matching_bracket+ 预筛。
+    # 惰性算一次，之后每次预筛只是一次整数比较——不能让它拖慢常见的「配对成功」路径。
+    def last_close_square
+      unless @close_square_ready
+        @last_close_square = last_unescaped(CLOSE_SQUARE, ESCAPE_OR_SQUARE)
+        @close_square_ready = true
+      end
+      @last_close_square
     end
 
-    # 从 +pos+（一个反引号序列的起点）跳到配对的结束反引号之后；找不到返回 nil。
-    def skip_code_span(pos, ticks)
-      cursor = pos + ticks
-      while cursor < @text.length
-        if @text[cursor] == "`"
-          run = run_length_at(cursor, "`")
-          return cursor + run if run == ticks
+    # 未被转义的最后一个 `)` 的位置，供 +matching_paren+ 预筛。
+    def last_close_paren
+      unless @close_paren_ready
+        @last_close_paren = last_unescaped(CLOSE_PAREN, ESCAPE_OR_PAREN)
+        @close_paren_ready = true
+      end
+      @last_close_paren
+    end
 
-          cursor += run
+    # 按 +matching_*+ 的扫描规则找「未被转义」的最后一个 +byte+ 的位置。
+    #
+    # 只求**保守**：代码串、引号内的出现也一并记入（宁可说「有」）——预筛只用于排除
+    # 「剩余文本里根本不存在该字符」这种必然无解的情形。
+    def last_unescaped(byte, pattern)
+      string = @scan.string
+      return nil unless string.include?(byte.chr)
+
+      scanner = StringScanner.new(string)
+      last = nil
+      while (ahead = scanner.exist?(pattern))
+        at = scanner.pos + ahead - scanner.matched_size
+        if string.getbyte(at) == byte
+          last = at if !block_given? || yield(at)
+          scanner.pos = at + 1
+        elsif at + 2 <= string.bytesize
+          scanner.pos = at + 2 # 转义对：连下一个字符一起跳过
         else
-          cursor += 1
+          scanner.pos = string.bytesize
         end
       end
+      last
+    end
+
+    # 从当前位置向后搜索 +pattern+：找到就返回匹配**起点**的字节位置，并把扫描位置
+    # 移到匹配之后；找不到返回 +nil+。
+    #
+    # 用 +exist?+ 而不是 +skip_until+——后者会把「跳过的整段」建成字符串返回，
+    # 而这里只要位置。
+    def seek(pattern)
+      ahead = @scan.exist?(pattern)
+      return nil if ahead.nil?
+
+      start = @scan.pos + ahead - @scan.matched_size
+      @scan.pos += ahead
+      start
+    end
+
+    # 从当前位置找长度恰好为 +count+ 的 +re+ 串，返回其起点；没有则 +nil+。
+    # （不等于 +count+ 的整串会被跳过，与原逐字符实现一致。）
+    def find_run(pattern, count)
+      cursor = @scan.pos
+      while seek(pattern)
+        return @scan.pos - @scan.matched_size if @scan.matched_size == count
+      end
+      @scan.pos = cursor
+      nil
+    end
+
+    # 从一个反引号串之后找**等长**的关闭串，返回其之后的位置；找不到 +nil+。
+    def skip_code_span_after(ticks)
+      while seek(TICKS)
+        return @scan.pos if @scan.matched_size == ticks
+      end
       nil
     end
 
     # 找可以充当闭定界符的 `*`：长度必须与 +count+ 相同，且左侧是非空白
     # （CSM §1.7）。跳过转义、行内代码与链接——它们的 `*` 不算定界符。
-    def find_emphasis_close(count)
-      cursor = @pos + count
-      while cursor < @text.length
-        case @text[cursor]
-        when "\\" then cursor += 2
-        when "`" then cursor = skip_code_span(cursor, run_length_at(cursor, "`")) || @text.length
-        when "[", "!"
-          cursor = link_extent(cursor) || cursor + 1
-        when "*"
-          run = run_length_at(cursor, "*")
-          return cursor if run == count && !blank?(@text[cursor - 1])
-
-          cursor += run
-        else cursor += 1
+    def find_emphasis_close(count, from)
+      @scan.pos = from
+      while (found = seek(EMPHASIS_JUMP))
+        case @scan.string.getbyte(found)
+        when BACKSLASH
+          advance_to(found + 2)
+        when BACKTICK
+          @scan.pos = found
+          @scan.pos = skip_code_span_after(@scan.skip(TICKS).to_i) || @scan.string.bytesize
+        when OPEN_SQUARE, EXCLAMATION
+          @scan.pos = link_extent(found) || found + 1
+        when STAR
+          @scan.pos = found
+          run = @scan.skip(STARS).to_i
+          return found if run == count && !blank?(char_before(found))
         end
       end
       nil
     end
 
-    # 找下一个未被转义的 +sequence+。
-    def find_sequence(sequence, from)
-      cursor = from
-      while (found = @text.index(sequence, cursor))
-        return found if found.zero? || @text[found - 1] != "\\"
-
-        cursor = found + 1
+    # 找下一个未被转义的 +re+ 匹配，返回起点字节位置；找不到 +nil+。
+    # 失败时扫描位置落在文末，调用方负责 +rewind+。
+    def find_sequence(pattern, from)
+      @scan.pos = from
+      while (found = seek(pattern))
+        return found unless char_before(found) == "\\"
       end
       nil
     end
 
     # 从 `[` 的位置找配对的 `]`，跳过嵌套、转义与行内代码。
     def matching_bracket(open)
+      # 乐观预筛：`[` 之后没有未被转义的 `]` 时必然找不到配对。少了这一步，
+      # 「大量未闭合 `[`」的输入会退化成 O(n²)——每个 `[` 都要扫到文末。
+      return nil unless maybe_closes?(any_close_square?, last_close_square, open)
+
       depth = 0
-      cursor = open
-      while cursor < @text.length
-        case @text[cursor]
-        when "\\" then cursor += 2
-        when "`" then cursor = skip_code_span(cursor, run_length_at(cursor, "`")) || @text.length
-        when "[" then depth += 1
-                      cursor += 1
-        when "]"
+      @scan.pos = open
+      while (found = seek(BRACKET_JUMP))
+        case @scan.string.getbyte(found)
+        when BACKSLASH
+          advance_to(found + 2)
+        when BACKTICK
+          @scan.pos = found
+          @scan.pos = skip_code_span_after(@scan.skip(TICKS).to_i) || @scan.string.bytesize
+        when OPEN_SQUARE
+          depth += 1
+        when CLOSE_SQUARE
           depth -= 1
-          return cursor if depth.zero?
-
-          cursor += 1
-        else cursor += 1
+          return found if depth.zero?
         end
       end
       nil
     end
 
     def matching_paren(open)
-      matching_pair(open, "(", ")")
+      return nil unless maybe_closes?(any_close_paren?, last_close_paren, open)
+
+      matching_pair(open, OPEN_PAREN, CLOSE_PAREN)
     end
 
-    # 若 +pos+（`[` 或 `!`）处是一个链接/图片，返回它之后的下标；否则 +nil+。
+    # 若 +pos+（`[` 或 `!` 的位置）处是一个链接/图片，返回它之后的位置；否则 +nil+。
     def link_extent(pos)
-      open = @text[pos] == "!" ? pos + 1 : pos
-      return nil unless @text[open] == "["
+      open = @scan.string.getbyte(pos) == EXCLAMATION ? pos + 1 : pos
+      return nil unless @scan.string.getbyte(open) == OPEN_SQUARE
+      return nil unless maybe_link?(open)
 
       closing = matching_bracket(open)
-      return nil if closing.nil? || @text[closing + 1] != "("
+      return nil if closing.nil? || @scan.string.getbyte(closing + 1) != OPEN_PAREN
 
       paren = matching_paren(closing + 1)
       paren && paren + 1
     end
 
     # 从 +open+（开括号的位置）找配对闭括号；跳过嵌套、反斜杠转义与引号内的括号。
+    # 定界符用 ASCII 码比较（扫描位置是字节偏移）。
     def matching_pair(open, opener, closer)
       depth = 0
       quote = nil
-      cursor = open
-      while cursor < @text.length
-        char = @text[cursor]
-        if char == "\\"
-          cursor += 2
+      @scan.pos = open
+      while (found = seek(PAREN_JUMP))
+        byte = @scan.string.getbyte(found)
+        if byte == BACKSLASH
+          advance_to(found + 2)
           next
         end
         if quote
-          quote = nil if char == quote
-          cursor += 1
+          quote = nil if byte == quote
           next
         end
 
-        case char
-        when "\"", "'" then quote = char
+        case byte
+        when DQUOTE, SQUOTE then quote = byte
         when opener then depth += 1
         when closer
           depth -= 1
-          return cursor if depth.zero?
+          return found if depth.zero?
         end
-        cursor += 1
       end
       nil
     end
 
+    # +position+（默认当前位置）之前第 +offset+ 个字符（+0+ = 紧邻的上一个字符，
+    # 调用方传 +1+ 表示「跳过紧邻的那一个再看」）；越过文本开头时返回 +nil+。
+    # UTF-8 下最多回退 3 个字节，不做多余分配。
+    def char_before(position = @scan.pos, offset = 0)
+      string = @scan.string
+      index = position
+      (offset + 1).times do
+        return nil if index <= 0
+
+        index -= 1
+        index -= 1 while index.positive? && (string.getbyte(index) & 0xC0) == 0x80
+      end
+
+      finish = position
+      string.byteslice(index, finish - index)
+    end
+
     def cjk_punctuation?(char)
       !char.nil? && CJK_PUNCTUATION.match?(char)
     end
@@ -552,13 +781,17 @@ module MDOM
       char.nil? || char.match?(/\s/)
     end
 
-    # 用 Prism 找出与当前位置的 `#{` 配对的 `}` 的下标；不是插值则返回 nil。
+    # 用 Prism 找出从 +rest+（`#{` 之后的剩余文本）起的 `#{...}` 的**字节长度**；
+    # 不是插值则返回 nil。
     #
     # 构造出的字面量里，插值之后若出现裸 `"`，整段就不再是合法 Ruby——Prism
     # 会报错，但错误恢复仍给出插值节点，边界照常可读。代价是每个插值解析一次
     # 剩余文本（各次解析互不影响）。
-    def interpolation_end
-      result = Prism.parse("\"#{@text[@pos..]}\"")
+    def interpolation_end(rest)
+      source = +'"#'
+      source << rest
+      source << '"'
+      result = Prism.parse(source)
       segment = first_embedded_statement(result.value)
       return nil if segment.nil?
 
@@ -566,7 +799,7 @@ module MDOM
       # 未闭合的 `#{` 会一直吞到字符串结尾，此时的 slice 不以 `}` 收尾。
       return nil unless slice.end_with?("}")
 
-      @pos + slice.length - 1
+      slice.bytesize
     end
 
     # 先序遍历，取第一个字符串插值节点。