How do you manage to make different custom Lua filters parse the syntaxes at the same time when they are nested in other unofficial syntaxes, similar to PyMdown and markdown-it?

[gusbemacbe]

Picture yourself creating three different Lua filters to find, parse and process:

• render-icons.lua
• render-keys.lua
• render-content-tabs-mkdocs.lua

And the codes in Markdown:

- :fontawesome-regular-face-laugh-wink:
- ++ctrl+alt+del++

# Content tabs

=== "Unordered list"

    * Sed sagittis eleifend rutrum
    * Donec vitae suscipit est
    * Nulla tempor lobortis orci

=== "Ordered list"

    1. Sed sagittis eleifend rutrum
    2. Donec vitae suscipit est
    3. Nulla tempor lobortis orc

These filters can find them and parse them, as they are not nested in other syntaxes.

But if I nest the syntaxes in other syntaxes:

# Keyboard Shortcuts

=== "Press ++ctrl+alt+del++ to toggle"

    * This shortcut — ++ctrl+alt+del++ activates the primary console.
    * It can be re-mapped in the settings menu.
    * Check for conflicts with system-level hotkeys.

=== "Press <kbd>Ctrl</kbd> + <kbd>S</kbd>"

    1. This shortcut saves the current document.
    2. A confirmation will appear in the status bar.
    3. Unsaved changes will be highlighted.

# Icon and Emoji Usage

=== "Standard Emoji :smile:"

    * Emojis are rendered using the system's default font.
    * Use them to add visual cues to text.
    * Overuse can reduce readability.

=== "SVG Icon :fontawesome-regular-face-laugh-wink:"

    * Icons are loaded as inline SVG elements.
    * This allows them to be styled with CSS.
    * Ensure the icon pack is loaded correctly.

=== "Icon with Class :fontawesome-brands-youtube:{.youtube}"

    1. Add a class using the `{.classname}` syntax.
    2. The `.youtube` class applies a custom red colour.
    3. This is useful for brand-specific styling.

These filters — render-icons and render-keys — can not find these syntaxes because they are nested in another syntax that was found and parsed by render-content-tabs-mkdocs filter.

The @facelessuser and the contributors are incredibly excellent at managing several Markdown extensions, written in Python, handling the nest support very well, but I do not want to use Python or MkDocs or Google’s material design. I want to use Pandoc and to have own HTML and CSS, hence I had to build several Lua filters inspired by @facelessuser’s, @squidfunk’s and other non-Lua Markdown extensions as well as Codebraid and Quarto. I built a content tabs group filter, it parsed correctly the content tab groups, supporting the text formatting in both tab title and content, both under fenced contained blocks and at the top-level, both under the disabled and enabled smart extension, but it prevented other filters from parsing other syntaxes as key syntax in the tab title and in the content.

I understood that PyMdown is very similar to markdown-it, what allows us to add many new extensions.

I do not know if Pandoc has this similar design and can handle the nest when the unofficial syntaxes are nested in other unofficial syntaxes.

I have read the discussion #11142 and @fiapps indicated panluna, but I am not certain if panluna can handle my filters when the unofficial syntaxes are nested in unofficial syntaxes. Perhaps @tarleb may know answering it.

[badumont]

I don't understand the problem. I don't know how render-content-tabs-mkdocs.lua modifies the AST, but if you apply render-icons.lua and render-keys.lua before render-content-tabs-mkdocs.lua, Pandoc will parse ++ctrl+alt+del++ and 😄 as regular Str objects and your filters will be able to replace the content of these Str with whatever you want.

[gusbemacbe]

(…) but if you apply render-icons.lua and render-keys.lua before render-content-tabs-mkdocs.lua (…)

I have ordered the filters before, but the key and icon syntaxes were not parsed, and I really did not know why it happened. Here is my Pandoc defaults file code:

