https://github.com/user-attachments/assets/7cab2d61-5858-4b62-87bf-0598e44af2e7

LiaScript 2.6.0

To see this document as an interactive LiaScript rendered version, click on the following link/badge:

If you need help, feel free to ask us any questions in the chat:

                        --{{0}}--

With LiaScript, we tried to implement an extended Markdown format that should enable everyone to create, share, adapt, translate or correct online courses without the need of being a web-developer. We believe that a language-based approach, instead of a tooling-centered one, provides more flexibility, freedom of creativity, and sustainability. Therefore we tried to develop a simplistic syntax that extends the static Markdown with quizzes, animations, spoken text, automated visualization ASCII-art and much more. Everything has been woven around Markdown, so that the content can still be read and interpreted with any kind of editor or Markdown-interpreter.

What is LiaScript?

• a Markdown dialect for interactive courses and data-driven publishing,

• everything is implemented in Elm/JavaScript and runs directly within the browser (online),

• the interpreter itself is also a reader, which allows for storing documents as well as the progress,

• courses can also be taken offline, since the interpreter is also a progressive web app (PWA), that allows to store documents and progress directly within the browser (locally),

• everything is private, we do not store any data about the courses nor the users and their progress

                        --{{1}}--
  

There are a couple of problems that we currently see in the creation of Open educational resources (OER). One of them is isolation, that means people, who want to create content, are seldom connected via the applied technologies, instead, they are separated by platforms, authoring tools and used core technologies (programming languages). Furthermore, it is not possible to simply grab an educational website/project and to adapt its content for another audience. Additionally, it seems to be nearly impossible for people without a technical background to simply set up a small course. Thus, they stuck with Word, PowerPoint, and PDF, since they provide a simple continuation of the static formats people have used before the computer-era. "If I want to publish content for the computer, I want my audience to dive in, experiment, simulate, play with the content... but not only read."

                          {{1}}

Goals

• Simplicity: with a human-centered markup-language, anyone should be enabled to create and modify content.
• Interactive: the browser is the next operating systems and although content with LiaScript is developed within a "static" markup-language it should not be presented that way.
• Extendability: everything that is not part of LiaScript shall be embeddable and importable.
• Durability: platforms go down, the development of proprietary software/formats is discontinued, but LiaScript is not hosted on one platform (it can be hosted everywhere) and even without the LiaScript interpreter the content is still readable and interpretable with every editor; you could even print or engrave it on stone or clay. Furthermore, if you use some kind of versioning system (e.g. git) you can refer to any previous version of your course.

                       --{{2}}--

Imagine a world where everyone would have the same access to high quality educational content for free. Imagine all kind of schoolbooks, technical or scientific literature could become open-courSe projects and more interactive, with collaborating teachers and students. Everything that is required is a simple text-editor and a web-browser.

                         {{2}}

Tools

                       --{{0}}--

As already mentioned all you need to work with LiaScript is an text-editor, but it can be useful to apply one of the following tools. At least we apply them to see the result of a change within the course document immediately. You will see, that the development of online-courses will speed up, especially if there is no need for memorizing complex point and click sequences.

"Let the editor be your canvas and the keyboard your brush."

Editing

                       --{{0}}--

There are currently 2 plugins for the Atom Editor and Visual-Studio-Code available, which are intended to ease and simplify the development of online courses with LiaScript. Additionally you can use the LiveEditor, an entirely browser based application.

1. LiveEditor: Fully functional online editor, that looks like CodiMD, but is entirely browser based. With support for uploading images and videos and collaborative editing.

2. Atom: This is the free and open and official GitHub editor, with lots of plugins for various use cases.

   1. liascript-preview: Is a tiny previewer that, if it was toggled ( Alt+L ), updates the view on your course each time you save your document.
   2. liascript-snippets: If you start typing lia in your Markdown document you switch on a fuzzy search, that contains a lot of LiaScript help, examples, and snippets.

   Detailed installation instructions can be found here.

3. Visual-Studio-Code: This is Microsoft's free popular editor with various plugins and extensions.

   1. liascript-preview: Is a tiny previewer that, if it was toggled ( Alt+L ), updates the view on your course each time you save your document.
   2. liascript-snippets: If you start typing lia in your Markdown document you switch on a fuzzy search, that contains a lot of LiaScript help, examples, and snippets.

   Detailed installation instructions can be found here.

4. Visual-Studio-Web:

   !?GitHub web-based Editor

   Using the GitHub builtin Web editor, you can install the following extension to preview your course while editing:

   liascript-preview-web

                         {{1}}
   

LiaScript-DevServer:

                       --{{1}}--

If you are used to another editor, you can also start a LiaScript development server locally. It works like the plugin for Atom and updates your course within your browser on every save, but this can also be used to monitor multiple projects. And you can also use it for testing purposes, as if you would deploy your projects. Started with --mcp, it also connects AI agents such as Claude Code or Codex to your course preview, with a chat and with agent links that send commands to the agent.

Get the project from:

• npmjs: https://www.npmjs.com/package/@liascript/devserver
• GitHub: https://github.com/LiaScript/LiaScript-DevServer

                         {{2}}

CodiLIA:

                       --{{2}}--

If you prefer to work with multiple authors simultaneously, then you should give CodiLIA a try. It is a fork of the collaborative editor CodiMD/HedgeDoc, but instead of a Markdown preview, you will have a LiaScript preview, and you can immediately publish your courses.

Project: https://github.com/liascript/codilia

!?CodiLIA deploy to Heroku

Projects

                       --{{0}}--

The easiest way of importing a LiaScript into another website or Learning Management System (LMS) such as Moodle, ILIAS, or OPAL, is via importing an external website or if possible via an iframe.

!?LiaScript embed into OPAL

                         {{1}}

LiaScript-Exporter:

                       --{{1}}--

However, there might be cases where you want to store the progress within the LMS. We therefore have developed an experimental exporter, which allows to bundle your entire project as an SCORM compliant zip-file that can be imported into most common LMS. Other formats than SCORM can be added too, simply write us a mail or create an issue, if you require another one.

• npmjs: https://www.npmjs.com/package/@liascript/exporter
• GitHub: https://github.com/liascript/liascript-exporter

                         {{2}}

Preview-Lia:

                       --{{2}}--

If you want to refer to your own courses or to foreign ones on your personal website or blog, you can make use of our "preview web component". This creates preview cards, which are updated at client-side, so that there is no need to manually update all information whenever there is a change in the course. Simply add the script tag as depicted in the code-snippet and link to your courses via the tag preview-lia.

<html>
  <head>
    <script type="text/javascript" src="https://liascript.github.io/course/preview-lia.js"></script>
  </head>
  <body>
    ...
    <preview-lia src="https://raw.githubusercontent.com/liaScript/docs/master/README.md">
    </preview-lia>

    <preview-lia src="https://liascript.github.io/course/?https://raw.githubusercontent.com/liaScript/docs/master/README.md">
    </preview-lia>

    ...
  </body>
</html>

For more information visit the blog entry: Markdown just got a new preview tag

However, you can also use this to refer to your personal GitHub projects.

                       --{{3}}--

LiaScript was originally developed for supporting programming courses for embedded systems. You can see an example of the previous eLab remote laboratory installation.

                         {{3}}

!?eLab demonstrator

                       --{{4}}--

