I would like it, especially if it could be used from inside Lua filters. One could then embed snippets of a DSL in code blocks/spans with some identifying attribute or raw blocks/spans with an identifying pseudo-format or inside attribute values, parse the DSL inside the Lua filter and take different paths based on the result.
For example my string interpolation DSL which I currently use a very slow and very verbose parser written in pure Lua (well actually MoonScript :-) where everything is enclosed in various brackets because balanced brackets are easy to match in Lua patterns with the `%b()` construct. Since Lua patterns don't support alternations or quantified groups I have to simulate alternations with huge arrays of maps which specify patterns to try in succession, along with the labels for the captures.
An example of an alternative in the table with possible interpolation forms:
``````moon
[40]: {
labels: {
[1]: "path"
[2]: "truth"
[3]: "then_expr"
[4]: "else_expr"
}
name: "path_if_non_empty_then_else"
pat: "^%$%(%s*(%b<>)%s*(%&)%?%s*(%$?%b())%s*%&%!%s*(%$?%b())%s*%)$"
strip: {
else_expr: "()"
path: "<>"
then_expr: "()"
}
}
``````
This matches something which when embedded in Markdown looks something like this:
``````markdown
`$( <var/foo> &? $(<var/bar>) &! $(<var/baz>) )`{.sic}
``````
where `<var/foo>` etc. each references a value in a mapping of `key: string` pairs obtained from the metadata, and the whole inserts the value of one of two such variables into the document depending on whether a third variable is non-empty or not (basically a ternary).
The table with such alternatives is built programmatically in nested loops over lists of subpatterns, so being able to use lpeg (probably even the re module[^1] since I have already written a Perl implementation in Pegex[^2]) would both speed things up and reduce the volume of the code, so it would be most welcome!