from: markdown+abbreviations+all_enabled_extensions
to: html5
filters:
  - "./assets/filters/disable-indented-code-block.lua"
  - "./assets/filters/render-attributes.lua"
  - "./assets/filters/render-icons.lua"
  - "./assets/filters/render-keys.lua"
  - "./assets/filters/render-marks-mkdocs.lua"
  - "./assets/filters/render-mixed-admonitions-mkdocs.lua"
  - "./assets/filters/render-content-tabs-mkdocs.lua"
  - "./assets/filters/transform-list-into-table.lua"
self-contained: false
strip-comments: true
standalone: true
syntax-highlighting: pygments
template: "./.pandocrafter/themes/default/template.html"
tab-stop: 2
toc: true
toc-depth: 6

metadata:
  diagram:
    cache: true
    cache-dir:
      - "./assets/images/"
      - "./public/assets/images/"
  lang: "en"

input-file: "./src/08-content-tabs-md.md"
output-file: "./public/08-content-tabs-md.html"

I will explain how is the code of four Lua filters:

• disable-indented-code-block.lua:

  It solves the misinterpretation of the indented HTML or Markdown content as code blocks by transforming the specific CodeBlock nodes in the AST of the document. It uses a recursive walker to traverse the blocks, identifying and handling the indented code blocks based on the context to preserve them, for example, the MkDocs-style admonitions (!!! or ???) and content tabs groups (=== "Title") have an indented simple text that will be converted to Para blocks, then, it will reparse other indented Markdown (for example, blockquotes, lists) via pandoc.read, and change the indented HTML-like content (starting with <) to RawBlock("html"). The fenced code blocks with the attributes are left intact.

• render-icons.lua:

  It parses Markdown-emoji-style icon syntax (for example, :fontawesome-regular-face-laugh-wink:) by replacing it with corresponding SVG content from configured packs, adding the ARIA attributes for accessibility, and sorting the SVG attributes alphabetically. It handles the icons with or without custom classes and identifiers (for example, {.youtube}), supports the fragmented syntax across AST nodes, and localises the labels based on the document’s language. For the core logic, it uses a recursive inline walker to detect and transform the patterns, exporting Pandoc and Inlines functions for the modularity.

  It performs the AST manipulation via the Pandoc(doc) entry function and doc:walk method to traverse and transform Para and Plain blocks, exporting walk_inlines (Inlines) for the modular inline parsing. It uses Lua’s pattern matching (string.match, string.gsub, gmatch) for the syntax detection, the table operations (table.insert, table.concat, pairs/ipairs) for the attribute handling, and pcall for safe file/system calls, with the utilities like system.read_file for SVG loading, utils.stringify for the metadata, List:new for inline collections, and RawInline for the HTML output insertion.

• render-keys.lua:

  It parses the custom keyboard shortcut syntax in three different modes:

  • text: ++key+key++ as <kbd>Key</kbd> + <kbd>Key</kbd>
  • symbol: ++key+key+++ as <kbd>⌃</kbd> + <kbd>⌥</kbd>
  • mixed (combing the symbol and text): ++key+key++++ as <kbd> elements with a class

  It uses a mapping table for common keys, symbols and mixed with classes, capitalising the unmapped keys, and replacing the matches with HTML via RawInline. It supports whole Str matching with the prioritised patterns (mixed > symbol > text). As for the core logic and the functions, it uses the similar cases, functions and logic of the render-icons.lua file.

