# Line Parser

Helper package that can parse a line from an ink story into **tokens** that can be used to add additional metadata. See `apps/example` in the root directory for an example of how it's used.

## Usage

```ts
import { parseLineIntoTokens } from "@a-morphous/frontispiece-line-parser"

let tokens = parseLineIntoTokens(text)
for (let t of tokens) {
	switch (t.type) {
		case "text":
			str += t.text
			break
		case "tag":
			if (t.isClosingTag) {
				str += `</span>`
			} else {
				str += `<span class="ink-${t.param}">`
			}
			break
		...
	}
}

```

`line-parser` will transform the string into a *flat* array of tokens; besides text tokens, most of them will have an opening token and closing token to mark tags. It's then the developer's responsibility to transform those tokens into the final line.

## Markup

### Text

Any text that doesn't match any other markup is represented as a `TextToken`.

### Tags

Tags can be used to make custom HTML or other markup, and have the following syntax:

```
<<tagname>>Content of the tag <</tagname>>

You can also have <<tag>>generic<</>> endings, which will nest them in order.
```

Tags will produce `TagTokens`:

```ts
type TagToken = {
	type: 'tag'
	param: string
	isClosingTag?: boolean // set to true if it's used as a closing tag.
}
```

### Links

Links are represented similarly to inline links in Markdown, and can be used to create a regular external link, or make any other note in the text that could be represented by some metadata.

```
[This is a link](target or url or link metadata)
```

They produce a single `LinkToken`:

```ts
export type LinkToken = {
	type: 'link'
	text: string
	target: string 
}
```
Link tokens don't have a closing tag; the text in them is the text rendered inside of the link body.

### Notes

Notes are exactly like links, except they use Markdown's image syntax, with a `!` before the rest of the syntax:

```
![This is a note](and a possible target).
```

They produce a `NoteToken`, and are distinct from links only to allow for different types of functionality.