@@ -34,10 +34,15 @@ def parse_inline_footnote(inline: "InlineParser", m: Match[str], state: "InlineS
         notes = state.env.get("footnotes")
         if not notes:
             notes = []
+        indexes = state.env.get("footnote_indexes")
+        if not indexes:
+            indexes = {note_key: index for index, note_key in enumerate(notes)}
+            state.env["footnote_indexes"] = indexes
         if key not in notes:
             notes.append(key)
+            indexes[key] = len(notes) - 1
             state.env["footnotes"] = notes
-        state.append_token({"type": "footnote_ref", "raw": key, "attrs": {"index": notes.index(key) + 1}})
+        state.append_token({"type": "footnote_ref", "raw": key, "attrs": {"index": indexes[key] + 1}})
     else:
         state.append_token({"type": "text", "raw": m.group(0)})
     return m.end()
 
@@ -15,20 +15,15 @@
 
 
 def parse_ruby(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
-    text = m.group(0)[1:-2]
-    items = text.split(")")
-    tokens = []
-    for item in items:
-        rb, rt = item.split("(")
-        tokens.append({"type": "ruby", "raw": rb, "attrs": {"rt": rt}})
-
-    end_pos = m.end()
-
-    next_match = _ruby_re.match(state.src, end_pos)
-    if next_match:
+    while True:
+        tokens = _parse_ruby_tokens(m)
+        end_pos = m.end()
+        next_match = _ruby_re.match(state.src, end_pos)
+        if not next_match:
+            break
         for tok in tokens:
             state.append_token(tok)
-        return parse_ruby(inline, next_match, state)
+        m = next_match
 
     # repeat link logic
     if end_pos < len(state.src):
@@ -41,6 +36,15 @@ def parse_ruby(inline: "InlineParser", m: Match[str], state: "InlineState") -> i
     return end_pos
 
 
+def _parse_ruby_tokens(m: Match[str]) -> List[Dict[str, Any]]:
+    text = m.group(0)[1:-2]
+    tokens = []
+    for item in text.split(")"):
+        rb, rt = item.split("(")
+        tokens.append({"type": "ruby", "raw": rb, "attrs": {"rt": rt}})
+    return tokens
+
+
 def _parse_ruby_link(
     inline: "InlineParser", state: "InlineState", pos: int, tokens: List[Dict[str, Any]]
 ) -> Optional[int]:
 
@@ -1,5 +1,5 @@
 import re
-from typing import TYPE_CHECKING, Match
+from typing import TYPE_CHECKING, Match, Optional
 
 if TYPE_CHECKING:
     from ..block_parser import BlockParser
@@ -12,7 +12,8 @@
 _BLOCK_SPOILER_START = re.compile(r"^ {0,3}! ?", re.M)
 _BLOCK_SPOILER_MATCH = re.compile(r"^( {0,3}![^\n]*\n)+$")
 
-INLINE_SPOILER_PATTERN = r">!\s*(?P<spoiler_text>.+?)\s*!<"
+INLINE_SPOILER_PATTERN = r">!"
+_INLINE_SPOILER_END = re.compile(r"\s*(?P<spoiler_text>.+?)\s*!<")
 
 
 def parse_block_spoiler(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
@@ -46,13 +47,28 @@ def parse_block_spoiler(block: "BlockParser", m: Match[str], state: "BlockState"
     return state.cursor
 
 
-def parse_inline_spoiler(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
-    text = m.group("spoiler_text")
+def parse_inline_spoiler(inline: "InlineParser", m: Match[str], state: "InlineState") -> Optional[int]:
+    pos = m.end()
+    cache_key = (id(state.src), "inline_spoiler")
+    cache = state.formatting_no_end.get(cache_key)
+    if cache is not None and cache[0] is state.src and pos <= cache[1]:
+        return None
+
+    line_end = state.src.find("\n", pos)
+    if line_end == -1:
+        line_end = len(state.src)
+
+    m2 = _INLINE_SPOILER_END.match(state.src, pos, line_end)
+    if not m2:
+        state.formatting_no_end[cache_key] = (state.src, line_end)
+        return None
+
+    text = m2.group("spoiler_text")
     new_state = state.copy()
     new_state.src = text
     children = inline.render(new_state)
     state.append_token({"type": "inline_spoiler", "children": children})
-    return m.end()
+    return m2.end()
 
 
 def render_block_spoiler(renderer: "BaseRenderer", text: str) -> str:
 
@@ -129,3 +129,28 @@ def render(size):
 
         self.assertLess(large, DEADLINE)
         self.assertLess(large, small * 3)
+
+    def test_repeated_unclosed_inline_spoilers_are_near_linear(self):
+        md = create_markdown(plugins=["spoiler"])
+
+        def render(size):
+            text = ">! a " * size + "\n"
+            start = time.process_time()
+            md(text)
+            return time.process_time() - start
+
+        render(200)
+        small = render(1000)
+        large = render(2000)
+
+        self.assertLess(large, DEADLINE)
+        self.assertLess(large, small * 3)
+
+    def test_adjacent_ruby_tokens_do_not_recurse_forever(self):
+        text = "[a(b)]" * 3000 + "\n"
+
+        start = time.monotonic()
+        create_markdown(plugins=["ruby"])(text)
+        elapsed = time.monotonic() - start
+
+        self.assertLess(elapsed, DEADLINE)