• render-content-tabs-mkdocs.lua:

  It parses the MkDocs-style tabbed content (=== "Title"), followed with a newline by the indented blocks with four indentation spaces by grouping the consecutive tabs into the HTML body with radio inputs, labels, and contents (nested with a div element), handling very well the cases of the quoted titles, the single and/or multi-block content, and the deindentation (for example, the Markdown headings with four indentation spaces).

  It uses the functions as:

  • is_tab_header: uses stringify to match ===;
  • extract_title: content tab title’s inline collection and quotes, chained modular walkers;
  • deindent_content: serialises the content to Markdown lines, computing the minimal indentation and reparsing with pandoc.read/write;
  • create_tabbed_set: builds the RawBlock and Div blocks with string.format.

  The logic iterates the blocks to collect the tabs, parses the titles and inlines, deindents and reparses the content, and finally serialises the trimmed HTML strings for the output.

  However, even the inner filters (render-icons and render-keys) were reordered correctly, it used to prevent these inner filters from fully parsing the nested syntax because it loaded their Pandoc globally on the document for the early AST nodes replacement, but then, in the deindent_content function, it serialises the content to the Markdown and HTML strings (via pandoc.write), losing or ignoring the RawInline and HTML parts from these inner filters, for example, in a single Para serialisation, only Str and SoftBreak parts could be handled, what ended up leaving RawInline behind, it is why the serialisation could flatten the AST, rendering nested key and icon syntax literal in the output content tabs.

  It now managed render-icons parsing by applying its Inlines walker to the titles (via icon_filter_walk_inlines), preserving the replacements in the title, but failed for render-keys because of the unapplied or conflicting walker order in the content, i.e., the keys walker follows the icons walker but the content serialisation discards both if it is not preserved, or the specific pattern does not match correctly in the fragmented content after the deindentation and/or reparsing.

[gusbemacbe]

After having performed several tests regarding @tarleb’s panluna and @facelessuser’s and @squidfunk’s PyMdown Extensions library, I have reached a conclusion.

For the purposes of my project which is written in Go and relies on Pandoc, I have determined that both panluna and the PyMdown Extensions library are, unfortunately, dead ends. Consequently, I will stop developing the purely Lua filters, as I have found a flexible and robust alternative.

Reasons

panluna

I attempted to use panluna to test the unofficial syntaxes, but it totally failed. The main issue is not with panluna itself, but with its critical dependency. It is lunamark. The lunamark has a hard requirement for a Unicode library that originates from the path lunamark/reader/markdown.lua, attempted to lua-utf8 (a misspelling of the common luautf8 library), failing to call the unicode package that mapped to the slnunicode library. The slnunicode library has not been maintained for 11 years and ends up failing to compile when you try to install it via luarocks.

Hence, this dependency is unmaintained and broken, and as a result, the entire panluna project is totally unusable for my project.

PyMdown Extensions

My investigation and test into PyMdown Extensions as an alternative was initially promising, but several tests showed a fundamental architectural mismatch.

This library is not a Markdown-to-Markdown pre-processor. It is a complete Markdown-to-HTML converter, which is a replacement for a tool like Pandoc. I do not want to abandon Pandoc because of many useful official extensions.

---

I have found a flexible and robust solution. It is to develop a customised and stateful, context-aware and precise Markdown-to-Markdown pre-processor implemented in both Python and Go, as it is my case for my project. I tested a script in Python or in Go, and it successfully converted my customised :icon: and ++kbd++ syntaxes into the raw HTML, leaving all other standard Markdown untouched. It fully processed the text, then, it piped to Pandoc, which handled the final conversion.

[squidfunk]

A friendly reminder: if you tag users, they get an email or notification. We have nothing to do with your project, and tagging us to raise our attention to this post is just rude. I kindly ask you to stop tagging me, if it doesn't directly involve my work.

[tarleb]

I'm using panluna in production, installed via luarocks. So it's definitely possible to install it that way. Check if your luarocks installation uses Lua 5.4, and adjust via --lua-version if necessary.

[gusbemacbe]

Good morning, Mr. Krewinkel!

I have just checked luarocks’s version via --lua-version:

$ luarocks --lua-version 5.4

LuaRocks 3.12.2, the Lua package manager

/home/linuxbrew/.linuxbrew/bin/luarocks - LuaRocks main command-line interface

Variables:
   Variables from the "variables" table of the configuration file can be
   overridden with VAR=VALUE assignments.

Configuration:
   Lua:
      Version    : 5.4
      LUA        : /home/linuxbrew/.linuxbrew/opt/lua/bin/lua5.4 (ok)
      LUA_INCDIR : /home/linuxbrew/.linuxbrew/opt/lua/include/lua5.4 (ok)
      LUA_LIBDIR : /home/linuxbrew/.linuxbrew/opt/lua/lib (ok)

   Configuration files:
      System  : /home/linuxbrew/.linuxbrew/etc/luarocks/config-5.4.lua (ok)
      User    : /home/gusbemacbe/.luarocks/config-5.4.lua (not found)

   Rocks trees in use:
      /home/gusbemacbe/.luarocks ("user")
      /home/linuxbrew/.linuxbrew ("system")

