Skip to content

@Args (At Arguments)


An additional type of argument is the @ argument. These are for operating on a table or elements that have already been defined. At-args can target existing elements to: apply attributes to them, replace their content, delete them, or insert content in their place.

Note: all elements support the addition of {} properties, but only some support deletion, insertion, or content replacement.

The primary use case of @Args is for modifying templated tables.

  • collapse - collapsible container (if it exists) -- .content - content div -- .title - titlebar -- .titletext - titlebar text (Supports: auto-replace (if arg has content, will replace element content)) -- .indicator - state indicator

  • - the tab div of group 'foo' -- .cell - the cell containing the div -- .content - the div content container -- .list - the tab list element

  • master - div that contains infobox

  • caption - table caption, if exists. (Supports: Deletion)
  • head - table head, if exists (Supports: Deletion)
  • foot - table foot, if exists (Supports: Deletion)
  • body - table body
  • row - table row

Most important of these is row. Follow row with an index number, separated with a period, ex: row.3 to target the row at that index. Adding another period-separated number (ex: row.3.2) will target that row's cell at that index. NOTE: both rows and cells are zero-indexed. Head and foot rows are not included in this count.

row will always target the body of index 0. To target a different body, use body. For example: row.1.2 is equivalent to body.0.1.2.

You can pass {} attributes to an @-targeted element as if it were an element itself.

More powerfully, you can pass $ parameters to alter the targeted elements:

  • $DEL - Delete
  • $CLR - Clear
  • $REP - Replace
  • $INS - Insert
  • $APP - Append


  • $DEL - Delete Outer Deletes the element.

  • $CLR - Delete Inner Empties the element.

  • $APP - Append Inner Appends to element contents.

  • When targeting a body, appends nested args to body

  • When targeting a row, appends nested args to row
  • When targeting a cell, appends arg contents to cell contents

  • $REP - Replace Inner Replaces that element's content with the argument contents. Equivalent to $CLR $APP

  • When targeting a body, replaces the body's contents with nested args.

  • When targeting a row, replaces the row's contents with nested args.
  • When targeting a cell, replaces the cell's contents with arg contents.

  • $INS - Insert At

Insert a new row or cell at that index, and append to it the argument contents. Inserts the arg contents

  • When targeting a body
  • when targeting a row, inserts arg contents and/or nested at row index
  • When targeting a cell, inserts arg contents and/or nested at cell index

  • $DEL $INS - Replace Outer

When targeting a row, using {$DEL $INS} functionally creates a new row in that slot. When creating a row in this way, nested arguments will be rendered in-place, as if they were depth-zero arguments in that location. However, their autofill context is sandboxed to the @arg.

Notes on execution order: in a template-invoking codeblock, any arguments (including @args) are appended (in declaration order) to the template arguments. In a normal codeblock, @args are executed where they are invoked, meaning that they cannot access rows that have not been created yet.

Additionally, note that the index is evaluated at each argument's execution, not beforehand. This means that if a previous @arg adds or removes rows, the indices will be different for any following @args.

Finally, while tab group elements can be accessed, specific tab elements cannot yet be accessed. This is an internal limitation (tabs are processed after all arguments) that may be remedied in the future.