Thanks, and apologies again about the delay. This is starting to look quite robust, but there are still some issues. Nesting is tricky and I guess we don't have any other feature to take inspiration from directly.

Consider this:

::: container
> shouldn't close, right?
> :::
> x  
:::

<div class="container">
<blockquote>
<p>shouldn't close, right?</p>
</blockquote>
</div>
<blockquote>
<p>x
:::</p>
</blockquote>

Another thing we try to stay conscious of is time complexity, to make sure untrusted input cannot cause parsing to become too slow. The current implementation seems to be quadratic when nesting containers.

With input generated like this (replace N with some number):

python -c 'print("\n".join(":"*k + "x" for k in range(N, 2, -1)))'

If I double the value of N, the size of the input quadruples (more or less). However, the runtime seems to slow down by ~16x:

That would indicate quadratic run time growth with respect to input size, which we generally want to avoid.

One solution to this is to limit the amount of nesting (or simply colons recognized, before saturating (similar to how {} are handled in math spans).

Don't stress about these too much. The runtime issue can definitely be fixed later. For now it would be enough to have something that works and is well specified by the spec tests. If nesting proves too difficult, we can also leave it out and try to get it working later.

Thanks, good work! I like the approach, but the container_depth counter is a pervasive change to firstpass.rs and I believe it's not really needed. Same with the depth field of ItemBody::Container. I'm still learning new things about the feature in commonmark.hs and others - apparently nesting can be done without increasing fence lengths too 😄

I gather that FirstPass.container_depth has two purposes: to enforce a nesting limit and to ensure that ::: can't close things outside their scope.

The first use case could be replaced by checking self.tree.spine_len(). That more or less provides the current container nesting level.

For the second use case, we can instead determine the scope from the ancestors when iterating self.tree.walk_spine().rev(). Whenever we encounter a node other than a Container or Paragraph, we can stop iterating. No container blocks that were opened outside that node should be closed inside it. I've implemented this idea in the first two code suggestions below - tests pass. The depth field of ItemBody::Container becomes unnecessary.

My suggestions also align the following test with commonmark-hs. A closing fence can close container blocks that were started outside other container blocks (but not other kinds of nodes):

::: a
:::: b
::::: c
::::
x

commonmark-hs:

<div class="a">
<div class="b">
<div class="c">

</div>
</div>
<p>x</p>
</div>

These tests are getting a little abstract aren't they...

This pretty much looks good to me. The test case covers most of the possibilities, and the implementation fits in with the rest of the code.

Other than some low-hanging optimization fruit, it looks fine.

Looking good now. Thanks for your continued efforts.