As for config-5.4.lua not found in the user-specific directory, I just copied from the linuxbrew-specific directory. Now it is founded. But when I ran the command luarocks install slnunicode, I received numerous errors, and we could this installation checked linuxbrew’s Lua version before:

slnunicode 1.1-2 depends on lua >= 5.1 (5.4-1 provided by VM: success)
Applying patch fix.patch...
Do not use 'module' as a build type. Use 'builtin' instead.
gcc -O2 -fPIC -I/home/linuxbrew/.linuxbrew/opt/lua/include/lua5.4 -c slnunico.c -o slnunico.o
slnunico.c: In function ‘str_rep’:
slnunico.c:342:17: error: implicit declaration of function ‘luaL_checkint’; did you mean ‘luaL_checkany’? [-Wimplicit-function-declaration]
  342 |         int n = luaL_checkint(L, 2);
      |                 ^~~~~~~~~~~~~
      |                 luaL_checkany
slnunico.c: In function ‘str_dump’:
slnunico.c:408:13: error: too few arguments to function ‘lua_dump’; expected 4, have 3
  408 |         if (lua_dump(L, writer, &b) != 0)
      |             ^~~~~~~~
In file included from slnunico.c:88:
/home/linuxbrew/.linuxbrew/opt/lua/include/lua5.4/lua.h:303:14: note: declared here
  303 | LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
      |              ^~~~~~~~
slnunico.c: At top level:
slnunico.c:445:19: error: ‘LUA_MAXCAPTURES’ undeclared here (not in a function)
  445 |         } capture[LUA_MAXCAPTURES];
      |                   ^~~~~~~~~~~~~~~
slnunico.c: In function ‘classend’:
slnunico.c:474:77: error: expected ‘)’ before ‘LUA_QL’
  474 |                 if (!*++p) luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
      |                                      ~                                      ^~~~~~~
      |                                                                             )
slnunico.c:479:81: error: expected ‘)’ before ‘LUA_QL’
  479 |                         if (!*p) luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
      |                                            ~                                    ^~~~~~~
      |                                                                                 )
slnunico.c: In function ‘gfind_nodef’:
slnunico.c:971:30: error: implicit declaration of function ‘LUA_QL’; did you mean ‘LUA_OK’? [-Wimplicit-function-declaration]
  971 |         return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
      |                              ^~~~~~
      |                              LUA_OK
slnunico.c:971:52: error: expected ‘)’ before string constant
  971 |         return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
      |                          ~                         ^~~~~~~~~~~~~~~~~~~
      |                                                    )
slnunico.c:971:30: error: passing argument 2 of ‘luaL_error’ makes pointer from integer without a cast [-Wint-conversion]
  971 |         return luaL_error(L, LUA_QL("string.gfind") " was renamed to "
      |                              ^~~~~~~~~~~~~~~~~~~~~~
      |                              |
      |                              int
In file included from slnunico.c:90:
/home/linuxbrew/.linuxbrew/opt/lua/include/lua5.4/lauxlib.h:76:56: note: expected ‘const char *’ but argument is of type ‘int’
   76 | LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
      |                                            ~~~~~~~~~~~~^~~
slnunico.c: In function ‘unic_gsub’:
slnunico.c:1038:21: error: implicit declaration of function ‘luaL_optint’; did you mean ‘luaL_opt’? [-Wimplicit-function-declaration]
 1038 |         int max_s = luaL_optint(L, 4, srcl+1);
      |                     ^~~~~~~~~~~
      |                     luaL_opt
slnunico.c: In function ‘addintlen’:
slnunico.c:1140:30: error: ‘LUA_INTFRMLEN’ undeclared (first use in this function)
 1140 |         strcpy(form + l - 1, LUA_INTFRMLEN);
      |                              ^~~~~~~~~~~~~
slnunico.c:1140:30: note: each undeclared identifier is reported only once for each function it appears in
slnunico.c: In function ‘str_format’:
slnunico.c:1081:44: error: ‘LUA_INTFRMLEN’ undeclared (first use in this function)
 1081 | #define MAX_FORMAT (sizeof(FLAGS) + sizeof(LUA_INTFRMLEN) + 10)
      |                                            ^~~~~~~~~~~~~
slnunico.c:1158:35: note: in expansion of macro ‘MAX_FORMAT’
 1158 |                         char form[MAX_FORMAT];  /* to store the format (`%...') */
      |                                   ^~~~~~~~~~
slnunico.c:1180:58: error: ‘LUA_INTFRM_T’ undeclared (first use in this function); did you mean ‘LUA_INT_INT’?
 1180 |                                                         (LUA_INTFRM_T) luaL_checknumber(L, arg) );
      |                                                          ^~~~~~~~~~~~
      |                                                          LUA_INT_INT
