markdownr 0.6.17 → 0.7.0

data/lib/markdown_server/app.rb

@@ -11,10 +11,18 @@ require "set"
 require "net/http"
 require "base64"
 require_relative "plugin"
+require_relative "helpers/path_helpers"
+require_relative "helpers/formatting_helpers"
+require_relative "helpers/markdown_helpers"
+require_relative "helpers/search_helpers"
+require_relative "helpers/fetch_helpers"
+require_relative "helpers/admin_helpers"
 
 module MarkdownServer
+  EXCLUDED = %w[.git .obsidian __pycache__ .DS_Store node_modules .claude].freeze
+
   class App < Sinatra::Base
-    EXCLUDED = %w[.git .obsidian __pycache__ .DS_Store node_modules .claude].freeze
+    EXCLUDED = MarkdownServer::EXCLUDED
 
     set :views, File.expand_path("../../views", __dir__)
 
@@ -39,1019 +47,24 @@ module MarkdownServer
       set :popup_external, true
       set :popup_external_domains, []
       set :dictionary_url, nil
+      set :plugin_dirs, []
     end
 
-    # Server-side Strong's dictionary cache
-    @@strongs_cache = nil
-    @@strongs_cache_url = nil
-    @@strongs_fetched_at = nil
-    DICTIONARY_TTL = 3600 # 1 hour
-
-    # CSS cache for external stylesheets (keyed by absolute URL)
-    @@css_cache = {}
-    CSS_TTL = 3600 # 1 hour
-
     def self.load_plugins!
       Dir[File.join(__dir__, "plugins", "*", "plugin.rb")].sort.each { |f| require f }
-      set :plugins, PluginRegistry.load_plugins(settings.root_dir, settings.plugin_overrides)
+      set :plugins, PluginRegistry.load_plugins(
+        settings.root_dir,
+        settings.plugin_overrides,
+        plugin_dirs: settings.plugin_dirs
+      )
     end
 
