@prostojs/rewrite 0.1.0 → 0.2.0

package/README.md

@@ -1,123 +1,193 @@
 # @prostojs/rewrite
 
-Easy and light templates renderer with HTML (XML) support based on [@prostojs/parser](https://www.npmjs.com/package/@prostojs/parser).
+A lightweight template engine for **code generation and scaffolding**. Embed conditional blocks, loops, and expressions directly in real source files — templates stay syntactically valid and readable. Supports both source code (text mode with comment-based directives) and HTML/XML (Vue-like `v-if`, `v-for`, `:attr` bindings).
 
-- Write syntactically valid templates (js, yaml, ...)
-- Use vue-like syntax for html-templates
-- Mix __html__ and __text__ modes at single template
+- Templates compile to cached JS functions — repeated renders are near-instant
+- Under 27 KB bundled, zero runtime dependencies beyond `@prostojs/parser`
+- Auto-detects text vs HTML mode by file extension; switch modes mid-file with directives
+- Point at a directory to scaffold entire projects with a single call
 
 ## Install
 
-npm: 
+```bash
+npm install @prostojs/rewrite
+# or
+pnpm add @prostojs/rewrite
+```
+
+## Quick Start
+
+```js
+import { ProstoRewrite } from '@prostojs/rewrite'
+
+const rw = new ProstoRewrite()
+
+// Text mode — rewrite a source code template
+const result = rw.textRewriter.rewrite(
+  `Hello {{ name }}! You have {{ count }} items.`,
+  { name: 'World', count: 3 }
+)
+// => "Hello World! You have 3 items."
+
+// HTML mode — rewrite markup
+const html = rw.htmlRewriter.rewrite(
+  `<ul><li v-for="item of items">{{ item }}</li></ul>`,
+  { items: ['apple', 'banana', 'cherry'] }
+)
+// => "<ul><li>apple</li>\n<li>banana</li>\n<li>cherry</li></ul>"
+```
+
+## Text Mode
+
+Text mode is designed for source code, config files, Dockerfiles, and any non-HTML content. Directives are embedded in line comments, keeping your templates syntactically valid.
+
+### Expressions
+
+Use `{{ }}` delimiters (customizable) to interpolate any JavaScript expression:
+
+```
+const greeting = '{{ salutation }} {{ name }}!'
+const sum = {{ a + b }}
+```
 
-`npm install @prostojs/rewrite`
+Context: `{ salutation: 'Hello', name: 'World', a: 2, b: 3 }`
 
-Via CDN:
+Output:
 ```
-<script src="https://unpkg.com/@prostojs/tree"></script>
-<script src="https://unpkg.com/@prostojs/parser"></script>
-<script src="https://unpkg.com/@prostojs/rewrite"></script>
+const greeting = 'Hello World!'
+const sum = 5
 ```
 
-## Usage
+### Conditional Blocks (IF / ELSE / ELSEIF)
 
-It's possible to point the `ProstoRewrite` to a file or a directory. It's also possible to rewrite any string using [rewriters](#rewriters) directly.
+```js
+//=IF (env === 'production')
+const API = 'https://api.prod.com'
+//=ELSEIF (env === 'staging')
+const API = 'https://api.staging.com'
+//=ELSE
+const API = 'http://localhost:3000'
+//=ENDIF
+```
 
+Context: `{ env: 'staging' }` produces:
 ```js
-const { ProstoRewrite } = require('@prostojs/rewrite')
-// or import module
-// import { ProstoRewrite } from '@prostojs/rewrite'
+const API = 'https://api.staging.com'
+```
 
-const rw = new ProstoRewrite()
-main()
-async function main() {
-    const context = { a: 1 } // context object for templates interpolation
-
-    // rewrite a single file
-    const renderedContent = await rw.rewriteFile({
-        // required:
-        input: 'path/to/file/filename.js',
-        // optional:
-        output: 'path/to/rewrite/filename.js',
-        mode: 'auto',   // text | html | auto
-    }, context)
-
-    // rewrite files in directory
-    await rw.rewriteDir({
-        // required:
-        baseDir: 'path/to/files',
-        // optional:
-        include: ['*.{js,html}'],   // glob pattern to include
-        exclude: ['*.svg'],         // glob pattern to exclude
-        output: 'output/path',
-        mode: 'auto',               // text | html | auto
-        onFile: (path, output) => {
-            console.log('Result for file ' + path + '\n' + output)
-        }
-    }, context)
-}
+The comment prefix (`//`, `#`, `--`, etc.) is automatically detected from the line. Use whatever comment style fits your language:
+
+```yaml
+#=IF (includeRedis)
+redis:
+  image: redis:alpine
+#=ENDIF
+```
+
+**Operation blocks reference:**
+
+| Key | Example | Description |
+|---|---|---|
+| `IF` | `//=IF(condition)` | Includes lines below only if `condition` is truthy. |
+| `ELSEIF` | `//=ELSEIF(condition)` | Alternative branch. Must follow `IF` or `ELSEIF`. |
+| `ELSE` | `//=ELSE` | Fallback branch. Must follow `IF` or `ELSEIF`. |
+| `ENDIF` | `//=ENDIF` | Closes the `IF` block chain. |
+| `FOR` | `//=FOR(a of b)` | Iterates with any valid JS loop expression. |
+| `ENDFOR` | `//=ENDFOR` | Closes the `FOR` block. |
+
+> Operation blocks can have spaces between words: `ELSE IF`, `END FOR`, etc.
+> All blocks work with `#` and `//` comment prefixes.
+
+### Loops (FOR / ENDFOR)
+
+```js
+//=FOR (const route of routes)
+app.get('{{ route.path }}', {{ route.handler }})
+//=ENDFOR
 ```
 
-## Templates
+Context: `{ routes: [{ path: '/api', handler: 'apiHandler' }, { path: '/', handler: 'indexHandler' }] }`
 
-### TEXT
+Output:
+```js
+app.get('/api', apiHandler)
+app.get('/', indexHandler)
+```
+
+### Nesting
+
+Blocks nest freely:
+
+```js
+//=IF (features.auth)
+//=FOR (const provider of authProviders)
+//=IF (provider !== 'local')
+import {{ provider }}Strategy from './strategies/{{ provider }}'
+//=ENDIF
+//=ENDFOR
+//=ENDIF
+```
 
-The text template is good for any text source (js, ts, yaml, ...).
+### Reveal Lines
 
-To keep the source files syntactically valid all the control flow blocks 
-must be written in comment `//` or `#`.
+Lines prefixed with `//:` (comment + reveal marker) are **hidden in the template but appear in the output**. This is the inverse of normal lines — useful for generating code that shouldn't be visible in the template source:
 
-Text template consists of:
-- operation blocks (`//=IF(...)`),
-- directives (`//!@ignore-next-line`),
-- reveal comments (`//: const a = 1`),
-- string expressions (`conat a = {{ scopedValue }}`).
+```js
+//=IF (useTypescript)
+//: import type { Config } from './types'
+//=ENDIF
+const config = {}
+```
 
-**Operation blocks*** **:**
-Key | Example | Description
----|---|---
-`IF`|`//=IF(condition)` or `#=IF(condition)`|WIll add the lines below only if the `condition` returns `true`. The `condition` must be a valid javascript and can use `context` vars.
-`ELSEIF`**|`//=ELSEIF(condition)` or `#=ELSEIF(condition)`|WIll add the lines below only if the `condition` returns `true`. The `condition` must be a valid javascript and can use `context` vars. Must be used after `IF` or `ELSEIF` operation block.
-`ELSE`|`//=ELSE` or `#=ELSE`|WIll add the lines below only if the previous conditions didn't match. Must be used after `IF` or `ELSEIF` operation block.
-`ENDIF`**|`//=ENDIF` or `#=ENDIF`|Ends the `IF` blocks series.
-`FOR`|`//=FOR(a of b)` or `#=FOR(a of b)`|Will iterate through the loop. The `a of b` part must be a valid javascript loop expression and can use `context` vars.
-`ENDFOR`**|`//=ENDFOR` or `#=ENDFOR`|Ends the `FOR` block.
+Context: `{ useTypescript: true }`
 
-*The operation block can have spaces before it and after it, but it must take only one line. All the operation blocks can start with `#` as well as with `//`
+Output:
+```js
+import type { Config } from './types'
+const config = {}
+```
 
-**The operation block may have spaces between words e.g. `ELSE IF`, `END FOR`...
+Reveal lines can contain expressions too:
 
-**Directives:**
+```js
+//: const {{ varName }} = {{ JSON.stringify(defaultValue) }}
+```
 
-Key|Example|Description
----|---|---
-`ignore-next-line` |`//!@ignore-next-line` or `#!@ignore-next-line`|Instruct the processor to ignore (not interpolate) the next line of the source. The next line will be copied without any change.
-`html-mode-on`|`//!@html-mode-on` or `#!@html-mode-on`|Instructs the processor (only if it is mixed rewriter) to start using HTML mode for the futher lines of the source.
-`html-mode-off`|`//!@html-mode-off` or `#!@html-mode-off`|Instructs the processor (only if it is mixed rewriter) to stop using HTML mode for the futher lines of the source and return to the text mode.
+### Directives
 
-**Reveal comments:** the line prefixed with `reveal comment` prefix will be rendered as **uncommented** line. Use this when needed to keep the source file syntatically valid.
+| Directive | Example | Description |
+|---|---|---|
+| `ignore-next-line` | `//!@ignore-next-line` | The next line passes through as-is, without interpolation. |
+| `html-mode-on` | `//!@html-mode-on` | Switch to HTML mode (mixed rewriter only). |
+| `html-mode-off` | `//!@html-mode-off` | Switch back to text mode. |
 
-**String expressions:** vue-like string expressions `{{ scopedValue }}` accepts valid javascript code and must interpolate into a `string` or anything that can be casted to `string`. The expression can access the context vars.
+```js
+//!@ ignore-next-line
+const template = '{{ this is not interpolated }}'
+const value = '{{ this IS interpolated }}'
+```
 
-**Example:**
+### Full Text Mode Example
 
 Source:
 ```js
 let myVar = 1
 //=IF (a === b)
-    //=FOR (const i of items)
+//=FOR (const i of items)
 //: const item{{ i }} = '{{ i }}' // reveal comment
-        //=IF (c === d)
+//=IF (c === d)
 myVar += 2
-        //=ELSE
+//=ELSE
 myVar -= 4
-        //=ENDIF
-    //=END FOR
+//=ENDIF
+//=END FOR
 //=END IF
 const myVar2 = 2
 ```
 
-Will be rewritten with context = `{ a: 1, b: 1, c: 2, d: 2, items: [1, 2] }`:
+Context: `{ a: 1, b: 1, c: 2, d: 2, items: [1, 2] }`
+
+Output:
 ```js
 let myVar = 1
 const item1 = '1' // reveal comment
@@ -127,46 +197,96 @@ myVar += 2
 const myVar2 = 2
 ```
 
-### HTML
+## HTML Mode
+
+HTML mode parses markup structure and supports Vue-inspired directives for conditionals, loops, and dynamic attributes.
+
+### Expressions
+
+Interpolation works the same as text mode:
+
+```html
+<h1>{{ title }}</h1>
+<p>Welcome, {{ user.name }}!</p>
+```
+
+### Conditional Rendering (v-if / v-else-if / v-else)
+
+```html
+<div v-if="user.isAdmin">
+    <h2>Admin Panel</h2>
+</div>
+<div v-else-if="user.isEditor">
+    <h2>Editor Dashboard</h2>
+</div>
+<div v-else>
+    <h2>Welcome, {{ user.name }}</h2>
+</div>
+```
+
+Only the matching block is rendered. The `v-if` / `v-else-if` / `v-else` chain must be on sibling elements.
+
+### Loops (v-for)
+
+```html
+<ul>
+    <li v-for="item of items">{{ item }}</li>
+</ul>
+```
+
+Any valid JavaScript loop expression works:
 
-The html template is good for XML-like sources (html, xml, svg, ...).
+```html
+<tr v-for="let i = 0; i < rows.length; i++">
+    <td>{{ rows[i].name }}</td>
+</tr>
+```
 
-By default html template uses vue-like syntax.
+`v-for` and `v-if` can be combined on the same element:
 
-**It supports:**
-- `v-for="..."`: attribute for loop the node. Expression must be a valid javascript loop expression.
-- `v-if="..."`: attribute for conditional rendering of the node. Expression must be a valid javascript condition expression.
-- `v-else-if="..."`: attribute for conditional rendering of the node. Expression must be a valid javascript condition expression.
-- `v-else`: attribute for conditional rendering of the node.
-- `:<attr_name>="..."`: expression as attribute value. Expression must be a valid javascript code that returns string/boolean or anything that casts to a string/boolean. If the expression result is type of boolean, the attribute will have no value and will be hidden if the result equals `false`.
-- `{{ ... }}`: vue-like string expressions `{{ scopedValue }}` accepts valid javascript code and must interpolate into a `string` or anything that can be casted to `string`. The expression can access the context vars.
+```html
+<li v-for="item of items" v-if="item.visible">{{ item.name }}</li>
+```
 
-### TEXT & HTML
+### Dynamic Attributes
 
-By default `ProstoRewrite` supports both: text and html modes at the same time. The default mode is controled by the [options](#options).
+Prefix any attribute with `:` to evaluate it as a JavaScript expression:
 
-If you want to switch to html mode in the middle of the text source you can use the following instruction:
+```html
+<img :src="baseUrl + '/images/' + image.file" :alt="image.title">
+<a :href="link.url" :target="link.external ? '_blank' : undefined">{{ link.text }}</a>
+```
 
-`//!@html-mode-on` or `#!@html-mode-on`
+**Smart boolean handling:** if the expression evaluates to `true`, the attribute is rendered without a value (`<input disabled>`). If `false`, the attribute is omitted entirely:
 
-And to switch back use:
+```html
+<input type="text" :disabled="isLocked" :required="isRequired">
+```
 
-`//!@html-mode-off` or `#!@html-mode-off`
+Context: `{ isLocked: true, isRequired: false }`
 
-If you want to switch to text mode in the middle of the html source you can use the following instruction:
+Output:
+```html
+<input type="text" disabled>
+```
 
-`<!--!@text-mode-on-->`
+### Switch to Text Mode
 
-And to switch back use:
+Inside an HTML file, switch to text-mode parsing with HTML comment directives:
 
-`<!--!@text-mode-off-->`
+```html
+<script>
+    <!--!@ text-mode-on -->
+    //=FOR (const key of Object.keys(config))
+    window.{{ key }} = {{ JSON.stringify(config[key]) }}
+    //=ENDFOR
+    <!--!@ text-mode-off -->
+</script>
+```
 
-**Examples:**
+And the reverse — switch to HTML inside a text file:
 
-Text template with embedded html processor:
 ```js
-const a = 'test'
-//=IF (condition)
 const html = `
 //!@ html-mode-on
 <div v-for='item of items'>
@@ -174,176 +294,174 @@ const html = `
 </div>
 //!@ html-mode-off
 `
-//=END IF
 ```
 
-Html template with embedded text processor:
-```html
-<div v-if="condition">
-    <!--!@ text-mode-on -->
-    const a = 'b'
-    #=IF (condition)
-    console.log(a)
-    #=ENDIF
-    <!--!@ text-mode-off -->
-</div>
-```
+## File and Directory Rewriting
 
-### Options
+The main use case: scaffold entire project templates.
 
-Options object is totally optional. The example below demonstrates the default values.
+### Rewrite a Single File
 
 ```js
-const rw = new ProstoRewrite({
-    defaultMode: 'auto',    // text | html | auto
-    debug: false,
-    htmlPattern: ['*.{html,xhtml,xml,svg}'],
-    textPattern: [
-                    '*.{js,jsx,ts,tsx,txt,json,yml,yaml,md,ini}',
-                    'Dockerfile',
-                    '*config',
-                    '.gitignore',
-                ],
-    html: {
-        exprDelimeters: ['{{', '}}'],
-        attrExpression: ':',
-        blockOperation: 'v-',
-        directive: '!@',
-        voidTags: [
-                    'area',
-                    'base',
-                    'br',
-                    'col',
-                    'command',
-                    'embed',
-                    'hr',
-                    'img',
-                    'input',
-                    'keygen',
-                    'link',
-                    'meta',
-                    'param',
-                    'source',
-                    'track',
-                    'wbr',
-                ],
-        textTags: ['script', 'style'],
-    },
-    text: {
-        exprDelimeters: ['{{', '}}'],
-        blockOperation: '=',
-        revealLine: ':',
-        directive: '!@',
-    },
-})
+import { ProstoRewrite } from '@prostojs/rewrite'
+
+const rw = new ProstoRewrite()
+
+// Returns rendered content; optionally writes to output path
+const content = await rw.rewriteFile(
+  {
+    input: 'path/to/template.js',
+    output: 'path/to/output.js',  // optional
+    mode: 'auto',                 // optional: 'text' | 'html' | 'auto'
+  },
+  { name: 'my-app', version: '1.0.0' }
+)
+```
+
+### Rewrite an Entire Directory
+
+```js
+await rw.rewriteDir(
+  {
+    baseDir: './template',
+    output: './my-new-project',
+    include: ['**/*'],                                        // optional glob patterns
+    exclude: ['node_modules/**'],                             // optional glob patterns
+    renameFile: (name) => name.replace('__name__', 'my-app'), // optional
+    onFile: (path, output) => console.log(`Wrote: ${path}`),  // optional callback
+    mode: 'auto',                                             // optional
+  },
+  {
+    name: 'my-app',
+    description: 'My awesome app',
+    useTypescript: true,
+    features: ['auth', 'api', 'database'],
+  }
+)
 ```
 
-Option | Type | Description
----|---|---
-defaultMode | `'text'` \| `'html'` \| `'auto'` | Determines the type of template processor used for templates. When `auto` it will use `htmlPattern` and `textPattern` options to decide on which processor to use.
-debug       | `boolean`   | Pushes debug messages to console when `true`.
-htmlPattern | `string[]`  | Glob pattern that defines files to be processed by `html` processor for `defaultMode` = `'auto'` mode.
-textPattern | `string[]`  | Glob pattern that defines files to be processed by `text` processor for `defaultMode` = `'auto'` mode.
-text        | `object`    | Options for `text` processor.
-text.exprDelimeters | `[string, string]` | Defines the delimeters for string expressions e.g. `{{ n.toLowerCase() }}`. Default: `['{{', '}}']`.
-text.blockOperation | `string` | Defines the prefix for block operations (e.g. `for`, `if`, ...). Default: `'='`.
-text.revealLine     | `string` | Defines the prefix for reveal commented line. Default: `':'`.
-text.directive      | `string` | Defines the prefix for directives (e.g. `ignore-next-line`, `html-mode-on`, ...). Default: `'!@'`.
-html        | `object`    | Options for `html` processor.
-html.exprDelimeters | `[string, string]` | Defines the delimeters for string expressions e.g. `{{ n.toLowerCase() }}`. Default: `['{{', '}}']`.
-html.attrExpression | `string` | Defines the prefix for attributes that have to be interpolated. Default: `':'`.
-html.blockOperation | `string` | Defines the prefix for block-operations attributes (e.g. `for`, `if`, ...). Default: `'v-'`.
-html.directive      | `string` | Defines the prefix for directives (e.g. `text-mode-on`, ...). Default: `'!@'`.
-html.voidTags       | `string[]` | List of void tags (without closing tags and without innerText)
-html.textTags       | `string[]` | List of text tags (that contain text and no other tags)
+**Mode auto-detection** picks the right parser based on file extension:
+- **HTML mode:** `*.html`, `*.xhtml`, `*.xml`, `*.svg`
+- **Text mode:** `*.js`, `*.ts`, `*.jsx`, `*.tsx`, `*.json`, `*.yml`, `*.yaml`, `*.md`, `*.txt`, `*.ini`, `Dockerfile`, `*config`, `.gitignore`
+
+Files that don't match any pattern are copied as-is.
 
 ## Rewriters
 
-Instance of `ProstoRewrite` ships 3 versions of rewriters:
-- text
-- html
-- mixed
+`ProstoRewrite` provides three rewriter flavors:
 
 ```js
 const rw = new ProstoRewrite()
-// 3 flavors:
-const trw = rw.textRewriter     // rewriter that can parse only text
-const hrw = rw.htmlRewriter     // rewriter that can parse only html
-const mrw = rw.mixedRewriter    // rewriter that can parse both
-// source for text rewriter:
-const source = '//=IF (a === 1)\nconst a = 1'
-const context = { a: 1 }
-// each rewriter has the same interface:
-trw.genRewriteCode(source)      // returns rendered function source code
-trw.genRewriteFunction(source)  // returns rewrite-function
-trw.printAsTree(source)         // prints parsed source as a tree
-trw.rewrite(source, context)      // renders the source with context
-```
-
-If you're going to use one template file for multiple renders it makes sense to cache its rewrite-function:
 
-```js
-// An abstract example of using cached rewrite-function
-const rw = new ProstoRewrite()
-const trw = rw.textRewriter
-const rewriteFunc = trw.genRewriteFunction(source)
-const result1 = rewriteFunc(context1)
-const result2 = rewriteFunc(context2)
-const result3 = rewriteFunc(context3)
+const trw = rw.textRewriter    // text only
+const hrw = rw.htmlRewriter    // html only
+const mrw = rw.mixedRewriter   // both (supports mode-switching directives)
+// mrw.text — text rewriter with html-mode-on support
+// mrw.html — html rewriter with text-mode-on support
 ```
 
-Besides those there is one more **String Expression Rewriter** comes as a _bonus_.
+Each rewriter has the same interface:
 
-It is can parse only string expressions and preserves the expression type if its source consists only from an expression. When the source has some surrounding string(s) it will cast the expression to string type.
-
-This kind of rewriter may be usefull when working with some configuration files that can have expressions as properties values.
-
-**Usage example**
 ```js
-import { getStringExpressionRewriter } from '@prostojs/rewrite'
+// Generate the compiled JavaScript source (for inspection/debugging)
+trw.genRewriteCode(source)
 
-const srw = getStringExpressionRewriter()
+// Compile once, execute many times — ideal for repeated renders
+const render = trw.genRewriteFunction(source)
+const out1 = render({ name: 'Alice' })
+const out2 = render({ name: 'Bob' })
 
-// the source has surrounding strings and the expression
-// will be casted to string type as well:
-console.log(srw.rewrite('before {{ a }} after', { a: 5 }))
-// output:
-// 'before 5 after'
+// One-shot: parse + compile + execute
+trw.rewrite(source, context)
 
-// the source consists only of a single expression
-// therefore its type will be preserved:
-console.log(srw.rewrite('{{ a }}', { a: 5 }) === 5 )
-// output:
-// true
+// Debug: print the parse tree to console
+trw.printAsTree(source)
 ```
 
-**Configuraton example**
+### String Expression Rewriter
 
-Let's assume that we want a config that must store some path generation logic. We can not store function as we're supposed to store the config to DB. We can use a string expression like so:
+For simple interpolation without block operations (config values, file paths):
 
 ```js
 import { getStringExpressionRewriter } from '@prostojs/rewrite'
 
 const srw = getStringExpressionRewriter()
 
-const config = {
-    path: 'some/path/{{ key.toLowerCase() }}.{{ type === \'javascript\' ? \'js\' : \'json\' }}'
-}
+// Mixed string: always returns string
+srw.rewrite('Hello {{ name }}, age {{ age }}', { name: 'World', age: 25 })
+// => "Hello World, age 25"
 
-const context = {
-    key: 'TEST',
-    type: 'javascript',
+// Single expression: preserves the original type
+srw.rewrite('{{ count }}', { count: 42 })
+// => 42 (number, not string)
+```
+
+This is useful for configuration files where property values can contain expressions:
+
+```js
+const config = {
+  path: "some/path/{{ key.toLowerCase() }}.{{ type === 'javascript' ? 'js' : 'json' }}",
 }
 
-// caching the rewrite function for path
-// to avoid parsing the path string every time
 const pathFunc = srw.genRewriteFunction(config.path)
+pathFunc({ key: 'TEST', type: 'javascript' })
+// => "some/path/test.js"
+```
 
-// rewriting the config path
-const thePath = pathFunc(context)
+## Options
 
-console.log(thePath)
-// output:
-// 'some/path/test.js'
+All options are optional. The example below shows the default values:
+
+```js
+const rw = new ProstoRewrite({
+  defaultMode: 'auto',   // 'text' | 'html' | 'auto'
+  debug: false,
+
+  htmlPattern: ['*.{html,xhtml,xml,svg}'],
+  textPattern: [
+    '*.{js,jsx,ts,tsx,txt,json,yml,yaml,md,ini}',
+    'Dockerfile',
+    '*config',
+    '.gitignore',
+  ],
+
+  text: {
+    exprDelimiters: ['{{', '}}'],
+    blockOperation: '=',
+    revealLine: ':',
+    directive: '!@',
+  },
+
+  html: {
+    exprDelimiters: ['{{', '}}'],
+    blockOperation: 'v-',
+    attrExpression: ':',
+    directive: '!@',
+    voidTags: ['area', 'base', 'br', 'col', 'command', 'embed', 'hr',
+               'img', 'input', 'keygen', 'link', 'meta', 'param',
+               'source', 'track', 'wbr'],
+    textTags: ['script', 'style'],
+  },
+})
+```
 
-```
+| Option | Type | Description |
+|---|---|---|
+| `defaultMode` | `'text'` \| `'html'` \| `'auto'` | Template processor selection. `auto` uses file patterns to decide. |
+| `debug` | `boolean` | Print debug parse trees to console. |
+| `htmlPattern` | `string[]` | Glob patterns for files processed by HTML parser. |
+| `textPattern` | `string[]` | Glob patterns for files processed by text parser. |
+| `text.exprDelimiters` | `[string, string]` | Expression delimiters. Default: `['{{', '}}']` |
+| `text.blockOperation` | `string` | Prefix for block operations (`IF`, `FOR`, ...). Default: `'='` |
+| `text.revealLine` | `string` | Prefix for reveal lines. Default: `':'` |
+| `text.directive` | `string` | Prefix for directives (`ignore-next-line`, ...). Default: `'!@'` |
+| `html.exprDelimiters` | `[string, string]` | Expression delimiters. Default: `['{{', '}}']` |
+| `html.blockOperation` | `string` | Prefix for block attributes (`if`, `for`, ...). Default: `'v-'` |
+| `html.attrExpression` | `string` | Prefix for expression attributes. Default: `':'` |
+| `html.directive` | `string` | Prefix for directives (`text-mode-on`, ...). Default: `'!@'` |
+| `html.voidTags` | `string[]` | Self-closing HTML tags. |
+| `html.textTags` | `string[]` | Tags with text-only content (no child tag parsing). |
+
+## License
+
+MIT