slnunico.c:1180:71: error: expected ‘)’ before ‘luaL_checknumber’
 1180 |                                                         (LUA_INTFRM_T) luaL_checknumber(L, arg) );
      |                                                                       ^~~~~~~~~~~~~~~~~
      |                                                                       )
slnunico.c:1179:48: note: to match this ‘(’
 1179 |                                         sprintf(buff, form,
      |                                                ^
slnunico.c:1191:66: error: expected ‘)’ before ‘LUA_INTFRM_T’
 1191 |                                                         (unsigned LUA_INTFRM_T) luaL_checknumber(L, arg) );
      |                                                         ~        ^~~~~~~~~~~~~
      |                                                                  )
slnunico.c:1236:53: error: expected ‘)’ before ‘LUA_QL’
 1236 |               return luaL_error(L, "invalid option " LUA_QL("%%%c") " to "
      |                                ~                    ^~~~~~~
      |                                                     )
slnunico.c: At top level:
slnunico.c:1285:14: error: unknown type name ‘luaL_reg’; did you mean ‘luaL_Reg’?
 1285 | static const luaL_reg uniclib[] = {
      |              ^~~~~~~~
      |              luaL_Reg
slnunico.c:1286:9: warning: braces around scalar initializer
 1286 |         {"byte", unic_byte}, /* no cluster ! */
      |         ^
slnunico.c:1286:9: note: (near initialization for ‘uniclib[0]’)
slnunico.c:1286:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1286 |         {"byte", unic_byte}, /* no cluster ! */
      |          ^~~~~~
slnunico.c:1286:10: note: (near initialization for ‘uniclib[0]’)
slnunico.c:1286:10: error: initializer element is not computable at load time
slnunico.c:1286:10: note: (near initialization for ‘uniclib[0]’)
slnunico.c:1286:18: warning: excess elements in scalar initializer
 1286 |         {"byte", unic_byte}, /* no cluster ! */
      |                  ^~~~~~~~~
slnunico.c:1286:18: note: (near initialization for ‘uniclib[0]’)
slnunico.c:1287:9: warning: braces around scalar initializer
 1287 |         {"char", unic_char},
      |         ^
slnunico.c:1287:9: note: (near initialization for ‘uniclib[1]’)
slnunico.c:1287:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1287 |         {"char", unic_char},
      |          ^~~~~~
slnunico.c:1287:10: note: (near initialization for ‘uniclib[1]’)
slnunico.c:1287:10: error: initializer element is not computable at load time
slnunico.c:1287:10: note: (near initialization for ‘uniclib[1]’)
slnunico.c:1287:18: warning: excess elements in scalar initializer
 1287 |         {"char", unic_char},
      |                  ^~~~~~~~~
slnunico.c:1287:18: note: (near initialization for ‘uniclib[1]’)
slnunico.c:1288:9: warning: braces around scalar initializer
 1288 |         {"dump", str_dump},
      |         ^
slnunico.c:1288:9: note: (near initialization for ‘uniclib[2]’)
slnunico.c:1288:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1288 |         {"dump", str_dump},
      |          ^~~~~~
slnunico.c:1288:10: note: (near initialization for ‘uniclib[2]’)
slnunico.c:1288:10: error: initializer element is not computable at load time
slnunico.c:1288:10: note: (near initialization for ‘uniclib[2]’)
slnunico.c:1288:18: warning: excess elements in scalar initializer
 1288 |         {"dump", str_dump},
      |                  ^~~~~~~~
slnunico.c:1288:18: note: (near initialization for ‘uniclib[2]’)
slnunico.c:1289:9: warning: braces around scalar initializer
 1289 |         {"find", unic_find}, /* cluster */
      |         ^
slnunico.c:1289:9: note: (near initialization for ‘uniclib[3]’)
slnunico.c:1289:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1289 |         {"find", unic_find}, /* cluster */
      |          ^~~~~~
slnunico.c:1289:10: note: (near initialization for ‘uniclib[3]’)
slnunico.c:1289:10: error: initializer element is not computable at load time
slnunico.c:1289:10: note: (near initialization for ‘uniclib[3]’)
slnunico.c:1289:18: warning: excess elements in scalar initializer
 1289 |         {"find", unic_find}, /* cluster */
      |                  ^~~~~~~~~
slnunico.c:1289:18: note: (near initialization for ‘uniclib[3]’)
slnunico.c:1290:9: warning: braces around scalar initializer
 1290 |         {"format", str_format},
      |         ^
slnunico.c:1290:9: note: (near initialization for ‘uniclib[4]’)
slnunico.c:1290:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1290 |         {"format", str_format},
      |          ^~~~~~~~
slnunico.c:1290:10: note: (near initialization for ‘uniclib[4]’)
slnunico.c:1290:10: error: initializer element is not computable at load time
slnunico.c:1290:10: note: (near initialization for ‘uniclib[4]’)
slnunico.c:1290:20: warning: excess elements in scalar initializer
 1290 |         {"format", str_format},
      |                    ^~~~~~~~~~
slnunico.c:1290:20: note: (near initialization for ‘uniclib[4]’)
slnunico.c:1291:9: warning: braces around scalar initializer
 1291 |         {"gfind", gfind_nodef},
      |         ^
slnunico.c:1291:9: note: (near initialization for ‘uniclib[5]’)
slnunico.c:1291:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1291 |         {"gfind", gfind_nodef},
      |          ^~~~~~~
slnunico.c:1291:10: note: (near initialization for ‘uniclib[5]’)
slnunico.c:1291:10: error: initializer element is not computable at load time
slnunico.c:1291:10: note: (near initialization for ‘uniclib[5]’)
slnunico.c:1291:19: warning: excess elements in scalar initializer
 1291 |         {"gfind", gfind_nodef},
      |                   ^~~~~~~~~~~
slnunico.c:1291:19: note: (near initialization for ‘uniclib[5]’)
slnunico.c:1292:9: warning: braces around scalar initializer
 1292 |         {"gmatch", gmatch}, /* cluster */
      |         ^
slnunico.c:1292:9: note: (near initialization for ‘uniclib[6]’)
slnunico.c:1292:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1292 |         {"gmatch", gmatch}, /* cluster */
      |          ^~~~~~~~
slnunico.c:1292:10: note: (near initialization for ‘uniclib[6]’)
slnunico.c:1292:10: error: initializer element is not computable at load time
slnunico.c:1292:10: note: (near initialization for ‘uniclib[6]’)
slnunico.c:1292:20: warning: excess elements in scalar initializer
 1292 |         {"gmatch", gmatch}, /* cluster */
      |                    ^~~~~~
slnunico.c:1292:20: note: (near initialization for ‘uniclib[6]’)
slnunico.c:1293:9: warning: braces around scalar initializer
 1293 |         {"gsub", unic_gsub}, /* cluster */
      |         ^
slnunico.c:1293:9: note: (near initialization for ‘uniclib[7]’)
slnunico.c:1293:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1293 |         {"gsub", unic_gsub}, /* cluster */
      |          ^~~~~~
slnunico.c:1293:10: note: (near initialization for ‘uniclib[7]’)
slnunico.c:1293:10: error: initializer element is not computable at load time
slnunico.c:1293:10: note: (near initialization for ‘uniclib[7]’)
slnunico.c:1293:18: warning: excess elements in scalar initializer
 1293 |         {"gsub", unic_gsub}, /* cluster */
      |                  ^~~~~~~~~
slnunico.c:1293:18: note: (near initialization for ‘uniclib[7]’)
slnunico.c:1294:9: warning: braces around scalar initializer
 1294 |         {"len", unic_len}, /* cluster/byte opt. */
      |         ^
slnunico.c:1294:9: note: (near initialization for ‘uniclib[8]’)
slnunico.c:1294:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1294 |         {"len", unic_len}, /* cluster/byte opt. */
      |          ^~~~~
slnunico.c:1294:10: note: (near initialization for ‘uniclib[8]’)
slnunico.c:1294:10: error: initializer element is not computable at load time
slnunico.c:1294:10: note: (near initialization for ‘uniclib[8]’)
slnunico.c:1294:17: warning: excess elements in scalar initializer
 1294 |         {"len", unic_len}, /* cluster/byte opt. */
      |                 ^~~~~~~~
slnunico.c:1294:17: note: (near initialization for ‘uniclib[8]’)
slnunico.c:1295:9: warning: braces around scalar initializer
 1295 |         {"lower", unic_lower},
      |         ^
slnunico.c:1295:9: note: (near initialization for ‘uniclib[9]’)
slnunico.c:1295:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1295 |         {"lower", unic_lower},
      |          ^~~~~~~
slnunico.c:1295:10: note: (near initialization for ‘uniclib[9]’)
slnunico.c:1295:10: error: initializer element is not computable at load time
slnunico.c:1295:10: note: (near initialization for ‘uniclib[9]’)
slnunico.c:1295:19: warning: excess elements in scalar initializer
 1295 |         {"lower", unic_lower},
      |                   ^~~~~~~~~~
slnunico.c:1295:19: note: (near initialization for ‘uniclib[9]’)
slnunico.c:1296:9: warning: braces around scalar initializer
 1296 |         {"match", unic_match}, /* cluster */
      |         ^
slnunico.c:1296:9: note: (near initialization for ‘uniclib[10]’)
slnunico.c:1296:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1296 |         {"match", unic_match}, /* cluster */
      |          ^~~~~~~
slnunico.c:1296:10: note: (near initialization for ‘uniclib[10]’)
slnunico.c:1296:10: error: initializer element is not computable at load time
slnunico.c:1296:10: note: (near initialization for ‘uniclib[10]’)
slnunico.c:1296:19: warning: excess elements in scalar initializer
 1296 |         {"match", unic_match}, /* cluster */
      |                   ^~~~~~~~~~
slnunico.c:1296:19: note: (near initialization for ‘uniclib[10]’)
slnunico.c:1297:9: warning: braces around scalar initializer
 1297 |         {"rep", str_rep},
      |         ^
slnunico.c:1297:9: note: (near initialization for ‘uniclib[11]’)
slnunico.c:1297:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1297 |         {"rep", str_rep},
      |          ^~~~~
slnunico.c:1297:10: note: (near initialization for ‘uniclib[11]’)
slnunico.c:1297:10: error: initializer element is not computable at load time
slnunico.c:1297:10: note: (near initialization for ‘uniclib[11]’)
slnunico.c:1297:17: warning: excess elements in scalar initializer
 1297 |         {"rep", str_rep},
      |                 ^~~~~~~
slnunico.c:1297:17: note: (near initialization for ‘uniclib[11]’)
slnunico.c:1298:9: warning: braces around scalar initializer
 1298 |         {"reverse", str_reverse},
      |         ^
slnunico.c:1298:9: note: (near initialization for ‘uniclib[12]’)
slnunico.c:1298:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1298 |         {"reverse", str_reverse},
      |          ^~~~~~~~~
slnunico.c:1298:10: note: (near initialization for ‘uniclib[12]’)
slnunico.c:1298:10: error: initializer element is not computable at load time
slnunico.c:1298:10: note: (near initialization for ‘uniclib[12]’)
slnunico.c:1298:21: warning: excess elements in scalar initializer
 1298 |         {"reverse", str_reverse},
      |                     ^~~~~~~~~~~
slnunico.c:1298:21: note: (near initialization for ‘uniclib[12]’)
slnunico.c:1299:9: warning: braces around scalar initializer
 1299 |         {"sub", unic_sub}, /* cluster/byte opt. */
      |         ^
slnunico.c:1299:9: note: (near initialization for ‘uniclib[13]’)
slnunico.c:1299:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1299 |         {"sub", unic_sub}, /* cluster/byte opt. */
      |          ^~~~~
slnunico.c:1299:10: note: (near initialization for ‘uniclib[13]’)
slnunico.c:1299:10: error: initializer element is not computable at load time
slnunico.c:1299:10: note: (near initialization for ‘uniclib[13]’)
slnunico.c:1299:17: warning: excess elements in scalar initializer
 1299 |         {"sub", unic_sub}, /* cluster/byte opt. */
      |                 ^~~~~~~~
slnunico.c:1299:17: note: (near initialization for ‘uniclib[13]’)
slnunico.c:1300:9: warning: braces around scalar initializer
 1300 |         {"upper", unic_upper},
      |         ^
slnunico.c:1300:9: note: (near initialization for ‘uniclib[14]’)
slnunico.c:1300:10: error: initialization of ‘int’ from ‘char *’ makes integer from pointer without a cast [-Wint-conversion]
 1300 |         {"upper", unic_upper},
      |          ^~~~~~~
slnunico.c:1300:10: note: (near initialization for ‘uniclib[14]’)
slnunico.c:1300:10: error: initializer element is not computable at load time
slnunico.c:1300:10: note: (near initialization for ‘uniclib[14]’)
slnunico.c:1300:19: warning: excess elements in scalar initializer
 1300 |         {"upper", unic_upper},
      |                   ^~~~~~~~~~
slnunico.c:1300:19: note: (near initialization for ‘uniclib[14]’)
slnunico.c:1301:9: warning: braces around scalar initializer
 1301 |         {NULL, NULL}
      |         ^
slnunico.c:1301:9: note: (near initialization for ‘uniclib[15]’)
slnunico.c:1301:10: error: initialization of ‘int’ from ‘void *’ makes integer from pointer without a cast [-Wint-conversion]
 1301 |         {NULL, NULL}
      |          ^~~~
slnunico.c:1301:10: note: (near initialization for ‘uniclib[15]’)
slnunico.c:1301:16: warning: excess elements in scalar initializer
 1301 |         {NULL, NULL}
      |                ^~~~
slnunico.c:1301:16: note: (near initialization for ‘uniclib[15]’)
slnunico.c: In function ‘luaopen_unicode’:
slnunico.c:1322:9: error: implicit declaration of function ‘luaL_register’; did you mean ‘lua_register’? [-Wimplicit-function-declaration]
 1322 |         luaL_register(L, SLN_UNICODENAME,
      |         ^~~~~~~~~~~~~
      |         lua_register
slnunico.c:1325:9: error: implicit declaration of function ‘luaI_openlib’; did you mean ‘luaL_openlibs’? [-Wimplicit-function-declaration]
 1325 |         luaI_openlib(L, SLN_UNICODENAME ".ascii", uniclib, 1);
      |         ^~~~~~~~~~~~
      |         luaL_openlibs

Error: Build error: Failed compiling object slnunico.o

I have checked the Lua version:

$ lua -v
Lua 5.4.8  Copyright (C) 1994-2025 Lua.org, PUC-Rio

[tarleb]

Installing slnunicode should not be necessary. In fact, the only dependency that requires a C compiler should be lpeg, and that one isn't necessary as it's built into pandoc. All other dependencies should be pure Lua. If you try again and want to install panluna, then make sure that luarocks targets the right Lua version during the install command.