-    helpers do
-      def root_dir
-        settings.root_dir
-      end
-
-      def h(text)
-        CGI.escapeHTML(text.to_s)
-      end
-
-      def encode_path_component(str)
-        URI.encode_www_form_component(str).gsub("+", "%20")
-      end
-
-      def safe_path(requested)
-        base = File.realpath(root_dir)
-        full = File.join(base, requested)
-
-        begin
-          real = File.realpath(full)
-        rescue Errno::ENOENT
-          halt 404, erb(:layout) { "<h1>Not Found</h1><p>#{h(requested)}</p>" }
-        end
-
-        unless real.start_with?(base)
-          halt 403, erb(:layout) { "<h1>Forbidden</h1>" }
-        end
-
-        relative = real.sub("#{base}/", "")
-        first_segment = relative.split("/").first
-        if EXCLUDED.include?(first_segment) || first_segment&.start_with?(".")
-          halt 403, erb(:layout) { "<h1>Forbidden</h1>" }
-        end
-
-        real
-      end
-
-      def format_size(bytes)
-        if bytes < 1024
-          "#{bytes} B"
-        elsif bytes < 1024 * 1024
-          "%.1f KB" % (bytes / 1024.0)
-        else
-          "%.1f MB" % (bytes / (1024.0 * 1024))
-        end
-      end
-
-      def format_date(time)
-        time.strftime("%Y-%m-%d %H:%M")
-      end
-
-      def icon_for(entry_name, is_dir)
-        if is_dir
-          "\u{1F4C1}"
-        else
-          ext = File.extname(entry_name).downcase
-          case ext
-          when ".md" then "\u{1F4DD}"
-          when ".pdf" then "\u{1F4D5}"
-          when ".json" then "\u{1F4CB}"
-          when ".py" then "\u{1F40D}"
-          when ".rb" then "\u{1F48E}"
-          when ".csv" then "\u{1F4CA}"
-          when ".epub" then "\u{1F4D6}"
-          else "\u{1F4C4}"
-          end
-        end
-      end
-
-      def breadcrumbs(path)
-        parts = path.split("/").reject(&:empty?)
-        crumbs = [{ name: "home", href: "/browse/" }]
-        parts.each_with_index do |part, i|
-          href = "/browse/" + parts[0..i].map { |p| encode_path_component(p) }.join("/") + "/"
-          crumbs << { name: part, href: href }
-        end
-        crumbs
-      end
-
-      def parse_frontmatter(content)
-        if content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
-          begin
-            meta = YAML.safe_load($1, permitted_classes: [Date, Time])
-            body = $2
-            [meta, body]
-          rescue => e
-            [nil, content]
-          end
-        else
-          [nil, content]
-        end
-      end
-
-      def render_markdown(text)
-        # Convert mermaid code fences to raw HTML divs before Kramdown so Rouge
-        # never touches them and the content is preserved exactly for Mermaid.js.
-        text = text.gsub(/^```mermaid[ \t]*\r?\n([\s\S]*?)^```[ \t]*(\r?\n|\z)/m) do
-          "<div class=\"mermaid\">\n#{h($1.rstrip)}\n</div>\n\n"
-        end
-
-        # Run plugin markdown transformations (e.g. Bible citation auto-linking)
-        settings.plugins.each { |p| text = p.transform_markdown(text) }
-
-        # Process wiki links BEFORE Kramdown so that | isn't consumed as
-        # a GFM table delimiter.
-        text = text.gsub(/\[\[([^\]]+)\]\]/) do
-          raw = $1
-          if raw.include?("|")
-            target, display = raw.split("|", 2)
-          else
-            target = raw
-            display = nil
-          end
-
-          if target.start_with?("#")
-            heading_text = target[1..]
-            anchor = heading_text.downcase.gsub(/\s+/, "-").gsub(/[^\w-]/, "")
-            label = display || heading_text
-            %(<a class="wiki-link" href="##{h(anchor)}">#{h(label)}</a>)
-          else
-            file_part, anchor_part = target.split("#", 2)
-            anchor_suffix = anchor_part ? "##{anchor_part.downcase.gsub(/\s+/, '-').gsub(/[^\w-]/, '')}" : ""
-            resolved = resolve_wiki_link(file_part)
-            label = display || target
-            if resolved
-              %(<a class="wiki-link" href="/browse/#{encode_path_component(resolved).gsub('%2F', '/')}#{anchor_suffix}">#{h(label)}</a>)
-            else
-              %(<span class="wiki-link broken">#{h(label)}</span>)
-            end
-          end
-        end
-
-        html = Kramdown::Document.new(
-          text,
-          input: "GFM",
-          syntax_highlighter: "rouge",
-          syntax_highlighter_opts: { default_lang: "text" },
-          hard_wrap: settings.hard_wrap
-        ).to_html
-
-        # Restore non-numeric footnote labels: Kramdown converts all footnote
-        # references to sequential numbers, but we want [^abc] to display "abc".
-        html = html.gsub(%r{<sup id="fnref:([^"]+)"[^>]*>\s*<a href="#fn:\1"[^>]*>\d+</a>\s*</sup>}m) do
-          full_match = $&
-          name = $1
-          if name =~ /\A\d+\z/
-            full_match
-          else
-            %(<sup id="fnref:#{name}" role="doc-noteref"><a href="#fn:#{name}" class="footnote" rel="footnote">#{h(name)}</a></sup>)
-          end
-        end
-        html.gsub(%r{<li id="fn:([^"]+)"[^>]*>\s*<p>}m) do
-          full_match = $&
-          name = $1
-          if name =~ /\A\d+\z/
-            full_match
-          else
-            %(<li id="fn:#{name}"><p><strong>#{h(name)}:</strong> )
-          end
-        end
-      end
-
-      def resolve_wiki_link(name)
-        filename = "#{name}.md"
-        base = File.realpath(root_dir)
-        # On case-sensitive filesystems (Linux/Docker), FNM_CASEFOLD doesn't help
-        # with directory listings. Try exact filename first, then lowercased variant.
-        candidates = [filename]
-        candidates << filename.downcase if filename != filename.downcase
-
-        # Check the current file's directory first (exact case, then case-insensitive)
-        if @current_wiki_dir
-          local_exact = nil
-          local_ci = nil
-          candidates.each do |fn|
-            Dir.glob(File.join(@current_wiki_dir, fn)).each do |path|
-              real = File.realpath(path) rescue next
-              next unless real.start_with?(base)
-              relative = real.sub("#{base}/", "")
-              first_segment = relative.split("/").first
-              next if EXCLUDED.include?(first_segment) || first_segment&.start_with?(".")
-              if File.basename(real) == filename
-                local_exact = relative
-                break
-              else
-                local_ci ||= relative
-              end
-            end
-            break if local_exact
-          end
-          return local_exact if local_exact
-          return local_ci if local_ci
-        end
-
-        # Fall back to global recursive search
-        exact_match = nil
-        ci_match = nil
-        candidates.each do |fn|
-          Dir.glob(File.join(base, "**", fn)).each do |path|
-            real = File.realpath(path) rescue next
-            next unless real.start_with?(base)
-            relative = real.sub("#{base}/", "")
-            first_segment = relative.split("/").first
-            next if EXCLUDED.include?(first_segment) || first_segment&.start_with?(".")
-            if File.basename(real) == filename
-              exact_match ||= relative
-            else
-              ci_match ||= relative
-            end
-          end
-          break if exact_match
-        end
-
-        exact_match || ci_match
-      end
-
-      def render_inline_wiki_links(str)
-        result = ""
-        last_end = 0
-        str.scan(/\[\[([^\]]+)\]\]/) do |match|
-          raw = match[0]
-          m_start = $~.begin(0)
-          m_end = $~.end(0)
-          result += h(str[last_end...m_start])
-          target, display = raw.include?("|") ? raw.split("|", 2) : [raw, nil]
-          label = display || target
-          if target.start_with?("#")
-            anchor = target[1..].downcase.gsub(/\s+/, "-").gsub(/[^\w-]/, "")
-            result += %(<a class="wiki-link" href="##{h(anchor)}">#{h(label)}</a>)
-          else
-            file_part, anchor_part = target.split("#", 2)
-            anchor_suffix = anchor_part ? "##{anchor_part.downcase.gsub(/\s+/, '-').gsub(/[^\w-]/, '')}" : ""
-            resolved = resolve_wiki_link(file_part)
-            if resolved
-              result += %(<a class="wiki-link" href="/browse/#{encode_path_component(resolved).gsub('%2F', '/')}#{anchor_suffix}">#{h(label)}</a>)
-            else
-              result += %(<span class="wiki-link broken">#{h(label)}</span>)
-            end
-          end
-          last_end = m_end
-        end
-        result += h(str[last_end..])
-        result
-      end
-
-      def render_frontmatter_value(value)
-        case value
-        when Array
-          value.map { |v|
-            str = v.to_s
-            if str.include?("[[")
-              render_inline_wiki_links(str)
-            else
-              %(<span class="tag">#{h(str)}</span>)
-            end
-          }.join(" ")
-        when String
-          if value =~ /\Ahttps?:\/\//
-            %(<a href="#{h(value)}" target="_blank" rel="noopener">#{h(value)}</a>)
-          elsif value.include?("[[")
-            render_inline_wiki_links(value)
-          elsif value.length > 120
-            render_markdown(value)
-          else
-            h(value)
-          end
-        when Numeric, TrueClass, FalseClass
-          h(value.to_s)
-        when NilClass
-          %(<span class="empty">—</span>)
-        else
-          h(value.to_s)
-        end
-      end
-
-      def syntax_highlight(code, language)
-        formatter = Rouge::Formatters::HTML.new
-        lexer = Rouge::Lexer.find_fancy(language) || Rouge::Lexers::PlainText.new
-        formatter.format(lexer.lex(code))
-      end
-
-      def extract_toc(html)
-        headings = []
-        html.scan(/<h([1-6])\s[^>]*id="([^"]*)"[^>]*>(.*?)<\/h\1>/mi) do |level, id, text|
-          clean_text = text.gsub(/<sup[^>]*id="fnref:[^"]*"[^>]*>.*?<\/sup>/i, "").gsub(/<[^>]+>/, "").strip
-          headings << { level: level.to_i, id: id, text: clean_text }
-        end
-        headings
-      end
-
-      def dir_title
-        return settings.custom_title if settings.respond_to?(:custom_title) && settings.custom_title
-        File.basename(root_dir).gsub(/[-_]/, " ").gsub(/\b\w/, &:upcase)
-      end
-
-      def search_form_path(relative_path)
-        "/search/" + relative_path.split("/").map { |p| encode_path_component(p) }.join("/")
-      end
-
-      def parent_dir_path(relative_path)
-        parts = relative_path.split("/")
-        parts.length > 1 ? parts[0..-2].join("/") : ""
-      end
-
-      BINARY_EXTENSIONS = %w[
-        .png .jpg .jpeg .gif .bmp .ico .svg .webp
-        .pdf .epub .mobi
-        .zip .gz .tar .bz2 .7z .rar
-        .exe .dll .so .dylib .o
-        .mp3 .mp4 .avi .mov .wav .flac .ogg
-        .woff .woff2 .ttf .eot .otf
-        .pyc .class .beam
-        .sqlite .db
-      ].freeze
-
-      MAX_SEARCH_FILES = 100
-      MAX_FILE_READ_BYTES = 512_000  # 500KB
-      CONTEXT_LINES = 2  # lines before/after match to send
-      MAX_LINE_DISPLAY = 200  # chars before truncating a line
-
-      def search_single_file(file_path, regexes)
-        base = File.realpath(root_dir)
-        begin
-          content = File.binread(file_path, MAX_FILE_READ_BYTES)
-        rescue
-          return []
-        end
-        content.force_encoding("utf-8")
-        return [] unless content.valid_encoding?
-        return [] unless regexes.all? { |re| re.match?(content) }
-
-        relative = file_path.sub("#{base}/", "")
-        lines = content.lines
-        matches = collect_matching_lines(lines, regexes)
-        [{ path: relative, matches: matches }]
-      end
-
-      def search_files(dir_path, regexes)
-        results = []
-        base = File.realpath(root_dir)
-
-        catch(:search_limit) do
-          walk_directory(dir_path) do |file_path|
-            throw :search_limit if results.length >= MAX_SEARCH_FILES
-
-            content = File.binread(file_path, MAX_FILE_READ_BYTES) rescue next
-            content.force_encoding("utf-8")
-            next unless content.valid_encoding?
-
-            # All regexes must match somewhere in the file
-            next unless regexes.all? { |re| re.match?(content) }
-
-            relative = file_path.sub("#{base}/", "")
-            lines = content.lines
-            matches = collect_matching_lines(lines, regexes)
-
-            results << { path: relative, matches: matches }
-          end
-        end
-
-        results
-      end
-
-      def walk_directory(dir_path, &block)
-        Dir.entries(dir_path).sort.each do |entry|
-          next if entry.start_with?(".") || EXCLUDED.include?(entry)
-          full = File.join(dir_path, entry)
-
-          if File.directory?(full)
-            walk_directory(full, &block)
-          elsif File.file?(full)
-            ext = File.extname(entry).downcase
-            next if BINARY_EXTENSIONS.include?(ext)
-            block.call(full)
-          end
-        end
-      end
-
-      def collect_matching_lines(lines, regexes)
-        match_indices = Set.new
-        lines.each_with_index do |line, i|
-          if regexes.any? { |re| re.match?(line) }
-            match_indices << i
-          end
-        end
-
-        # Build context groups
-        groups = []
-        sorted = match_indices.sort
-
-        sorted.each do |idx|
-          range_start = [idx - CONTEXT_LINES, 0].max
-          range_end = [idx + CONTEXT_LINES, lines.length - 1].min
-
-          if groups.last && range_start <= groups.last[:end] + 1
-            groups.last[:end] = range_end
-          else
-            groups << { start: range_start, end: range_end }
-          end
-        end
-
-        groups.map do |g|
-          context_lines = (g[:start]..g[:end]).map do |i|
-            distance = match_indices.include?(i) ? 0 : match_indices.map { |m| (m - i).abs }.min
-            { number: i + 1, text: lines[i].to_s.chomp, distance: distance }
-          end
-          { lines: context_lines }
-        end
-      end
-
-      def highlight_search_line(text, regexes, is_match)
-        # Build a combined regex with non-greedy quantifiers for shorter highlights
-        combined = Regexp.union(regexes.map { |r|
-          Regexp.new(r.source.gsub(/(?<!\\)([*+}])(?!\?)/, '\1?'), r.options)
-        })
-
-        # Truncate long lines, centering around the first match
-        prefix_trunc = false
-        suffix_trunc = false
-        if text.length > MAX_LINE_DISPLAY
-          if is_match && (m = combined.match(text))
-            center = m.begin(0) + m[0].length / 2
-            half = MAX_LINE_DISPLAY / 2
-            start = [[center - half, 0].max, [text.length - MAX_LINE_DISPLAY, 0].max].min
-          else
-            start = 0
-          end
-          prefix_trunc = start > 0
-          suffix_trunc = (start + MAX_LINE_DISPLAY) < text.length
-          text = text[start, MAX_LINE_DISPLAY]
-        end
-
-        html = ""
-        html << '<span class="truncated">...</span>' if prefix_trunc
-        if is_match
-          pieces = text.split(combined)
-          matches = text.scan(combined)
-          pieces.each_with_index do |piece, i|
-            html << h(piece)
-            html << %(<span class="highlight-match">#{h(matches[i])}</span>) if matches[i]
-          end
-        else
-          html << h(text)
-        end
-        html << '<span class="truncated">...</span>' if suffix_trunc
-        html
-      end
-
-      FETCH_MAX_BYTES = 512_000
-      FETCH_TIMEOUT   = 5
-
-      def strongs_map
-        url = settings.dictionary_url
-        return {} unless url
-
-        now = Time.now
-        if @@strongs_cache && @@strongs_cache_url == url && @@strongs_fetched_at
-          if url.match?(/\Ahttps?:\/\//i)
-            return @@strongs_cache if (now - @@strongs_fetched_at) < DICTIONARY_TTL
-          else
-            path = File.expand_path(url, root_dir)
-            mtime = File.mtime(path) rescue nil
-            return @@strongs_cache if mtime && mtime <= @@strongs_fetched_at
-          end
-        end
-
-        begin
-          raw = if url.match?(/\Ahttps?:\/\//i)
-            uri = URI.parse(url)
-            http = Net::HTTP.new(uri.host, uri.port)
-            http.use_ssl = (uri.scheme == "https")
-            http.open_timeout = FETCH_TIMEOUT
-            http.read_timeout = 10
-            req = Net::HTTP::Get.new(uri.request_uri)
-            req["Accept"] = "application/json"
-            resp = http.request(req)
-            return @@strongs_cache || {} unless resp.is_a?(Net::HTTPSuccess)
-            resp.body
-          else
-            path = File.expand_path(url, root_dir)
-            return @@strongs_cache || {} unless File.exist?(path)
-            File.read(path, encoding: "utf-8")
-          end
-
-          data = JSON.parse(raw)
-          url_tpl = data["url"] || ""
-          map = {}
-          %w[greek hebrew].each do |lang|
-            stems = data.dig("stems", lang)
-            next unless stems.is_a?(Hash)
-            stems.each_value do |entry|
-              sn = entry["strongs"].to_s.strip.upcase
-              next if sn.empty?
-              map[sn] = url_tpl.gsub("{filename}", entry["filename"].to_s)
-            end
-          end
-          @@strongs_cache = map
-          @@strongs_cache_url = url
-          @@strongs_fetched_at = now
-          map
-        rescue StandardError
-          @@strongs_cache || {}
-        end
-      end
-
-      def strongs_popup_url(strongs)
-        sn = strongs.to_s.strip.upcase
-        return nil unless sn.match?(/\A[GH]\d+\z/)
-        url = strongs_map[sn]
-        return url if url
-        # Fallback: Blue Letter Bible
-        prefix = sn.start_with?("H") ? "wlc" : "tr"
-        "https://www.blueletterbible.org/lexicon/#{sn.downcase}/nasb20/#{prefix}/0-1/"
-      end
-
-      def inject_strongs_urls(html)
-        return html unless settings.dictionary_url
-        html = html.gsub(/<span\s+class="subst"([^>]*data-strongs="([^"]+)"[^>]*)>/) do
-          attrs, strongs = $1, $2
-          popup_url = strongs_popup_url(strongs)
-          if popup_url && !attrs.include?("data-popup-url")
-            %(<span class="subst" data-popup-url="#{h(popup_url)}"#{attrs}>)
-          else
-            $&
-          end
-        end
-        # Interlinear .word spans: inject data-popup-url when Strong's is in dictionary
-        html.gsub(/<span\s+class="word"([^>]*data-strongs="([^"]+)"[^>]*)>/) do
-          attrs, strongs = $1, $2
-          dict_url = strongs_map[strongs.strip.upcase]
-          if dict_url && !attrs.include?("data-popup-url")
-            %(<span class="word" data-popup-url="#{h(dict_url)}"#{attrs}>)
-          else
-            $&
-          end
-        end
-      end
-
-      # Tags kept as-is (attributes stripped)
-      ALLOWED_HTML = %w[p h1 h2 h3 h4 h5 h6 blockquote ul ol li
-                        pre br hr strong b em i sup sub code
-                        table tr td th].to_set
-      # Block containers — replaced with a newline (content kept)
-      BLOCK_HTML   = %w[div section aside figure figcaption
-                        thead tbody tfoot].to_set
-      # Elements removed completely, including their content
-      STRIP_FULL   = %w[script style nav header footer form input
-                        button select textarea svg iframe noscript].to_set
-
-      def fetch_css(url_str)
-        cached = @@css_cache[url_str]
-        return cached[:body] if cached && (Time.now - cached[:at]) < CSS_TTL
-
-        uri = URI.parse(url_str)
-        return nil unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
-        http.open_timeout = FETCH_TIMEOUT
-        http.read_timeout = FETCH_TIMEOUT
-        req = Net::HTTP::Get.new(uri.request_uri)
-        req["Accept"] = "text/css"
-        resp = http.request(req)
-        body = resp.is_a?(Net::HTTPSuccess) ? resp.body.to_s.encode("utf-8", invalid: :replace, undef: :replace) : nil
-        @@css_cache[url_str] = { body: body, at: Time.now } if body
-        body
-      rescue
-        @@css_cache.dig(url_str, :body)
-      end
-
-      def fetch_external_page(url_str)
-        uri = URI.parse(url_str)
-        return nil unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
-        fetch_follow_redirects(uri, 5)
-      rescue
-        nil
-      end
-
-      def fetch_follow_redirects(uri, limit)
-        return nil if limit <= 0
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = (uri.scheme == "https")
-        http.open_timeout = FETCH_TIMEOUT
-        http.read_timeout = FETCH_TIMEOUT
-        req = Net::HTTP::Get.new(uri.request_uri)
-        req["User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
-        req["Accept"] = "text/html,application/xhtml+xml;q=0.9,*/*;q=0.8"
-        req["Accept-Language"] = "en-US,en;q=0.5"
-        resp = http.request(req)
-        case resp
-        when Net::HTTPSuccess
-          ct = resp["content-type"].to_s
-          return nil unless ct.match?(/html|text/i)
-          body = resp.body.to_s
-          body = body.b[0, FETCH_MAX_BYTES].force_encoding("utf-8")
-          body.encode("utf-8", invalid: :replace, undef: :replace, replace: "?")
-        when Net::HTTPRedirection
-          loc = resp["Location"].to_s
-          new_uri = (URI.parse(loc) rescue nil)
-          return nil unless new_uri
-          new_uri = uri + new_uri unless new_uri.absolute?
-          return nil unless new_uri.is_a?(URI::HTTP) || new_uri.is_a?(URI::HTTPS)
-          fetch_follow_redirects(new_uri, limit - 1)
-        end
-      rescue
-        nil
-      end
-
-      def page_title(html)
-        html.match(/<title[^>]*>(.*?)<\/title>/im)&.then { |m|
-          m[1].gsub(/<[^>]+>/, "").gsub(/&amp;/i, "&").gsub(/&lt;/i, "<")
-              .gsub(/&gt;/i, ">").gsub(/&quot;/i, '"').gsub(/&#?\w+;/, "").strip
-        } || ""
-      end
-
-      def page_html(raw, base_url = nil)
-        w = raw.dup
-        # Remove inert elements and their entire contents
-        STRIP_FULL.each { |t| w.gsub!(/<#{t}[^>]*>.*?<\/#{t}>/im, " ") }
-        w.gsub!(/<!--.*?-->/m, " ")
-        # Remove known ad/recommendation blocks
-        w.gsub!(/Bible\s+Gateway\s+Recommends[\s\S]*?View\s+more\s+titles/i, " ")
-        # Remove BibleGateway header/toolbar noise (promo text + login/toolbar block)
-        w.gsub!(/trusted\s+resources\s+beside\s+every\s+verse[\s\S]*?Your\s+Content/i, " ")
-        w.gsub!(/Log\s+In\s*\/\s*Sign\s+Up[\s\S]*?Your\s+Content/i, " ")
-
-        # Prefer a focused content block
-        content = w.match(/<article[^>]*>(.*?)<\/article>/im)&.[](1) ||
-                  w.match(/<main[^>]*>(.*?)<\/main>/im)&.[](1) ||
-                  w.match(/<body[^>]*>(.*?)<\/body>/im)&.[](1) ||
-                  w
-
-        # Rewrite tags: keep allowed (strip attrs), preserve <a href>, block→newline, rest→empty
-        out = content.gsub(/<(\/?)(\w+)([^>]*)>/) do
-          slash, tag, attrs = $1, $2.downcase, $3
-          if ALLOWED_HTML.include?(tag)
-            "<#{slash}#{tag}>"
-          elsif tag == "a"
-            if slash.empty?
-              m = attrs.match(/href\s*=\s*["']([^"']*)["']/i)
-              if m && !m[1].match?(/\Ajavascript:/i)
-                href = m[1].gsub(/&amp;/i, "&")
-                if base_url && href !~ /\Ahttps?:\/\//i && !href.start_with?("#")
-                  href = (URI.join(base_url, href).to_s rescue href)
-                end
-                %(<a href="#{h(href)}" target="_blank" rel="noopener">)
-              else
-                ""
-              end
-            else
-              "</a>"
-            end
-          elsif BLOCK_HTML.include?(tag)
-            "\n"
-          else
-            ""
-          end
-        end
-
-        # Strip any preamble before the first heading (site chrome, toolbars, etc.)
-        out.sub!(/\A[\s\S]*?(?=<h[1-6]>)/i, "")
-
-        # Decode HTML entities
-        out = out
-          .gsub(/&nbsp;/i, " ").gsub(/&amp;/i, "&").gsub(/&lt;/i, "<").gsub(/&gt;/i, ">")
-          .gsub(/&quot;/i, '"').gsub(/&apos;/i, "'")
-          .gsub(/&mdash;/i, "—").gsub(/&ndash;/i, "–").gsub(/&hellip;/i, "…")
-          .gsub(/&#(\d+);/)         { [$1.to_i].pack("U")      rescue " " }
-          .gsub(/&#x([\da-f]+);/i)  { [$1.to_i(16)].pack("U") rescue " " }
-          .gsub(/&\w+;/, " ")
-          .gsub(/[ \t]+/, " ")
-          .gsub(/\n{3,}/, "\n\n")
-          .gsub(/<(\w+)>\s*<\/\1>/, "")  # drop empty tags
-          .strip
-
-        # Strip all footer navigation after "Read full chapter" up to (but not including) copyright
-        out.gsub!(/(<a[^>]*>Read\s+full\s+chapter<\/a>)[\s\S]*?(?=©|Copyright\b)/i, "\\1\n")
-
-        out.length > 10_000 ? out[0, 10_000] : out
-      end
-
-      def markdownr_html(html)
-        # Extract .md-content from a trusted markdownr page, preserving HTML as-is
-        content = html[/<div[^>]+class="md-content"[^>]*>([\s\S]*?)<\/div>\s*(?:<div\s+class="frontmatter"|<\/div>\s*<\/div>|\z)/im, 1]
-        return page_html(html) unless content && content.length > 10
-
-        # Also extract frontmatter if present
-        fm = html[/<div\s+class="frontmatter">([\s\S]*?)<\/div>\s*<\/div>/im, 0] || ""
-
-        result = content.strip
-        result += "\n#{fm}" unless fm.empty?
-        result.length > 15_000 ? result[0, 15_000] : result
-      end
-
-      def blueletterbible_html(html, url)
-        base = "https://www.blueletterbible.org"
-
-        # ── Word ──────────────────────────────────────────────────────────────
-        word = html[/<h6[^>]+class="lexTitle(?:Gk|Hb)"[^>]*>(.*?)<\/h6>/im, 1]
-                 &.gsub(/<[^>]+>/, "")&.strip || ""
-
-        # ── Transliteration ───────────────────────────────────────────────────
-        transliteration = html[/<div[^>]+id="lexTrans".*?<em>(.*?)<\/em>/im, 1]&.strip || ""
-
-        # ── Pronunciation + audio ─────────────────────────────────────────────
-        pronunciation = html[/class="[^"]*lexicon-pronunc[^"]*"[^>]*>\s*([^\n<]{1,50})/i, 1]&.strip || ""
-        data_pronunc  = html[/data-pronunc="([a-fA-F0-9]{20,})"/i, 1] || ""
-        audio_btn = if data_pronunc.length > 10
-          au = "#{base}/lang/lexicon/lexPronouncePlayer.cfm?skin=#{data_pronunc}"
-          %(<button onclick="var a=this._a||(this._a=new Audio('#{h(au)}'));a.currentTime=0;a.play();" ) +
-            %(style="background:none;border:none;cursor:pointer;padding:0 0 0 4px;font-size:1.1em;vertical-align:middle;" title="Play pronunciation (Blue Letter Bible)">&#128266;</button>)
-        else
-          ""
-        end
-
-        # StudyLight pronunciation button — extract Strong's number from URL
-        sl_match = url.to_s.match(%r{/lexicon/([hg])(\d+)/}i)
-        if sl_match
-          sl_lang = sl_match[1].downcase == "h" ? "hebrew" : "greek"
-          sl_num = sl_match[2]
-          sl_url = "https://www.studylight.org/multi-media/audio/lexicons/eng/#{sl_lang}.html?n=#{sl_num}"
-          audio_btn += %(<button onclick="var a=this._a||(this._a=new Audio('#{h(sl_url)}'));a.currentTime=0;a.play();" ) +
-            %(style="background:none;border:none;cursor:pointer;padding:0 0 0 4px;font-size:1.1em;vertical-align:middle;" title="Play pronunciation (StudyLight)">&#128266;</button>)
-        end
-
-        # ── Part of speech ────────────────────────────────────────────────────
-        pos = html[/<div[^>]+id="lexPart".*?small-text-right"[^>]*>(.*?)<\/div>/im, 1]
-               &.gsub(/<[^>]+>/, "")&.strip || ""
-
-        # ── Info table ────────────────────────────────────────────────────────
-        info_rows = [
-          ["Word",            h(word)],
-          ["Transliteration", "<em>#{h(transliteration)}</em>"],
-          ["Pronunciation",   "#{h(pronunciation)}#{audio_btn}"],
-          ["Part of Speech",  h(pos)],
-        ]
-        info_html = %(<table class="blb-table">) +
-          info_rows.map { |label, v|
-            %(<tr><th class="blb-th">#{h(label)}</th><td>#{v}</td></tr>)
-          }.join + "</table>"
-
-        # ── Inflections ───────────────────────────────────────────────────────
-        infl_html = ""
-        if (m = html.match(/<div\s[^>]*id="greek-tr-inflections"[^>]*>/im))
-          after_infl = html[m.end(0)..]
-          stop       = after_infl.index(/<div\s[^>]*id="greek-(?:mgnt|lxx)-inflections"/i) || after_infl.length
-          infl_section = after_infl[0...stop]
-          inflections  = []
-          infl_section.scan(/<div\s[^>]*class="greekInflection"[^>]*>(.*?)<\/div>\s*<\/div>/im) do |mv|
-            chunk = mv[0]
-            href  = chunk[/href="([^"]+)"/i, 1]
-            gk    = chunk[/<span[^>]+class="Gk"[^>]*>(.*?)<\/span>/im, 1]&.gsub(/<[^>]+>/, "")&.strip || ""
-            freq  = chunk[/&#8212;\s*(\d+)x<\/a>/i, 1]&.to_i || 0
-            next if gk.empty? || freq.zero?
-            inflections << { word: gk, freq: freq,
-                             href: href ? base + href.gsub("&amp;", "&") : nil }
-          end
-          inflections.sort_by! { |i| -i[:freq] }
-          if inflections.any?
-            rows = inflections.map { |i|
-              match = i[:word] == word
-              cls   = match ? ' class="blb-match"' : ""
-              link  = i[:href] ? %(<a href="#{h(i[:href])}" target="_blank" rel="noopener">#{h(i[:word])}</a>) : h(i[:word])
-              %(<tr><td#{cls}>#{link}</td><td class="blb-right">#{i[:freq]}x</td></tr>)
-            }.join
-            infl_html = %(<h4 class="blb-heading">Inflections</h4>) +
-              %(<table class="blb-table"><thead><tr><th class="blb-th">Form</th>) +
-              %(<th class="blb-th blb-right">Count</th></tr></thead><tbody>#{rows}</tbody></table>)
-          end
-        end
-
-        # ── Biblical Usage ────────────────────────────────────────────────────
-        usage_html = ""
-        if (um = html.match(/<div[^>]+id="outlineBiblical"[^>]*>/im))
-          after_usage = html[um.end(0)..]
-          if (inner = after_usage.match(/\A\s*<div>([\s\S]*?)<\/div>\s*<\/div>/im))
-            cleaned = inner[1]
-              .gsub(/<(\/?)(\w+)[^>]*>/) { "<#{$1}#{$2.downcase}>" }
-              .gsub(/[ \t]+/, " ")
-              .strip
-            usage_html = %(<h4 class="blb-heading">Biblical Usage</h4><div class="blb-usage">#{cleaned}</div>)
-          end
-        end
-
-        # ── Concordance ───────────────────────────────────────────────────────
-        conc_html  = ""
-        trans_name = html[/id="bibleTable"[^>]+data-translation="([^"]+)"/i, 1] || ""
-        verses = []
-        html.split(/<div\s[^>]*id="bVerse_\d+"[^>]*>/).drop(1).each do |chunk|
-          cite_href = chunk[/tablet-order-2[^>]*>[\s\S]{0,400}?href="([^"]+)"/im, 1] || ""
-          cite      = chunk[/tablet-order-2[^>]*>[\s\S]{0,400}?<a[^>]*>(.*?)<\/a>/im, 1]
-                        &.gsub(/<[^>]+>/, "")&.strip || ""
-
-          # Process verse HTML: highlight the matched word, strip all Strong's refs
-          raw_html = chunk[/class="EngBibleText[^"]*"[^>]*>([\s\S]*?)<\/div>/im, 1] || ""
-          raw_html.gsub!(/<img[^>]*>/, "")
-          raw_html.gsub!(/<a[^>]*class="hide-for-tablet"[^>]*>[\s\S]*?<\/a>/im, "")
-          raw_html.gsub!(/<span[^>]*class="hide-for-tablet"[^>]*>[\s\S]*?<\/span>/im, "")
-          # Use control-char placeholders so blb-match survives the tag-strip pass
-          verse_html = raw_html.gsub(/<span\s[^>]*class="word-phrase"[^>]*>([\s\S]*?)<\/span>/im) do
-            inner = $1
-            word = inner.sub(/<sup[\s\S]*/im, "").gsub(/<[^>]+>/, "")
-                        .gsub(/&nbsp;/i, " ").strip
-            inner.match?(/<sup[^>]*class="[^"]*strongs criteria[^"]*"/i) ?
-              "\x02#{word}\x03" : word
-          end
-          # Fallback for translations without word-phrase spans (NASB, ESV, etc.)
-          # The criteria word appears directly before its <sup class="strongs criteria"> tag
-          unless verse_html.include?("\x02")
-            verse_html.gsub!(/([\w]+[,;:.!?'"]*)\s*<sup[^>]*class="[^"]*strongs criteria[^"]*"[\s\S]*?<\/sup>/im) do
-              "\x02#{$1}\x03"
-            end
-          end
-          verse_html.gsub!(/<sup[^>]*>[\s\S]*?<\/sup>/im, "")
-          verse_html.gsub!(/<[^>]+>/, "")
-          verse_html.gsub!(/&nbsp;/i, " ")
-          verse_html.gsub!(/&#(\d+);/)         { [$1.to_i].pack("U")      rescue " " }
-          verse_html.gsub!(/&#x([\da-f]+);/i)  { [$1.to_i(16)].pack("U") rescue " " }
-          verse_html.gsub!(/&amp;/, "&")
-          verse_html.gsub!(/&lt;/, "<")
-          verse_html.gsub!(/&gt;/, ">")
-          verse_html.gsub!(/\s+/, " ")
-          verse_html.strip!
-          # Strip the mobile citation prefix ("Mat 5:17 - ") left by hide-for-tablet removal
-          verse_html.sub!(/\A#{Regexp.escape(cite)}\s*-\s*/i, "")
-          # Restore match placeholders as highlighted spans
-          verse_html.gsub!(/\x02([^\x03]*)\x03/) { %(<span class="blb-match">#{h($1.strip)}</span>) }
-
-          next if cite.empty? || verse_html.empty?
-          full_href = cite_href.empty? ? nil : (cite_href.start_with?("http") ? cite_href : base + cite_href)
-          verses << { cite: cite, verse_html: verse_html, href: full_href }
-        end
-        if verses.any?
-          heading = trans_name.empty? ? "Concordance" : "Concordance (#{h(trans_name)})"
-          rows = verses.map { |v|
-            link = v[:href] ? %(<a href="#{h(v[:href])}" target="_blank" rel="noopener">#{h(v[:cite])}</a>) : h(v[:cite])
-            %(<tr><td class="blb-nowrap">#{link}</td><td>#{v[:verse_html]}</td></tr>)
-          }.join
-          conc_html = %(<h4 class="blb-heading">#{heading}</h4>) +
-            %(<table class="blb-table"><tbody>#{rows}</tbody></table>)
-        end
-
-        info_html + infl_html + usage_html + conc_html
-      end
-
-      def scrip_html(html, source_url = nil)
-        # Extract the passage content block
-        content = html[/<div\s+class="passage-text[^"]*"[^>]*>([\s\S]*)<\/div>\s*(?:<nav|<script|<style|\z)/im, 1] || ""
-        return page_html(html, source_url) if content.empty?
-
-        # Add data-verse attributes to verse spans for popup scrolling.
-        # Verse numbers live in <sup class="verse-number">N </sup> inside verse spans.
-        content = content.gsub(/<sup class="verse-number">(\d+)[^<]*<\/sup>/) do
-          %(<sup class="verse-number" data-verse="#{$1}">#{$1} </sup>)
-        end
-
-        # Fetch referenced stylesheets from the source page and inline them
-        css_blocks = ""
-        if source_url
-          base_uri = URI.parse(source_url) rescue nil
-          html.scan(/<link[^>]+rel=["']stylesheet["'][^>]*>/i).each do |tag|
-            href = tag[/href=["']([^"']+)["']/i, 1]
-            next unless href
-            abs = (base_uri ? (URI.join(base_uri, href).to_s rescue nil) : nil)
-            next unless abs
-            css_body = fetch_css(abs)
-            # Resolve @import within the CSS (one level deep)
-            if css_body
-              css_dir = abs.sub(%r{/[^/]*\z}, "/")
-              css_body = css_body.gsub(/@import\s+url\(["']?([^"')]+)["']?\)\s*;/) do
-                import_url = (URI.join(css_dir, $1).to_s rescue nil)
-                import_url ? (fetch_css(import_url) || "") : ""
-              end
-              css_blocks += "<style>#{css_body}</style>\n"
-            end
-          end
-        end
-
-        content = inject_strongs_urls(content)
-        css_blocks + '<div style="font-family:Georgia,serif;line-height:1.7">' + content + "</div>"
-      end
-
-      def inline_directory_html(dir_path, relative_dir)
-        entries = Dir.entries(dir_path).reject { |e| e.start_with?(".") || EXCLUDED.include?(e) }
-        items = entries.map do |name|
-          stat = File.stat(File.join(dir_path, name)) rescue next
-          is_dir = stat.directory?
-          href = "/browse/" + (relative_dir.empty? ? "" : relative_dir + "/") +
-                 encode_path_component(name) + (is_dir ? "/" : "")
-          { name: name, is_dir: is_dir, href: href }
-        end.compact.sort_by { |i| [i[:is_dir] ? 0 : 1, i[:name].downcase] }
-
-        rows = items.map do |i|
-          %(<li><a href="#{h(i[:href])}"><span class="icon">#{icon_for(i[:name], i[:is_dir])}</span> ) +
-          %(#{h(i[:name])}#{i[:is_dir] ? "/" : ""}</a></li>)
-        end.join
-        %(<ul class="dir-listing">#{rows}</ul>)
-      end
-
-      def compile_regexes(query)
-        words = query.split(/\s+/).reject(&:empty?)
-        return nil if words.empty?
-        words.map { |w| Regexp.new(w, Regexp::IGNORECASE) }
-      rescue RegexpError => e
-        raise RegexpError, e.message
-      end
-
-      def client_ip
-        if settings.behind_proxy
-          fwd = env["HTTP_X_FORWARDED_FOR"].to_s.split(",").map(&:strip).first
-          fwd && !fwd.empty? ? fwd : env["REMOTE_ADDR"]
-        else
-          env["REMOTE_ADDR"]
-        end
-      end
-
-      def setup_config
-        @setup_config ||= begin
-          path = File.join(root_dir, ".setup.yml")
-          (File.exist?(path) && YAML.safe_load(File.read(path))) || {}
-        rescue StandardError
-          {}
-        end
-      end
-
-      def inject_pronunciation_icon(html, meta)
-        return html unless meta.is_a?(Hash) && meta["strongs"] && meta["language"]
-        strongs = meta["strongs"].to_s.strip
-        lang = meta["language"].to_s.strip.downcase
-        return html unless strongs.match?(/\A[GH]\d+\z/i) && %w[hebrew greek].include?(lang)
-
-        icon = %(<button class="pronunciation-btn" data-strongs="#{h(strongs.upcase)}" ) +
-          %(title="Play pronunciation (Blue Letter Bible)" ) +
-          %(style="background:none;border:none;cursor:pointer;padding:0 0 0 6px;font-size:1.1em;vertical-align:middle;line-height:1;color:#888;" ) +
-          %(onclick="(function(btn){if(btn._loading)return;var a=btn._audio;if(a){a.currentTime=0;a.play();return;}btn._loading=true;btn.style.opacity='0.4';\
-fetch('/pronunciation?strongs='+btn.dataset.strongs).then(function(r){return r.json()}).then(function(d){\
-if(d.audio){a=new Audio(d.audio);btn._audio=a;a.play();}btn._loading=false;btn.style.opacity='1';}).catch(function(){\
-btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
-
-        sl_lang = lang == "hebrew" ? "hebrew" : "greek"
-        sl_num = strongs.upcase.sub(/\A[HG]/, "")
-        sl_url = "https://www.studylight.org/multi-media/audio/lexicons/eng/#{sl_lang}.html?n=#{sl_num}"
-        icon2 = %(<button class="pronunciation-btn" ) +
-          %(title="Play pronunciation (StudyLight)" ) +
-          %(style="background:none;border:none;cursor:pointer;padding:0 0 0 4px;font-size:1.1em;vertical-align:middle;line-height:1;color:#888;" ) +
-          %(onclick="var a=this._a||(this._a=new Audio('#{h(sl_url)}'));a.currentTime=0;a.play();">&#128266;</button>)
-
-        icon = icon + icon2
-
-        # Insert before the closing tag of the first <h2>
-        html.sub(%r{</h2>}) { " #{icon}</h2>" }
-      end
-
-      # Returns true when serving an HTML file that should have popup assets injected.
-      # Add additional path prefixes here as needed.
-      def inject_assets_for_html_path?(_relative_path)
-        true
-      end
-
-      # Injects popup CSS and JS into an HTML document before </body>.
-      # Runs plugin HTML transformations (e.g. Bible citation auto-linking).
-      # Falls back to appending before </html>, then to end of document.
-      def inject_markdownr_assets(html_content)
-        settings.plugins.each { |p| html_content = p.transform_html(html_content) }
-        html_content = inject_strongs_urls(html_content)
-
-        popup_config_script = "<script>var __popupConfig = {" \
-          "localMd:#{settings.popup_local_md}," \
-          "localHtml:#{settings.popup_local_html}," \
-          "external:#{settings.popup_external}," \
-          "externalDomains:#{settings.popup_external_domains.to_json}" \
-          "};</script>\n"
-        assets = popup_config_script + File.read(File.join(settings.views, "popup_assets.erb"))
-        inserted = false
-        result = html_content.sub(/<\/(body|html)>/i) { inserted = true; "#{assets}</#{$1}>" }
-        inserted ? result : html_content + assets
-      end
-
-      def admin?
-        return true if session[:admin]
-
-        adm = setup_config["admin"]
-        return false unless adm.is_a?(Hash)
-
-        return true if adm["ip"].to_s.strip == client_ip
-
-        if adm["user"] && adm["pw"]
-          auth = request.env["HTTP_AUTHORIZATION"].to_s
-          if auth.start_with?("Basic ")
-            user, pw = Base64.decode64(auth[6..]).split(":", 2)
-            return true if user == adm["user"].to_s && pw == adm["pw"].to_s
-          end
-        end
-
-        false
-      end
-
-    end
+    helpers Helpers::PathHelpers,
+            Helpers::FormattingHelpers,
+            Helpers::MarkdownHelpers,
+            Helpers::SearchHelpers,
+            Helpers::FetchHelpers,
+            Helpers::AdminHelpers
 
     # Routes
 
@@ -1137,6 +150,7 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
     end
 
     get "/debug/raw-fetch" do
+      halt 404, "not available" unless respond_to?(:blueletterbible_html)
       url = params[:url].to_s.strip
       halt 400, "missing ?url=" if url.empty?
       html = fetch_external_page(url)
@@ -1218,6 +232,7 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
     end
 
     get "/debug/fetch" do
+      halt 404, "not available" unless respond_to?(:blueletterbible_html)
       url = params[:url].to_s.strip
       halt 400, "missing ?url=" if url.empty?
       html = fetch_external_page(url)
@@ -1266,7 +281,7 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
       title = (meta.is_a?(Hash) && meta["title"]) || File.basename(real, ".md")
       @current_wiki_dir = File.dirname(real)
       html = render_markdown(body)
-      html = inject_pronunciation_icon(html, meta)
+      settings.plugins.each { |p| html = p.post_render(html, meta, self) }
 
       frontmatter_html = ""
       if meta && !meta.empty?
@@ -1280,6 +295,7 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
     end
 
     get "/pronunciation" do
+      halt 404 unless respond_to?(:blueletterbible_html)
       content_type :json
       strongs = params[:strongs].to_s.strip.upcase
       halt 400, '{"error":"invalid strongs"}' unless strongs.match?(/\A[GH]\d+\z/)
@@ -1309,8 +325,8 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
 
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = FETCH_TIMEOUT
-      http.read_timeout = FETCH_TIMEOUT
+      http.open_timeout = Helpers::FetchHelpers::FETCH_TIMEOUT
+      http.read_timeout = Helpers::FetchHelpers::FETCH_TIMEOUT
       req = Net::HTTP::Get.new(uri.request_uri)
       req["Accept"] = "application/json"
       resp = http.request(req)
@@ -1330,21 +346,18 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
       html = fetch_external_page(url)
       halt 502, '{"error":"fetch failed"}' unless html
 
-      if url.match?(/blueletterbible\.org\/lexicon\//i)
-        raw = page_title(html)
-        title = raw.match(/^([GH]\d+ - \w+)/i)&.[](1)&.sub(" - ", " – ") ||
-                raw.sub(/ [-–] .*/, "").strip
-        JSON.dump({ title: title, html: blueletterbible_html(html, url) })
-      elsif url.match?(%r{/definitions/[^/]+\.md(\?|#|\z)}i)
-        title = page_title(html).sub(/ [-–] .*/, "").strip
-        JSON.dump({ title: title, html: markdownr_html(html) })
-      elsif url.match?(/scrip\.risensavior\.com/i)
-        title = page_title(html).sub(/ [-–] .*/, "").strip
-        JSON.dump({ title: title, html: scrip_html(html, url) })
-      else
+      result = nil
+      settings.plugins.each do |p|
+        result = p.process_fetch(url, html, self)
+        break if result
+      end
+
+      unless result
         title = page_title(html).sub(/ [-–] .*/, "").strip
-        JSON.dump({ title: title, html: page_html(html, url) })
+        result = { title: title, html: page_html(html, url) }
       end
+
+      JSON.dump(result)
     end
 
     get "/search/?*" do
@@ -1445,7 +458,7 @@ btn._loading=false;btn.style.opacity='1';});})(this)">&#128266;</button>)
         @meta, body = parse_frontmatter(content)
         @current_wiki_dir = File.dirname(real_path)
         @content = render_markdown(body)
-        @content = inject_pronunciation_icon(@content, @meta)
+        settings.plugins.each { |p| @content = p.post_render(@content, @meta, self) }
         relative_dir = File.dirname(relative_path)
         relative_dir = "" if relative_dir == "."
         listing = -> { inline_directory_html(File.dirname(real_path), relative_dir) }