Now it is the opposite, our main focus lays in the development of the Markup language, but parts of the old systems can still be used. Especially if you want to teach programming in (Java, C, C++, C#, Mono, Go and Python). The CodeRunner is an open-source project that enables remote compiling and execution of code. We apply it to teach procedural and object-oriented programming. You can either host your own server or use our free herokuapp:

   {{4}}

CodeRunner:

• GitHub: https://github.com/liascript/CodeRunner

• Try the interactive LiaScript version at:

  https://liascript.github.io/course/?https://github.com/liascript/CodeRunner

• Or if you want to import this functionality into your course, then add the following statement into the main header of your LiaScript course:

  import: https://raw.githubusercontent.com/LiaScript/CodeRunner/master/README.md

Publishing

                       --{{0}}--

By now you should have a basic idea of what you can do with LiaScript, but probably not how you can publish your courses. The best way is actually to use GitHub, this way no prior versions of your course get lost, and you give others (you can even invite them) the opportunity to contribute to your project.

                       --{{1}}--

No further hosting is required, no further compilation step, the JavaScript interpreter of LiaScript does everything else directly within the browser at client-side.

                       --{{2}}--

As you can see from the example, it is also possible to refer to a specific slide. You only have to add a # with the number of the slide, or you can add the name of the specific slide as well.

                       --{{3}}--

You can also add additional tags to your project to make it discoverable. We currently use three distinct categories: liascript to mark it to be related to the projects, while the others liascript-course and liascript-template are used to distinguish the projects into courses or extension, which can be added to courses.

                       --{{4}}--

The same way you can also refer to courses that you have put into your DropBox, ownCloud, NextCloud, or if you have access to some old-fashioned web-space then you can also store all of your files there. You only have to make them publicly available and to refer to the raw or in other words, the text document. All other sources are loaded relative to this URL.

1. Create a free account at https://github.com

2. Refer to your projects as via a URL parameter:

   https://LiaScript.github.io/course/?YOUR_RAW_COURSE_URL.md

3. Example with reference to a specific slide:

   https://liascript.github.io/course/?https://raw.githubusercontent.com/liaScript/docs/master/README.md#5

4. Make your document discoverable by adding the tags liascript and or liascript-course, liascript-template to make it appear in one of the following GitHub topics:

   • general: https://github.com/topics/liascript
   • free courses: https://github.com/topics/liascript-course
   • extensions: https://github.com/topics/liascript-template

   More information on tagging projects can be found here.

5. Use other ways of hosting repositories as well (e.g. DropBox, ownCloud, NextCloud).

LiaBooks

                       --{{0}}--

However, we have no idea who is using LiaScript elsewhere, so it might be hard to find some resources online. From time to time we translate open-books into LiaScript and make them more interactive. You can see some of our the experiments at the following URL and use them as a source of inspiration:

https://github.com/LiaBooks

Full overview on courses via the topic liascript-course:

https://github.com/topics/liascript-course

LiaTemplates

                       --{{0}}--

If you tried out CodeRunner, you will have probably noticed that you can reuse functionality from different courses, simply by using the keyword import: within the main definition of your LiaScript document. Such a functionality is defined with the help of macros. We will dive deeper into this feature at the end of this document, but if you are interested you can inspect some of our templates, which shall provide self-explaining courses of how to embed and use the implemented macros.

https://github.com/LiaTemplates

Full overview on extensions via the topic liascript-template:

https://github.com/topics/liascript-template

Using LiaScript

                       --{{0}}--

Before we dive into the syntax, a short tour through the LiaScript app itself. Everything in this chapter is available in every course, authors do not have to write anything for it. It is the part you might want to explain to your learners.

Home Screen & Kanban Board

                       --{{0}}--

Every course you open is stored in your browser and shows up as a card on the home screen. By default the cards are shown as a list, but you can also sort them into your own columns, like on a kanban board.

• Switch the layout: use the "Layout" button on the left of the header and choose "List" or "Kanban". It is only shown if there is at least one course.

• Columns: the board starts with one column named "Courses". New columns are added via the field "new column" at the end of the board (press Enter or click "Add column"). The actions of a column appear on hover or focus (on touch devices they are always shown): rename, move to the left or right, and delete. If you delete a column, its courses move to the first column.

• Move courses: drag a card with the mouse, or press and hold it on a touch screen, and drop it into another column. The board shows where the card will land. Alternatively, expand a card via "Show details" and choose a column in "Move to column".

• Compact cards: on the board, a card only shows its image, title and the open button. "Show details" expands the description and all actions. Courses without a logo get the LiaScript bird, colored per course.

                       --{{1}}--
  

The layout and the columns are stored only within this browser. New courses always end up in the first column.

Offline Use

                       --{{0}}--

LiaScript is a progressive web app, once loaded, the app and the courses you visited also work without a network connection. Images, audio and video files are normally loaded from their original location. If you want to take a course with you, for example on a train or into a classroom with a bad connection, you can download its media files in advance.

• Information menu of a course: "Download media for offline use"

• Course card on the home screen: the download icon (on the kanban board within "Show details")

                       --{{1}}--
  

This stores the logo, all images, audio and video files of the course, including the recordings of narrator comments. Streams like YouTube or Vimeo cannot be downloaded and are skipped. A small box at the bottom right shows the progress and how many files could not be loaded.

  {{1}}

Note: The download is not available in SCORM, xAPI and other LMS packages, they bring their own files. The stored files can only be removed by deleting the site data of LiaScript within your browser settings.

Hiding the Navigation

                       --{{0}}--

If you want more space for the content, for example on a small screen or while presenting, you can hide the navigation. Open the menu where you choose between Textbook, Presentation and Slides mode, and click on "Hide navigation".

                       --{{1}}--

The table of contents and the header disappear. What remains is a slim column of floating buttons for the menus, the button for the table of contents, two arrows for the previous and next slide, and the bar for text-to-speech. Click on "Hide navigation" again to bring everything back. This setting is not stored, after a reload the navigation is visible again.

Accessibility Settings

                       --{{0}}--

LiaScript tries to be usable with a keyboard, a screen reader and in all color settings. Two settings are worth knowing:

• Do not rely on color alone (settings menu): adds patterns to the series of charts, and checked quiz answers get a solid border if they are correct and a dashed one if they are wrong. Thus, the result can be seen without distinguishing red and green.

• Reduce motion (a setting of your operating system or browser): LiaScript stops all animations and transitions, also those defined by course authors.

                       --{{1}}--
  

For authors this means, the content of a slide should also be understandable without its animations.

Keyboard Navigation

                       --{{0}}--

All parts of LiaScript can be used with the keyboard. The arrow keys switch slides only, if no other element needs them, while you are within a text field, a slider, a dropdown, a radio group, the table of contents or a matrix quiz, they belong to that element.

General

Table of contents

The search in the table of contents tolerates one typo per word (for words with 4 or more characters). In right-to-left languages, → and ← are mirrored.

Content

KaiOS Keypad

                       --{{0}}--

LiaScript also runs on feature phones with KaiOS, which have a numeric keypad instead of a touch screen. On these devices, courses can be navigated with the following keys, as long as the focus is not within an input field:

Markdown-Syntax

                      --{{0}}--

This section is intended to give a brief overview on the basic Markdown syntax elements. The only difference to common Markdown at this point is, that you can define meta-information such as author, language, voice, etc. within a HTML-comment at the beginning of every document. We will describe all of these elements in more detail in section: Macros. All of these macros start with a single word, which is followed by a colon. If you require more space, like for comment: or link: you can use multiple lines, but every following line has to start with an indentation.

Initial LIA-comment-tag for basic definitions:

<!--

author:   Andre Dietrich

email:    [email protected]

version:  0.0.1

language: en

narrator: US English Female

comment:  Write a short abstract of your course, that
          might contain multiple lines and sentences.

script:   https://javascript_resourse_url

script:   https://another_javascript_resourse_url

link:     https://some_css_stuff
          https://and_some_more_css
-->

                      --{{1}}--

The meta-information from your document is later shown within the information-section as well as within the home-section.

                        {{1}}

                      --{{2}}--

If you already know Markdown, then you can skip most of the content in this section. However, there are some slight differences that will be marked with a trailing star at the section title.

        {{2}}

Something might be different 💫

Structuring

                      --{{0}}--

A course is structured as any other Markdown document with starting hash-tags, whereby the number of hash-tags is used to define the hierarchy of your document.

# Main Title

 ...

## Section Title 1

 ...

### Subsection Title

 ...
## Section Title 2

                      --{{1}}--

Every section is presented separately. In contrast to most Markdown-parsers, LiaScript applies a two step-approach. Sections are parsed at first, which means that the parsers searches for patterns as depicted below. Parsing the content of a section is quite time-consuming, that is why the section-content gets only analyzed, if this specific section should be displayed to the user. However, this happens only at the first appearance, afterwards the resulting view is restored from a local cache.

                        {{1}}

Preprocessing pattern: ## foo bar

Semantic Correct HTML

                      --{{0}}--

As mentioned earlier, the preprocessor searches for patterns ## header at the beginning of a line to identify sections. However, there might be cases where you want to have multiple different sections on one slide, with different headers. Semantic HTML can help us to deal with this, especially the two HTML5 tags section and article.

# Slide-Title

<section>
## Section-Title

...
</section>

<article>
## Article-Title

...
</article>

                      --{{1}}--

LiaScript will identify these HTML-tags and the content, such that the content within cannot be used as a separator. If you use these two semantic tags, your content is grouped in semantic correct way, which improves the readability if screen-readers are used or keyboard navigation is used.

                      --{{2}}--

When to use which tag might be philosophical question. We can say, if you just want to structure your content with different sub-headers, then use <section>. If your content represents a self-contained document, then use <article>. However, the visually presented result will be the same, such that you could also use a <div> to structure your content.

Sub-Titles 💫

                      --{{0}}--

There might be some cases, where you want to add further headings quickly. We therefore apply the following syntax with underlining "equal signs" or "dashes". In common Markdown, this alternative syntax is applied to define level-1 and level-2 headings. We use it to create headings that are one level = or two levels - below the main heading. However, these subsections will not be part of the table of contents, and since their interpretation is slightly different to common Markdown, you should use the method presented in the previous section.

...

## Section Title

Local Subsection
================

Local Sub-SubSection
--------------------

Content blocks

                      --{{0}}--

How would you separate paragraphs or other content elements from each other, if you only have a type-writer? The easiest way is a spatial separation, and in Markdown this is done via an empty line. Thus, whenever you have blocks such as paragraphs, enumerations, or tables, it is common practice to separate them via a newline. This makes it easier for you to edit and structure your course, and it prevents the interpreter from too much work.

This is a paragraph that consist only of one line.

Here comes another paragraph
with multiple lines.
And multiple sentences.

Text-Formatting 💫

                        --{{0}}--

How does text-highlighting work in a text file and thus within a paragraph? Well, Markdown defines some basic characters that can be used to surround a word or a collection of words. We tried to use the GitHub flavored Markdown style for simple formatting, thus simply use multiple asterisks or underscores to mark certain parts of a text.

• *italic* -> italic

• **bold** -> bold

• ***bold and italic *** -> ***bold and italic ***

• _also italic_ -> also italic

• __also bold__ -> also bold

• ___also bold and italic___ -> also bold and italic

• ~strike~ -> strike

                      --{{1}}--
  

We define some additions to common Markdown, such as underline and superscript, which can be defined with the following syntax:

                        {{1}}

• ~~underline~~ -> underline
• ~~~strike and underline~~~ -> ~~~strike and underline~~~
• ^superscript^ -> ^superscript^

Combinations

                      --{{0}}--

As you can see from the examples, you can combine and nest all elements freely.

• **bold _bold italic_** -> bold bold italic
• **~bold strike~ ~~bold underline~~** -> bold strike bold underline
• *~italic strike~ ~~italic underline~~* -> italic strike italic underline

Typography

                      --{{0}}--

It is now possible within a LiaScript Markdown to apply sequences of dashes for typography. A sequence of dashes is now translated into:

1. single dash - --> Hyphen or minus sign -

2. double dash -- --> En dash --

3. triple dash --- --> Em dash ---

                      --{{1}}--
   

An Ellipsis is indicated by a sequence of three dots:

                        {{1}}

... will be translated to the Unicode symbol ...

Quotes

                      --{{0}}--

Additionally single and double quotes are translated into their typographical counterparts, based on the defined language in the header of the course. German, French, English or Welsh will be translated into different Unicode symbols.

"That's a 'magic' shoe." --> “That’s a ‘magic’ shoe.”

Applied quote translation as defined here: https://en.wikipedia.org/wiki/Quotation_mark

                      --{{1}}--

If you want o use the original characters, you will have to escape them, as shown also in the next section:

  {{1}}

\" --> "
\' --> '

                        {{2}}

                      --{{2}}--

<q>That's a 'magic' shoe.</q>\
<q lang="de">Das ist ein magischer Schuh.</q>

---

<!-- lang="fr" -->
Et voici un autre example: <q>C'est une chaussure magique.</q>

Escape Characters

                      --{{0}}--

If you want to use asterisks, hash-tags, or other syntax elements within your document without applying their functionality, then you can escape or in other words indicate them with a starting backslash. If you want to escape a backslash, you will have to write two subsequent backslashes. But you do not have to use it, if there is only one asterisk within a line, this will be interpreted as a single character. So you will have to apply this kind of escaping only to prevent misunderstandings between you and the interpreter.

\*, \~, \_, \#, \{, \}, \[, \], \|, \`, \$, \@, \\, \<, \>, \", \'

Result: *, ~, _, #, {, }, [, ], |, `, $, @, \, <, >, ", '

Symbols & Unicode 💫

                      --{{0}}--

One thing that we missed in standard Markdown, was an implementation for arrows. The verbatim text shows, how arrows are defined in our Markdown implementation with their result on the right.

-> ->, ->> ->>, >-> >->, <- <-, <-< <-<, <<- <<-, <-> <->, => =>, <= <=, <=> <=>

--> -->, <-- <--, <--> <-->, ==> ==>, <== <==, <==> <==>

~> >, <~ <

                      --{{1}}--

But you can also use some basic smileys. We will try to extend this partial support in the future.

                        {{1}}

:-) :-), ;-) ;-), :-D :-D, :-O :-O, :-( :-(, :-| :-|, :-/ :-/, :-P :-P, :-* :-*, :') :'), :'( :'(

                      --{{2}}--

However, since LiaScript accepts Unicode, you can also copy and paste any kind of character including emojis.

References

The next section shows how external resources can be referenced and integrated.

Simple Links

                      --{{0}}--

There are two ways of adding links to a Markdown document, either by inlining the URL directly or you can name it (as shown in listing 2), by applying the typical brackets and parenthesis notation, the optional information is put in double quotes at the end of the URL. This optional information is used as a title attribute, and it is shown, when the user hovers the link with the mouse.

1. Example of an URL-link -> http://goo.gl/fGXNvu

   text-formatting can be applied also *** http://goo.gl/fGXNvu *** -> *** http://goo.gl/fGXNvu ***

2. Naming the link ([title](http://goo.gl/fGXNvu "optional info")) -> title

3. For internal navigation you can refer to the slide number or to title with a starting #

   • [next slide](#18) -> next slide

   • [next slide](#preview-lia-💫) -> next slide

   • If your internal link includes parentheses or other characters, you can also use percent-encoding. An opening parentheses would then be written as %28 and a closing one as %29.

     For more information visit: https://developer.mozilla.org/en-US/docs/Glossary/percent-encoding

Autolinks & Escaping

                      --{{0}}--

URLs containing parentheses, brackets, or quotation marks can confuse Markdown parsers, which may misinterpret these characters as part of the link syntax. The safest solution is to wrap the URL in angle brackets — a feature known as autolinks, supported by most Markdown readers and by LiaScript since Version 1.0.5.

• Plain autolink: <https://en.wikipedia.org/wiki/Gymnasium_(Germany)>

  Result: https://en.wikipedia.org/wiki/Gymnasium_(Germany)

• Named link with autolink URL: [Gymnasium (Germany)](<https://en.wikipedia.org/wiki/Gymnasium_(Germany)>)

  Result: Gymnasium (Germany)

                      --{{1}}--
  

As an alternative to angle brackets, you can also escape individual parentheses or brackets with a backslash. This avoids the need for percent-encoding (e.g., %28 and %29) while keeping the URL readable. The result looks like follows:

                        {{1}}

• Escaped URL: https://en.wikipedia.org/wiki/Gymnasium_\(Germany\)

  Result: https://en.wikipedia.org/wiki/Gymnasium_\(Germany\)

• Named link with escaped URL: [Gymnasium (Germany)](https://en.wikipedia.org/wiki/Gymnasium_\(Germany\))

  Result: Gymnasium (Germany)

Preview-Lia 💫

                      --{{0}}--

LiaScript has an advanced preview link, that will load the remote course and parse the meta-information such as title, version, comment, logo, email, tags, form your main HTML-comment at the top of your document. To do this, you will have to use [preview-lia] as the title of your link, which is followed by the raw URL of your course document.

[preview-lia](https://raw.githubusercontent.com/LiaScript/docs/master/README.md)

preview-lia

                      --{{1}}--

You can use this technique also to create previews for other courses on your personal website or for other GitHub projects, as it was described in section Projects. For more information follow the link:

{{1}} https://liascript.github.io/blog/markdown-just-got-a-new-preview-tag/

QR-Codes 💫

                      --{{0}}--

Sometimes it might be required to have both, a link and a visual representation of it as an QR-Codes. Similar to previews, you simply name your link qr-code:

• Syntax: [qr-code](https://LiaScript.github.io)

• Example:

  qr-code

                      --{{1}}--
  

You can add further information to your link by adding a title. Markdown is also allowed within the link title. In case of an image or media link, the title will be used as a subtitle and displayed accordingly.

                        {{1}}

• Syntax: [qr-code](https://LiaScript.github.io "Checkout the LiaScript website or the __[blog](https://liascript.github.io/blog/)__")

• Example:

  qr-code

eMail, Telephone & other Protocols 💫

  --{{0}}--

These are additional link types that you can also use within the <a> tag, but LiaScript supports them natively.

    {{1}}

• mailto:

  [Write me a Mail](mailto:[email protected]) --> Write me a Mail

  [LiaScript\@web.de](mailto:[email protected]) --> [email protected]

  --{{1}}--
  

  The mailto link type does not need to be explained. On most modern systems, clicking on such a link will open your email client and insert the email address after the colon directly into the recipient address field. Since the @ symbol is used for macro calls, this has to be escaped at the moment.

    {{2}}
  

• tel:

  [Call me](tel:+49-12345-67890) --> Call me

  [+49-12345-67890](tel:+49-12345-67890) --> +49-12345-67890

  --{{2}}--
  

  The tel link type is lesser known and has been introduced for mobile phones. Clicking on such a link will trigger the dial dialog, allowing you to call the pre-set number without any need for copy and paste.

    {{3}}
  

  --{{3}}--

There are a couple more protocols that are less common on the web, but useful in education, from sending a prefilled SMS to opening a map at a meeting point. For content, LiaScript additionally accepts ipfs:, ipns:, dat:, hyper:, data:, blob:, and file: as sources for links, images, and other media, see also the appendix. Any other protocol, such as javascript:, is dropped for security reasons.

Experimental Agent Links

  --{{0}}--

LiaScript courses can also be used together with AI agents. A link with the scheme agent: does not open a page; instead, it sends a command to an agent that is connected to your course. It has the form agent:<agent>/<command>?<parameters>, and the agent receives the agent name, the command, and the parameters, together with what the user is currently looking at: the file, the slide, its title, and the selected text.

[Explain this simpler](agent:tutor/explain?level=easy)

<button data-agent="agent:author/rewrite?tone=short">Shorten this section</button>

[Give me an exercise](#)<!-- data-agent="agent:tutor/exercise?n=3" -->

  --{{1}}--

What tutor or explain mean is up to you: define them as sub-agents, skills, or simply within the instructions of your agent. An empty agent name, as in agent:/explain, addresses the main agent.

  --{{2}}--

At the moment, these links are only handled by the LiaScript-DevServer, if it is started with --mcp, and by the embeddable LiaScript chat. In every other context, such a link leads nowhere and the data-agent forms are inert, which is why the examples above are not rendered as links.

    {{2}}

Note: This protocol is experimental, its parameters and behavior might still change.

Images 💫

                      --{{0}}--

Images are defined similar to links, but they are indicated with a starting exclamation mark.

                      --{{1}}--

The name of the link or the alt-text is not wasted, since it is not displayed anymore. Instead, it is displayed, if the image cannot be loaded for some reasons, and it is used by screen readers to give visually impaired people a hint, of what will be visible on the image. So please, don't leave it empty.

                      --{{2}}--

The URL can be either relative to your Markdown document or it can be absolute, which means it is pointing to an external resource.

                      --{{3}}--

The optional title in LiaScript is not only used as a title attribute, instead it is used as a real sub-title for all media links.

Image-notation: ![{1}{alt-text}]({2}{url} {3}{"optional sub-title"})

                        {{2}}

• relative URL: ![Beautiful Lenna](img/lenna.jpg)

  

• absolute URL: ![Annunciation of ...](https://upload.wiki...jpg)

  

                      --{{4}}--
  

Note, that LiaScript is smart enough to scale your images to the optimal size. If your image is smaller than the current maximal applicable width, it is shown in full size. If it is larger, than it is scaled to fit in width and also in height. You can further click on all images to open them as modal and if the image is quite large, such as Leonardo's painting, then you can also zoom and inspect it, by hovering with the mouse or thumb.

                     --{{5}}--

Additionally, if you start a paragraph with an image, LiaScript expects it to be a floating object, which is depicted with a maximal size of 50% of your view-port, if it is not smaller than that.

                       {{5}}

![Beautiful Lenna](img/lenna.jpg "subtitles are allowed too")
Lorem ipsum dolor sit amet, consectetur adipisicing elit, ...

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

Galleries 💫

                      --{{0}}--

How would you interpret a paragraph full of images? We thought that the only reasonable depiction of this could be a gallery.

![img1](url) ![img2](url) ![img3](url)
![img4](url)
![img5](url)

                      --{{1}}--

And we like this idea... You can click on every image and inspect it also with the zooming feature.

                        {{1}}

Audio 💫

                      --{{0}}--

If an exclamation mark indicates visual content, why not using a question mark to indicate auditive content. (From our perspective it resembles an ear.) Everything is similar to images and the URLs can be either relative or absolute.

• Syntax: ?[a horse](https://www.w3schools.com/html/horse.mp3 "hear a horse")

• Example:

  ?a horse

                      --{{1}}--
  

Additionally, you can also directly reference music from the SoundCloud website or from Music.YouTube. The associated song will be automatically embedded for you.

                        {{1}}

• Syntax: ?[soundcloud](https://soundcloud.com/glennmorrison/beethoven-moonlight-sonata)

• Example:

  ?soundcloud

Movies 💫

                      --{{0}}--

Images are marked with a starting exclamation mark before the link, audio by a starting question mark and movies are made of images and sound, that is why you combine both marks !?. Defining resources this way shows at least the links correctly in other Markdown parsers or on GitHub. There is baked-in support for YouTube, Vimeo, PeerTube, DailyMotion and TeacherTube, which means that you only have to include the link and the resource will be embedded appropriately.

Movie-notation: !?[alt-text](movie-url)

• YouTube: !?[The Future of Programming](https://www.youtube.com/watch?v=8pTEmbeENF4)

  !?The Future of Programming

• relative path: !?[Something about math](vid/math.mp4)

  !?Something about math

• List of supported Video Platforms

  • DailyMotion
  • PeerTube
  • TeacherTube
  • Video TU-Freiberg
  • Vimeo
  • YouTube

                      --{{1}}--
  

If you required more control over your video, such as autoplay, muted, start-time, and probably also size and colors, the you can also apply custom styling rules, then you should take a look at the following section:

                        {{1}}

Customizing-Multimedia

So what is left?? 💫

                      --{{0}}--

If it is something else that you want to embed something else from another website, then you should try out the link syntax with two starting question marks. This means, LiaScript will try to use the oEmbed service, which is offered by a couple of websites. If this succeeds, this will embed only a specific part. If it fails, then LiaScript will at least try to embed the website via an iframe.

Examples:

• SketchFab: ??[3D triceratops](https://sketchfab.com/3d-models/animated-triceratops-skeleton-06cb55f941d94dc8b95ac46f92d89e7c)

  ??3D triceratops

• StoryMaps: ??[presentation](https://storymaps.arcgis.com/stories/d550dc4997e94b18a829fd68dba26602)

  ??presentation

• CircuitJS: ??[Simulation: Non-inverting Amplifier](https://www.falstad.com/circuit/circuitjs.html?startCircuit=amp-noninvert.txt)

  ??Simulation: Non-inverting Amplifier

• Phet: ??[Phet Simulation: Molecule Polarity](https://phet.colorado.edu/sims/html/molecule-polarity/latest/molecule-polarity_all.html)

  ??Phet Simulation: Molecule Polarity

Galleries #2 💫

                      --{{0}}--

What you have seen previously with images is also possible with any kind of multimedia link. Simply put everything into one paragraph and LiaScript will automatically generate a gallery for you:

![img](url) ?[audio](url) !?[movie](url)
??[something else](url)
??[something else](url)

?a horse !?Fun with Tables ??VTK VolumeContour ??Circuit simulation ??Bust of Nefertiti

Markdown-Blocks

                      --{{0}}--

So far we had introduced Markdown only on a tiny level, which means, by now you should know how to emphasize words and phrases within a paragraph, how to add images and how you can use references to point to internal or external resources. But, all we did so far is to work with paragraphs. But as pointed out in the quote below, Markdown can do even more.

... Markdown’s syntax is comprised entirely of punctuation characters, which punctuation characters have been carefully chosen so as to look like what they mean. E.g., asterisks around a word actually look like *emphasis*. Markdown lists look like, well, lists. Even blockquotes look like quoted passages of text, assuming you’ve ever used email.

-- Markdown philosophy by John Gruber

                      --{{1}}--

Within the following part we will learn how to deal with Markdown blocks and how to format your content to define the following elements:

   {{1}}

1. Lists
2. Blockquotes
3. Tables
4. HTML
5. Code-Snippets
6. Horizontal rules

Lists

                      --{{0}}--

The GitHub-flavored Markdown supports two types of lists, ordered and unordered ones, and so does LiaScript. If you every used a typewriter then the following syntax for lists would look natural to you. The only thing that matters here is the correct indentation.

Use spaces for correct indentation! Tabs are allowed too, but might be confusing, since editors tend to use varying lengths from 2 to 4 spaces to display them...

Unordered Lists

                      --{{0}}--

To define an unordered list, starting asterisks *, pluses +, and dashes - can be used and mixed. If one point has more than one line, you can also use multiple lines to define paragraphs. All other Markdown elements, you will get to know, can be included in the same way.

Markdown-Syntax:

* alpha
+ **beta**
- gamma
  and delta

  new Paragraph

  - and another
  - important list

- epsilon

                      --{{1}}--

As you can see from the result, you can apply all Markdown styling elements freely. The starting characters will be interpreted equally, thus it makes no difference, if you use asterisks, pluses and dashes. To improve the readability of your document, we would recommend to stick with one format for every level. Starting with asterisks on the first level and dashes within the second level, etc.

                        {{1}}

Result:

• alpha

• beta

• gamma and delta

  new Paragraph

  • and another
  • important list

• epsilon

                       {{2}}

[!NOTE] Since LiaScript version 1.0, the following syntax is also supported and is easier for AI tools to generate correctly.

The interpreter can distinguish between a continuation of the current list item and a nested sublist. In earlier versions, the structure had to be indicated more explicitly.

Although both forms are valid, adding a blank line before a nested list makes the document easier to read and clearly communicates that a new sublist begins.

* This belongs to a single list item
  - and is interpreted as a continuation introduced by a dash.

---

* This is a separate list item.

  - This is a nested sublist.

• This belongs to a single list item

  • and is interpreted as a continuation introduced by a dash.

---

• This is a separate list item.

  • This is a nested sublist.

Ordered Lists 💫

                  --{{0}}--

Ordered lists are created by placing a number followed by a period in front of each item. In LiaScript, the numbers you specify are preserved and therefore become part of the list's structure. This differs from standard Markdown and GitHub Flavored Markdown, which usually ignore the numbers written in the source and automatically number each list starting from 1. Because LiaScript preserves the explicit numbering, you can interrupt a list with additional content, continue it later, or use animations to show and hide individual parts without losing the intended numbering.

Markdown syntax:

0. alpha
1. **beta**

Something else ...

3. *gamma*
   * delta
   * and epsilon
2. probably zeta

Result:

1. alpha
2. beta

Something else ...

1. gamma

   • delta
   • and epsilon

2. probably zeta

   {{1}}

--{{1}}--

<!-- type="a" -->
1. one
2. two
12. twelve
99. risk

{{2}}

<!-- style="list-style-type: lower-greek" -->
1. alpha
2. beta
3. gamma

decimal
decimal-leading-zero
lower-alpha
upper-alpha
lower-roman
upper-roman
lower-greek

Blockquotes

                      --{{0}}--

If you, from time to time, reply to emails, than the following notation will look quite familiar to you. To make use of quoted text, simply start a line with a > greater than character.

Markdown-Syntax:

> This was said some time ago ...
>
>> This was said even longer ago,
> > I guess ...
>
> * aleph
> * beth

                      --{{1}}--

As you can see from the example, all Markdown elements can be used within a blockquote and vice versa. Everything you have learned so far can be easily combined, it could also be a gallery or an embedded object...

                        {{1}}

Result:

This was said some time ago ...

This was said even longer ago, I guess ...

• aleph
• beth

Alerts

                      --{{0}}--

Many Markdown readers — including GitHub and LiaScript — support a special alert syntax built on top of blockquotes. An alert is simply a blockquote whose first line contains a keyword in square brackets, prefixed with an exclamation mark. Five types are defined by the GitHub flavored Markdown specification, each carrying a different semantic meaning and visual style.

Syntax:

> [!NOTE]
> Highlights information that users should take into account, even when skimming.

> [!TIP]
> Optional information to help a user be more successful.

> [!IMPORTANT]
> Crucial information necessary for users to succeed.

> [!WARNING]
> Critical content demanding immediate user attention due to potential risks.

> Nesting is of course also possible:
>
>> [!CAUTION]
>> Negative potential consequences of an action.
>>
>> - due to
>> - some reasons

{{1}}

                      --{{1}}--

                        {{2}}

                      --{{2}}--

> [!NOTE] 📝 Keep this in mind
> Both GitHub and GitLab will render this, though the visual style differs
> between platforms.

> [!TIP] 💡 Pro tip
> Use custom titles to give your alerts more context at a glance.

> [!IMPORTANT] ❗ Don't skip this
> Custom titles replace the default icon with whatever emoji you choose.

> [!WARNING] ⚠️ Proceed with caution
> This action cannot be undone once confirmed.

> [!CAUTION] 🔥 Danger zone
> Misusing this feature may lead to data loss.

                  {{3}}

                   --{{3}}--

Citations 💫

                      --{{0}}--

Blockquotes are often used for citations, and so do we. You can use the following pattern to mark a blockquote as a citation. Simply use two paragraphs within a blockquote and start the second one with two dashes --.

LiaScript-Syntax:

> “Live as if you were to die tomorrow.
> Learn as if you were to live forever.”
>
> -- Mahatma Gandhi

                      --{{1}}--

The resulting blockquote looks slightly different. Furthermore, the paragraph followed by dashes is put into and HTML cite-tag.

         {{1}}

“Live as if you were to die tomorrow. Learn as if you were to live forever.”

-- Mahatma Gandhi

                      --{{2}}--

You can use this syntax, with starting dashes, everywhere within a LiaScript document and your corresponding paragraph it will be rendered within a cite-tag. But, at this time it will only affect the representation of blockquotes. We are not sure yet, how this can also be applied to images, tables, lists, etc.

         {{2}}

lorem ipsum ....

-- Some more citations

Tables

                      --{{0}}--

Tables, as we hope, are easy to interpret and to create. Simply use horizontal rules to separate cells. The header is always defined by the first line, while the second line is used to separate the table header from the body visually and to define the column alignment.

Markdown-format:

| Tables               |      Are      |  Cool |
| -------------------- |:-------------:| -----:|
| *** columns 3 is *** | right-aligned | $1600 |
| ** column 2 is **    |   centered    |   $12 |
| * zebra stripes *    |   are neat    |    $1 |

                      --{{1}}--

As you can see in the result, you can sort tables, by clicking onto the icon that appears on the right of every header cell. A table will then be either sorted ascending, descending, or not sorted, which means your initial row order will be restored.

                        {{1}}

Result:

                      --{{2}}--

The position of the colon defines whether a column should be centered, aligned to the left or to the right. By default, if you do not use colons, all columns are aligned to the left.

      {{2}}

• centered --> :---:
• right --> ---:
• left --> :--- or --- (default)

Tables <--> Data (Demo) 💫

                      --{{0}}--

But why stopping here? A table, in many cases, is just a representation of a dataset. If so, why not simply visualizing it accordingly and plot a graph, display a chart or a map, or whatever fits the most for your data. At the moment we apply simple rules to identify the nature of your dataset and thus choose a visual representation.

For more details have a look at section Fun With Tables, which provides and extensive overview onto all supported representation schemes.

                      --{{1}}--

The easiest and probably most obvious representation of a simple plot, would be the following. A header with some names and columns that contain numbers. The first column is interpreted as the main column and thus defines the x values, the rest is up to you. A cell is then only associated with a number, if the first "word", sequence of characters separated by a space, can be parsed as a number. The 0km within this example gets ignored. So if you want certain values to be ignored, simply attach something directly to the number, or add a character in front of it.

      {{1}}

| x's |  some y's  |                  dist |
| --- |:----------:| ---------------------:|
| 1   |    1 \$    |                 16 km |
| 2.2 |    2 \$    |                 12 km |
| 3.3 |    5 \$    |                  1 km |
| 4   | -12.333 \$ | 0km _will be ignored_ |

                      --{{2}}--

LiaScript identifies this pattern and automatically adds a button above the table, which allows to switch between the table and the "line chart" representation. You can modify the chart interactively and even download the resulting image.

      {{2}}

                        --{{3}}--

A function cannot possess different y-values for one x-value, thus, if you have two or more equal x-values, the resulting plot will be a scatter plot.

       {{3}}

| x's |  some y's  |  dist |
| --- |:----------:| -----:|
| 1   |    1 \$    | 16 km |
| 2.2 |    2 \$    | 12 km |
| 3.3 |    5 \$    |  1 km |
| 4   | -12.333 \$ | -5 km |
| 4   |            |     1 |

       {{3}}

                               --{{4}}--

Last but not least bar-charts. If the first column contains at least one cell, that cannot be parsed as a number while the others do have, then this table gets interpreted as a bar-chart. The first column thus defines your set of groups. It is now also possible to sort your table according to different columns, and to see this ordering also within the bar-chart representation.

                           {{4}}

| Animal          | weight in kg | Lifespan years | Mitogen |
| --------------- | ------------:| --------------:| -------:|
| Mouse           |        0.028 |             02 |      95 |
| Flying squirrel |        0.085 |             15 |      50 |
| Brown bat       |        0.020 |             30 |      10 |
| Sheep           |           90 |             12 |      95 |
| Human           |           68 |             70 |      10 |

                           {{4}}

                      --{{5}}--

As mentioned earlier, this is only a brief introduction into this topic. So check out section Fun With Tables for a complete overview.

Editing

                      --{{0}}--

Editing tables might seem tedious, but actually it is not. There is a huge number of plugins for different editors that you can use, which do the formatting for you. You can use them to quickly navigate through your cells, and some even allow sorting.

Editors: Plugins

• Atom: markdown-table-editor
• VS-Code: Markdown Table
• Obsidian: Advanced Tables

HTML

                      --{{0}}--

You can also use plain HTML in your Markdown, if you miss something. It will mostly work pretty good, but it should be used with caution, since some interpreters apply different rules. Some interpret everything within an HTML tag as HTML, while others allow mixing. Thus, HTML can contain Markdown, which contains HTML, which contains... By the way, LiaScript allows mixing. Thus, keep in mind that newlines and indentation are still relevant.

Markdown-Syntax:

<div style="color: green">

Test <q>**bold**</q> and <b>HTML bold</b> works also inline

![Beautiful Lenna](img/lenna.jpg "Image of Lenna with a hat")

</div>

                      --{{1}}--

The result shows how the inline-CSS is applied to all nested Markdown elements. However, if you want to apply some styling to your document, LiaScript supports another minimal invasive way of doing that. We will describe this in detail in section Styling.

                        {{1}}

Result:

See the following list for an complete overview onto all HTML elements:

HTML Element Reference

                      --{{2}}--

If you use custom HTML instead of Markdown, then no styling will be applied. You can of course create more complex content or tables, this way you can apply your own styling to all elements.

                        {{2}}

CSS-Reference

                      --{{3}}--

If you want to, you can also copy the generated LiaScript structure and use our classes. Most Browsers include an inspector, which can be used to interactively inspect the entire DOM-tree.

                        {{3}}

Open Inspector: Ctrl+Shift+i or Ctrl+Shift+k

                        {{3}}

!?Inspecting the DOM

                      --{{4}}--

But, you can also import your own styles within the main document comment by using the link definition. We will explain this in more details within the macro section link.

                        {{4}}

<!--
...
link: file.css
...
-->

# Main Title

Details & Summary

                      --{{0}}--

The details and summary tags are standard HTML tags and GitHub also supports their usage with Markdown. These tags offer a neat way to define something what is nowadays called accordion. Thus, your user can click on the summary text to make the body of the details-tag appear.

Syntax:

<details>

<summary>**Honest Textbook ads (click to enlarge)**</summary>

!?[If High School and College Textbooks Were Honest - Honest Ads](https://www.youtube.com/watch?v=lhSjYT7pWkw)

</details>

Result:

<lia-keep> 💫

                      --{{0}}--

If you want to embed more complex HTML, and only HTML, without taking care about indentation and formatting, then should use the lia-keep tag to surround your code.

<lia-keep>
  <style>
    table, th, td {
      border: 1px solid black;
      width: 250px; height: 40px;
      text-align: center;
    }
  </style>

  <table style="margin: 1em">
    <tr>
      <th>**Header 1**</th>
      <th>**Header 2**</th>
    </tr>
    <tr>
      <td>Cell 1</td>
      <td rowspan="2">Cell 2</td>
    </tr>
    <tr>
      <td>Cell 3</td>
    </tr>
  </table>
</lia-keep>

                      --{{1}}--

As it is demonstrated in the result, everything within this tag will be treated as HTML only, no Markdown parsing will be applied and indentation will be checked.

                        {{1}}

Result:

                      --{{2}}--

This way, you could for example also import even more complex HTML-tables, pictures with multiple sources for different screen-sizes, and more. With great power comes great responsibility. Thus, you will also be responsible for your styling.

Code

                      --{{0}}--

In Markdown, you can use a sequence of at least three subsequent backticks ``` to indicate a code-block that should not be treated as Markdown, but instead contains some kind of code for which syntax-highlighting should be used, if possible. The first word after the backticks is used as an indicator, for which kind of syntax-highlighting should be applied.

``` python
import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print(i)
```

                      --{{1}}--

In case you are wondering, how to embed a code-block into a code-block with backticks? Three backticks are the minimum, thus you can surround your Markdown code-block example with a sequence of 4 or more backticks. If you start with four backticks, LiaScript will parse everything as code until it reaches a matching number of backticks.

    {{1}}

import time
# Quick, count to ten!
for i in range(10):
  # (but not *too* quick)
  time.sleep(0.5)
  print(i)

                      --{{2}}--

However, we are still in the Markdown world with static code visualization. LiaScript has also support for interactive programming, thus all of your code-snippet can be made executable and editable. This will be described in more detail in section Interactive Coding.

Differences to Markdown 💫

                      --{{0}}--

Markdown also supports adding code by using tilde ~ characters instead of backticks. This is at the moment not supported by LiaScript, but might be added in the future.

~~~ javascript
var a = "b"
~~~

                      --{{1}}--

Additionally, it is also possible in standard Markdown to use indentation with at least 4 spaces to mark a block or a line as code. In LiaScript this is treated differently. You can use indentation to keep your document readable. The two indicators for text-to-speech in the example are treated equally by LiaScript, but another Markdown interpreter will interpret the second example as a single paragraph, while the indicator in the first example will be treated as code, and thus be easier to read with any other Markdown interpreter (including the representation on GitHub).

                        {{1}}

This is not code ...

    Any kind of text with a 4 space
    indentation will be treated as code
    in Markdown ...

                --{{1}}--
This text will be spoken out loud in LiaScript.

--{{2}}--
This text will be spoken out loud too.

Projects 💫

                      --{{0}}--

If you want to bundle a couple of code-blocks into something that mirrors a project, you can achieve this with the following syntax. All code-blocks are simply attached to each other, in order to indicate a grouping. If you separate them at least by one newline, they will be treated separately. This will be pretty neat, if we introduce the concept of interactive code-blocks.

``` js     -EvalScript.js
let who = data.first_name + " " + data.last_name;

if(data.online) {
  who + " is online"; }
else {
  who + " is NOT online"; }
```
``` json    +Data.json
{
  "first_name" :  "Sammy",
  "last_name"  :  "Shark",
  "online"     :  true
}
```

                      --{{1}}--

You can define optional names within the head of your code-block. The starting plus + and minus - symbols are used to indicate, if the resulting code-blocks should be visible or hidden. However, you can change this, by clicking onto the resulting title-bar to either maximize or minimize the code-block.

                        {{1}}

let who = data.first_name + " " + data.last_name;

if(data.online) {
  who + " is online"; }
else {
  who + " is NOT online"; }

{
  "first_name" :  "Sammy",
  "last_name"  :  "Shark",
  "online"     :  true
}

                      --{{2}}--

If you do not add a plus or a minus as a prefix to your file, the plus is used as default.

Supported Languages 💫

                      --{{0}}--

In most cases you can simply add the name of the language or the common filename ending into the head of a code snippet. Most Markdown interpreters will use highlight.js for language rendering, since we require also an editor with syntax highlighting capabilities, we use ace. Thus, the language support might differ to other systems. We therefore apply a mapping, so that you can still use all highlight.js short-codes but also those of ace.

Overview: https://github.com/LiaScript/docs/blob/master/Code.md

JavaScript 💫

                             --{{0}}--

In contrast to common Markdown parsers or viewers, LiaScript allows you to include and execute JavaScript code. When combined with HTML elements, you are free to integrate whatever functionality you desire.

                             --{{1}}--

The last statement of your script also defines the result that will be shown, but only if it is not undefined. You can also use console.log to log the script activities. As the examples below show, you can combine your scripts with LiaScript animations, so they will only be executed in the right fragment/context. However, you can do much more with scripts.

                              {{1}}

Checkout Section JavaScript for more information!

Do some internal calculation <script> 99 * 88  </script>, the next script
contains an error <script> 99 * a </script>.

                                  {{2}}
<script>
    // Initialize a Line chart in the container with the ID chart
    new Chartist.Line('#chart', {
        labels: [1, 2, 3, 4],
        series: [[100, 120, 180, 200]]
    });

    console.debug("loaded #chart") // or undefined
</script>
<div class="ct-chart ct-golden-section" id="chart"></div>

Do some internal calculation , the next script contains an error: .

                            {{2-3}}

                            {{3}}

--{{4}}--

When discussing events, whether past, present, or future, your course may quickly become outdated. This is where scripts, as an initial building block, can shine. Using basic datetime calculations ensures precise determination of when events have occurred or will occur. Rather than relying solely on your calculations, users have the opportunity to inspect and validate your code by double-clicking on the highlighted script result. Even more, it is possible to modify the code, enabling them to double-check your findings and experiment with the results.

  {{4}}

Russia started its invasion of Ukraine
<script format="relativetime" unit="day">
// Define the start date of the invasion
const invasionStartDate = new Date('2022-02-24');

// Get the current date
const currentDate = new Date();

// Calculate the difference in milliseconds
const differenceInMs = currentDate - invasionStartDate;

// Convert milliseconds to days
const differenceInDays = differenceInMs / (1000 * 60 * 60 * 24);

// Calculate the number of full days
const daysSinceInvasion = Math.floor(differenceInDays);

-daysSinceInvasion
</script>.

  {{4}}

Russia started its invasion of Ukraine

 --{{5}}--

We combined scripts with the Internationalization API, which enables appropriate formatting of outputs. The days output is not hardcoded in our code. If we change the locale to another language, such as in the following example, the result will be optimized for the Russian language. Furthermore, by using the embedded Google Translator functions, the locale will be automatically set according to the selected language.

 {{5}}

Россия начала вторжение в Украину
<script format="relativetime" unit="day" locale="ru">
// Define the start date of the invasion
const invasionStartDate = new Date('2022-02-24');
...

--{{6}}--

Now, imagine that instead of performing simple calculations, a script could access any kind of real-world data and output it as either HTML or LiaScript. What's more, picture scripts being directly combined with input fields, and a change in one script triggering the execution of another. All of this is possible in LiaScript. We have re-imagined the usage of scripts as interactive powerhouses, and we will delve into the details in chapter JavaScript or JS-Components.

  {{6}}

longitude: <script default="13.33125" input="range" aria-label="longitude" output="longitude">@input</script>

latitude: <script default="50.92558" input="range" aria-label="latitude" output="latitude">@input</script>

<script run-once="true" style="display: block">
  fetch("https://api.open-meteo.com/v1/forecast?latitude=@input(`latitude`)&longitude=@input(`longitude`)&hourly=temperature_2m")
    .then(response => response.json())
    .then(data => {
      let table = "<!-- data-show data-type='line' data-title='Open-Meteo Weather API' -->\n"

      table += "| Time | Temperature |\n"
      table += "| ---- | ----------- |\n"

      for (let i=0; i < data.hourly.time.length; i++) {
        table += "| " + data.hourly.time[i] + " | " + data.hourly.temperature_2m[i] + " |\n"
      }
      send.lia("LIASCRIPT: "+table) }
    )
    .catch(e => {
      send.lia("ups, something went wrong")
    })
  "waiting for the weather"
</script>

Horizontal rules 💫

                      --{{0}}--

At the moment it is possible to insert horizontal rules by adding lines with at least 3 dashes, longer sequences of dashes are allowed too. Common Markdown also allows to define such rules with asterisks *, but this is used in LiaScript to group blocks, as we will described later...

Markdown-Syntax:

some paragraph

---

something else

----------------

Result:

some paragraph

something else

Custom Styling

             <!-- style="color: red" -->
                      --{{0}}--

In order to support a nearly equal experience for all Markdown interpreters you should stick with the basic Markdown notation or use simple HTML-tags as much as possible, for example if you want to change the color of a sentence or a word.

                      --{{1}}--

However, LiaScript allows you also to inject attributes into all Markdown blocks and inline elements by attaching an HTML-comment to that specific object. If the content of this HTML-comment can be parsed as HTML-attributes, then these settings will be applied to the element attached.

                       {{1-2}}

<!--
style="color: red;" id = "elementID" class="foo bar"
-->

                        {{2}}

Further resources:

                     --{{2}}--

The following resources will give you a full overview onto the most common HTML attributes and onto styling elements. It might be pretty overwhelming at first glance, what is possible, but you will see, that with some basic elements you can already achieve a lot. And when it comes to HTML and styling, you can find examples for pretty much everything on your preferred search-engine, e.g. ecosia.

• HTML attributes:

  Checkout the following link to get a full overview onto all HTML attributes, which you can also apply in LiaScript: w3schools: HTML Attribute Reference

• Styling with CSS:

  In most cases inline-styling will be applied, the following website covers all CSS-Syntax elements, which then can be used simply by attaching comments in the following way:

  <!-- style="color: red; font-size: 20px;" -->

  w3schools CSS-Tutorial

  !?Basic Inline Styling - CSS

Block-Styling

                        --{{0}}--

So what is actually a block in LiaScript or Markdown? Basically it is everything that is separated by a newline, such as a paragraph, a table, a code-block or a list. But it can also be a block of multiple blocks, such as a list, which may consist of different bullet points, where every bullet point can be a list of multiple blocks by itself.

• Blocks:

  • tables
  • paragraphs
  • lists (ordered/unordered)
  • blockquotes
  • horizontal rules
  • HTML-blocks (if standing alone)

• LiaScript-Extensions:

  • comments

  • citations

  • effects

  • quizzes

  • surveys

  • tables

  • ASCII-Art & Charts

  • executable code-blocks and projects

                      --{{1}}--
    

Settings for entire blocks can be set with a starting comment that includes all required HTML-attributes and can even contain animation settings. This can also be used to highlight specific elements of your slides.

                        {{1}}

LiaScript-Syntax:

<!-- class = "animated rollIn" style = "animation-delay: 3s; color: purple" -->
The whole text-block should appear in purple color and with a wobbling effect.
Which is a **bad** example, please use it with caution ...

Result: (be patient)

The whole text-block should appear in purple color and with a wobbling effect. Which is a bad example, please use it with caution ...

                      --{{2}}--

Additionally, this method can be used to overwrite some aspects of all Markdown element. The example shows how you can change the background color for a certain element. This comes quite handy, if you want to emphasize further some parts of your document.

                        {{2}}

<!-- style="background-color: tomato;"-->
> **Warning**
>
> You have to be aware, that this does not affect the
> font-color (dark/light mode). Try to use  pastel
> colors, or overwrite the color manually with:
>
> `color: white;`

Warning

You have to be aware, that this does not affect the font-color (dark/light mode). Try to use pastel colors, or overwrite the color manually with:

color: white;

                      --{{3}}--

The following example depicts the interconnection of nested block-elements. For the entire table and also for all other blocks, it is possible to set the properties for width, font-color and font size, which will be applied onto every cell. And every cell can overwrite these values simply by adding a style-comment as the first element. These settings are even preserved, if you reorder the table.

                        {{3}}

               <!-- style="width: 50%; min-width: 400px; color: red; font-size:20px" -->
| <!-- style="background: azure"--> Header 1 | <!-- style="background: brown"--> Header 2        |
|:------------------------------------------ |:------------------------------------------------- |
| <!-- style="background: coral"--> Item 1   | <!-- style="background: rgb(12,12,111)"--> Item 2 |
| <!-- style="background: cyan" --> Item 3   | <!-- style="background: #b88608"--> Item 4        |

Result

            <!-- style="width: 50%; min-width: 400px; color: red; font-size:20px" -->

                      --{{4}}--

There are some special (internal) formats for changing the appearance of code-blocks and how to deal with tables. These topics will be handled separately.

Inline-Styling

                      --{{0}}--

So what are inline elements? These are basically all the tiny parts, such as single words, bold-text, links, inline-code, but also images and videos. In contrast to blocks where you attach the comment to front, inline elements can be modified by attaching a comment to the end. That's it ...

LiaScript-Syntax:

This **is an important**<!-- style="color: red" --> part
of the text<!-- style="color: green; font-size: 10rem;" -->.


![image](...Creative-Tail-Animal-lion.svg)<!--
style = "width: 300px;
         border: 10px solid;"
class = "animated infinite bounce"
-->

Some blurry and black-and-white video:

!?[movie](https://www.youtube.com/watch?v=8pTEmbeENF4)<!--
style = "filter: blur(2px); grayscale(80%);"
-->

                      --{{1}}--

As you can see from the results, the entire bold text is treated as one block, whereby in the second case only the single word "text" gets modified.

                        {{1}}

Result:

This is an important part of the text.

Some blurry and black-and-white video:

!?movie

                      --{{2}}--

CSS is a pretty powerful tool and by using HTML-comments to tweak your Markdown, you can still read the document with any ordinary Markdown interpreter that simply ignores these comments.

Images and Styling

                      --{{0}}--

Styling images might happen quite often. However, you have to be aware of the fact, that the modal view functionality is only possible if LiaScript is in total control of the image. Thus, it will handle the optimal scaling for you and adds a click-event to switch to the modal view.

![The Wave](...ave_off_Kanagawa_%28Kanagawa_oki_nami.jpg "without attribute injection")

![Workplace](https://www.w3schools.com/htmL/workplace.jpg "with attribute are added")<!-- usemap="#workmap" -->

<map name="workmap">
  <area shape="rect" coords="34,44,270,350" title="Computer" onclick="alert('You clicked the Computer')" >
  <area shape="rect" coords="290,172,333,250" title="Phone" href="#12">
  <area shape="circle" coords="337,300,44" title="Cup of coffee" href="#Projects">
</map>

                      --{{1}}--

Thus, if you click onto the first image, you will be able to inspect it in more detail. If you click onto the second image, then a map associated with this image is in charge of it, which handles click-events differently.

                        {{1}}

Result

-- The example for the map was taken from w3schools.

What else can you do

                     --{{0}}--

The following examples present some useful application of combining attribute injection into LiaScript components.

Hiding Content

                      --{{0}}--

There might be use cases where you either want to show some parts only on GitHub and provide and alternative view at LiaScript. As it was shortly introduced in the sections before, you can add comments to the start of every block to add additional attributes. These attributes can also be used as a trigger to hide or show content.

<!-- style="display:block" -->
<div style="display:none">

Visible only in LiaScript, but not on GitHub.

</div>

-----------------------------------------------

<!-- style="display:none" -->
<div style="display:block" id="fooBar">

Not visible in LiaScript, but on GitHub!

</div>

                      --{{1}}--

The attributes within the comment will overwrite the attributes within the block. Thus, if there would be more stuff within style, this will be overwritten too, but other attributes like id that are not contained within the comment won't be affected...

Customizing Multimedia

                      --{{0}}--

As you have seen previously sizing videos and applying CSS filters is easy. However, there might also be the case that you want to start a video from some special point or to play it automatically, when it appears.

                      --{{1}}--

If the video is yours, then you can use the following attributes autoplay and muted to control the behavior and the additional fragment #t=4,12 attached to the URL of the video, will tell the browser where to start and where to stop the video. The stop-parameter should be optional.

                        {{1}}

!?[Something about math](vid/math.mp4#t=4,12)<!--
autoplay="true"
muted="true"
-->

                      --{{2}}--

The resulting video starts immediately at second 4 and stops at second 10, and of course it will be muted.

             {{2}}

!?Something about math

Platform Diversity

                      --{{0}}--

However, if you are referencing other resource on platforms such as YouTube, Vimeo, DailyMotion, PeerTube or TeacherTube you can achieve something similar, but in a slightly different way. These settings have to be added to the URL of your resource and different platforms might have different capabilities.

                      --{{1}}--

In most cases, you can use something like &autoplay=1, &muted=true or &mute=false as it is depicted below:

                        {{1}}

!?[Multimedia](url/...?autoplay=1&mute=1&start=1895&end=1905)

                      --{{2}}--

But, different platforms support different functionalities. Here is a link list of the different possible settings. For PeerTube and TeacherTube we could not find any settings so far.

                        {{2}}

URL Parameters:

• DailyMotion
• Vimeo
• YouTube
• PeerTube
• TeacherTube

Ignoreable Comments

                      --{{0}}--

As you have seen in the previous examples, you can use HTML comments to define certain settings within your course or to change the styling of elements.

                      --{{1}}--

However, since it is pretty difficult to separate ordinary comments from comments with HTML-parameters within, we have now added a special comment type, which is defined by at least three dashes.

{{1}}

<!---
  This is a comment, which will be ignored by the parser.
  It will not be rendered in the final document.
  It is only visible in the source code.
--->

                      --{{2}}--

At least means, that you can use more than three dashes...

{{2}}

<!---------------------------------------------------------
This style of comment might be visually more appealing ...
---------------------------------------------------------->

                      --{{3}}--

And of course this can be used to comment out content or settings.

{{3}}

<!--- style="color: red" class="to be ignored" --->
Lorem ipsum dolor sit amet, consectetur adipiscing elit.

Math & Formulas

             --{{0}}--

The following will not work on GitHub, but most Markdown-interpreters do support formulas with a LaTeX-like syntax. As it is common in many Markdown dialects, such as in Pandoc-Markdown, you can apply dollar signs to surround a "math"-environment. Everything within the dollar signs belongs to the formula only, there is currently no nesting of other HTML or LiaScript/Markdown allowed.

          --{{1}}--

Use single dollar signs to define an inline formula, which will be treated as an ordinary text element.

                      {{1}}

Inline math-mode $ \frac{a}{\sum{b+i}} $ -> $ \frac{a}{\sum{b+i}} $

         --{{2}}--

Use double dollar signs to indicate a formula-block. This way you can also use multiple lines to define a formula or a set of formulas that will furthermore be displayed larger.

                      {{2}}

                       --{{3}}--

Currently, we apply the KaTeX library for typesetting. If you are already familiar with LaTeX or MathJAX, as another alternative library, then you can start immediately to define formulas. If not, then check out some of the following resources.

     {{3}}

• via KaTeX: http://katex.org

• Supported functions:

  https://katex.org/docs/supported.html

• Alphabetically sorted features:

  https://katex.org/docs/support_table.html

• Detexify: get the appropriate command by drawing symbols

  http://detexify.kirelabs.org/classify.html

             --{{4}}--
  

Sometimes it might be tedious to find the right, command for the intended symbol, if you can draw it, then you should give detexify a try.

Formula Playground

                      --{{0}}--

Alignment is a typical use case for formulas. The code below, shows how this can be achieved by using ampersands, which are used as an anchor for the center of a formula.

\begin{split}
  a &=b+c \\
    &=e+f \\
    &=g+h+i+j\\
a+b+&c+d=12\\
\end{split}

@runFormula

                      --{{1}}--

If you want to number your formulas, we recommend using the \tag command to add or overwrite the reference number. Automatic numbering does not work well at the moment, since the formulas are rendered within a web component, and it does conflict with the LiaScript idea of animation, which we describe in a later part of this series.

  {{1}}

\tag{33}
\begin{equation}
 a =b+c
\end{equation}

@runFormula

                      --{{2}}--

And finally it is possible to add some styling, but with KaTeX-functionalities, this includes some basic styling, with the same inline CSS, as we had described it in section Custom Styling. (Can you spot the strange looking german character Eszett.) And you can mark elements as links with \href and add images with the command \includegraphics.

  {{2}}

\begin{Bmatrix}
   a & b & c & d & e & f \\
   g & h & i & j & k & l \\
   m & n & o & p & q & r \\
   s & t & u & v & w & x \\
   y & z & ä & ö & ü &
   \htmlStyle{color: red; font-size: 26px}{ß}
\end{Bmatrix}
\\
\href{https://katex.org/docs/supported.html#html}{\KaTeX HTML support}
\\
\includegraphics[height=0.8em, totalheight=0.9em, width=0.9em, alt=KA logo]{https://katex.org/img/khan-academy.png}

@runFormula

Formula-Macros

             --{{0}}--

Additionally, you can define custom macros, as it is supported by KaTeX. However, there are currently two options to define macros, which can be either local or global.

   {{1}}

  --{{1}}--

{{2}}

--{{2}}--

<!--
author: ...

formula:  foo   {x^2}
formula:  \bar  {#1^2}

-->

# Main

$ \foo + \foo $

$ \bar{y} + \bar{y} $

{{3}}

--{{3}}--

...

## Subsection
<!--
formula: \foo  {y^3}
-->

$ \bar{\foo} + \bar{\foo} $

{{4}}

--{{4}}--

Chemical Formulas

--{{0}}--

LiaScript now supports rendering chemical formulas using KaTeX! With this update, you can include chemical equations in your slides using the mhchem macros.

--{{1}}--

To display chemical equations, simply wrap your formula using the \ce{...} command. For example:

  {{1}}

$\ce{CO2 + C -> 2 CO}$

--{{2}}--

This will render as:

  {{2}}

$\ce{CO2 + C -> 2 CO}$

  {{3}}

For further details on the syntax and additional features provided by mhchem, please refer to the official mhchem documentation.

Reading Formulas Aloud

--{{0}}--

Formulas are not only rendered, they are also read aloud, the way people speak maths. LiaScript generates a spoken description for every formula, which is used by screen readers, by the narrator comments, and by the playback buttons. It is generated in English or in German, depending on the language of the voice, other languages fall back to English. Decimal marks, fractions, roots, units, matrices, cases, and chemical formulas are covered as well.

--{{1}}--

If you want to define your own text, simply attach an aria-label as an annotation directly to the formula. It replaces the generated description everywhere, for screen readers, as well as for the narrator and the playback buttons. This works for inline and block formulas.

  {{1}}

    {{|>}}
Generated: $\sin(x)$, and with an own text: $\sin(x)$<!-- aria-label="to sine or not to sine" -->

    {{|>}}
$$\int_0^\pi \sin(x)\,dx = 2$$<!-- aria-label="the area below one arc of the sine is two" -->

{{|>}}

{{|>}}

Footnotes

                        --{{0}}--

Before moving on to the LiaScript specific features, such as quizzes, surveys, animations, ASCII-art, etc., we would like present a last feature that is common to many Markdown dialects and these are footnotes. So, what are footnotes in general and when to use them.

                        {{0-1}}

{{|> UK English Male}}

Footnotes are notes at the foot of the page while endnotes are collected under a separate heading at the end of a chapter, volume, or entire work. Unlike footnotes, endnotes have the advantage of not affecting the layout of the main text, but may cause inconvenience to readers who have to move back and forth between the main text and the endnotes.

-- Wikipedia

                      --{{1}}--

In LiaScript a "section", which is defined by a header and a body, resembles a page. Thus, the body might contain a couple of footnote-marks, while the actual footnotes have to be defined at the end of the body. Other Markdown interpreters might define a more "wide-spread" usage of footnotes, but in LiaScript this is not possible at the moment. We parse/interpret only one section at a time and not the entire document. So keep this in mind when using footnotes.

                        {{1}}

### header 3

body

body

body

footnotes

## ...

Standard-Footnotes

                      --{{0}}--

The standard way of creating footnotes is to attach a marker to important elements within your sections. A marker is defined by brackets with a starting ^. Then you can insert numbers, symbols and words.

           <!-- class="translate"-->

Something[^1] important[^2] about[^🦶] notes.

                      --{{1}}--

At the end of your body, you simply add a list with all indented remarks you want to add. This list starts with your markers, that are followed by a colon. Your notes or footnote-bodies can consist of multiple paragraphs and all other block-elements that you have mentioned so far, but they have to be indented with at least 2 spaces.

                        {{1}}
            <!-- class="translate"-->

[^1]: **Something** and **anything** are concepts of existence in ontology,
  contrasting with the concept of nothing. Both are used to describe the
  understanding that what exists is not nothing without needing to address the
  existence of everything. The philosopher, David Lewis, has pointed out that
  these are necessarily vague terms, asserting that "ontological ...

  -- [Wikipedia](https://en.wikipedia.org/wiki/Something_%28concept%29)

[^2]:> It is **important** to mention that anything can be added to a footnote
  > also some piece of code, images, videos, etc.
  >
  > ??[How to Use Footnotes](https://www.youtube.com/watch?v=Gg6vXoHO95I)

[^🦶]: Actually you are not forced to use numbers, you can use any kind of
       symbol or even words too.

       _But, please be concise._

                      --{{2}}--

By clicking onto the footnote, all of your comments will be shown in a modal view in all view-modes. If you are in "textbook" mode, then these footnotes are additionally displayed at the very end of the current "page".

                        {{2}}

Result:

Something[^1] important[^2] about[^🦶] notes.

[^1]: Something and anything are concepts of existence in ontology, contrasting with the concept of nothing. Both are used to describe the understanding that what exists is not nothing without needing to address the existence of everything. The philosopher, David Lewis, has pointed out that these are necessarily vague terms, asserting that "ontological ...

-- Wikipedia

[^2]:> It is important to mention that anything can be added to a footnote

also some piece of code, images, videos, etc.

??How to Use Footnotes

[^🦶]: Actually you are not forced to use numbers, you can use any kind of symbol or even words too.

   _But, please stick to one explicit format._

Inline-Footnotes

                      --{{0}}--

The following idea of defining inline-footnotes was borrowed from LaTeX. If you want to add only some text without further Markdown-syntax then you can add this in parentheses to your footnote-mark. In this case it is not necessary to add a more sophisticated explanation to the end of the sections.

Inline Footnote [^x](__explanation__ in one line) => Inline Footnote[^x](__explanation__ in one line)

State

                      --{{0}}--

Some words about state. The LiaScript runtime-environment preserves the internal state of the following elements, depending on where you execute your courses and depending on the version.

• Tasks

• Quizzes

• Surveys

• Code

• (<script>)

                      --{{1}}--
  

LiaScript currently runs in three different environments. You can either share and read courses via the project website, generate SCORM-packages, which can be uploaded to an LMS, or create self-containing websites.

                        {{1}}

1. LiaScript PWA

                      --{{2}}--
   

   If you share your course via the website, then all the courses and the current course states are preserved within the Browser database IndexedDB locally. All of the states? Well ... the internal state of the previous components is only preserved, if your course has a version greater than or equal to 1.0.0. The default version is 0.0.1, which means that the course is in development mode, and thus the structure of your course might change every time. If a user reloads the course, then all states are cleared.

   • Where: https://LiaScript.github.io/course/
   • Source: liascript/src/typescript/connectors/Browser

2. SCORM 1.2 & 2004, xAPI & H5P

                      --{{3}}--
   

   SCORM stands for Sharable Content Object Reference Model and allows you to store the course state directly within every LMS that has support for SCORM 1.2 or

   1. For this case you have to use our exporter, which translates your course into a "SCORM-compliant" zip-file. You can check if your LMS has support for SCORM, by visiting our LMS-overview.
   • Where: https://github.com/LiaScript/LiaScript-Exporter#scorm12
   • Source: liascript/src/typescript/connectors/SCORM1.2 and SCORM2004
   • Does your LMS support SCORM 1.2: LMS-Overview

   By default, a SCORM package stores only the settings and, depending on the version, the quiz states. If you export it with the option --scorm-storage suspend, the whole learner state (quizzes, surveys, tasks, code, settings, and the last slide) is kept compressed in cmi.suspend_data, even in SCORM 1.2. Additionally, every answer is reported readably to the LMS, such that teachers can check them in the reports of their LMS.

   • Where: https://github.com/LiaScript/LiaScript-Exporter#scorm-learner-data---scorm-storage
   • Source: liascript/src/typescript/connectors/SCORMSuspend

   xAPI packages send all answers and code runs as statements to a Learning Record Store (LRS) and restore them, if a learner opens the course again. H5P packages use the same engine as the suspend mode of SCORM.

   • Where: https://github.com/LiaScript/LiaScript-Exporter#xapi and https://github.com/LiaScript/LiaScript-Exporter#h5p
   • Source: liascript/src/typescript/connectors/XAPI and H5P

3. Base

                      --{{4}}--
   

   You can also use our exporter-tool to create single websites of your course. But, this "base" does only support to store user-settings, such as style, mode, etc. This "base-connector" is also used for the live-server and editors. If you are a developer and want to extend the LiaScript support to store state within your backend, then this is the right place to look at. This module provides an abstract class, to which all stateful data is sent. You can simply inherit from this class and implement the access to your system.

   • Where: https://github.com/LiaScript/LiaScript-Exporter#web

   • Source: liascript/src/typescript/connectors/Base

                      --{{5}}--
     

For more information on versioning and how to use it, check out section version within the macros section. But for now, it is okay to know, that you can adapt, restructure and share your courses freely, if you are in dev-mode. If your course is ready to be launched, use versioning to preserve the state of your users.

Tasks

                      --{{0}}--

Before we show you how to create quizzes, we would like to introduce tasks, which were also a source of inspiration for us, for developing a similar syntax for quizzes and surveys. The GitHub flavored Markdown offers a very intuitive way of creating check-lists or task-lists.

**Which topics did you master so far?**

- [ ] Biology
- [ ] Chemistry
- [ ] Computer Science
- [X] Something about LiaScript

                      --{{1}}--

It is basically a list where the brackets are used to symbolize check-boxes and by using an upper- or lowercase x, it is possible to mark a checkbox as checked. In LiaScript however, it is possible for the user to manipulate these states, and they will be preserved if your document is in version 1 or greater.

                        {{1}}

Which topics did you master so far?

• Biology
• Chemistry
• Computer Science
• Something about LiaScript

                      {{2}}

                    --{{2}}--

**Which topics did you master so far?**

- [ ] __Biology__

      Photosynthesis, cell division, genetics, ... check this box once you feel
      confident, no matter how many details you still mix up.

- [ ] __Chemistry__

      Split into a few sub-goals:

      - [ ] Balancing equations
      - [ ] The periodic table
      - [X] Acids and bases

- [X] __Computer Science__

      ``` js
      console.log("Hello, LiaScript!")
      ```

      Already ticked off, since you are reading this in a LiaScript course ;-)

Tasks and Scripting

                      --{{0}}--

In case you are wondering where the "Script" in LiaScript comes from? We wanted to make documents more interactive, by embedding native support for scripting. Coding will become an essential skill in the future so why not using it to directly extend the native capabilities of static documents and its elements. Scripts can either be executed separately or they can be attached to tasks, quizzes, surveys, and code-snippets.

                      --{{1}}--

The example might look a bit weird for the moment, but it is only meant as a demonstration. You can use scripting in LiaScript, if you want to, but it is not required. Thus, whenever you change the state of the task-list, then the script below gets executed and the @input-macro will be substituted by current input. output="tasks" says, that the result is published under the topic "tasks", thus, every script that contains an @input(\tasks`)` will be executed afterwards as well with the changed input. Task-lists simply produces and array with boolean values.

                        {{1}}

**What do you want to learn today?**

- [X] Biology
- [ ] Chemistry
<script output="tasks">"@input"</script>

<script style="width: 100%">
try {
  let task = @input(`tasks`) // interpret the output="tasks"

  if(task[0]) {
    send.liascript(`## Biology

Hey, great, you want to learn something about Biology.

* resource 1
* resource 2

The input from the tasks above was: [${task}]`)
  } else send.clear()
} catch(e) { }
</script>

                      --{{2}}--

Depending on the input scripts can generate different results, it is even possible to return LiaScript code, which will be analyzed and rendered dynamically. If an empty string or undefined gets returned, then the script will not be visible to the user. We will describe all Lia-Scripting capabilities and features in more detail in a later chapter.

                        {{2}}

What do you want to learn today?

• Biology
• Chemistry

                      --{{3}}--

If we are talking about embedding scripts, that perform some kind of calculation, data analysis, etc. Why shouldn't this be visible to the user as well? We all know what can happen when you cannot get access to primary data and the code that was used to analyze it. In LiaScript you can inspect these highlighted elements with rounded corners, which represent the result of a script, simply by double-clicking or double-tabbing. The user can manipulate them and observe the results, simply by changing the code. If the editor is closed, then the code gets reevaluated.

                        {{3}}

Europe's entire austerity policy after the debt crisis was based on wrong conclusions drawn from incorrect data and false calculations from a single Excel spreadsheet.

https://en.wikipedia.org/wiki/Growth_in_a_Time_of_Debt

                      --{{4}}--

But, this is enough for the moment, let us continue with quizzes...

Quizzes

                      --{{0}}--

Quizzes are an essential element of every online course, which allow students to reflect and test their knowledge. As mentioned before, we used the GitHub-flavored Markdown notation for tasks as an inspiration for quizzes.

                      --{{1}}--

Long story short, everything that is related to quizzes is defined as a combination of brackets with brackets or parentheses.

{{1-2}}

• [[ ]]

• [( )]

                      --{{2}}--
  

LiaScript currently supports 7 different types of quizzes and one, so-called generic type, which can be used to created custom quizzes of any kind.

                        {{2-3}}

1. Multiple-Choice: [[X|x| ]] ...

2. Single-Choice: [(X|x| )] ...

3. Matrix: as a combination of multiple- and single-choice quizzes

4. Text-Quiz: [[solution]]

5. Selection-Quiz: [[ opt. 1 | opt. 2 | (solution opt.) ]]

6. Drag & Drop-Quiz: [->[ opt. 1 | opt. 2 | (solution opt.) ]]

7. Gap-Text everything: Use text-, selection-, and drag & drop-quizzes within Markdown-blocks

8. "Generic": [[!]]

                      --{{3}}--
   

Additionally, it is possible to tweak every quiz with additional features, such as hints, a resolution that is presented if the users solves the quiz by their own or clicks onto the "show solution" button. And finally, as you have seen it with tasks, you can attach scripts to each quiz in order to implement more sophisticated quizzes or simply to log the output.

                        {{3}}

1. Hints: [[?]]
2. Solutions: some arbitrary Markdown content
3. Associated scripts: to be executed, when the user clicks onto the "check"-button

Quiz Types

                      --{{0}}--

Within the following section we will introduce the 7 types of quizzes, which are currently supported by LiaScript. Additionally, you have to know that users cannot fail, by default it is possible to retry a quiz until it is solved, or the user clicks onto the resolve button. The only thing that is counted is the number of trials.

via GIPHY

                      --{{1}}--

If testing knowledge becomes something deeply personal, without any limitation on the number of trials, why should anyone cheat at all. In this sense, LiaScript is meant to be a language for learning and education instead of assessment. But, if you want to, you can also tweak this by using scripts 😉.

1. Multiple-Choice

                       --{{0}}--

A multiple-choice quiz can also be interpreted as a task list with a predefined solution. Thus, the only thing that has to be done, is to surround your "ASCII" checkboxes with additional brackets, which are followed by a line of Markdown/LiaScript.

- [[ ]] Empty means not checked
- [[X]] Uppercase `X` means checked ...
- [[x]] ... and lowercase `x` too ...
- [[ ]] **as defined in the first line** ...

                      --{{1}}--

As you can see from the example it does not matter, whether you use lowercase or uppercase X to mark a checked element.

                        {{1}}

Result:

• [[ ]] Empty means not checked
• [[X]] Uppercase X means checked ...
• [[x]] ... and lowercase x too ...
• [[ ]] as defined in the first line ...

                      --{{2}}--

The starting dashes for quizzes are also optional, you can omit them and GitHub and other Markdown renderer will present a single paragraph. Or, you can also use an indentation of at least 4 spaces, which will be presented by other interpreters as code. However, all the following representations will be interpreted by LiaScript as the same quiz.

                        {{2}}

Without starting dashes (paragraph):

[[ ]] Empty means not checked
[[X]] Uppercase `X` means checked ...
[[x]] ... and lowercase `x` too ...
[[ ]] **as defined in the first line** ...

With indentation of at least 4 spaces (code):

    [[ ]] Empty means not checked
    [[X]] Uppercase `X` means checked ...
    [[x]] ... and lowercase `x` too ...
    [[ ]] **as defined in the first line** ...

1.1 Multiple-Choice Blocks

                      --{{0}}--

Exactly as with tasks, every option of a multiple-choice quiz can also carry an indented block. This comes in handy whenever an option needs more than a single line, for example to let the user compare different snippets of code and decide which of them is written in valid LiaScript syntax.

**Which of the following snippets define a valid multiple-choice quiz?**

- [[X]] Using dashes, this is correct syntax

        ``` markdown
        - [[X]] Yes
        - [[ ]] No
        ```

- [[ ]] Mixing brackets and parentheses

        ``` markdown
        - [[X)] Yes
        - [[ )] No
        ```

- [[X]] Omitting the dashes and indenting the block as code instead

        ``` markdown
            [[X]] Yes
            [[ ]] No
        ```

- [[ ]] Forgetting the outer, double brackets

        ``` markdown
        - (X) Yes
        - ( ) No
        ```

                      --{{1}}--

Each option now consists of a short label, followed by its own indented code-block, exactly the same way as a paragraph or a nested list would be attached to a task. Just keep in mind that the marker - [[X]] is two characters longer than a task's - [ ] , so here the block has to be indented by 8 spaces instead of 6, always line it up with the text right after the checkbox.

                        {{1}}

Which of the following snippets define a valid multiple-choice quiz?

• [[X]] Using dashes, this is correct syntax

    ``` markdown
    - [[X]] Yes
    - [[ ]] No
    ```
  

• [[ ]] Mixing brackets and parentheses

    ``` markdown
    - [[X)] Yes
    - [[ )] No
    ```
  

• [[X]] Omitting the dashes and indenting the block as code instead

    ``` markdown
        [[X]] Yes
        [[ ]] No
    ```
  

• [[ ]] Forgetting the outer, double brackets

    ``` markdown
    - (X) Yes
    - ( ) No
    ```
  

2. Single-Choice

                      --{{0}}--

If brackets are used to define checkboxes, why not using parentheses to indicate radio-buttons. In contrast to multiple-choice quizzes only one option can be selected.

- [( )] Not selected
- [(X)] **This one has to be selected**
- [( )] ~~Do not select this one ...~~

                      --{{1}}--

You can also omit the starting dashes and/or use indentation as with multiple-choice quizzes and use upper- or lowercase X to indicate the solution.

                        {{1}}

Result:

• [( )] Not selected
• [(X)] This one has to be selected
• [( )] Do not select this one ...

                      --{{2}}--

However, you can also define multiple possible solutions a user might select only one option, but multiple might be correct.

                        {{2}}

What is the correct spelling of H(D)D?

    [(X)] hard (**disk**) drive
    [( )] hard (**desk**) drive
    [(x)] hard (**disc**) drive

                        {{3}}

Result:

What is the correct spelling of H(D)D?

[(X)] hard (**disk**) drive
[( )] hard (**desk**) drive
[(x)] hard (**disc**) drive

                      --{{3}}--

Thus, if the user selects the first or the last option, the quiz will be marked as solved, or if the user clicks onto the "show solution" button, both options will be presented.

2.1 Single-Choice Blocks

                      --{{0}}--

Just like multiple-choice quizzes, every option of a single-choice quiz can carry its own indented block. Since only one option can ever be the solution, this is a good place to attach a code-snippet per option and let the user spot the single correct one, everything else in the list still has to obey the "only one X" rule of a radio-button quiz.

**Which of the following snippets defines a valid single-choice quiz?**

- [(X)] Using dashes together with parentheses

        ``` markdown
        - [(X)] Yes
        - [( )] No
        ```

- [( )] Using square brackets instead of parentheses

        ``` markdown
        - [X] Yes
        - [ ] No
        ```

- [( )] Mixing brackets and parentheses

        ``` markdown
        - [(X]] Yes
        - [( ]] No
        ```

- [( )] Forgetting the closing parenthesis

        ``` markdown
        - [(X] Yes
        - [( ] No
        ```

                        {{1}}

Which of the following snippets defines a valid single-choice quiz?

• [(X)] Using dashes together with parentheses

    ``` markdown
    - [(X)] Yes
    - [( )] No
    ```
  

• [( )] Using square brackets instead of parentheses

    ``` markdown
    - [X] Yes
    - [ ] No
    ```
  

• [( )] Mixing brackets and parentheses

    ``` markdown
    - [(X]] Yes
    - [( ]] No
    ```
  

• [( )] Forgetting the closing parenthesis

    ``` markdown
    - [(X] Yes
    - [( ] No
    ```
  

                      --{{1}}--

As with multiple-choice blocks, the marker - [(X)] is 8 characters wide, so the indented block always has to line up with 8 spaces, exactly the same rule, just applied to a single-choice radio-button list.

                        {{2}}

How to create a true/false quiz?

                   --{{2}}--

Using single-choice quizzes, it is also possible to define something simple as a True or False quiz.

Do you know an easier way of creating quizzes?

    [( )] Yes
    [(X)] No

Result:

Do you know an easier way of creating quizzes?

[( )] Yes
[(X)] No

3. Matrix-Quiz

                      --{{0}}--

You can also combine multiple single- and multiple-choice quizzes into one larger matrix-quiz. The "vector" quizzes are now simply defined as rows, whereby you have to define a custom header, which represent the solution options. It makes no real difference if you use parentheses or brackets within the header line, use brackets if you want to insert parenthesis and vice versa.

                        {{0}}

- [[male (der)] (female [die]) [neuter (das)]]
- [    [X]           [ ]             [ ]     ]  Mann - German for man
- [    ( )           (X)             ( )     ]  Frau - German for woman

                      --{{1}}--

However, within the quiz-body, which is contains the quiz-vectors as rows, the brackets and parenthesis make a difference. The first row gets presented as multiple-choice with checkboxes, while the second line defines a single-choice with radio buttons.

                        {{1}}

Man or woman is obvious, but you guess the remaining German grammatical genders?

[[male (der<!-- class="notranslate"-->)]   (female [die<!-- class="notranslate"-->])   [neuter (das<!-- class="notranslate"-->)]]
[    [X]           [ ]             [ ]     ]  Mann<!-- class="notranslate"--> - German for man
[    ( )           (X)             ( )     ]  Frau<!-- class="notranslate"--> - German for woman
[    [X]           [ ]             [ ]     ]  Junge<!-- class="notranslate"--> - German for boy
[    ( )           ( )             (X)     ]  Mädchen<!-- class="notranslate"--> - German for girl
[    [X]           [X]             [ ]     ]  Paprika<!-- class="notranslate"--> - German for bell pepper
[    (X)           (X)             (X)     ]  Joghurt<!-- class="notranslate"--> - German for yogurt

                        {{2}}

Fun fact:

                    --{{2}}--

The number of elements within a row does not necessarily have to match the number of elements within the head. Although it might be rendered strangely, this does not cause an error. You as a course designer can see, that there might have a mistake occurred, but maybe you use it with a purpose.

[[option 1] [option 2]]
[   [X]                     ] only with option 1
[   [ ]        [X]          ] with two options
[   [X]        [ ]       [X]] with three options

[[option 1] [option 2]] [ [X] ] only with option 1 [ [ ] [X] ] with two options [ [X] [ ] [X]] with three options

4. Text-Quiz

                      --{{0}}--

A simple text-input quiz is defined only by two brackets that contain the solution string. For these simple kind of quizzes, it is currently not allowed to add a starting dash, but you can use optional indentation. The reason for this is, that in the future we would like to extend the usage of text- and selection-quizzes to be used everywhere, within paragraphs or tables to from clozes.

What did the fish say when he swam into the wall?

    [[dam]]

                        {{1}}

Result:

What did the fish say when he swam into the wall?

[[dam]]

                      --{{1}}--

The user input will be compared with your solution-string, and if and only if they are equal the quiz will be labelled as solved. For different reasons it might be necessary to clean up the input, in order to deal with different types of spelling, uppercase and lowercase, etc. Fort this purpose scripts can be associated to a quiz, see therefore section Quizzes and Scripting.

5. Selection-Quiz

                      --{{0}}--

Finally, a selection-quiz is a collection of LiaScript/Markdown options that are separated by vertical bars |. The solution is defined by the option or options that are surrounded by parenthesis. An option can be any kind of LiaScript inline element and since vertical bars | are used as separators, you can simplify the readability by using newlines.

What is the derivative function of $f(x) = x^6$?

[[ $f'(x) = 6$ | ( $f'(x) = 6x^5$ ) | $f'(x) = 5x^6$ ]]

Can be also written as:

    [[  $f'(x) = 6$
    | ( $f'(x) = 6x^5$ )
    |   $f'(x) = 5x^6$
    | ( **This will be counted as correct too...** )
    ]]

                      --{{1}}--

This type of quiz allows you to have multiple correct options and starting dashes are not supported yet, due to their future usage as native input elements for clozes. And you can use indentation, such as it is possible for all quizzes.

                        {{1}}

Result:

What is the derivative function of $f(x) = x^6$?

[[ $f'(x) = 6$ | ( $f'(x) = 6x^5$ ) | $f'(x) = 5x^6$ ]]

Can be also written as:

[[  $f'(x) = 6$<!-- class="notranslate"-->
| ( $f'(x) = 6x^5$<!-- class="notranslate"-->  )
|   $f'(x) = 5x^6$<!-- class="notranslate"-->
| ( **This will be counted as correct too...** )
]]

6. Drag & Drop-Quiz

                      --{{0}}--

Selections are nice, but sometimes you want your learners to actually grab something and put it into the right place. A drag & drop quiz uses exactly the same notation as a selection-quiz, the only difference is the little arrow -> within the opening brackets [->[, which indicates that something has to be moved.

What is the capital of Germany?

[->[ Paris | ( Berlin ) | Madrid ]]

                      --{{1}}--

All options are presented as little cards beneath a drop zone. Simply drag the correct card onto the drop zone and click onto check. If you are not a fan of dragging, you can also click onto the drop zone (or press Enter or Space) and then onto a card. On touch devices, a long press onto a card starts the dragging.

                        {{1}}

Result:

What is the capital of Germany?

[->[ Paris | ( Berlin ) | Madrid ]]

                      --{{2}}--

Same as with selections, the options can contain any LiaScript inline element, they can be spread over multiple lines, and you can define more than one correct option. And if you define only one option without any parentheses, then this one is automatically the correct one, which makes more sense within gap-texts, as you will see in the next section.

                        {{2}}

Which of the following is equal to $4$?

    [->[   $\sqrt{8}$
       | ( $2^2$ )
       | ( $\frac{8}{2}$ )
       |   $4^2$
       ]]

Result:

Which of the following is equal to $4$?

[->[   $\sqrt{8}$<!-- class="notranslate"-->
   | ( $2^2$<!-- class="notranslate"--> )
   | ( $\frac{8}{2}$<!-- class="notranslate"--> )
   |   $4^2$<!-- class="notranslate"-->
   ]]

                      --{{3}}--

Be careful, if you do not mark any option with parentheses and if you have defined at least two options, then your quiz turns into a survey. Have a look at section Drag and Drop Survey for more information.

7. Gap-Text Extreme

                 --{{0}}--

Internally we call this type a multi-quiz, it allows to freely use text-, selection-, and drag & drop-quizzes within all other kinds of Markdown-blocks to generate more complex test situations.

 {{1}}

                --{{1}}--

__I (learn) [[  have been learning  ]] English for seven years now.__
But last year I (not / work) [[ was not working ]] hard enough for English,
that's why my marks (not / be) _[[ were not ]]_ really that good then.
As I (pass / want) [[ want to pass ]] my English exam successfully next year,
I (study) ~[[ am going to study ]]~ harder this term.

 {{2}}

                --{{2}}--

Wladimir [[ Putin ]] is the richest (still living) dictator
with an estimated fortune of over
__4,500,000,000 [[ (US Dollar 💵) | Euro 💶 | _Rubel 💸_ | Pound 💷 ]]__!

 {{3}}

                --{{3}}--

<!-- data-randomize -->
The [->[ Sun ]] is a star, the [->[ (Moon) | Mars ]] is orbiting the
Earth, and [->[ Jupiter ]] is the largest planet in our solar system.
Pluto is a [[ (dwarf planet) | planet | comet ]] and its moon is called
[[ Charon ]].

 {{4}}

                --{{4}}--

<!-- data-show-partial-solution -->
The [->[ Sun ]]<!-- style="min-width: 10rem" --> is a star, the
[->[ (Moon) | Mars ]]<!-- style="min-width: 10rem" --> is orbiting the Earth.

More!!!

 --{{0}}--

Since text inputs and selections are now a so-called first class member within LiaScript, you can think of creating other kinds of quizzes, by not only using simple paragraphs. This section shows only some inspirational examples that you can use and extend for your own purpose.

   {{1}}

           --{{1}}--

``` ascii
.----------.      .----------.
| ⭐       |      |  ⭐ ⭐   |
|      ⭐  |      | ⭐ ⭐ ⭐ |
'----------'      '----------'
```

[[ 2 ]] + [[ 5 ]] = [[ 7 ]]

.----------.      .----------.
| ⭐       |      |  ⭐ ⭐   |
|      ⭐  |      | ⭐ ⭐ ⭐ |
'----------'      '----------'

   {{2}}

  --{{2}}--

> “How is education supposed to make me feel smarter?
> Besides, every time I learn something new, it pushes some old stuff out of my brain.
> Remember when I took that home winemaking course, and I forgot how to drive?”
>
> -- By [[ Dieter Nuhr | Nida Mohammad Nadim | (Homer Simpson)]]

   {{3}}

                     --{{3}}--

                    {{English Male |>}}
The film that I saw [[(that)|those|these|then]] night wasn’t very good.
It was all [[ about ]] a man [[ who ]] built a
time machine so he [[ could ]] travel back in time.
It took him ages and ages [[ to ]] build the machine.

                {{English Male |>}}

{{4}}

                   --{{4}}--

German grammar test:

| Verb    |   Person      | Präsens von "werden" | Partizip II    | Infinitiv von haben/sein |
|---------|:-------------:|:--------------------:|:--------------:|:------------------------:|
| gehen   | Ich           |     [[ werde  ]]     | [[ gegangen ]] | [[ sein ]].              |
| sage    | Du            |     [[ wirst  ]]     | [[ gesagt ]]   | [[ haben ]].             |
| machen  | Er / Sie / Es |     [[ wird   ]]     | [[ gemacht ]]  | [[ haben ]].             |
| laufen  | Wir           |     [[ werden ]]     | [[ gelaufen ]] | [[ sein ]].              |
| singen  | Ihr           |     [[ werdet ]]     | [[ gesungen ]] | [[ haben ]].             |
| spielen | Sie           |     [[ werden ]]     | [[ gespielt ]] | [[ haben ]].             |

  {{5}}

      --{{5}}--

<!-- data-title="LMS market share 2022 (North America)" -->
| Brightspace    | Canvas          | Classroom      | Moodle          | Others         | Schoology      |
|:--------------:|:---------------:|:--------------:|:---------------:|:--------------:|:--------------:|
| [[(3 %)|11 %]] | [[13 %|(28 %)]] | [[8 %|(24 %)]] | [[(11 %)|31 %]] | [[2 %|(12 %)]] | [[7 %|(22 %)]] |

---

| LMS | Average cost per month   |
|-----|--------------------------|
| Brightspace | [[13 $|(80 $)]]  |
| Canvas      | [[(10 $)|99 $]]  |
| Classroom   | [[(0 free)|3 $]] |
| Moodle      | [[11 $ |(15 $)]] |
| Schoology   | [[(4 $)|12 $]]   |

    {{6}}

          --{{6}}--

![image 1](https://img1 "Markdown subtitle [[(option 1)|option 2|option 3]]")
![image 2](https://img2 "Another [[subtitle]]")
!?[video](https://www.youtube.com/watch?v=... "Subtitle for [[multi-media]]")

{{7}}

  --{{7}}--

<!-- data-show-partial-solution -->
``` ascii
                        .----------------------.
                       /                      /|
             .--------+----------------------+ +---------.
            /         |      " [[  24   ]] " |/         /|
  .--------+----------+----------+-----------+---------+ +----------.
 /         |         11          |      "[[   13   ]] "|/          /|
+----------+----------+----------+----------+----------+----------+ +
|      " [[   5   ]] "|          6          |          7          |/
+---------------------+---------------------+---------------------+
```

--{{8}}--

  {{8}}

                        .----------------------.
                       /                      /|
             .--------+----------------------+ +---------.
            /         |      " [[  24   ]] " |/         /|
  .--------+----------+----------+-----------+---------+ +----------.
 /         |         11          |      "[[   13   ]] "|/          /|
+----------+----------+----------+----------+----------+----------+ +
|      " [[   5   ]] "|          6          |          7          |/
+---------------------+---------------------+---------------------+

Lists, Headers & HTML

                      --{{0}}--

Gaps are not limited to paragraphs, tables, quotes, galleries, and ASCII-art. You can also put them into headers, into ordered and unordered lists, and even into HTML blocks. By default, every paragraph within a list (or within an HTML block) that contains a gap is treated as a quiz of its own, with its own check-button.

- Berlin is the capital of [[ (Germany) | France | Spain ]].
- Paris is the capital of [->[ (France) | Italy ]].
- Madrid is the capital of [[ Spain ]].

                        {{0-1}}

Result:

• Berlin is the capital of [[ (Germany) | France | Spain ]].
• Paris is the capital of [->[ (France) | Italy ]].
• Madrid is the capital of [[ Spain ]].

                      --{{1}}--

If you would rather like to check the entire list at once, then simply add data-group to the comment in front of the list. Now, all gaps belong to one single quiz with one check-button, and all drag & drop cards are collected within one common pool. This works the same way for HTML blocks. Quotes and ASCII-art are always grouped, since they cannot be split into separate quizzes.

                        {{1}}

<!-- data-group -->
- Berlin is the capital of [[ (Germany) | France | Spain ]].
- Paris is the capital of [->[ (France) | Italy ]].
- Madrid is the capital of [[ Spain ]].

Result:

• Berlin is the capital of [[ (Germany) | France | Spain ]].
• Paris is the capital of [->[ (France) | Italy ]].
• Madrid is the capital of [[ Spain ]].

0. Generic Quizzes

                      --{{0}}--

Generic quizzes can be used to define any kind of quiz. The course-developer can define own types of quizzes, whereby the following combination of brackets with an additional exclamation mark has to be associated with a script.

[[!]]
<script>
  const random = Math.random()

  alert("random value: "+ random)

  random < 0.2
</script>

                      --{{1}}--

This script does only generate a random number, outputs the result in an alert and checks if the random value is less than 0.2. And if so, the quiz will be marked as solved otherwise not. Thus, the last statement has to be true in order to mark a quiz as solved, any other value will be accounted as false.

                        {{1}}
[[!]]
<script>
  const random = Math.random()

  alert("random value:"+ random)

  random < 0.2
</script>

                      --{{2}}--

The usage of associated scripts for quizzes will be described in detail in section Quizzes and Scripting.

Notes about Questions

                      --{{0}}--

Not all of the previous examples we have shown were perfect in the sense of accessibility. Although these quizzes look good "for us", they might not be perfectly for people that require a screen-reader to go through a course. However, you can improve your quizzes by asking your question as a paragraph, which is followed by your quiz. This way LiaScript will associate or label the quiz with your question.

Ask a question as an ordinary Markdown paragraph,
which is followed by what?

    [[quiz]]

                      --{{1}}--

If your question requires more elements, then it is also possible to group it with supplemental elements by putting it into a single HTML-element such as a div. The div will get a unique ID and the question will be labeled with this ID by using the aria-labelledby attribute.

                        {{1}}

<div>

Ask a question as an ordinary Markdown paragraph,
which is followed by what?

1. important
2. also relevant ...
3. [an image](http://...)

</div>

    [[quiz]]

Tweaks

                      --{{0}}--

All of the following elements can be added to any type of quiz that you have seen before. This includes and arbitrary number of hints, a more detailed solution or a custom script that handles the user input.

via GIPHY

Hints

                      --{{0}}--

To any type of quiz you can add as many hints as you want, the pattern is simply two brackets with an additional question mark. If you want to, you can also add starting dashes to the hints.

What is $37 + 15$?

    [[52]]
    [[?]] the solution is larger than 50
    [[?]] it is less than 55
    [[?]] it should be an even number

This is also a valid quiz ...

[[52]]
- [[?]] the solution is larger than 50
- [[?]] it is less than 55
- [[?]] it should be an even number

                      --{{1}}--

The user can reveal these hints, step by step by clicking onto the light bulb or "show hint" button.

                        {{1}}

What is $37 + 15$?

[[52]]
[[?]] the solution is larger than 50
[[?]] it is less than 55
[[?]] it should be an even number

Solution

                               --{{0}}--

And finally, some quizzes might require some more explanations, if they are solved or not. Therefore, simply use two "lines" that are defined by at least three asterisks to group your solution. The solution explanation can contain an arbitrary number of LiaScript elements.

What is $37 + 15$?

[[52]]
[[?]] the solution is larger than 50
[[?]] it is less than 55
[[?]] it should be an even number
***********************************************************************

52 is the correct solution, you get this by adding:

``` ascii
                        .------.
                        |      |
                        |      v
                        |
                        |     (1)
  37           3(7)     |     (3)x          37
+ 15         + 1(5)     |   + (1)x        + 15
---- -->     ------ --> |   ------ -->    ----
  ??           (12)     |     (5)2          52
                |       |                 ====
                '-------'
                  carry
```

??[MS-DOS Math Game](https://archive.org/embed/msdos_Super_Solvers_Teasure_MathStorm_1992)

***********************************************************************

                      --{{1}}--

In this case the solution contains an ASCII-art drawing, but it can be anything, such as a an image, a video, or even something like a small game. Narrator comments within a solution stay hidden and are only read aloud once the quiz has been solved, and scripts within a solution are only executed once it becomes visible. Surveys can also have such a block, see Survey Solutions.

                        {{1}}

What is $37 + 15$?

[[52]] [[?]] the solution is larger than 50 [[?]] it is less than 55 [[?]] it should be an even number

52 is the correct solution, you get this by adding:

                        .------.
                        |      |
                        |      v
                        |
                        |     (1)
  37           3(7)     |     (3)x          37
+ 15         + 1(5)     |   + (1)x        + 15
---- -->     ------ --> |   ------ -->    ----
  ??           (12)     |     (5)2          52
                |       |                 ====
                '-------'
                  carry

??MS-DOS Math Game

Randomization

                   --{{0}}--

You can randomize the order of options of nearly all quiz types, just by adding the option data-randomize to the comment attached to the head of the quiz. For single- and multiple-choice quizzes as well as for matrix quizzes, this means that the order of rows is shuffled. For selections and drag & drop quizzes the order of options gets shuffled, and within gap-texts the options of every gap as well as the common pool of drag & drop cards are mixed. This happens only once, when the slide is loaded for the first time, this includes also page reloads.

Are the options of the quiz in order?

<!-- data-randomize -->
- [(X)] option 1 (yes)
- [( )] option 2 (no)
- [(X)] option 3 (maybe)
- [( )] option 4 (I don't care)

Which word is a verb?

<!-- data-randomize -->
[->[ house | tree | (run) | blue ]]

                   --{{1}}--

If you reload the page, the order of the options will change, but not when you go to another slide and come back.

    {{1}}

Further Settings

          --{{0}}--

Next to randomization you can also use the following configuration options and also combine them:

            {{1}}

• Maximum Trials data-max-trials

          --{{1}}--
  

  Pass an integer to data-max-trials and the quiz will be automatically solved after x wrong trials.

  What happens if you check 3 times the wrong answer?
  
  <!-- data-max-trials="3"-->
  [( )] Absolutely nothing?
  [(X)] The quiz will be solved!
  

  ---

  What happens if you check 3 times the wrong answer?

  [( )] Absolutely nothing? [(X)] The quiz will be solved!

            {{2}}
  

• Hide and reveal the solve button data-solution-button

          --{{2}}--
  

  You can either use values such as on|off, true|false, disable|enable to show or hide the solution button. By default it is always on, but it is also possible to pass an integer value to reveal this button at a certain user trial. In this case 0 is not interpreted as false, but that it should be immediately visible and 1 only after the first wrong trial.

  Can you reveal the solution button?
  
  <!-- data-solution-button="off" -->
  [( )] YES
  [(X)] NO
  
  ---
  
  How many trials are necessary to show the solution button?
  
  <!-- data-solution-button="3" -->
  [[3]]
  

  ---

  Can you reveal the solution button?

  [( )] YES [(X)] NO

  ---

  How many trials are necessary to show the solution button?

  [[3]]

            {{3}}
  

• Hide and reveal the hint button data-hint-button

          --{{3}}--
  

  This configuration options can be used similarly as the previous one, although there won't be many occasions to disable or enable the hint button when no hints were defined. However, you can use the numerical value to show hints only after a certain amount of wrong trials, thus 1 will reveal the button only after the first wrong trial.

  How many trials are necessary to show the hints?
  
  <!-- data-hint-button="2" -->
  [[2]]
  [[?]] The solution is smaller than 3
  [[?]] Try an even number
  

  ---

  How many trials are necessary to show the hints?

  [[2]] [[?]] The solution is smaller than 3 [[?]] Try an even number

             {{4}}
  

• Revealing Partial Solutions data-show-partial-solution

           --{{4}}--
  

  If a quiz might have to many input options and you require a way to separate partially correct answers from wrong ones, then you need to use this attribute. It can be applied onto gap-texts and matrix-quizzes. In contrast to a gap-text, which can also contain single selections, in a matrix the entire row will be highlighted as correct or wrong.

  <!-- data-show-partial-solution -->
  ``` ascii
                          .----------------------.
                         /                      /|
               .--------+----------------------+ +---------.
              /         |      " [[  24   ]] " |/         /|
    .--------+----------+----------+-----------+---------+ +----------.
   /         |         11          |      "[[   13   ]] "|/          /|
  +----------+----------+----------+----------+----------+----------+ +
  |      " [[   5   ]] "|          6          |          7          |/
  +---------------------+---------------------+---------------------+
  ```
  

  ---

                          .----------------------.
                         /                      /|
               .--------+----------------------+ +---------.
              /         |      " [[  24   ]] " |/         /|
    .--------+----------+----------+-----------+---------+ +----------.
   /         |         11          |      "[[   13   ]] "|/          /|
  +----------+----------+----------+----------+----------+----------+ +
  |      " [[   5   ]] "|          6          |          7          |/
  +---------------------+---------------------+---------------------+
  

            {{5}}
  

• Scoring a quiz data-score

          --{{5}}--
  

  The result of this setting will not be visible at all, instead it is used to score a quiz, if the course is exported into a SCORM package and uploaded to an LMS. Within an export every quiz is rated equally with a value of 1. It is possible to pass an integer or float value, e.g. 2, 2.0, 2.12345.

            {{6}}
  

• Combinations

          --{{6}}--
  

  And as mentioned earlier, you can freely combine all of these configurations.

  You have only two trials, without a solution button ;-)
  
  <!--
    data-max-trials="2"
    data-solution-button="off"
    data-randomize
  -->
  [( )] Wrong
  [(X)] Right
  

  ---

  You have only two trials, without a solution button ;-)

  [( )] Wrong [(X)] Right

            {{7}}
  

• Custom Texts

          --{{7}}--
  

  Finally, you can also customize the texts that are shown to the user, when a quiz is solved, failed or resolved after reaching the maximum number of trials.

  How is this project called?
  
  <!--
  data-text-solved="This was a __Very__ hard quiz"
  data-text-failed="Try again!"
  data-text-resolved="Next time it will be better"
  -->
  [[LiaScript]]
  

  ---

  How is this project called?

  [[LiaScript]]

Associated Scripts

                      --{{0}}--

The following section contains a list of use-cases and ideas how to use quizzes and scripts in association to generate a more complex user experience.

via GIPHY

Cleaning up

                      --{{0}}--

If you are using for example the text-quiz, and you want to react to different ways of spelling or to clean starting and trailing white-spaces. Then you can attach a script to your quiz. The @input is marker that will be substituted by the current user input. trim and toLowerCase are JavaScript functions/methods that are used to clean the input string. The last statement of your quiz-script defines if the quiz is marked as solved or not. Only if the last statement evaluates to true it is marked as solved, for any other value it is simply a failed trial.

What did the fish say when he swam into the wall?

[[dam]]
<script>
let input = "@input".trim().toLowerCase()

input == "dam" || input == "damn"
</script>

                      --{{1}}--

Try out the following quiz. You can now enter "damn" or "dam" in different ways, surrounded by spaces.

                        {{1}}

What did the fish say when he swam into the wall?

[[dam]]

Quiz @inputs

                      --{{0}}--

@input will be replaced by the current state of the quiz that should be checked. If you are not sure, how the input might look like, you can always experiment with a simple alert that shows the current input.

                        {{1}}

Text-quiz:

                      --{{1}}--

The output or in LiaScript terms the @input gets substituted by a string, without apostrophes. This might look strange since you have to add apostrophes within the code, but all inputs are substituted without any additional type formatting, this way they can be used in different ways and even contain peaces of code.

[[text]]
<script> alert("@input") </script>

Result:

[[text]]

                        {{2}}

Selection-quiz:

                      --{{2}}--

A selection quiz is defined by a number that represents the current input, starting from 0. The initial state is marked with -1 to indicate that nothing has been selected so far. In this example A would be represented by 0, B by 1, C by 2 and so on. The same applies to drag & drop quizzes [->[A|B|C|(D)]], here the number represents the option that has been dropped into the drop zone.

[[A|B|C|(D)]]
<script> alert(@input) </script>

Result:

[[A|B|C|(D)]]

                        {{3}}

Multiple-choice:

                      --{{3}}--

A multiple-choice quiz is represented by an array of ones and zeros, whereby a 1 means checked and 0 the opposite.

[[X]] A
[[ ]] B
[[X]] C
<script> alert("@input") </script>

Result:

[[X]] A [[ ]] B [[X]] C

                        {{4}}

Single-choice:

                      --{{4}}--

A single-choice quizzes behave similar as selections, the state is represented by a number, starting from 0, which represents the first option. A quiz that has been not touched by the user will return -1 as input value.

[(X)] 0
[( )] 1
[(X)] 2
<script> alert("@input") </script>

Result:

[(X)] 0 [( )] 1 [(X)] 2

                        {{5}}

Matrix:

                      --{{5}}--

As matrices are arrays of "vector" quizzes, their input state is represented as an array of multiple-choice and single-choice states. Thus, a list of lists with zeros and ones as well as numbers.

Weird, isn't it ;-)

[[male (der)]   (female [die])   [neuter (das)]]
[    [X]           [ ]             [ ]     ]  Mann - German for man
[    ( )           (X)             ( )     ]  Frau - German for woman
[    [X]           [ ]             [ ]     ]  Junge - German for boy
[    ( )           ( )             (X)     ]  Mädchen - German for girl
[    [X]           [X]             [ ]     ]  Paprika - German for bell pepper
[    (X)           (X)             (X)     ]  Joghurt - German for yogurt
<script>alert("@input")</script>

Result:

[[male (der)] (female [die]) [neuter (das)]] [ [X] [ ] [ ] ] Mann - German for man [ ( ) (X) ( ) ] Frau - German for woman [ [X] [ ] [ ] ] Junge - German for boy [ ( ) ( ) (X) ] Mädchen - German for girl [ [X] [X] [ ] ] Paprika - German for bell pepper [ (X) (X) (X) ] Joghurt - German for yogurt

                        {{6}}

Generic:

                      --{{6}}--

In case of a generic quiz, the developer is responsible for defining and storing state. Thus, there will be no input. The only case where @input gets substituted by a value, is when the user clicks onto the resolve button. This is indicated by the input true.

[[!]]
<script>alert("@input")</script>

[[!]]

Async & Errors

                      --{{0}}--

There might be the rare case, where you have to send the user input to an external service to check them. Scripts in LiaScript can also define asynchronous code, as it is displayed within the example.

What is $37 + 15$?

[[52]]
<script>
setTimeout(function(){
  alert("your input was: '@input'")
  send.lia("true")
}, 1000)

"LIA: wait"
</script>

                      --{{1}}--

In LiaScript, we can use some command strings that trigger a certain behavior, these are global to all scripts and will be described in more detail in section Communication.

                        {{1}}

• "LIA: wait": mark the script as still running

• "LIA: stop": halt the execution of the script

                      --{{2}}--
  

Additionally, you can see a function-call within the example. setTimeout triggers the execution of the internally defined function, which performs an alert with the user input and then sends "true" back to the internal quiz-event handler. Every script is executed with an additional send object and send.lia means send this back to LiaScript. Thus, the result could also be evaluated by an external service, and this result will then be used to control the quiz.

                        {{2}}

• send: general object to for communicating with the LiaScript internal event-handler for a specific entity, for more information see section Communication

                      --{{3}}--
  

Let us extend this example a little bit further. The send to lia can have two meanings, one if everything was ok while the second might be the result of an error. send.lia can have three values, the first is the message, the second one contains more detailed information about the result, which is not required at the moment, while the last value tells LiaScript if everything was ok or by using false that an error has occurred. The default value is always ok.

                        {{3}}

What is $37 + 15$?

[[52]]
<script>
setTimeout(function(){
  alert("your input was: '@input'")

  if ("@input" === "") {
    // generic error message
    send.lia("You have to fill in something into the input field", [], false)
  } else {
    // this is equal to send.lia("some message", [], true)
    send.lia("true")
  }
}, 1000)

"LIA: wait"
</script>

                      --{{4}}--

Thus, if you try out the following example, you will have to wait one second until the result is evaluated, which in this case always results in a solved quiz. But, if you do not add any input, then an error message will be displayed.

                        {{4}}

Result:

What is $37 + 15$?

[[52]]

Obfuscate Quizzes

                      --{{0}}--

We would like to note, that this is only one method to obfuscate a quiz, by using JavaScript, in this case by using the function btoa.

[[...]]
<script>
// btoa("solution") == "c29sdXRpb24="
"c29sdXRpb24=" == btoa( "@input".trim().toLowerCase() )
</script>

                      --{{1}}--

btoa creates a Base64-encoded ASCII string, while atob does the opposite. You can try out to the following two scripts to encode and decode different strings.

                        {{1}}

• btoa:

  (Beautiful TO Awful)

• atob:

  (Awful TO Beautiful)

                        {{2}}
  

                      --{{2}}--

The result is a quiz, where it is not possible to see the solution immediately, simply by getting a glimpse onto the raw course document.

Result:

[[...]]

Quizzes & Macros

                      --{{0}}--

It might look tedious to create these trailing scripts and to add them again and again to your document, which makes a course harder to maintain and to develop. However, in LiaScript you can define macros, that can be used to solve repetitive tasks.

                      --{{1}}--

As depicted in the example, you can define custom macros within an HTML-comment of a section or within the main comment at the head of every document. Wherever you write the macro @customQuiz within your document, this macro will be substituted by the content defined in the HTML-comment, which comes between @customQuiz and @end. For more information see section Macros.

                        {{1}}

##### Quizzes & Macros
<!--

@customQuiz
[[...]]
<script>
"@0" == btoa( "@input".trim().toLowerCase() )
</script>
@end

-->

...

@customQuiz(c29sdXRpb24=)


@customQuiz(NTI=)

                      --{{2}}--

You can further parameterize your macros, as you can see in the code, there is an @0, which can be interpreted as a placeholder that shall be substituted by the first parameter of your macro call.

                      --{{3}}--

That's it, you can add as much as @customQuiz-macros and if you do some changes, you do not have to go through all scripts, but instead you only have to change one single macro.

                        {{3}}

The solution should be "solution":

@customQuiz(c29sdXRpb24=)

What is $37 + 15$?

@customQuiz(NTI=)

                       --{{4}}--

By defining macros it is furthermore possible to create LiaScript libraries that can imported into other courses, see therefore also section Macros.

Final thoughts on wrong solution

                      --{{0}}--

The quiz for adding two numbers was actually taken from the presentation of Greg Wilson, and it gives a good example for what scripts can be used for. Instead of logging and checking if an answer is correct or not, we should use it to assist students while they are learning and try to identify patterns in wrong answers.

                       {{0-1}}

!?What Everyone in Tech Should Know About Teaching and Learning

                      --{{1}}--

As you have seen it for tasks, the result of a script can also be published, in this case the topic is defined by the output attribute.

                        {{1}}

What is $37 + 15$?

[[52]]
<script output="quiz:37+15">
  if ("@input" == "52") {
    true
  } else {
    "@input"
  }
</script>

                      --{{2}}--

Other scripts can be defined, that are subscribed to the output of the quiz, see the different @input macro. These scripts are executed when the output of the previous script changes. Every script can be used to identify another pattern, since students can be wrong for different reasons. We need to identify such patterns and react properly instead of measuring only fail and success.

                        {{2}}

<script style="display: block">
//   3(7)       (3)7
// + 1(5)     + (1)5       The first and second steps were correct,
// ------ ->  ------  ->   but the student forgot to carry the 1
//   (12)       (4)2       in the 10 digit column.

if ("@input(`quiz:37+15`)" == "42") {
  send.liascript(`## Maybe you forgot to carry...

Checkout the follow video to recap carrying.

!?[Carrying for larger digits](https://www.youtube.com/watch?v=VPsYRPdlIpU)
`)
} else ""
</script>

<script style="display: block">
//   3(7)       (3)7       The first and second steps were also
// + 1(5)     + (1)5       correct, but carrying was not provided
// ------ ->  ------  ->   properly, maybe there is a problem with
//   (12)      (4)12       understanding digit columns...


if ("@input(`quiz:37+15`)" == "412") {
  send.lia(`You are nearly there, there might be a problem with the 10 digit columns...`)
} else ""
</script>

                      --{{3}}--

With LiaScript you do not have to come up immediately with a perfect online course, you can adapt it in little steps and let it increasingly grow.

                        {{3}}

What is $37 + 15$? This time you should make the mistakes 42 and 412.

[[52]]

Generic++

                      --{{0}}--

Ok, German articles behave strangely. This is a more complex example of a generic quiz that is connected to multiple scripts with an input, which are implemented with a single LiaScript macro.

Do you know which German articles belong to which gender in which case?

[[!]]

                      --{{1}}--

The following code-block shows how this quiz was actually implemented.

                        {{1}}

##### Generic++
<!--
@article: <script output="@0" value="select" input="select" aria-label="article" options="der|die|das|dem|den|des">
            if("@input(`articles`)" == "true") {
              "@1"
            } else {
              "@input"
            }
          </script>
-->

                          --{{0}}--
Ok, German articles behave strangely. This is a more complex example of a
generic quiz that is connected to multiple scripts with an input, which are
implemented with a single LiaScript macro.

Do you know which German articles belong to which gender in which case?

[[!]]
<script output="articles">
if ("@input" !== "true") {
  "@input(`11`)"=="der"  &&  "@input(`21`)"=="die"  &&  "@input(`31`)"=="das"  &&  "@input(`41`)"=="die" &&
  "@input(`12`)"=="des"  &&  "@input(`22`)"=="der"  &&  "@input(`32`)"=="des"  &&  "@input(`42`)"=="der" &&
  "@input(`13`)"=="dem"  &&  "@input(`23`)"=="der"  &&  "@input(`33`)"=="dem"  &&  "@input(`43`)"=="den" &&
  "@input(`14`)"=="den"  &&  "@input(`24`)"=="die"  &&  "@input(`34`)"=="das"  &&  "@input(`44`)"=="die"
}
</script>

| Case      | Masculine        | Feminine         | Neuter           | Plural           |
| --------- | ---------------- | ---------------- | ---------------- | ---------------- |
| Nominativ | @article(11,der) | @article(21,die) | @article(31,das) | @article(41,die) |
| Genitiv   | @article(12,des) | @article(22,der) | @article(32,des) | @article(42,der) |
| Dativ     | @article(13,dem) | @article(23,der) | @article(33,dem) | @article(43,den) |
| Accusativ | @article(14,den) | @article(24,die) | @article(34,das) | @article(44,die) |

Surveys

                           --{{0}}--

A survey or questionnaire from our perspective is a quiz without a predefined solution. Thus, the syntax is the same to quizzes, but instead of a solution you have to provide options. If you use the LiaScript-Exporter to generate SCORM-packages of a course, then the state of the quizzes, surveys, and tasks will be stored within the LMS-backend.

via GIPHY

                           --{{1}}--

But, if you are also using LiaScript for your live presentations, you can also open a classroom directly from your Browser and create a shared experience, where all the connected peers will get the same and anonymous view. We will explain the classroom-idea in more detail in section Classrooms.

Text-Inputs

                           --{{0}}--

As already mentioned, the difference to quizzes is, that you have to provide options or placeholders. In case of a text-input, you have to provide a placeholder, which consists of at least 3 underscores that are separated spaces.

You can have a single text-input by using the following pattern:

**This is a one liner, you can use commas `,` to separate your inputs:**

    [[___]]

                             {{1}}

This is a one-liner, you can use commas to separate your inputs:

[[___]]

                           --{{1}}--

In this type of survey, you can use commas to separate different phrases or keyword/topics. Apply this for short comments or reactions only.

                           --{{2}}--

Similar to text-quizzes, use the following syntax to define a text-survey, where the number of underlines defines the presented line numbers:

                             {{2}}

Please describe your opinion in a few sentences:

    [[___ ___ ___ ___]]

    [[______   ___   ___   ______]]

                           --{{3}}--

Thereby, it does not matter how many spaces you add or how long the underscore lines are, both definitions will result in the same textarea input.

                             {{3}}

Please describe your opinion in a few sentences:

[[___   ___   ___   ___]]

Single-Choice Vector

                           --{{0}}--

And also this kind of survey is similar to a single choice quiz, but in this case, numbers within parenthesis are used to define some kind of variable identifier. That is why they do not have to be in order.

Select one option:

    [(1)] option 1
    [(2)] option 2
    [(3)] option 3
    [(0)] option 0

                           --{{1}}--

The result will look like the one presented below:

                             {{1}}

Select one option:

[(1)] option 1
[(2)] option 2
[(3)] option 3
[(0)] option 0

But, instead of numbers, you can also define more complex option names. There is only one difference, the options that start with numbers, will be plotted in the classroom presentation as distributions, whereby not numbers will be presented as categorical values.

         {{2}}

Select one option:

- [(very good)]       I like it very much
- [(good)]            It is ok
- [(bad)]             I don't like it
- [(something else)]  I am not sure

As you can see from the example, you can apply different styles for encoding surveys too. Either you use indentation, so that other Markdown interpreter will show it as code, or you use lists.

                             {{2}}

Select one option:

• [(very good)] I like it very much
• [(good)] It is ok
• [(bad)] I don't like it
• [(something else)] I am not sure

Single-Choice Vector Blocks

                           --{{0}}--

Exactly as with tasks and quizzes, every option of a survey vector can carry its own indented block. This lets you explain what a rating actually means before someone picks it, which is especially useful for anything more nuanced than a plain number.

How was the pacing of this chapter?

- [(fast)] Too fast

           I had to pause and re-read things to keep up.

- [(slow)] Too slow

           I found myself waiting for new content to show up.

- [(good)] Just right

           The speed felt natural, I could follow along easily.

- [(okay)] Okay-ish

           Not perfect, but I got through it just fine.

                           --{{1}}--

Note that the required indentation now depends on the length of your own identifier. Here - [(good)] is 11 characters wide, so every continuation line has to line up with 11 spaces, exactly the same rule as with tasks and quizzes, just applied to whatever label you choose.

                             {{1}}

How was the pacing of this chapter?

• [(fast)] Too fast

       I had to pause and re-read things to keep up.
  

• [(slow)] Too slow

       I found myself waiting for new content to show up.
  

• [(good)] Just right

       The speed felt natural, I could follow along easily.
  

• [(okay)] Okay-ish

       Not perfect, but I got through it just fine.
  

Multi-Choice Vector

                           --{{0}}--

Similar to multi-choice quizzes, you can define multi-choice survey vectors with a number in double square brackets. But, and this is also possible for all other kinds of surveys, you can define some kind of variable name with a starting colon.

What are your favorite colors?

[[red]]         is it red
[[green]]       green
[[blue]]        or blue
[[dark purple]] last chance ;-)

                           --{{1}}--

Within a LiaScript classroom, this represents categorical values.

                             {{1}}

What are your favorite colors?

[[red]]         is it red
[[green]]       green
[[blue]]        or blue
[[dark purple]] no one likes purple ( last chance ;-) )

                             --{{2}}--

If you want to turn this into a continuous representation, you have to work with starting numbers.

                              {{2}}

What are your favorite colors?

- [[1 red]]         is it red
- [[2 green]]       green
- [[3 blue]]        or blue
- [[4 dark purple]] last chance ;-)

What are your favorite colors?

• [[1 red]] is it red
• [[2 green]] green
• [[3 blue]] or blue
• [[4 dark purple]] last chance ;-)

Multi-Choice Vector Blocks

                           --{{0}}--

The same idea applies to multi-choice survey vectors: attach an indented block to any option to add more context, a nested list, or even a snippet of code.

Which parts of this documentation helped you the most?

- [[text]] Written explanations

           Reading through the prose and examples at your own pace.

- [[code]] Ready-made snippets

           Copy-pasting blocks like this one straight into your course:

           ``` markdown
           - [[X]] just like this
           ```

- [[demo]] Live "Result" previews

           Seeing immediately how a block renders inside the document.

- [[link]] Links to further reading

           Following the references to GitHub, MDN, or Wikipedia.

                           --{{1}}--

As before, everything lines up with 11 spaces, since - [[text]] and its siblings are all exactly that wide. Feel free to mix option-label lengths, just remember that each option's own block only has to align with its own marker.

                             {{1}}

Which parts of this documentation helped you the most?

• [[text]] Written explanations

       Reading through the prose and examples at your own pace.
  

• [[code]] Ready-made snippets

       Copy-pasting blocks like this one straight into your course:
  
       ``` markdown
       - [[X]] just like this
       ```
  

• [[demo]] Live "Result" previews

       Seeing immediately how a block renders inside the document.
  

• [[link]] Links to further reading

       Following the references to GitHub, MDN, or Wikipedia.
  

Single-Choice Matrix

                          --{{0}}--

For defining survey blocks, you only have to have a header row, whose definition is also used by the trailing rows.

Markdown-format:

What is your opinion about LiaScript?

    [(totally)(agree)(unsure)(maybe not)(disagree)]
    [                                             ] LiaScript is great?
    [                                             ] I would use it to make online **courses**?
    [                                             ] I would use it for online **surveys**?

Result:

What is your opinion about LiaScript?

[(totally)(agree)(unsure)(maybe not)(disagree)]
[                                             ] LiaScript is great?
[                                             ] I would use it to make online **courses**?
[                                             ] I would use it for online **surveys**?


                           --{{1}}--

And also in this case, again, you can use numbers to display the summary as categorical.

                           --{{2}}--

As depicted below, the brackets [ ] do not have to match with the first line.

                             {{1}}

Markdown-format:

What is your opinion about LiaScript?

- [(1 totally)(2 agree)(3 unsure)(4 maybe not)(5 disagree)]
- [                ] LiaScript is great?
- [                ] I would use it to make online **courses**?
- [                ] I would use it for online **surveys**?

Result:

What is your opinion about LiaScript?

• [(1 totally)(2 agree)(3 unsure)(4 maybe not)(5 disagree)]
• [ ] LiaScript is great?
• [ ] I would use it to make online courses?
• [ ] I would use it for online surveys?

Multi-Choice Matrix

                           --{{0}}--

The multi-choice blocks are self-explanatory and behave exactly as the single-choice blocks from the previous section.

Markdown-format:

[[1][2][3][4][5][6][7]]
[                     ] question 1 ?
[                     ] question 2 ?
[                     ] question 3 ?

Result:

[[1][2][3][4][5][6][7]]
[                     ] question 1 ?
[                     ] question 2 ?
[                     ] question 3 ?

Select Survey

                           --{{0}}--

Do you remember the selection-quiz? If you remove all parentheses, then there is no correct option anymore, and the selection turns into a survey. Your users can pick exactly one option from a dropdown menu.

Which fruit do you like the most?

    [[ Apple 🍎 | Banana 🍌 | Cherry 🍒 | __None of them__ ]]

                           --{{1}}--

The difference between a quiz and a survey is only defined by the existence of a solution. Thus, [[ Apple | (Banana) ]] is a selection-quiz, while a single word [[ Banana ]] without any vertical bars is a text-quiz. A survey requires at least two options without any parentheses.

                             {{1}}

Result:

Which fruit do you like the most?

[[ Apple 🍎 | Banana 🍌 | Cherry 🍒 | __None of them__ ]]

Drag and Drop Survey

                           --{{0}}--

The same trick works for drag & drop. If you omit all parentheses, your users can choose their option by dragging a card into the drop zone, or by clicking onto the drop zone and then onto a card. Again, you have to define at least two options.

Which fruit do you like the most?

    [->[ Apple 🍎 | Banana 🍌 | Cherry 🍒 | __None of them__ ]]

                             {{1}}

Result:

Which fruit do you like the most?

[->[ Apple 🍎 | Banana 🍌 | Cherry 🍒 | __None of them__ ]]

Survey Options

                           --{{0}}--

Similar to quizzes, surveys can be configured by adding some attributes to the comment in front of them. By default, a survey has to be filled out completely before it can be submitted, and once it is submitted, it is locked. The following options allow you to change this behavior:

• data-randomize: Shuffles the order of options for vectors, selections, and drag & drop surveys, and the order of rows for matrix surveys. The order is kept until the next page reload. It has no effect on text-surveys.
• data-updates-allowed (or shorter data-updates): After submitting, the submit-button turns into an update-button, which allows your users to change their minds and resubmit their answers.
• data-incompleteness-allowed (or shorter data-incomplete): Skips the check for completeness, thus it is possible to submit an empty text, a matrix where not all rows have been answered, or even nothing at all.

<!--
data-randomize
data-updates
data-incomplete
-->
[(1 totally)(2 agree)(3 unsure)(4 maybe not)(5 disagree)]
[                                                       ] Surveys are fun?
[                                                       ] I like to change my mind?
[                                                       ] I never answer all questions?

                           --{{1}}--

Try to submit the survey below without answering all questions, and afterwards use the update-button to change your answers. If you reload the page, the order of rows will also change.

                             {{1}}

Result:

[(1 totally)(2 agree)(3 unsure)(4 maybe not)(5 disagree)] [ ] Surveys are fun? [ ] I like to change my mind? [ ] I never answer all questions?

Survey Solutions

                           --{{0}}--

Surveys have no right or wrong answers, but sometimes you want to reveal something after the users have committed to their answers: the actual result of an estimation, a sample solution for a free-text question, some background information, or simply a "thank you". Therefore, you can attach a solution block to every type of survey, in the same way as with quiz solutions: just add two lines of at least three asterisks directly below the survey.

How many people live on earth today?

[(1)] about 2 billion
[(2)] about 5 billion
[(3)] about 8 billion
[(4)] about 12 billion
*********************************************************

The world population passed __8 billion__ in November 2022.

*********************************************************

                           --{{1}}--

The solution is revealed and scrolled into view once the survey has been submitted. Like all other blocks, it can contain any LiaScript content, also narrator comments, which are read aloud at this moment, and scripts, which are only executed once the solution becomes visible.

                             {{1}}

                           --{{2}}--

This also works with free-text surveys, for example, to present a sample solution, after your users have tried to answer the question on their own.

                             {{2}}

Explain in one sentence, why the sky is blue.

[[___ ___ ___]]
*********************************************************

        --{{2}}--
Sunlight is scattered by the molecules of the air, and
short, blue wavelengths are scattered much more than red.

__Sample solution:__ Sunlight is scattered by the molecules
of the air, and short (blue) wavelengths are scattered much
more strongly than long (red) ones (Rayleigh scattering).

*********************************************************

    --{{2}}--

Surveys and Scripting

                           --{{0}}--

As it was done with tasks and quizzes, you can also associate a script to every survey to change its behavior or to send the result to an external service. By default, you have to provide some input in order to submit the data. Within the following example, both cases are treated as errors, whether the user just hits the submit button or if only spaces and tabs will be entered. The script returns true, if the input matches your experience. Otherwise, an error message will be presented to the user, depending on the input length. If you just return false, then no information will be presented to the user.

Please enter some spaces at first:

[[___]]
<script>
  let input = `@input`.trim()

  if (input.length > 4) {
    true
  } else if (input.length == 0) {
    send.lia("Please enter some text", [], false)
  } else {
    send.lia("Please provide some meaningful input", [], false)
  }
</script>

Result:

[[___]]

                           --{{1}}--

The input-data for different types of summaries is the same as for quizzes, but you can check the input always manually via alert function. Note that console.log will not work in this case at the moment.

                             {{1}}

What are your favorite colors?

[[1 red]]         is it red
[[2 green]]       green
[[3 blue]]        or blue
[[4 dark purple]] last chance ;-)
<script>
  alert(`@input`)
</script>

What are your favorite colors?

[[1 red]] is it red [[2 green]] green [[3 blue]] or blue [[4 dark purple]] last chance ;-)

Classrooms

                           --{{0}}--

A LiaScript classroom is a lightweight way to work together with your class in real time, without accounts and without any central authority or server that stores your data. All connected browsers synchronize their state directly, the servers that are used, are only relays that pass on messages. Thus, everyone who has opened the same course can join a room and you will instantly see what the others are doing.

What is Synced?

• Quizzes & Surveys: an anonymous overview of the results of all participants
• Executable code: can be switched into a collaborative editor
• Chat: every message is interpreted as LiaScript, thus you can post quizzes, surveys, code, or media to the chat on the fly
• Templates: can bring their own collaborative features, such as a shared drawing canvas, see Classroom API

                           --{{1}}--

The basic idea is, if you join a room, you bring your data with you, if you leave the room, then all of your data will be removed from the global state. Thus, nothing is logged and you have the control over your data. Chat messages and collaborative changes to a code snippet will remain within the classroom as long as one user is within the room. If all leave the room, the chat and the collaborative changes are lost, unless you have decided to save your classroom.

I don't want Classrooms

                           --{{0}}--

You can also disable this feature for your course, simply by adding the command classroom: disable or classroom: false to your main definition.

<!--
author: ...

classroom: disable
-->

# Title

Opening a Classroom

                           --{{0}}--

If you are on the LiaScript website and if you have a course started, you can directly switch to the classroom by clicking onto the share button in the top right corner and then onto "Classroom".

      {{0-1}}

                           --{{1}}--

This opens the classroom overview. You can either start a private notebook just for yourself with the pencil button, choose a backend to connect to, or open "What can a classroom do?" to get a longer explanation about all features.

      {{1-2}}

                           --{{2}}--

There are many different backends that can be used to connect the browsers of your class. Each entry shows how many users it can roughly handle and what kind of infrastructure it uses. If you are not sure, simply take one of the public ones, such as Nostr. More details on this are presented in the next section.

      {{2-3}}

                           --{{3}}--

After choosing a backend, you have to define a room name, which must be unique. To help you, you can click onto the circle arrow symbol and a name will be generated randomly for you. Your name and the password are optional, the name is shown to the others in the chat and within the details view of quizzes. On the right side you will find information about the selected backend, the "Infrastructure settings" allow you to change the servers to be used.

      {{3-4}}

                           --{{4}}--

If you then click onto connect and a connection could be established, the classroom settings will be closed automatically. Otherwise, an error message will be shown. If everything worked fine, the classroom button will show the number of users within the room, a chat button will appear in the top bar, and the URL of your course will have changed. You can share this new URL, it contains all required settings, except for the password. If you have defined one, your peers have to type it in by themselves.

      {{4-5}}

                           --{{5}}--

From now on, all participants will see the anonymous summary of all quizzes and surveys. In order to disconnect, you have to open the classroom settings again and click onto the disconnect button. The URL of the course will change back to the original representation.

       {{5}}

                             {{5}}

Note: You can try this out, if you open LiaScript on different browsers and go back to the quizzes and surveys sections. You should experiment a bit with the resulting presentations. Additionally, try to disconnect and observe the effect on the connected instances.

Choosing a Backend

                           --{{0}}--

LiaScript tries to be as backend-agnostic as possible. All backends offer the same features, they differ only in the way how browsers find each other and how messages are passed on. Some of them require no setup at all, some use public and decentralized relays, and for some you can (or have to) run your own servers. If you choose a password, the communication is additionally encrypted.

Note: All backends that start with "Trystero-" use the relays or trackers only to find each other, afterwards the browsers talk directly via WebRTC. Since LiaScript 2.6.0 the former backends "Torrent", "MQTT" and "IPFS" are called "Trystero-Torrent", "Trystero-MQTT" and "Trystero-IPFS". Shared links and saved classrooms that still use the old names are no longer recognized, thus you have to open and share these rooms again.

                           --{{1}}--

Every backend comes with a set of default servers, thus you can directly start without any configuration. But, if you want to use your own infrastructure, you can change this within the "Infrastructure settings" at the bottom of the right side. In the case of Nostr, you can define your own list of relays, and by checking "save class data on server", snapshots of your classroom are stored on these relays, such that the room survives, even if everyone has disconnected. This way you can come back later and find the chat and the results again.

                             {{1}}

                           --{{2}}--

Be aware that the default relays are publicly hosted servers, so only use the saving option for data that may be stored there. If you want to keep your class data under your own control, configure your own servers. The "Infrastructure settings" are locked while you are connected, and if you open a classroom via a shared link, they are hidden, since the link already defines which servers have to be used.

                             {{2}}

Thank you! The relay wss://relay.edufeed.org is kindly provided by the Edufeed project, which builds decentralized communities for education on top of Nostr, and we have their permission to use it. All other default relays and servers are public community services.

Classroom Modes

                           --{{0}}--

By default, a classroom runs in "Shared" mode, where all participants are equal and everyone sees the summary of all quizzes and surveys. But sometimes, for example in an exam-like situation or for a live poll, you might not want your students to see the answers of the others. Therefore, you can choose between three modes:

• ☮️ Shared: All are equal and see the summary of quizzes and surveys.
• 🛂 Summary: Only the initiator of the classroom can see the summaries.
• 🛰️ Details: The initiator can additionally see the details per participant, that is, who has answered what and how many trials were required.

      {{0-1}}

                           --{{1}}--

The modes "Summary" and "Details" require an owner, who has created the room. Thus, before you can connect, you have to click onto the "generate owner token" button. The token stays within your browser and only a hash of it is shared, this way you can prove later that you are the initiator of this classroom, for example if you reconnect. Within the share menu, the owner gets a little ✨ next to the number of users.

      {{1-2}}

                           --{{2}}--

Your students join as usual via the shared link, but in these modes they will only see a "Thank you for your feedback!" after submitting, without any summary of the others.

      {{2-3}}

                           --{{3}}--

As the initiator, you will see the summary, and in "Details" mode you can additionally open the details table beneath every quiz and survey. It shows, for every participant, whether they are online, whether they have answered, how many trials were required, and the resulting score.

       {{3}}

Chat and Collaborative Code

                           --{{0}}--

As soon as you are connected, a chat button appears in the top bar, which opens the chat next to your course. Every message is interpreted as LiaScript, thus you can not only write text, but also post formulas, tables, images, or even a spontaneous survey or quiz, which will be synchronized like any other quiz or survey within the course. If you also want to allow scripts within chat messages, you have to check "Allow scripts to be executed in the chat" in the classroom settings.

      {{0-1}}

                           --{{1}}--

Every executable code block gets an additional button beneath the editor, which allows you to switch to a collaborative editor. Now all participants are editing the same code and you can see the cursors and names of the others. Click onto the same button again to switch back to your own version.

       {{1}}

Saving Classrooms

                           --{{0}}--

If you want to meet again with the same class, check "Remember this classroom" before connecting. Then the settings of the classroom are saved within your browser and its content (chat, results, collaborative code) is cached locally. You can additionally give it a local name and a note, which are only visible to you. Opening a shared link of a saved classroom also reuses its local cache.

                           --{{1}}--

All saved classrooms are listed on the classroom overview under "Your classrooms". You can rename them, add comments, delete them, or simply reconnect with a single click. The colored dot indicates the mode and "Initiator" marks the rooms you have created.

       {{1}}

Own Notes

                           --{{0}}--

And finally, a classroom can also be a room just for yourself. If you click onto the pencil button on the overview, a local classroom is opened, which does not require any network connection. You can use the chat as a notebook for the current course, with all the features of LiaScript, for example to write down some notes or to create your own little quiz for later. Everything is stored only within your browser.

Collaborative Templates

                           --{{0}}--

Templates can also use the classroom for their own collaborative features. The CollaborativeDrawing template, for example, offers a canvas, on which everyone draws on an own layer. Without a classroom you only see your own drawing, which is stored within your browser. If you join a classroom, it is synchronized with the others and the classroom mode decides, who sees which drawings, in the same way as for quizzes. Thus, in "Details" mode, only you as the owner see the drawings of all your students with their names.

                           --{{1}}--

If you want to build such a template on your own, have a look at the Classroom API.

Classroom Experience in Action

                           --{{0}}--

The following video shows how to open, share, and close a LiaScript classroom.

!?LiaScript classroom demo

Enabling the Classrooms in any LMS

                           --{{0}}--

If you have exported your course to a SCORM or IMS package with the LiaScript-Exporter you can also establish classrooms between different users of the same course within a single LMS or between different ones, such as Moodle or ILIAS.

                           --{{1}}--

By default, the classroom-feature is disabled within any exports, but as you can disable it for your course, it is also possible to enable it. Thus, at first, you have to enable this feature within your course, before you export it.

                             {{1}}

<!--
...

classroom: enable

-->

# Your Course

                           --{{2}}--

Secondly, the classroom name has to be truly unique and surrounded by quotations. By default, the URL of your Markdown file and the room-name are used to generate a unique ID for the classroom, which prevents collisions between different courses, which accidentally use the same room name. However, by surrounding the room-name with single or double quotation marks, you instruct LiaScript to use this specific room name and to ignore the course URL. All the roommates have to enter exactly the same name for the classroom. That's it!

                             {{2}}

Room name: "This has to be a truly unique name 129281715#123"

Under the Hood

                           --{{0}}--

If you are interested in the implementation stuff, we build classrooms with the help of CRDTs and try to make LiaScript as backend-agnostic as possible. You can add support for your own systems within the LiaScript repository.

Implementation: https://github.com/LiaScript/LiaScript/tree/development/src/typescript/sync

Effects

                           --{{0}}--

There are currently three types of effects that we call:

1. Animations

2. Comments via Text-to-Speech

3. and Playback functions

                           --{{1}}--
   

All of these elements can be used inline and as block-level elements. Every effect is defined by two braces:

                             {{1}}

    --{{1}}--
Spoken comments.

     {{1-2}}
Blocks that appear at animation
step 1 and disappear on step 2.

     {{|>}}
To be read aloud when user clicks
the on the play button...

                           --{{2}}--

Animations are only visible, and comments are read aloud in "Presentation" or "Slides" mode. If you set the mode to "Textbook", then all animations and comments will be displayed on one slide where you have placed them within the document. In the other two modes, they are revealed step by step with each click.

                            {{3 |>}}

You need to balance these features properly so that your course can be read in Textbook mode and used for presentations and more.

Animations

                               --{{0}}--

Animations are defined by two curly braces: one starting and one optional ending number. They can be associated with single blocks, multiple blocks, and also inline elements.

{{start-stop?}} | {start-stop?}{inline}

Block Animations

                               --{{0}}--

Animations can be associated with blocks by adding two curly braces above the block. We recommend indenting the animation definition by at least 4 spaces. Other Markdown renderers will highlight this as code, making it easier to read.

     {{1}}
This is an example for a *single* block animations.

     {{2-3}}
This one will appear on animation step 2 and disappear on 3.

{{4}} This is also ok, but it will look be harder to spot on GitHub.

                           --{{2}}--

Use a starting and an ending number, if you want the element to disappear at a certain point.

Result:

 {{1}}

This is an example for a single block animations.

 {{2-3}}

This one will appear on animation step 2 and disappear on 3.

{{4}} This is also ok, but it will look be harder to spot on GitHub.

Multi-Block Animations

                           --{{0}}--

Similarly to quizzes, as described in section Quiz-Solution, you can group multiple markdown blocks by lines of asterisks. Simply add the curly braces with the animation definition above the upper line.

            {{1-2}}
************************************

This is an example...

| that     | contains |
|----------|----------|
| multiple | blocks.  |

************************************


             {{2}}
<section>

As an alternative, you can also use
HTML-tags ...


... to surround multiple blocks.

</section>

                           --{{1}}--

Blocks can also have a starting and disappearing number.

                           --{{2}}--

Depending on your preferred style, you can also use HTML tags to group blocks. These will then be displayed slightly differently on GitHub.

Result:

        {{1-2}}

This is an example...

         {{2}}

Inline Animations

                               --{{0}}--

Inline effects can be used in nearly all LiaScript elements. In this case, you will have to unpack the curly braces: the first pair surrounds the animation definition, while the second pair contains all inline elements that should appear and/or disappear.

* no effect here
* but in this line {2}{show ***second***}
* as well as this one {1-2}{show ***first*** remove on __second__}

• no effect here
• but in this line {2}{show second}
• as well as this one {1-2}{show first remove on second}

Combinations & Styling

                           --{{0}}--

Animations can also be grouped freely, allowing one multi-block animation to contain multiple block animations, and one block can also contain further inline animations:

<!--
class="animate__animated animate__backInUp"
style="background:#CCC; padding:3rem; min-height: 40vh; border-radius: 3rem"
-->
                 {{1}}
*******************************************

This block contains {2}{multiple} inline animations.
With some
{2-3}{styled}<!-- class="animate__animated animate__flash" -->
elements as well.

<!-- class="animate__animated animate__backInDown" -->
                  {{3}}
!?[Animated paintings](https://www.youtube.com/watch?v=-DDphfCnFQc&autoplay=true)

*******************************************

             {{1}}

This block contains {2}{multiple} inline animations. With some {2-3}{styled} elements as well.

              {{3}}

!?Animated paintings

                           --{{4}}--

Any kind of CSS can also be added to an animation, as described in the section on Custom Styling. Additionally, we have included an additional CSS stylesheet in the main HTML comment of this document. This will load Animate CSS, but you can use any other CSS library or custom styling as well.

                             {{4}}

Animate.css documentation: https://animate.style

<!--
author: ...

link:   https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css
-->

# LiaScript

Comments: Text 2 Speech

                           --{{0}}--

The idea of a comment is that they should be associated with animations. When animation $x$ is revealed, then the comment $x$ is read aloud. Similar to a PowerPoint presentation, when one element appears and the presenter says something, then clicks and the next element appears and is also commented. Thus, a comment is a paragraph that is marked by two sets of curly braces, which contain a number, and two dashes around the braces. If multiple comments have the same number, then they will be replayed in the order of appearance.

          --{{1}}--
This will be spoken out loud.

          --{{2}}--
This will be spoken out loud too,
but at animation step 2.

          --{{2}}--
Don't forget me.

            {{1}}
__I am animation 1 {2}{and 2 too}.__

      --{{1}}--

This will be spoken out loud.

      --{{2}}--

This will be spoken out loud too, but at animation step 2.

      --{{2}}--

Don' forget me.

        {{1}}

I am animation 1 {2}{and 2 too}.

                           --{{3}}--

If you change the presentation mode, you will notice that these comments will be displayed in place in "Textbook" mode. In "Slides" mode, they will also be presented to the user, while they will be hidden in "Presentation" mode. If you switch off the sound, then this is the mode that can be used for presenting content, while the others can be used for self-studying.

Voices & Language

                           --{{0}}--

But where does the voice come from? In LiaScript, within the initial comment, you can use the language macro to define the document translation and narrator to define the default voice. Currently, we are using responsivevoice as a backup solution if your browser does not support text-to-speech. Otherwise, your default browser and operating system text-to-speech is utilized, which can vary across browsers and systems. Within the settings, it is possible to switch between the browser and backup TTS. It is possible to change the narrator on different layers: globally within the main comment tag, per slide, and also per comment, by inserting the voice into the comment definition.

1. Backup Speech-Engine: https://responsivevoice.org
2. Default narrator must be defined within the initial comment, otherwise US English Male is used
3. You can overwrite the default narrator per slide, by attaching a comment to the title tag
4. Use --{{number}}-- to indicate what is spoken and when
5. Use --{{number voice}}-- to change the voice for this particular comment
6. It is also possible to define custom macros for language definitions
7. You can have multiple comments with the same number, those will be combined, but only the voice of the first one is used
8. See a complete list of all supported voices in section narrator

<!--
author:   ...
language: en
narrator: US English Male
-->

# Title

...

#### Voices & Language
<!--
narrator: UK English Female
@Tanja:   Russian Female
-->

                    --{{1}}--
The entire ***Markdown*** paragraph right below the effect definition in double
minus notation is sent to responsivevoice to speak the text out loud in
`Presentation` or `Slides` mode.

                    --{{3 Deutsch Female}}--
Markdown ist eine vereinfachte Auszeichnungssprache, die von John Gruber und
Aaron Swartz entworfen und im Dezember 2004 mit Version 1.0.1 spezifiziert ...

                    --{{4 @Tanja}}--
«Для торжества зла достаточно бездействия хороших людей».

                --{{1}}--

The entire Markdown paragraph right below the effect definition in double minus notation is sent to responsivevoice to speak the text out loud in Presentation or Slides mode.

                --{{3 Deutsch Female}}--

Markdown ist eine vereinfachte Auszeichnungssprache, die von John Gruber und Aaron Swartz entworfen und im Dezember 2004 mit Version 1.0.1 spezifiziert ...

                --{{4 @Tanja}}--

«Для торжества зла достаточно бездействия хороших людей».

Hidden Comments

                           --{{0}}--

Sometimes, it might be necessary to add a comment or to read a part aloud to underline a certain point, which might be necessary in the narrated mode but not in the Textbook. Therefore, it is possible to put your TTS output into simple HTML comments. This won't be shown to anyone and also not visible on most other Markdown parsers and renderers.

<!-- --{{1}}--
Speak this out, but do not show it to anyone.
-->

                             {{1}}

The associated hidden comment to this point will not be visible in Textbook mode!

Translations

                           --{{0}}--

If you click on the language settings, you can either click on the element "Translate with Google (experimental)" and select another language. In this case, a JavaScript library will be injected that implements the translation feature. As you can see from the example, not all parts will be translated. Code blocks will not be translated by default, as well as comments that have been marked with another voice than the default. These comments remain as they are, while LiaScript tries to find an appropriate voice for the new language and gender.

                           --{{1}}--

You can attach specific parameters to the comment that prohibit or enforce translation. By default, Google will search for the class definition translate or notranslate, but other external browser plugins might also take into account the HTML5 attribute translate. So it is always good to use both definitions.

                             {{1}}

<!-- class="notranslate" translate="no" style="color: red" -->
                    --{{2}}--
I will not be translated!

                    --{{3 Russian Female}}--
«Для торжества зла достаточно бездействия хороших людей».

                --{{2}}--

I will not be translated!

                --{{3 Russian Female}}--

«Для торжества зла достаточно бездействия хороших людей».

                           --{{4}}--

You can attach these language attributes to any kind of Markdown block or inline element to control the translation. Note that code environments and foreign language comments will be tagged automatically with no-translate.

                           --{{5}}--

Diagrams are translated as well, this includes all tables that are visualized as charts and your own ECharts diagrams. Titles, axis names, legends, categories, and node names follow the selected language, and the built-in texts of the charts, such as tooltips or the toolbox, use the locale of the new language. This works with the Google Translator as well as with the built-in translators of Chrome and Firefox.

Note: Texts that are added to a diagram later on, for example by a script or by loading data, are only translated after you change the language again.

Speaker Annotations and Avatars

                           --{{0}}--

In the same way, you can attach any data-* annotation to a comment, for example, to mark who is speaking. On its own, such an annotation does not change anything, but it is passed on to an avatar, if your course imports a template that provides one.

<!-- data-speaker="anna" -->
                    --{{1 UK English Female}}--
Hi, I am Anna, and I will guide you through this chapter.

                           --{{1}}--

An avatar is shown within the same draggable and resizable overlay as the video comments, for every animation step that has comments but no video, videos always take precedence. While the comment is read aloud, either by text-to-speech or from an audio recording, the avatar can move its lips, and it can be switched off in the settings, like the video comments.

                             {{1}}

<!--
import: https://raw.githubusercontent.com/LiaTemplates/virtual-speaker/0.1.1/README.md

@onload
window.VirtualSpeakerConfig = {
  default:  { style: 'lorelei', seed: 'Mika', name: 'Mika' },
  speakers: { anna: { style: 'micah', seed: 'Anna', name: 'Anna' } }
}
@end
-->

# My Course

    @VirtualSpeaker.speaker(anna)
    --{{0 UK English Female}}--
Hi, I am Anna.

    @VirtualSpeaker.dicebear(bottts,R2)
    --{{1 US English Male}}--
Beep. I am a robot, created on the fly.

                           --{{2}}--

If you want to build your own avatar, see the narrator API of the global LIA object.

Comments: Multimedia

{{|>}}

At the recent eLearning Africa Conference 2024 in Kigali, Rwanda, we recognized that relying solely on browser-based text-to-speech output is insufficient for supporting all spoken languages and dialects. To enhance personalization and diversify language and content, we have introduced two highly requested types of comments, which complement the existing format. Since LiaScript version 0.15.7, you can now add audio or video recordings to your comments.

Audio

--{{0}}--

To play an audio file during your animation step, simply attach the multimedia link at the end of your comment. ?⏯

    --{{0}}--
To play an audio file during your animation step,
simply attach the multimedia link at the end of
your comment.
?[⏯](recording/audio_1.mp3)

--{{1}}--

?⏯ Or, add it to the front.

  {{1}}

    --{{1}}--
?[⏯](recording/audio_2.mp3)
Or, add it to the front.

    --{{1}}--
?[⏯](recording/audio_3.mp3)
Of course, you can also combine multiple comments.
The playback will occur in the order they appear
in the document.

--{{1}}--

?⏯ Of course, you can also combine multiple comments. The playback will occur in the order they appear in the document.

Video

--{{0}}--

!?⏯ We had a lengthy discussion and brainstorming session on where to add video content so it remains visible without affecting the user experience. Our solution: let the user decide. The user can choose where to place the overlaid video and adjust its size based on their screen size, orientation, and resolution.

--{{1}}--

!?⏯ To add short video content, simply include a video link at the beginning or the end of your comment.

  {{1}}

    --{{1}}--
!?[⏯](recording/video2.webm)
To add short video content, simply include a video
link at the beginning or the end of your comment.

    --{{1}}--
As before, you can combine multiple comments, which
will be replayed in sequence.
!?[⏯](recording/video3.webm)

--{{1}}--

As before, you can combine multiple comments, which will be replayed in sequence. !?⏯

Videos from YouTube, Vimeo & Co.

--{{0}}--

!?⏯ Your recordings do not have to be stored next to your course. Videos from YouTube, Vimeo and other platforms can be attached to a comment in the same way, and they are shown in the same overlay.

    --{{0}}--
!?[⏯](https://www.youtube.com/watch?v=8pTEmbeENF4&start=60&end=75)
Your recordings do not have to be stored next to your
course. Videos from YouTube, Vimeo and other platforms
can be attached to a comment in the same way, and they
are shown in the same overlay.

    --{{1}}--
Vimeo videos are cut with a time fragment.
!?[⏯](https://vimeo.com/76979871#t=10,25)

--{{1}}--

The rules are the same as for your own videos: one link at the beginning or the end of a comment, multiple comments are played in sequence. The text of the comment is shown, but it is not read out loud, the video replaces the voice.

  {{1}}

--{{2}}--

Videos are only shown if the sound is turned on and the course is not in Textbook mode. They require an internet connection, they cannot be downloaded for offline use. If a course is translated, the translated comment is read out loud and YouTube and Vimeo videos are muted.

Playback

                           --{{0}}--

Since Text2Speech output is integrated into the LiaScript notation, it can be intentionally used for language learners. Simply add a stylized play button to the effect definition to indicate what should be spoken out loud. You can also use different voices.

    {{|>}}
This entire paragraph will be spoken out __LOUD__.

    {{!> Australian Female}}
* But in this case, this can also be combined
* with a couple of
* - different
  - Markdown elements
  - whether it makes sense or not.

{{|>}}

This entire paragraph will be spoken out LOUD.

{{!> Australian Female}}

• But in this case, this can also be combined
• with a couple of
• • different
  • Markdown elements
  • whether it makes sense or not.

Tip: Formulas are read aloud as maths, and you can define your own text for them, see Reading Formulas Aloud.

Playback-Blocks

                           --{{0}}--

And, as introduced for animations, you can also group multiple blocks together. Simply add as many Markdown blocks between two lines of asterisks, and they will be interpreted as one larger block.

<!--style="background: #EEE; padding:2rem"-->
                  {{|>}}
**************************************************
This entire paragraph will be spoken out __LOUD__.

* But in this case, this can also be combined
* with a couple of
* - different
  - Markdown elements
  - whether it makes sense or not.

**************************************************

              {{|>}}

This entire paragraph will be spoken out LOUD.

• But in this case, this can also be combined
• with a couple of
• • different
  • Markdown elements
  • whether it makes sense or not.

                           --{{1}}--

As an alternative, you can also use an HTML tag like <section> or <div> to group blocks. The LiaScript result will remain the same, but it will be rendered differently on other Markdown interpreters.

Playback-Inlines

                           --{{0}}--

Like in the presented example, the exclamation will not interfere with the table definition. And as presented before, you can also use inlining for Playback elements, as it was used for animations, by simply using two pairs of braces. Depending on your preferences and the current context, it is also possible to define the stylized play-button with a vertical line or an exclamation mark. Like in the presented example, the exclamation will not interfere with the table definition.

| English              | German                            | Russian                                 | Arabic male               | Arabic female               |
| -------------------- |:--------------------------------- |:--------------------------------------- |:------------------------- | --------------------------- |
| {!>}{I go}           | {!> Deutsch Male}{ich gehe}       | {!> Russian Male}{я хожу}               | {!> Arabic Male}{أذْهبُ}  |                             |
| {!>}{you go}         | {!> Deutsch Male}{du gehst}       | {!> Russian Male}{ты ходишь}            | {!> Arabic Male}{تذْهبُ}  | {!> Arabic Female}{تذْهبين} |
| {!>}{he/she/it goes} | {!> Deutsch Male}{er/sie/es geht} | {!> Russian Male}{он / она / оно ходит} | {!> Arabic Male}{يذْهبُ}  | {!> Arabic Female}{تذْهبُ}  |
| {!>}{we go}          | {!> Deutsch Male}{wir gehen}      | {!> Russian Male}{мы ходим}             | {!> Arabic Male}{نذْهبُ}  |                             |
| {!>}{you go}         | {!> Deutsch Male}{ihr geht}       | {!> Russian Male}{вы ходите}            | {!> Arabic Male}{تذْهبون} | {!> Arabic Female}{تذْهبْن} |
| {!>}{they go}        | {!> Deutsch Male}{sie gehen}      | {!> Russian Male}{они ходят}            | {!> Arabic Male}{يذْهبون} | {!> Arabic Female}{يذْهبْن} |

                           --{{1}}--

The result is displayed within the table; all elements can be played on demand.

                             {{1}}

Hiding Text

                           --{{0}}--

If you only want to show the play buttons but not the text, it is possible to use some HTML tricks. The easiest way is to put your text into an HTML element and to remove it from the screen by using a span whose content is shifted off the screen. Simply styling the element with display: none will not work, since the TTS function requires the text to be rendered within the DOM, and the translation via Google will not work if the element is not visible.

                           --{{1}}--

But, since it is possible to define custom Macros, we can also apply a more elegant way. We define a set of local macros directly within a comment attached to the current heading. The @play macro has two parameters, one for the voice and the other for the text; the other macros are simply shortcuts for the voice that pass the text as the second parameter to the @play macro. Within the Arabic macro, it is also possible to define the gender of the narrator.

                             {{1}}

#### Hiding Text
<!--
@play: {!> @0}{<span style="display: inline-block; text-indent: -10000px">@1</span>}
@en: @play(UK English Male,@0)
@de: @play(Deutsch Male,@0)
@ru: @play(Russian Female,@0)
@ar: @play(Arabic @0,@1)
-->

| go        |         EN          |         DE          |            RU             |      AR male      |      AR female      |
| --------- |:-------------------:|:-------------------:|:-------------------------:|:-----------------:|:-------------------:|
| I         |      @en(I go)      |    @de(ich gehe)    |        @ru(я хожу)        | @ar(Male,أذْهبُ)   |                     |
| you       |     @en(you go)     |    @de(du gehst)    |      @ru(ты ходишь)       | @ar(Male,تذْهبُ)   | @ar(Female,تذْهبين) |
| he/she/it | @en(he/she/it goes) | @de(er/sie/es geht) | @ru(он / она / оно ходит) | @ar(Male,يذْهبُ)   | @ar(Female,تذْهبُ)   |
| we        |     @en(we go)      |   @de(wir gehen)    |       @ru(мы ходим)       | @ar(Male,نذْهبُ)   |                     |
| you       |     @en(you go)     |    @de(ihr geht)    |      @ru(вы ходите)       | @ar(Male,تذْهبون) | @ar(Female,تذْهبْن)  |
| they      |    @en(they go)     |   @de(sie gehen)    |      @ru(они ходят)       | @ar(Male,يذْهبون) | @ar(Female,يذْهبْن)  |

                           --{{3}}--

The outcome is a table with playback buttons only, where the text is concealed, and the primary language will be translated while the other languages remain unchanged.

                             {{3}}

Animations to Playback

                           --{{0}}--

Since we are utilizing the double braces notation for playback elements, this can also be combined with animations by adding appearance and disappearance numbers. Depending on the current state of the animation, this will result in different sentences.

    {{1 |>}}
This is an example where {|> 1-2}{I go} _{|> 2}{I am going}_ to work.

                           --{{1}}--

You need to keep in mind that this will function as intended only if the user is not in Textbook mode. Otherwise, all elements will be read out loud, and nothing will be hidden.

{{1 |>}}

This is an example where {|> 1-2}{I go} {|> 2}{I am going} to work.

Fun with Tables

--{{0}}--

As previously noted, tables serve not only as structural elements within a Markdown document but also as datasets. In essence, there's minimal distinction between a diagram and a collection of values.

  9 |                                       (* dots)
    |
  y |                              *
  - |
  a |                    *
  x |
  i |          *
  s |
    |*
  0 +------------------------------------
    0            x-axis                 36

--{{1}}--

The same values can be collected within a list. By clicking on the small icon above this list, you will obtain the same plot as depicted previously.

  {{1}}

--{{2}}--

One of the most significant challenges in science is the scarcity of primary data. Initiatives like the Open Science Framework (http://osf.io) aim to address this issue by providing a platform where scientists can store and document extensive datasets. However, rather than relying on external tools to create visualizations, why not directly incorporate and visualize the data? This would enable others to utilize and examine the data more readily.

--{{3}}--

Everyone who creates or utilizes data and incorporates it into Markdown is already engaging in some form of configuration. Leveraging the structural settings of tables or data, we can automatically visualize data. It's rather surprising that Markdown tables have not been treated as datasets before. The following sections aim to provide a brief overview of various visualization options and how the system determines which one to apply. Additionally, you have the flexibility to enforce your preferred visualization style.

Note: If a course is translated, the texts within the diagrams are translated too, and the charts use the locale of the selected language.

Guessing the Type

--{{0}}--

If a table has no data-type, LiaScript looks at its numbers and checks the following rules in this order. The first rule that matches defines the type of the diagram. You do not have to remember them, the following sections show an example for every type, and you can always set the type on your own.

1. Text or numbers? Only the columns after the first one are counted. A column is numeric if more than half of its filled cells are numbers. If there are not more numeric than text columns, the table is not visualized.

2. Adjacency matrix: if the header (after the first cell) and the first column contain the same names in the same order, the table is a Graph. If there are values on the diagonal (self-references), it becomes a HeatMap.

3. Truth table: if all values are 0 or 1, the table is not visualized.

4. One row: a table with a header and a single row of values greater than zero becomes a PieChart.

5. Numbers in the first column (x-values):

   • if the header also contains only numbers (and the x-values are unique), it is a HeatMap,
   • if the x-values are strictly rising or falling, it is a LinePlot,
   • otherwise it is a ScatterPlot.

6. Categories in the first column:

   • if all of them start with a digit, like dates or times (2024-03-01, 01.05.2024, 08:00), it is a LinePlot,
   • if there are at least three numeric columns and the table has 50 or more cells, it is a Parallel plot,
   • if the maximum of one column is more than ten times larger than the maximum of another, it is a Radar chart (three or more numeric columns) or a Parallel plot,
   • otherwise it is a BarChart.

   --{{1}}-- Numbers are written with a decimal point, optionally followed by a unit, which is separated by a space.

   {{1}}

LinePlot

--{{0}}--

The following dataset, sourced from https://ourworldindata.org, illustrates government expenditure on education as a percentage of GDP. The first column represents the x-values, while the subsequent columns denote different categories. Since the years are strictly rising, the values are connected as lines. This also works with dates or times in the first column, like 2024-03-01 or 08:00.

--{{1}}--

If you click on the image icon again, you'll encounter a more elaborate representation complete with a title and labels.

https://ourworldindata.org/financing-education#all-charts-preview

--{{2}}--

The rationale behind this functionality is that you can incorporate additional settings, similar to how different Markdown elements are styled, by simply attaching an HTML comment to the beginning of the table. The type of representation is still automatically determined based on the table structure. However, you can still add attributes like data-title, data-xlabel, and data-ylabel to adjust the graphical representation. Refer to the section Attributes for more detailed information.

  {{2}}

<!--
data-title="Government expenditure on education"
data-xlabel="year"
data-ylabel="% of GDP"
-->
| Year | Finland | USA | Germany |   China |
| ---- | -------:| ---:| -------:| -------:|
| 1995 | 6.80942 |     | 4.42079 | 1.84192 |
| 1996 | 6.86052 |     | 4.48319 | 1.85338 |
| ...  |     ... | ... |     ... |     ... |

--{{3}}--

Certainly, you can visualize any type of table that doesn't adhere to the classification of a line or ScatterPlot. Let's define another type of presentation, such as a bar chart. If not all values within the first column can be parsed as numbers, they are interpreted as categories. Additionally, if you change the order of the table, the order of categories in the visualization will also change accordingly.

  {{3}}

| Animal          | weight in kg | Lifespan years | Mitogen |
| --------------- | ------------:| --------------:| -------:|
| Mouse           |        0.028 |              2 |      95 |
| Flying squirrel |        0.085 |             15 |      50 |
| Brown bat       |        0.020 |             30 |      10 |
| Sheep           |           90 |             12 |      95 |
| Human           |           68 |             70 |      10 |

  {{3}}

ScatterPlot

--{{0}}--

If your table resembles that of a LinePlot, but the numbers in the first column are not strictly rising or falling, for example because some of them appear twice, then this data cannot be interpreted as a "function" in a mathematical sense. In this case, the data is simply visualized as a ScatterPlot, displaying only the dots without connecting lines.

| Random |    I |  II |
| ------:| ----:| ---:|
|    5.0 |  1.0 |   5 |
|    ... |      |     |
|    5.0 | 10.0 |   7 |
|    ... |      |     |

BoxPlot

--{{0}}--

If you have a dataset presented in a ScatterPlot-like format but wish to utilize this data as primary data for a BoxPlot, you can manually change the type of visualization to a BoxPlot. This can be achieved by adding the following attribute to the beginning of your table, as demonstrated in the snippet below. Each column is then treated as a dataset and visualized accordingly.

<!-- data-type="boxplot" -->
| Random |    I |  II |
| ------:| ----:| ---:|
|    5.0 |  1.0 |   5 |
|    ... |  ... |  .. |

BarChart

--{{0}}--

In contrast to a Line or ScatterPlot, if the first column contains at least one entry that cannot be parsed as a number, it might be represented as a BarChart. This concept works well with the following example. If the maximum values of the columns do not differ too much, then the dataset is represented as a BarChart. However, if the maximum values vary significantly (more than ten times), you might end up seeing only one huge bar, making the other bars indistinguishable from each other. In such cases, a Radar or Parallel plot is chosen instead.

| Animal          | weight in kg | Lifespan years | Mitogen |
| --------------- | ------------:| --------------:| -------:|
| Mouse           |        0.028 |              2 |      95 |
| Flying squirrel |        0.085 |             15 |      50 |
| Brown bat       |        0.020 |             30 |      10 |
| Sheep           |           90 |             12 |      95 |
| Human           |           68 |             70 |      10 |

Radar

--{{0}}--

If, for example, humans and sheep are removed from the dataset, then weight in kilograms would not be visible in a BarChart at all. In such a case, a RadarChart is selected, if there are at least three numeric columns. This type of visualization allows for the analysis of data visually with different "y"-axes, accommodating for the diverse nature of the dataset.

PieChart

--{{0}}--

If you have a table with a header and only one row filled with numbers greater than zero, it will be automatically presented as a pie chart. In this representation, the header represents the categories, while the body denotes the quantities associated with each category.

--{{1}}--

You can utilize the first column to provide additional information about your data. If the first element of the list body contains text that cannot be directly interpreted as a number, then these two text snippets are used to define the main title and the subtitle of your chart.

  {{1}}

PieChart(s)

--{{0}}--

The default behavior for the table below would be to represent it as a barchart. However, you can enforce the usage of pie charts simply by adding the attribute piechart into the HTML comment directly above the table:

<!-- data-type="PieChart" -->
| Music-Style | Classic | Country | Reggae | Hip-Hop | Hard-Rock | Samba |
|:----------- | -------:| -------:| ------:| -------:| ---------:| -----:|
| 1994        |      50 |      50 |    100 |     200 |       350 |   250 |
| ...         |     ... |     ... |    ... |     ... |       ... |   ... |

--{{1}}--

This instruction overrides the default behavior and ensures that the data is visualized as a piechart. The result looks as follows:

  {{1}}

Animating Charts

--{{0}}--

Since data is parsed at runtime, you can also incorporate animations to dynamically change the values of the chart as you progress through your slides or navigate backward. However, it's important to consider that this approach may not be suitable for all audiences, especially those who prefer a more traditional textbook-style presentation.

   {{1}}

Transposing Data

--{{0}}--

If the previous table was too long and you prefer to condense it into two columns and grow your data vertically, you can use the attribute data-transpose, which mirrors your data along an imaginary vertical axis. This allows you to present your data in a more compact format.

<!-- data-transpose -->
| Music-Style {1-2}{1994} {2}{2014} |    Student rating |
|:--------------------------------- | -----------------:|
| Classic                           | {1-2}{50} {2}{20} |
| Country                           | {1-2}{50} {2}{30} |
| ...                               |               ... |

--{{1}}--

The result remains the same as above, but organizing your data in this transposed format might make it easier to handle and interpret.

  {{1}}

Funnel

--{{0}}--

The Funnel is a similar representation to the PieChart, but it is not selected automatically. If you wish to use the funnel visualization, you'll need to set the data-type parameter to "funnel".

<!-- data-type="funnel" -->
| Classic | Country | Reggae | Hip-Hop | Hard-Rock | Samba |
| -------:| -------:| ------:| -------:| ---------:| -----:|
|      50 |      50 |    100 |     200 |       350 |   250 |

 --{{1}}--

The process for using effects to generate animated diagrams remains the same as for pie charts.

   {{1}}

Map

--{{0}}--

A map visualization is akin to a BarChart in terms of the table structure. However, if you intend to depict your data on an actual map, you'll need to include a GeoJSON file containing all relevant geographic information about the shapes of your countries, states, cities, etc. The first column of your table must match the names of the objects in your GeoJSON data, which is attached to your table as follows:

<!-- data-type="map" data-src="https://code.highcharts.com/mapdata/custom/europe.geo.json" -->
| Country                | percent |
| ---------------------- | ------- |
| Albania                | 73.5    |
| Andorra                | 98.9    |

Currently, there is only support for visualizing one column, but this limitation will be addressed in future updates, allowing for more comprehensive visualizations of multi-column data.

HeatMap

--{{0}}--

Another type of visualization is a HeatMap, which is utilized when the table header and the first column exclusively contain numerical values, essentially representing coordinates. An adjacency matrix (see Graph) with values on its diagonal is also shown as a HeatMap. However, if you prefer to use categories instead of numerical coordinates, you can enforce the usage of a HeatMap by adding the following comment:

<!--
data-type="heatmap"
data-title="Seattle mean temperature in Fahrenheit"
data-show
-->
| Seattle |  Jan |  Feb |  Mar |  Apr |  May |  ... |
| -------:| ----:| ----:| ----:| ----:| ----:| ----:|
|       0 | 40.7 | 41.5 | 43.6 | 46.6 | 51.4 |  ... |
|       2 |  ... |  ... |  ... |  ... |  ... |  ... |

--{{1}}--

The attribute data-show simply displays the diagram by default, rather than using the table as the primary representation.

  {{1}}

{{1}}

https://datavizpyr.com/heatmaps-with-seaborn-in-python/

Parallel

--{{0}}--

A Parallel representation is employed when there are simply too many categories, making a BarChart impractical due to the resulting thin lines. This is the case for tables with at least three numeric columns and 50 or more cells. It is also used, if the values of only one or two columns differ too much for a BarChart.

Graph

--{{0}}--

If the values in the first column and the header of the table are equal, then the interpreter attempts to interpret the content of the table as an adjacency matrix, which defines a graph. If these values are symmetrical across the diagonal, then the matrix defines an undirected graph.

--{{1}}--

In contrast to this, if those values differ, then the result is simply a directed graph, where the values define the strength of the connections between nodes.

  {{1}}

  {{1}}

Unfortunately, self-referencing or multigraphs are currently not supported. If there are values on the diagonal, the table is shown as a HeatMap instead.

Sankey

--{{0}}--

A Sankey diagram is a special type of directed graph that is used to visualize the flow of something, such as energy, money, or other resources, typically represented as streams or flows between nodes.

https://en.wikipedia.org/wiki/Sankey_diagram

WordCloud

--{{0}}--

Word clouds are never guessed automatically, you have to set data-type="wordcloud". The header cells define the words, and every row defines one cloud, where the cell values are the weights of the words. If the first column is not numeric, it is used as the name of the cloud. All clouds share one font scale, thus equal values result in equal font sizes.

<!-- data-type="wordcloud" data-show data-title="Favorite programming languages" -->
| Class | Python | JavaScript | C  | Rust | Elm | Haskell | Java | Lua |
| ----- | ------:| ----------:| --:| ----:| ---:| -------:| ----:| ---:|
| 10a   |     12 |          8 |  3 |    2 |   1 |       1 |    5 |   2 |
| 10b   |      7 |         11 |  1 |    4 |   3 |       0 |    6 |   1 |

--{{1}}--

Long lists of words are easier to write and to read downwards. Use data-transpose in this case, so that the first column defines the words and every further column one cloud.

  {{1}}

<!-- data-type="wordcloud" data-show data-transpose data-title="Good learning in one word" -->
| Word        | Mentions |
| ----------- | --------:|
| curiosity   |       14 |
| patience    |        9 |
| creativity  |       11 |
| teamwork    |        7 |
| feedback    |        6 |
| failure     |        3 |
| practice    |       10 |
| motivation  |        8 |

None

--{{0}}--

Simply set data-type="none" to prevent any kind of visualization for the corresponding table. Tables that contain mostly text, as well as truth tables with only 0 and 1, are not visualized anyway. The following adjacency matrix would otherwise be shown as a graph.

<!-- data-type="none" -->
| Sankey |  A  |  B  |  C  |  D  |  E  |
|:------ |:---:|:---:|:---:|:---:|:---:|
| A      |     |  2  |     |     |     |
| B      |  3  |     |     |     |     |
...

Attributes

• data-type

  --{{0}}--
  

  You can use the attribute data-type to overwrite the automatically identified representation with your desired one. The names can be taken from the presented list, and it is not relevant whether you use lower or upper case. This approach also enables the use of types that cannot be automatically inferred at the moment, such as Sankey or BoxPlot. If you do not want to show tables as diagrams, you can also use none, and only the table will be visible.

  • data-type="bar|barchart"
  • data-type="boxplot"
  • data-type="funnel"
  • data-type="graph"
  • data-type="heatmap"
  • data-type="line|lineplot"
  • data-type="map"
  • data-type="none"
  • data-type="parallel"
  • data-type="pie|piechart"
  • data-type="radar"
  • data-type="sankey"
  • data-type="scatter|scatterplot"
  • data-type="wordcloud"

  Note: The none datasets will turn of the first fixed column. For the other cases the table is treated as a dataset and the header and the first column will be fixed while scrolling.

    {{1}}
  

• data-show

  --{{1}}--
  

  Simply add this attribute or set it to true, if you want to visualize your data immediately, without the need to click on the switch button. However, users still retain the ability to switch to the table representation if desired.

  <!-- data-show --> or <!-- data-show="true" -->

    {{2}}
  

• data-transpose:

  --{{2}}--
  

  Similar to the mathematical sense, set this attribute or set it to true if you want to transpose rows and columns. One benefit is that you can, for example, use a PieChart and let your table grow vertically instead of using a horizontal layout.

  <!-- data-transpose --> or <!-- data-transpose="true" -->

    {{3}}
  

• data-title:

  --{{3}}--
  

  By default, the first cell defines the title of your diagram. However, if you prefer larger titles and want to avoid writing gigantic table headers, you can apply this attribute.

  <!-- data-title="Use whatever title you want to ..." -->

    {{4}}
  

• data-xlabel:

  --{{4}}--
  

  Similarly, as described above, you can also define the strings for the labels, in this case, for the label for the x-axis.

  <!-- data-xlabel="Time in minutes" -->

    {{5}}
  

• data-ylabel:

  --{{5}}--
  

  Or, in this case label for the y-axis.

  <!-- data-ylabel="Distance in meters" -->

    {{6}}
  

• data-xlim & data-ylim:

  --{{6}}--
  

  The limits are automatically determined, but you can also overwrite them with the following command.

  <!-- data-xlim="0,12.3" -->

  --{{6}}--
  

  The first value is used as the minimum, the second as the maximum value. If you skip a number, then the automatically determined value is used.

  <!-- data-ylim=",12" -->

    {{7}}
  

• data-src:

  --{{7}}--
  

  Currently, this attribute is used to refer to your GeoJSON data if you use the map representation. However, this functionality might change in the future to allow for the loading and visualization of data directly, such as CSV files. See sections Fun with Tables - Map

  <!-- data-type="map" data-src="https://..." -->

  --{{8}}--
  

  Be careful when utilizing GeoJSON files from external websites, as this may result in CORS (Cross-Origin Resource Sharing) problems. It's better to store these files in your own projects and refer to them directly to avoid such issues.

    {{8}}
  

  https://code.highcharts.com/mapdata/

    {{9}}
  

• data-sortable:

  By default a table is sortable by each column. This behavior can be turned off or on by using the data-sortable parameter. Use it as a global parameter per table by placing it into the main comment or turn it on or of within every column. The local column parameter will overwrite the global one.

  <!-- data-sortable="false" -->
  | Header 1 | <!-- data-sortable="true" --> Header 2 |
  | :------- | :------------------------------------- |
  | Item 1   | Item 2                                 |
  | Item 5   | Item 6                                 |
  | Item 9   | Item 10                                |
  | Item 13  | Item 14                                |
  

    {{10}}
  

• data-orientation:

  Depending on the default setting for a diagram it is possible to switch between vertical and horizontal orientation.

  <!-- data-orientation="horizontal" -->
  | Animal          | weight in kg | Lifespan years | Mitogen |
  | --------------- | ------------:| --------------:| -------:|
  | Mouse           |        0.028 |              2 |      95 |
  | Flying squirrel |        0.085 |             15 |      50 |
  | Brown bat       |        0.020 |             30 |      10 |
  | Sheep           |           90 |             12 |      95 |
  | Human           |           68 |             70 |      10 |
  

  Animal	weight in kg	Lifespan years	Mitogen
  Mouse	0.028	2	95
  Flying squirrel	0.085	15	50
  Brown bat	0.020	30	10
  Sheep	90	12	95
  Human	68	70	10

Custom Diagrams with ECharts

--{{0}}--

LiaScript utilizes ECharts for the diagrams and therefore uses a custom HTML tag or web component called lia-chart. You can check out examples at the following site:

https://echarts.apache.org/examples/en/index.html

--{{1}}--

Using this tag, you can pass your diagram configuration directly as an option in JSON format or as a simple dictionary, which will be evaluated automatically.

  {{1}}

<lia-chart option="{
  title: { text: 'Two Value-Axes in Polar' },
  polar: { center: ['50%', '54%'] },
  tooltip: { trigger: 'axis',
    axisPointer: { type: 'cross' }
  },
  angleAxis: { type: 'value', startAngle: 0 },
  radiusAxis: { min: 0 },
  series: [{ coordinateSystem: 'polar',
    name: 'line',
    type: 'line',
    showSymbol: false,
    data: (function() {
      const data = [];
      for (let i = 0; i <= 360; i++) {
        let t = (i / 180) * Math.PI;
        let r = Math.sin(2 * t) * Math.cos(2 * t);
        data.push([r, i]);
      }
      return data
    })()
  }],
  animationDuration: 2000
}"></lia-chart>

--{{2}}--

This approach allows you to rebuild nearly every example directly, providing flexibility and ease of customization.

  {{2}}

  {{3}}

--{{3}}--

ASCII-Art

--{{0}}--

Based on the SvgBob project by Ivan Ceras, LiaScript also has support for basic ASCII art drawings.

--{{1}}--

We had to rebuild the library in Elm. The project can be found here:

  {{1}}

https://github.com/andre-dietrich/elm-svgbob/

--{{2}}--

If you want to use it, simply create a new Markdown code block with at least 9 backticks, or use ascii (or shorter art) as the language indicator.

  {{2}}

``` ascii
+------+   +-----+   +-----+   +-----+
|      |   |     |   |     |   |     |
| Foo  +-->| Bar +---+ Baz |<--+ Moo |
|      |   |     |   |     |   |     |
+------+   +-----+   +--+--+   +-----+
              ^         |
              |         V
.-------------+-----------------------.
| Hello here and there and everywhere |
'-------------------------------------'
```

--{{3}}--

The result will be an SVG image that is scaled according to the full width of the available screen.

  {{3}}

+------+   +-----+   +-----+   +-----+
|      |   |     |   |     |   |     |
| Foo  +-->| Bar +---+ Baz |<--+ Moo |
|      |   |     |   |     |   |     |
+------+   +-----+   +--+--+   +-----+
              ^         |
              |         V
.-------------+-----------------------.
| Hello here and there and everywhere |
'-------------------------------------'

How to Draw things ...

--{{0}}--

Remember, all you require is a keyboard, so you can use basic characters to draw different shapes. Unicode is fully supported in LiaScript, which means you can use emojis within your drawings. Additionally, you can embed LiaScript elements for integrating anything LiaScript related.

via GIPHY

1. Boxes

--{{0}}--

Depending on the type of characters, you can define different kinds of boxes, triangles, or rectangular shapes. Supported characters for borders include:

borders:

• straight: -, _, |

• rounded: (, )

• diagonal: , /

• dashed: ~ horizontal, : or ! vertical

• double: = horizontal, || vertical

  {{1}}
  

--{{1}}--

--{{2}}--

Here are some examples for different shapes:

  {{2}}

``` ascii
+-----+      _____      +-----+      _____       _____
|  0  |     |  1  |     |  2  |     |  3  |     |_ 4 _|
+-----+     |_____|     |_____|     +-----+

.-----.     ._____.     ,-----,     -------     '-----'
|  5  |     |  6  |     |  7  |     |  8  |     |  9  |
'-----'     ,_____,     |_____|     -------     '_____'

o------o    *------*    #------#    O------O    .-----+
|  10  |    |  11  |    |  12  |    |  13  |    |  14 |
o------o    *------*    #------#    O------O    +-----'

 .----+     +----.      .-----.     /\       .------.
(  15 |     | 16  )    (  17   )   /18\     /  19  /
 `----+     +----´      `-----´   /____\   /______/
```

--{{3}}--

And here is their representation as an ASCII art image:

  {{3}}

+-----+      _____      +-----+      _____       _____
|  0  |     |  1  |     |  2  |     |  3  |     |_ 4 _|
+-----+     |_____|     |_____|     +-----+

.-----.     ._____.     ,-----,     -------     '-----'
|  5  |     |  6  |     |  7  |     |  8  |     |  9  |
'-----'     ,_____,     |_____|     -------     '_____'

o------o    *------*    #------#    O------O    .-----+
|  10  |    |  11  |    |  12  |    |  13  |    |  14 |
o------o    *------*    #------#    O------O    +-----'

 .----+     +----.      .-----.     /\       .------.
(  15 |     | 16  )    (  17   )   /18\     /  19  /
 `----+     +----´      `-----´   /____\   /______/

--{{4}}--

Dashed and double lines are drawn with ~, :, !, and =. Since these characters are also common in normal text, a run of them is only turned into a line if it continues a line, a corner, or an arrow at one of its ends and does not touch any text. That is why Note:, a == b, or ~~strike~~ remain text.

  {{4}}

<!-- style="max-width: 600px" -->
``` ascii
 .~~~~~~~~~~~~.          +==========+          +~~~~~~~~~~~+
 ! optional   !  ~~~~~~> |  stored  |=========>: cached    :
 '~~~~~~~~~~~~'          +==========+          +~~~~~~~~~~~+

 Note: a == b, x = 1, ~~strike~~ and ( : ) stay text
```

 .~~~~~~~~~~~~.          +==========+          +~~~~~~~~~~~+
 ! optional   !  ~~~~~~> |  stored  |=========>: cached    :
 '~~~~~~~~~~~~'          +==========+          +~~~~~~~~~~~+

 Note: a == b, x = 1, ~~strike~~ and ( : ) stay text

2. Arrows & Connectors

--{{0}}--

Depending on the direction of your arrow, you can use < or > for left and right, v or V for down, and ^ or A for up. The other endings (*, #, o, O) are direction independent. Arrows can also be dashed (~~~~>, - - ->) or double (====>), and double arrowheads such as >> only work in the middle of a line, at the end, the second > remains text. On vertical lines, v and V require a | directly above them, and ^ and A a | directly below, a + does not work here.

``` ascii
---->   -->>--   ----o   ----O   ----*   ----#

<--->   -<<-->>-  o---o   O---O   *---*   #---#

~~~~>   ====>    - - ->  <~~~~   <====   <- - -
_______________________________________
 |     |     |     |     |     |     |
 v     V     #     o     O     *

 ^     A     #     o     O     *
 |     |     |     |     |     |     |
-+-----+-----+-----+-----+-----+-----+-

^     A     #        o     O     *
 \     \     \      /     /     /
  \     \     \    /     /     /
   v     V     #  o     O     *
```

--{{1}}--

The result looks quite nice indeed. This approach enables you to draw some fancy images and to change them quite easily. Similar to "toki pona," sometimes a reduced set of features allows you to get directly to the point.

  {{1}}

 ---->   -->>--   ----o   ----O   ----*   ----#

 <--->   -<<-->>-  o---o   O---O   *---*   #---#

 ~~~~>   ====>    - - ->  <~~~~   <====   <- - -
 _______________________________________
  |     |     |     |     |     |     |
  v     V     #     o     O     *

  ^     A     #     o     O     *
  |     |     |     |     |     |     |
 -+-----+-----+-----+-----+-----+-----+-

 ^     A     #        o     O     *
  \     \     \      /     /     /
   \     \     \    /     /     /
    v     V     #  o     O     *

--{{2}}--

You can also use arrows to connect your other drawings, but keep in mind that in some cases, you will have to use the + sign to fully attach your lines to another edge.

  {{2}}

``` ascii
+-----+     +-----+     +-----+     +-----+
|  0  |---->|  1  |     |  2  +---->|  3  |
+-----+     +-----+     +-----+     +-----+

+-----+     +-----+     +-----+     +-----+
|     |     |     |     |     |     |     |
|  4  *-----#  5  |-----+  6  o----->  7  |
|     |     |     |     |     |     |     |
+-----+     +-----+     +-----+     +-----+

      +---#--o---*---<--->---O---.
      |  .-<<---,      .---.      \
      A /      /      /     \      \
      |/      (      V       o      #
      *        \    /         \    /
                `--+           `--*
```

--{{3}}--

The result looks as follows:

  {{3}}

+-----+     +-----+     +-----+     +-----+
|  0  |---->|  1  |     |  2  +---->|  3  |
+-----+     +-----+     +-----+     +-----+

+-----+     +-----+     +-----+     +-----+
|     |     |     |     |     |     |     |
|  4  *-----#  5  |-----+  6  o----->  7  |
|     |     |     |     |     |     |     |
+-----+     +-----+     +-----+     +-----+

      +---#--o---*---<--->---O---.
      |  .-<<---,      .---.      \
      A /      /      /     \      \
      |/      (      V       o      #
      *        \    /         \    /
                `--+           `--*

3. More Shapes

--{{0}}--

Here are some more examples of rounded shapes that can be used in simple drawings:

``` ascii
                                   /\
+-----+   .-----.    .-----.      /  \
|  1  |   |  2  |   (   3   )    /    \
+-----+   '-----'    '-----'    '------'

  _______            ________      .-------.
 /       \      /\   \       \    /         \
/    5    \    /  \   )   7   )  (     8     )
\         /    \  /  /_______/    \         /
 \_______/      \/                 '-------'

  +----------+
 /            \
+      9       +
 \            /
  +----------+

   .-----------.       .  <-.      .->  .
  (     10      )     (  11  )    (  12  )
   '-----+ ,---'       `->  '      `  <-'
         |/
         '
   _   __   .-.   .--.   .--.--.    .---.
  (_) (__) ( X ) ( 16 ) ( 1( )7 )  ( 1 8 )
            '-'   `--'   `--'--'    `---´

.-----.  .----.   +----+  *----*
 \   /    \    \   \    \  \    \
  \ /      \    \   \    \  \    \
   '        '----'   +----+  O----O
```

--{{1}}--

As you can see, by using parentheses, different rounded shapes can be generated too.

  {{1}}

                                   /\
+-----+   .-----.    .-----.      /  \
|  1  |   |  2  |   (   3   )    /    \
+-----+   '-----'    '-----'    '------'

  _______            ________      .-------.
 /       \      /\   \       \    /         \
/    5    \    /  \   )   7   )  (     8     )
\         /    \  /  /_______/    \         /
 \_______/      \/                 '-------'

  +----------+
 /            \
+      9       +
 \            /
  +----------+

   .-----------.       .  <-.      .->  .
  (     10      )     (  11  )    (  12  )
   '-----+ ,---'       `->  '      `  <-'
         |/
         '
   _   __   .-.   .--.   .--.--.    .---.
  (_) (__) ( X ) ( 16 ) ( 1( )7 )  ( 1 8 )
            '-'   `--'   `--'--'    `---´

.-----.  .----.   +----+  *----*
 \   /    \    \   \    \  \    \
  \ /      \    \   \    \  \    \
   '        '----'   +----+  O----O

4. Box Drawing

--{{0}}--

The Unicode standard defines a set of characters/symbols that were used in the past for drawing user interfaces and menus within the console. You can use these symbols individually or in combination with the symbols and shapes mentioned above.

``` ascii
╔════════════════════════════════════[×]═╗       ╭─────╮
║ Fenstertitel                           ║       │     │     ╳
╟──────────────────────────────────────┬─╢       ╵     ╷    ╱ ╲
║ Fensterinhalt                        │▲║       ╰─────╯
║                                      │░║
║                                      │░║       ┌─┬┐  ╔═╦╗  ╓─╥╖  ╒═╤╕
║                                      │░║       │ ││  ║ ║║  ║ ║║  │ ││
║                                      │░║       ├─┼┤  ╠═╬╣  ╟─╫╢  ╞═╪╡
║                                      │█║       └─┴┘  ╚═╩╝  ╙─╨╜  ╘═╧╛
║                                      │░║
║                                      │░║       ┌───────────────────┐
║                                      │░║       │  ╔═══╗ Some Text  │▒
║                                      │░║       │  ╚═╦═╝ in the box │▒
║                                      │░║       ╞═╤══╩══╤═══════════╡▒
║                                      │░║       │ ├──┬──┤           │▒
║                                      │░║       │ └──┴──┘           │▒
║                                      │▼║       └───────────────────┘▒
╚══════════════════════════════════════╧═╝        ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
```

--{{1}}--

These Unicode images can also be combined with the previous ASCII art examples, or you can use these box drawing elements to add shadows and more detail to your drawings. But note that box drawing characters are drawn as text and not as lines: they keep the text color, ignore stroke, and do not connect to ASCII lines, thus do not mix both within one outline. If you need double lines within an ASCII drawing, use = and || instead of ═ and ║.

  {{1}}

╔════════════════════════════════════[×]═╗       ╭─────╮
║ Fenstertitel                           ║       │     │     ╳
╟──────────────────────────────────────┬─╢       ╵     ╷    ╱ ╲
║ Fensterinhalt                        │▲║       ╰─────╯
║                                      │░║
║                                      │░║       ┌─┬┐  ╔═╦╗  ╓─╥╖  ╒═╤╕
║                                      │░║       │ ││  ║ ║║  ║ ║║  │ ││
║                                      │░║       ├─┼┤  ╠═╬╣  ╟─╫╢  ╞═╪╡
║                                      │█║       └─┴┘  ╚═╩╝  ╙─╨╜  ╘═╧╛
║                                      │░║
║                                      │░║       ┌───────────────────┐
║                                      │░║       │  ╔═══╗ Some Text  │▒
║                                      │░║       │  ╚═╦═╝ in the box │▒
║                                      │░║       ╞═╤══╩══╤═══════════╡▒
║                                      │░║       │ ├──┬──┤           │▒
║                                      │░║       │ └──┴──┘           │▒
║                                      │▼║       └───────────────────┘▒
╚══════════════════════════════════════╧═╝        ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

--{{2}}--

The following table contains a set of characters that can be used via copy and paste to draw various types of boxes:

  {{2}}

--{{3}}--

If you need shadows or different kinds of shadings, you can use some of the following elements:

  {{3}}

5. Emojis

--{{0}}--

Emojis are defined in the Unicode standard as well, which is why you can use any kind of symbols that you use in your day-to-day chat messages.

``` ascii
😎             👩

Bob            Alice
|    hello      |
+-------------->|
|               |
|  Is it ok?    |
|<~~~~~~~~~~~~~~+
Bob            Alice

😎             👩
```

😎             👩

Bob            Alice
|    hello      |
+-------------->|
|               |
|  Is it ok?    |
|<~~~~~~~~~~~~~~+
Bob            Alice

😎             👩

--{{1}}--

You can either install a plugin to your editor for emojis or you can search the net for emojis. Check out the following links or see section Unicode Symbols in the Appendix.

  {{1}}

6. Pitfalls

--{{0}}--

Whether a character becomes a line or remains text depends on its neighbors. Most of the time this works as expected, but some letters and symbols within labels can turn into shapes. If something looks strange, replace the character with a similar Unicode symbol:

--{{1}}--

Emojis and CJK characters take up two cells, so a box with an emoji needs one space less for every wide character to keep its right border in place. Some symbols, such as ⚙ ❤ ⚠ ☁, are only displayed as emoji with an additional variation selector (U+FE0F), thus copy them from an emoji picker.

Styling ASCII

--{{0}}--

As explained in section Custom Styling, it is also possible to add custom styles here by attaching an HTML comment to the beginning of an ASCII art image. This enables you, for example, to center the image, define a maximum width, or change the color of some base SVG elements: stroke and stroke-width change the lines, fill the arrowheads and dots, and background the background. Note that any style replaces the default style of the drawing, thus its background becomes transparent. Without a width, a drawing is scaled to the full width of the page, a good max-width is about 10 pixels per column.

<!--
style="
  display: block;
  margin-left: auto;
  margin-right: auto;
  max-width: 315px;
  fill: red;
  stroke: green;" -->
``` ascii
                           .--->  F
  A       B     C   D     /
  *-------*-----*---*----*----->  E
           \            ^ \
            v          /   '--->  G
             B --> C -'
```

                           .--->  F
  A       B     C   D     /
  *-------*-----*---*----*----->  E
           \            ^ \
            v          /   '--->  G
             B --> C -'

--{{1}}--

The text within a drawing, the arrowheads, and the dots can only be changed via CSS. Therefore, attach a class to the drawing and define the styles within the @style section of your course header. The elements of the SVG are line and path for lines, polygon for arrowheads, circle for dots, rect for squares, and text for all characters, including box drawing and emojis.

  {{1}}

<!--
@style
svg.ascii-demo text { fill: royalblue; font-weight: bold; }
svg.ascii-demo polygon,
svg.ascii-demo circle { fill: crimson; }
@end
-->

...

<!-- class="ascii-demo" style="max-width: 400px" stroke-width="2" -->
``` ascii
+--------+       +---------+       +--------+
| Input  +------>| Process +------>| Output |
+--------+       +----+----+       +--------+
                      |
                      o  log
```

+--------+       +---------+       +--------+
| Input  +------>| Process +------>| Output |
+--------+       +----+----+       +--------+
                      |
                      o  log

Adding Titles

--{{0}}--

As shown in section Code - Projects 💫, you can add a title after the language indicator. This "title" can be a one-liner of Markdown-LiaScript and is displayed directly below the ASCII art image, similar to how it is done for images.

<!--
style="
  display: block;
  max-width: 450px;" -->
``` ascii  Fig.: Working with branches in git checkout the __[git-Workflow](https://about.gitlab.com/topics/version-control/what-is-git-workflow/)__

new feature      .---#---.
                 |       |
development    .-o---o---o----o----o-.
               |                     |
main   *---*-+-*---*---*-------------*----
```

new feature      .---#---.
                 |       |
development    .-o---o---o----o----o-.
               |                     |
main   *---*-+-*---*---*-------------*----

Embedding LiaScripts

--{{0}}--

And of course, it is also possible to add LiaScript elements into your ASCII art drawing. This is accomplished by using double quotes ", which define something like a verbatim environment. There are currently two different types of environments: simple one-liner and blocks.

--{{1}}--

The code example demonstrates three applications for such verbatim LiaScript elements. Firstly, you can integrate and style a simple one-liner, which is not possible for text otherwise. Secondly, you can add entire blocks with a subsequent number of quotations that start at the same horizontal x-position. Lastly, this can also contain executable elements, animations, other inputs, and more.

  {{1}}

```` ascii
 .---------------------------------------.          ╔════════════════════════════════════[×]═╗
 |     https://LiaScript.github.io       |          ║ (3) Interactive JavaScript Console     ║▒
 +---------------------------------------+          ╟──────────────────────────────────────┬─╢▒
 | (1) "_ https://LiaScript.github.io _" |          ║"``` js                              "│▲║▒
 '---------------------------------------'          ║"console.log('hello world')          "│░║▒
                                                    ║"```                                 "│░║▒
                    (2)                             ║"<script>@input</script>             "│░║▒
"* Verbatim blocks start with quotes at the "       ║                                      │░║▒
"  same x position                          "       ║                                      │█║▒
"* The quote with the maximum length defines "      ║                                      │░║▒
"  the width of the block "                         ║                                      │░║▒
"* The number of subsequent quotes gets ignored,"   ║                                      │░║▒
"  LiaScript elements are placed above the      "   ║                                      │▼║▒
"  SVG-image "                                      ╚══════════════════════════════════════╧═╝▒
                                                     ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

````

--{{2}}--

As visible in the generated image, the verbatim elements are not as precisely placed as the normal text. This might require some adjustment of the positions of the quotations to achieve the desired result. You can observe that the verbatim elements are overlaid as foreignObjects above the SVG images by executing the code example.

  {{2}}

 .---------------------------------------.          ╔════════════════════════════════════[×]═╗
 |     https://LiaScript.github.io       |          ║ (3) Interactive JavaScript Console     ║▒
 +---------------------------------------+          ╟──────────────────────────────────────┬─╢▒
 | (1) "_ https://LiaScript.github.io _" |          ║"``` js                              "│▲║▒
 '---------------------------------------'          ║"console.log('hello world')          "│░║▒
                                                    ║"```                                 "│░║▒
                    (2)                             ║"<script>@input</script>             "│░║▒
"* Verbatim blocks start with quotes at the "       ║                                      │░║▒
"  same x position                          "       ║                                      │█║▒
"* The quote with the maximum length defines "      ║                                      │░║▒
"  the width of the block "                         ║                                      │░║▒
"* The number of subsequent quotes gets ignored,"   ║                                      │░║▒
"  LiaScript elements are placed above the      "   ║                                      │▼║▒
"  SVG-image "                                      ╚══════════════════════════════════════╧═╝▒
                                                     ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

1. Animations

--{{0}}--

Such integration of LiaScript into ASCII art can shine when you want to use animations to highlight a certain point. For example, in the following example, different usages of animations are demonstrated. The first three are inline animations, where the number is bound to the text. The last example is a block animation where the number is hidden.

``` ascii

 😀                                           😐
  |             "{1}{_How are you?_}"         |
  +------------------------------------------>|
  |           "{2}{**Need to do math**}"      |
  |<------------------------------------------+
  |          "{3}{How difficult can it be?}"  |
  +------------------------------------------>|
  | "                {{4}}                  " |
  | "$$                                     " |
  | " x = \sqrt[3]{ y                       " |
  | "   + \sqrt {y^2 + \bigg( \dfrac{c}{3a} " |
  | "   - \dfrac{b^2}{9a^2} \bigg)^3}}      " |
  | "$$                                     " |
  +<------------------------------------------+
  |                                           |
```

 😀                                           😐
  |             "{1}{_How are you?_}"         |
  +------------------------------------------>|
  |           "{2}{**Need to do math**}"      |
  |<------------------------------------------+
  |          "{3}{How difficult can it be?}"  |
  +------------------------------------------>|
  | "                {{4}}                  " |
  | "$$                                     " |
  | " x = \sqrt[3]{ y                       " |
  | "   + \sqrt {y^2 + \bigg( \dfrac{c}{3a} " |
  | "   - \dfrac{b^2}{9a^2} \bigg)^3}}      " |
  | "$$                                     " |
  +<------------------------------------------+
  |                                           |

2. Animations with TTS

--{{0}}--

The same animation can also be combined with text-to-speech output by using comments or hidden comments as shown in the example. Hidden comments are simply comments that are not shown to the public as normal comments. They are placed into an HTML comment, and different voices can be added too.

``` ascii

 😀                                           😐
  |             "{1}{_How are you?_}"         |
  +------------------------------------------>|
  |           "{2}{**Need to do math**}"      |
  |<------------------------------------------+
  .                 ...                       .
```

<!-- --{{1}}-- How are you? -->
<!-- --{{2 UK English Female}}-- Need to do some math.-->
<!-- --{{3}}-- How difficult can it be?-->
<!-- --{{4}}-- What the hell! -->

|             "{1}{_How are you?_}"         |
+------------------------------------------>|
|           "{2}{**Need to do math**}"      |
|<------------------------------------------+
|          "{3}{How difficult can it be?}"  |
+------------------------------------------>|
| "                {{4}}                  " |
| "$$                                     " |
| " x = \sqrt[3]{ y                       " |
| "   + \sqrt {y^2 + \bigg( \dfrac{c}{3a} " |
| "   - \dfrac{b^2}{9a^2} \bigg)^3}}      " |
| "$$                                     " |
+<------------------------------------------+
|                                           |

3. Quizzes

--{{0}}--

Of course, you can use this in combination with quiz text inputs or selections. Since every quotation in this example is a separated Markdown block, we need to trick the interpreter from trying to embed a single line text quiz into a gap text element by adding a space before the input. Together with the data-show-partial-solution command, this is an easy way of creating more complex quizzes.

<!-- data-show-partial-solution -->
``` ascii
                        .----------------------.
                       /                      /|
             .--------+----------------------+ +---------.
            /         |      " [[  24   ]] " |/         /|
  .--------+----------+----------+-----------+---------+ +----------.
 /         |         11          |      "[[   13   ]] "|/          /|
+----------+----------+----------+----------+----------+----------+ +
|      " [[   5   ]] "|          6          |          7          |/
+---------------------+---------------------+---------------------+
```

--{{1}}--

If you try out the following example, correct and incorrect inputs will be highlighted.

  {{1}}

                        .----------------------.
                       /                      /|
             .--------+----------------------+ +---------.
            /         |      " [[  24   ]] " |/         /|
  .--------+----------+----------+-----------+---------+ +----------.
 /         |         11          |      "[[   13   ]] "|/          /|
+----------+----------+----------+----------+----------+----------+ +
|      " [[   5   ]] "|          6          |          7          |/
+---------------------+---------------------+---------------------+

4. Working with Macros

--{{0}}--

Since the size of a LiaScript element is defined based on the width of the quotation, too long LiaScript definitions, such as an external image URL, might cause some problems. To solve this, you can define a local macro, in this case @image, which is basically only a substitution for the larger image. This macro can then be used as a placeholder within the verbatim. For more information on this topic, check out the section Macros.

#### 4. Working with Macros
<!--
@image: ![](https://upload.wikimedia.org/wikipedia/commons/thumb/9/9c/Human_Eye_Transverse_Cut_Unlabeled.jpg/1280px-Human_Eye_Transverse_Cut_Unlabeled.jpg)
-->

Name the elements in the following image:

<!-- data-show-partial-solution -->
``` ascii
        "                  @image                      "


" [[ (lens) | optic disc ]] "
        *---------------------->


                                               <------"[[  sclera  ]] "





" [[ (retina) | chorid ]] "
        *----------->




                        <----*" [[   optic nerve   ]] "
```

--{{1}}--

The result looks as follows, where the lower quotations are placed above the image. The size of the image was defined by the space between the quotes and required some manual moving till it fits. Can you solve it?

{{1}}

        "                  @image                      "


" [[ (lens) | optic disc ]] "
        *---------------------->


                                               <------"[[  sclera  ]] "





" [[ (retina) | chorid ]] "
        *----------->




                        <----*" [[   optic nerve   ]] "

Scaleable Vector Graphics

--{{0}}--

The latest version of LiaScript now supports tight integration with SVG images, enabling you to embed and manipulate vector graphics directly within your slides and notes. SVG (Scalable Vector Graphics) is an XML-based format for defining two-dimensional vector graphics. Unlike bitmap images (e.g., PNG or JPEG), SVG graphics are resolution-independent and can scale without loss of quality. They can be styled and animated using CSS and JavaScript, making them ideal for diagrams, charts, icons, and interactive visualizations.

• Specification & Tutorials

  • W3C SVG Specification
  • MDN Web Docs - SVG
  • SVG Tutorial by W3Schools

• Why Use SVG?

  • Scalability: Perfect display on high-DPI and retina screens.

  • Styling: Apply CSS rules for fills, strokes, gradients, and animations.

  • Interactivity: Bind events and manipulate elements via JavaScript.

  • Accessibility: SVG elements can be made accessible with ARIA attributes.

    --{{1}}-- To embed SVG images in your LiaScript document, you can use the standard <svg> container and include any valid SVG elements.

    {{1}}

<svg viewBox="0 0 200 100">
  <circle cx="50" cy="50" r="40" fill="lightblue" stroke="blue" stroke-width="2"/>
  <text x="50" y="55" font-size="10" text-anchor="middle">SVG Circle</text>

  <rect x="110" y="10" width="80" height="80" fill="lightgreen" stroke="green" stroke-width="2"/>
  <text x="150" y="55" font-size="10" text-anchor="middle">SVG Rectangle</text>
</svg>

--{{2}}--

This example draws a circle and a rectangle, with labels centered on each shape. You can adjust coordinates, colors, and text as needed.

  {{2}}

foreignObject

--{{0}}--

The <foreignObject> element lets you include HTML or other XML content inside an SVG. LiaScript leverages this to inject Markdown-rendered math or interactive elements directly into graphics. Using <foreignObject> you will always have to define the x, y, width, and height attributes, which define the position and size of the element.

<svg viewBox="0 0 280 200">

<!-- place the circumference formula around the top of the circle -->
<foreignObject x="130" y="0" width="200" height="80">
Circumference:

$$C = 2 \pi r$$
</foreignObject>

<!-- the circle -->
<circle id="circle" cx="100" cy="100" r="80" fill="lightblue" stroke="blue" stroke-width="2"/>

<!-- radius line -->
<line x1="100" y1="100" x2="180" y2="100" stroke="red" stroke-width="2"/>

<!-- center dot -->
<circle cx="100" cy="100" r="2" fill="black"/>

<!-- label "r" at the midpoint of the radius -->
<foreignObject x="110" y="78" width="100" height="30"> Radius: $r$ </foreignObject>

<!-- place the area formula inside, bottom-centered -->
<foreignObject x="55" y="100" width="100" height="100">
Area:

$$A = \pi r^2$$
</foreignObject>
</svg>

--{{1}}--

The resulting SVG image will look like this, where the mathematical expressions are rendered as LiaScript math elements. It will always apply the full width and scale embedded elements accordingly.

  {{1}}

$$C = 2 \pi r$$

Radius: $r$

$$A = \pi r^2$$

  {{2}}

--{{2}}--

<svg viewBox="0 0 780 300" style="width: 80%; background-color: white; color: black;">

<!-- Define arrow marker -->
<defs>
<marker id="arrow" markerWidth="10" markerHeight="10" refX="10" refY="3" orient="auto" markerUnits="strokeWidth">
<path d="M0,0 L0,6 L9,3 z" fill="#333" />
</marker>
</defs>

<text x="35" y="20">Setpoint</text>
<text x="38" y="40">Voltage</text>

<!-- Summing junction -->
<circle cx="60" cy="130" r="20" fill="#eee" stroke="#333"/>
<text x="35" y="100">+</text>
<text x="35" y="170">-</text>
<foreignObject x="50" y="118" width="100" height="100">
$ \sum $
</foreignObject>

<text x="140" y="135" width="20" height="20">Error</text>

<!-- PID Controller block -->
<rect x="250" y="0" width="120" height="60" fill="yellow" stroke="#333"/>
<foreignObject x="260" y="5" width="100" height="60">
{{1}}
$$ K_p e(t) $$
</foreignObject>

<rect x="250" y="100" width="120" height="60" fill="magenta" stroke="#333"/>
<foreignObject x="260" y="95" width="100" height="60">
{{2}}
$$ K_i \int_{0}^{t} e(t) dt $$
</foreignObject>

<rect x="250" y="200" width="120" height="60" fill="cyan" stroke="#333"/>
<foreignObject x="260" y="198" width="100" height="60">
{{3}}
$$ K_d \frac{\Delta e(t)}{dt} $$
</foreignObject>

<!-- Summing junction -->
<circle cx="450" cy="130" r="20" fill="#eee" stroke="#333"/>
<foreignObject x="440" y="118" width="100" height="100">
$\sum$
</foreignObject>

<text x="505" y="125">Control</text>
<text x="505" y="145">Voltage</text>

<rect x="600" y="110" width="100" height="40" fill="#f9f9f9" stroke="#333"/>
<text x="625" y="135">Process</text>
<text x="625" y="240">Output</text>

<!-- Arrows between elements -->
<!-- From setpoint to left summing junction -->
<line x1="60" y1="50" x2="60" y2="110" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<!-- From measurement (feedback) to left summing junction -->
<path d="M650,250 L650,290 L60,290 L60,150" fill="none" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<!-- From Error to P -- to summing -->
<path d="M155,115 L155,30 L250,30" fill="none" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<path d="M370,30 L450,30 L450,109" fill="none" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<!-- From Error to I -- to summing-->
<line x1="80" y1="130" x2="130" y2="130" stroke="#333" stroke-width="2" />
<line x1="180" y1="130" x2="250" y2="130" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<line x1="370" y1="130" x2="430" y2="130" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<!-- From Error to D -- to summing -->
<path d="M155,145 L155,230 L250,230" fill="none" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<path d="M370,230 L450,230 L450,150" fill="none" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<!-- From right summing to process -->
<line x1="470" y1="130" x2="600" y2="130" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<!-- From process down to output -- to world -->
<line x1="650" y1="150" x2="650" y2="220" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
<line x1="680" y1="235" x2="750" y2="235" stroke="#333" stroke-width="2" marker-end="url(#arrow)" />
</svg>

Experimenting with SVG

--{{0}}--

SVG has a wide range of features, including gradients, patterns, and advanced shapes, but also animations and interactivity. We are more than happy to see your experiments with SVG in LiaScript.

--{{1}}--

The following example was generated by ChatGPT and implements an ant colony optimization algorithm to find the shortest path.

  {{1}}

Charts

--{{0}}--

In many cases, a diagram is only used to present some kind of signal paths, primitive functions, clusters, or point clouds. While you can still generate images for these tasks, why not apply some basic ASCII art to solve the most common tasks? Using ASCII art can be a lightweight and versatile way to represent such simple structures, saving time and effort compared to creating and embedding images.

              Dunning-Krueger-Effect
100 |   *
    |                                               *
  C |    *                                     *
  o |
  n |  *  *                                 *
  f |
  i |      *
  d |                                   *
  e | *     *
  n |
  c |         *                  *
  e |           *            *
    |*               *
  0 +-----------------------------------------------
     0              Competence                   100