How to use the railroad-diagrams.Diagram function in railroad-diagrams

} else if (tok.macrocall) {
                return new rr.Comment("Pas implementé.");
            } else if (tok.tokens) {
                return new rr.Sequence(tok.tokens.map(renderTok));
            } else if (typeof(tok) === 'string') {
                return new rr.NonTerminal(tok);
            } else if (tok.constructor === RegExp) {
                return new rr.Terminal(tok.toString());
            } else if (tok.token) {
                return new rr.Terminal(tok.token);
            } else {
                return new rr.Comment("[Unimplemented]");
            }
        }

        return new rr.Diagram([renderTok(outer)]);
    }

<div>
									The argument is a list of columns by which the relation should be ordered (see examples)

									<div>
										order the result by the first column (default is ascending) and the second column descending:
										<code>τ [1], firstname desc (π id, firstname ( Customer ) )</code>
									</div>

									<div>
										</div></div>

<div>no argument

									<div>
										<code>( pi firstname ( Customer ) ) - ( rho test{'&lt;'}-lastname (
					pi lastname ( Customer )
				) )</code>
									</div>
									the schemas must be unifiable

									<div>
										
									</div>
								</div>
							
							<div>
								<h4 id="relalg-operations-crossjoin">cross product</h4>
								<table>
									<tbody>
										<tr>
											<th>symbol</th>
											<td>⨯</td></tr></tbody></table></div>

const productionToDiagram = (production, options) => {
  if (production.identifier) {
    return production.complex
      ? ComplexDiagram(productionToDiagram(production.definition, options))
      : Diagram(productionToDiagram(production.definition, options));
  }
  if (production.terminal) {
    return Terminal(production.terminal);
  }
  if (production.nonTerminal) {
    return NonTerminal(production.nonTerminal, {
      href: `#${dasherize(production.nonTerminal)}`
    });
  }
  if (production.skip) {
    return Skip();
  }
  if (production.specialSequence) {
    const sequence = NonTerminal(" " + production.specialSequence + " ", {});
    sequence.attrs.class = "special-sequence";
    return sequence;

<code><i>QUALIFIER.COLUMN_NAME</i>:<i>COLUMN_TYPE</i></code> <b>separated by any whitespace,
										comma or semicolon.</b>
										The <i>QUALIFIER</i> is optional. Also the <i>COLUMN_TYPE</i> can be omitted if the type is well
										defined by the values of that column. The first non null value of a column defines its type.
										<br>True and false (case insensitive without quotes) are reserved for a boolean type. They can
										be used as a simple string but they do not define the type of the column as string.
										<br>The <i>COLUMN_TYPE</i> can be one of the following
										<ul>
											<li>string</li>
											<li>number</li>
											<li>date</li>
											<li>boolean</li>
										</ul>
										<div>
											</div>

<strong>from_item</strong> [ INNER ] JOIN <strong>from_item</strong> ON join_condition
				<strong>from_item</strong> [ INNER ] JOIN <strong>from_item</strong> NATURAL
				<strong>from_item</strong> [ INNER ] JOIN <strong>from_item</strong> USING ( join_column [, ...] )
				<strong>from_item</strong>
				<strong>from_item</strong> {'{'} LEFT | RIGHT | FULL } [ OUTER ] JOIN ON join_condition
				<strong>from_item</strong>
				<strong>from_item</strong> {'{'} LEFT | RIGHT | FULL } [ OUTER ] JOIN NATURAL <strong>from_item</strong>
				<strong>from_item</strong> {'{'} LEFT | RIGHT | FULL } [ OUTER ] JOIN USING ( join_column [, ...] ) <strong>from_item</strong>

				and <strong>with_query</strong> is:

				<strong>with_query_name</strong> AS ( <strong>select</strong> )

							<div>
								</div>

}`}
									
								
							
							<div>
								<h4 id="relalg-relalgexpr">relational algebra expression</h4>

								<div>
									<p>A valid relational algebra expression is built by connecting <i>relation-name</i> or <i>inline-relation</i>
										as atoms with the defined unary and binary operators.</p>

									So a relational algebra expression is recursively defined as follows:

									<div>
										</div></div></div>