├── .editorconfig
├── .github
    ├── ISSUE_TEMPLATE
    │   └── bug_report.md
    ├── contributing.md
    ├── funding.yml
    ├── pull_request_template.md
    └── workflows
    │   └── nodejs.yml
├── .gitignore
├── .npmignore
├── .nycrc
├── INDEX.md
├── changelog.md
├── lib
    ├── backup.js
    ├── escape.js
    ├── index.d.ts
    ├── index.js
    ├── locals.js
    ├── loops.js
    ├── placeholders.js
    └── tags.js
├── license
├── package-lock.json
├── package.json
├── readme.md
└── test
    ├── expect
        ├── attr_param.html
        ├── basic.html
        ├── boolean_attr.html
        ├── conditional.html
        ├── conditional_customtags.html
        ├── conditional_expression.html
        ├── conditional_if.html
        ├── conditional_if_key_not_exists.html
        ├── conditional_nested.html
        ├── conditional_norender.html
        ├── conditional_tag_break.html
        ├── custom_delimiters.html
        ├── directives.html
        ├── escape_html.html
        ├── expression_custom_delimiters_ignored.html
        ├── expression_ignored.html
        ├── expression_spacing.html
        ├── local_missing.html
        ├── local_missing_keep.html
        ├── local_missing_remove.html
        ├── local_missing_replace.html
        ├── loop.html
        ├── loop_conditional.html
        ├── loop_conditional_locals.html
        ├── loop_conflict.html
        ├── loop_customtag.html
        ├── loop_locals.html
        ├── loop_metadata.html
        ├── loop_nested.html
        ├── loop_nested_metadata.html
        ├── loop_object.html
        ├── raw.html
        ├── raw_custom.html
        ├── raw_in_condition.html
        ├── raw_in_switch.html
        ├── scope.html
        ├── scope_nested.html
        ├── script-locals-global-not-informed.html
        ├── script-locals-global.html
        ├── script-locals-remove.html
        ├── script-locals.html
        ├── switch.html
        ├── switch_customtag.html
        ├── switch_default.html
        ├── switch_nested.html
        ├── switch_number.html
        └── unescaped.html
    ├── fixtures
        ├── attr_param.html
        ├── basic.html
        ├── boolean_attr.html
        ├── conditional.html
        ├── conditional_customtags.html
        ├── conditional_elseif_error.html
        ├── conditional_expression.html
        ├── conditional_expression_error.html
        ├── conditional_if.html
        ├── conditional_if_error.html
        ├── conditional_if_key_not_exists.html
        ├── conditional_nested.html
        ├── conditional_norender.html
        ├── conditional_tag_break.html
        ├── custom_delimiters.html
        ├── directives.html
        ├── escape_html.html
        ├── expression_custom_delimiters_ignored.html
        ├── expression_error.html
        ├── expression_ignored.html
        ├── expression_spacing.html
        ├── local_missing.html
        ├── local_missing_keep.html
        ├── local_missing_remove.html
        ├── local_missing_replace.html
        ├── loop.html
        ├── loop_conditional.html
        ├── loop_conditional_locals.html
        ├── loop_conflict.html
        ├── loop_customtag.html
        ├── loop_expression_error.html
        ├── loop_locals.html
        ├── loop_metadata.html
        ├── loop_nested.html
        ├── loop_nested_metadata.html
        ├── loop_no_args.html
        ├── loop_no_attr.html
        ├── loop_no_collection.html
        ├── loop_no_in.html
        ├── loop_object.html
        ├── raw.html
        ├── raw_custom.html
        ├── raw_in_condition.html
        ├── raw_in_switch.html
        ├── scope.html
        ├── scope_nested.html
        ├── script-locals-global-not-informed.html
        ├── script-locals-global.html
        ├── script-locals-remove.html
        ├── script-locals.html
        ├── switch.html
        ├── switch_bad_flow.html
        ├── switch_customtag.html
        ├── switch_default.html
        ├── switch_nested.html
        ├── switch_no_attr.html
        ├── switch_no_case_attr.html
        ├── switch_number.html
        └── unescaped.html
    ├── test-conditionals.js
    ├── test-core.js
    ├── test-locals.js
    ├── test-loops.js
    ├── test-scopes.js
    └── test-switch.js


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | indent_size = 2
 6 | end_of_line = lf
 7 | indent_style = space
 8 | trim_trailing_whitespace = true
 9 | insert_final_newline = true
10 | 
11 | [*.{md,html}]
12 | trim_trailing_whitespace = false
13 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ## Problem
 2 | 
 3 | Briefly describe the issue you are experiencing (or the feature you want to see
 4 | added to the plugin). Tell us what you were trying to do and what happened
 5 | instead. Remember, this is _not_ a place to ask questions. For that, go to
 6 | http://gitter.im/posthtml/posthtml
 7 | 
 8 | ## Details
 9 | 
10 | Describe in more detail the problem you have been experiencing, if necessary.
11 | 
12 | ## Error Logs
13 | 
14 | Create a [gist](https://gist.github.com) which is a paste of your **full**
15 | logs(_result.tree_ (PostHTML Tree), _result.html_ (HTML)), and link them here.
16 | Do **not** paste your full logs here, as it will make this issue long and hard
17 | to read! If you are reporting a bug, **always** include logs!
18 | 
19 | ## Issue [ Code ]
20 | 
21 | Please remember that, with sample code; it's easier to reproduce bug and much
22 | faster to fix it.
23 | 
24 | Please refer to a simple code example.
25 | 
26 | ```bash
27 | $ git clone https://github.com/<user>/<sample>
28 | ```
29 | 
30 | ## Environment
31 | 
32 | Please provide information about your environment.
33 | 
34 | | OS              | Node      | npm       | PostHTML  |
35 | |:---------------:|:---------:|:---------:|:---------:|
36 | | [name][version] | [version] | [version] | [version] |
37 | 


--------------------------------------------------------------------------------
/.github/contributing.md:
--------------------------------------------------------------------------------
 1 | You want to help? You rock! Now, take a moment to be sure your contributions make sense to everyone else.
 2 | 
 3 | ## Reporting Issues
 4 | 
 5 | Found a problem? Want a new feature?
 6 | 
 7 | - See if your issue or idea has [already been reported].
 8 | - Provide a [reduced test case] or a [live example].
 9 | 
10 | Remember, a bug is a _demonstrable problem_ caused by _our_ code.
11 | 
12 | ## Submitting Pull Requests
13 | 
14 | Pull requests are the greatest contributions, so be sure they are focused in scope, and do avoid unrelated commits.
15 | 
16 | 1. To begin, [fork this project], clone your fork, and add our upstream.
17 | 	```bash
18 | 	# Clone your fork of the repo into the current directory
19 | 	git clone https://github.com/<your-username>/PLUGIN_NAME
20 | 	# Navigate to the newly cloned directory
21 | 	cd PLUGIN_NAME
22 | 	# Assign the original repo to a remote called "upstream"
23 | 	git remote add upstream https://github.com/GITHUB_NAME/PLUGIN_NAME
24 | 	# Install the tools necessary for development
25 | 	npm install
26 | 	```
27 | 
28 | 2. Create a branch for your feature or fix:
29 | 	```bash
30 | 	# Move into a new branch for a feature
31 | 	git checkout -b feature/thing
32 | 	```
33 | 	```bash
34 | 	# Move into a new branch for a fix
35 | 	git checkout -b fix/something
36 | 	```
37 | 
38 | 3. Be sure your code follows our practices.
39 | 	```bash
40 | 	# Test current code
41 | 	npm run test
42 | 	```
43 | 
44 | 4. Push your branch up to your fork:
45 | 	```bash
46 | 	# Push a feature branch
47 | 	git push origin feature/thing
48 | 	```
49 | 	```bash
50 | 	# Push a fix branch
51 | 	git push origin fix/something
52 | 	```
53 | 
54 | 5. Now [open a pull request] with a clear title and description.
55 | 
56 | [already been reported]: issues
57 | [fork this project]:     fork
58 | [live example]:          http://codepen.io/pen
59 | [open a pull request]:   https://help.github.com/articles/using-pull-requests/
60 | [reduced test case]:     https://css-tricks.com/reduced-test-cases/
61 | 


--------------------------------------------------------------------------------
/.github/funding.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: posthtml
 5 | open_collective: posthtml
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
13 | 


--------------------------------------------------------------------------------
/.github/pull_request_template.md:
--------------------------------------------------------------------------------
 1 | ## Proposed Changes
 2 | 
 3 | Describe the big picture of your changes here to communicate to the maintainers
 4 | why we should accept this pull request. If it fixes a bug or resolves a feature
 5 | request, be sure to link to that issue.
 6 | 
 7 | ## Types of Changes
 8 | 
 9 | What types of changes does your code introduce
10 | _Put an `x` in the boxes that apply_
11 | 
12 | - [ ] Bug (non-breaking change which fixes an issue)
13 | - [ ] Feature (non-breaking change which adds functionality)
14 | - [ ] Breaking Change (fix or feature which changes existing functionality)
15 | 
16 | ## Checklist
17 | 
18 | _Put an `x` in the boxes that apply. You can also fill these out after creating
19 | the PR. If you're unsure about any of them, don't hesitate to ask. We're here to
20 | help! This is a reminder of what we are going to look for before merging your
21 | code._
22 | 
23 | - [ ] I have read the [CONTRIBUTING](/CONTRIBUTING.md) guide
24 | - [ ] Lint and unit tests pass with my changes
25 | - [ ] I have added tests that prove my fix is effective/works
26 | - [ ] I have added necessary documentation (if appropriate)
27 | - [ ] Any dependent changes are merged and published in downstream modules
28 | 
29 | ## Further Comments
30 | 
31 | If this is a large or complex change, kick off the discussion by explaining why
32 | you chose the solution you did and what alternatives you considered, etc...
33 | 
34 | ### Reviewers:  @mrmlnc, @jescalan, @michael-ciniawsky, @posthtml/collaborators
35 | 


--------------------------------------------------------------------------------
/.github/workflows/nodejs.yml:
--------------------------------------------------------------------------------
 1 | name: Actions Status
 2 | on:
 3 |   pull_request:
 4 |     types: [opened, synchronize]
 5 |     branches:
 6 |       - master
 7 | env:
 8 |   CI: true
 9 | 
10 | jobs:
11 |   run:
12 |     name: Node ${{ matrix.node }} on ${{ matrix.os }}
13 |     runs-on: ${{ matrix.os }}
14 | 
15 |     strategy:
16 |       fail-fast: false
17 |       matrix:
18 |         node: [10, 12, 14]
19 |         os: [ubuntu-latest]
20 | 
21 |     steps:
22 |       - name: Clone repository
23 |         uses: actions/checkout@v2
24 | 
25 |       - name: Set Node.js version
26 |         uses: actions/setup-node@v1
27 |         with:
28 |           node-version: ${{ matrix.node }}
29 | 
30 |       - name: Install npm dependencies
31 |         run: npm ci
32 | 
33 |       - name: Run tests
34 |         run: npm run test
35 | 
36 |       - name: Run Coveralls
37 |         uses: coverallsapp/github-action@master
38 |         with:
39 |           github-token: "${{ secrets.GITHUB_TOKEN }}"
40 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # OS
 2 | 
 3 | .DS_Store
 4 | ._*
 5 | 
 6 | # NODEJS
 7 | 
 8 | .nyc_output
 9 | 
10 | npm-debug.log
11 | 
12 | dmd
13 | coverage
14 | jsdoc-api
15 | node_modules
16 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
 1 | # FILES
 2 | 
 3 | .travis.yml
 4 | .gitignore
 5 | .editorconfig
 6 | .mversionrc
 7 | 
 8 | CHANGELOG.md
 9 | CONTRIBUTING.md
10 | README.md
11 | 
12 | npm-debug.log
13 | 
14 | # DIRECTORIES
15 | 
16 | .github
17 | .nyc_output
18 | 
19 | dmd
20 | test
21 | coverage
22 | jsdoc-api
23 | node_modules
24 | 


--------------------------------------------------------------------------------
/.nycrc:
--------------------------------------------------------------------------------
1 | {
2 |   "reporter": ["lcov", "text"],
3 |   "extension": [".js"]
4 | }


--------------------------------------------------------------------------------
/INDEX.md:
--------------------------------------------------------------------------------
  1 | ## Modules
  2 | 
  3 | <dl>
  4 | <dt><a href="#module_backup">backup</a> : <code>Object</code></dt>
  5 | <dd></dd>
  6 | <dt><a href="#module_escape">escape</a> : <code>function</code></dt>
  7 | <dd></dd>
  8 | <dt><a href="#module_posthtml-expressions">posthtml-expressions</a> ⇒ <code>Object</code></dt>
  9 | <dd><p>Expressions Plugin for PostHTML</p>
 10 | </dd>
 11 | <dt><a href="#module_loops">loops</a> : <code>function</code></dt>
 12 | <dd></dd>
 13 | <dt><a href="#module_placeholders">placeholders</a> : <code>function</code></dt>
 14 | <dd></dd>
 15 | <dt><a href="#module_tags">tags</a> : <code>function</code></dt>
 16 | <dd></dd>
 17 | </dl>
 18 | 
 19 | ## Functions
 20 | 
 21 | <dl>
 22 | <dt><a href="#makeLocalsBackup">makeLocalsBackup(keys, locals)</a> ⇒ <code>Object</code></dt>
 23 | <dd><p>Creates a backup of keys values</p>
 24 | </dd>
 25 | <dt><a href="#revertBackupedLocals">revertBackupedLocals(keys, locals, backup)</a> ⇒ <code>Object</code></dt>
 26 | <dd><p>Returns the original keys values</p>
 27 | </dd>
 28 | <dt><a href="#escapeRegexpString">escapeRegexpString(input)</a> ⇒ <code>function</code></dt>
 29 | <dd><p>Replace String based on RegExp</p>
 30 | </dd>
 31 | <dt><a href="#executeLoop">executeLoop(params, p1, p2, locals, tree)</a> ⇒ <code>function</code></dt>
 32 | <dd><p>Creates a set of local variables within the loop, and evaluates all nodes within the loop, returning their contents</p>
 33 | </dd>
 34 | <dt><a href="#executeScope">executeScope(scope, locals, node)</a> ⇒ <code>function</code></dt>
 35 | <dd><p>Runs walk function with arbitrary set of local variables</p>
 36 | </dd>
 37 | <dt><a href="#getLoopMeta">getLoopMeta(index, target)</a> ⇒ <code>Object</code></dt>
 38 | <dd><p>Returns an object containing loop metadata</p>
 39 | </dd>
 40 | <dt><a href="#parseLoopStatement">parseLoopStatement(input)</a> ⇒ <code>Object</code></dt>
 41 | <dd><p>Given a &quot;loop&quot; parameter from an &quot;each&quot; tag, parses out the param names and expression to be looped.</p>
 42 | </dd>
 43 | <dt><a href="#escapeHTML">escapeHTML(unescaped)</a> ⇒ <code>String</code></dt>
 44 | <dd><p>Escape HTML characters with their respective entities</p>
 45 | </dd>
 46 | <dt><a href="#placeholders">placeholders(input, ctx, settings, opts)</a> ⇒ <code>String</code></dt>
 47 | <dd><p>Replace Expressions</p>
 48 | </dd>
 49 | <dt><a href="#getNextTag">getNextTag(nodes, i)</a> ⇒ <code>Array</code></dt>
 50 | <dd><p>Get the next tag from a node list</p>
 51 | </dd>
 52 | </dl>
 53 | 
 54 | <a name="module_backup"></a>
 55 | 
 56 | ## backup : <code>Object</code>
 57 | **Requires**: <code>module:fclone</code>  
 58 | **Properties**
 59 | 
 60 | | Name | Type | Description |
 61 | | --- | --- | --- |
 62 | | make | <code>function</code> | Make Locals backup |
 63 | | revert | <code>function</code> | Revert backuped Locals |
 64 | 
 65 | <a name="module_escape"></a>
 66 | 
 67 | ## escape : <code>function</code>
 68 | <a name="module_posthtml-expressions"></a>
 69 | 
 70 | ## posthtml-expressions ⇒ <code>Object</code>
 71 | Expressions Plugin for PostHTML
 72 | 
 73 | **Returns**: <code>Object</code> - tree PostHTML Tree  
 74 | **Requires**: <code>module:vm</code>, <code>module:./tags</code>, <code>module:./loops</code>, <code>module:./escape</code>, <code>module:./backup</code>, <code>module:./placeholders</code>  
 75 | **Version**: 1.0.0  
 76 | **Author**: Jeff Escalante Denis (@jescalan),
 77 |         Denis Malinochkin (mrmlnc),
 78 |         Michael Ciniawsky (@michael-ciniawsky)  
 79 | **License**: MIT  
 80 | 
 81 | | Param | Type | Description |
 82 | | --- | --- | --- |
 83 | | options | <code>Object</code> | Options |
 84 | 
 85 | <a name="module_loops"></a>
 86 | 
 87 | ## loops : <code>function</code>
 88 | <a name="module_placeholders"></a>
 89 | 
 90 | ## placeholders : <code>function</code>
 91 | **Requires**: <code>module:vm</code>  
 92 | <a name="module_tags"></a>
 93 | 
 94 | ## tags : <code>function</code>
 95 | <a name="makeLocalsBackup"></a>
 96 | 
 97 | ## makeLocalsBackup(keys, locals) ⇒ <code>Object</code>
 98 | Creates a backup of keys values
 99 | 
100 | **Kind**: global function  
101 | **Returns**: <code>Object</code> - backup Backup Locals  
102 | 
103 | | Param | Type | Description |
104 | | --- | --- | --- |
105 | | keys | <code>Object</code> | Keys |
106 | | locals | <code>Object</code> | Locals |
107 | 
108 | <a name="revertBackupedLocals"></a>
109 | 
110 | ## revertBackupedLocals(keys, locals, backup) ⇒ <code>Object</code>
111 | Returns the original keys values
112 | 
113 | **Kind**: global function  
114 | **Returns**: <code>Object</code> - locals Reverted Locals  
115 | 
116 | | Param | Type | Description |
117 | | --- | --- | --- |
118 | | keys | <code>Object</code> | Keys |
119 | | locals | <code>Object</code> | Locals |
120 | | backup | <code>Object</code> | Backup |
121 | 
122 | <a name="escapeRegexpString"></a>
123 | 
124 | ## escapeRegexpString(input) ⇒ <code>function</code>
125 | Replace String based on RegExp
126 | 
127 | **Kind**: global function  
128 | **Returns**: <code>function</code> - input Replaced Input  
129 | 
130 | | Param | Type | Description |
131 | | --- | --- | --- |
132 | | input | <code>String</code> | Input |
133 | 
134 | <a name="executeLoop"></a>
135 | 
136 | ## executeLoop(params, p1, p2, locals, tree) ⇒ <code>function</code>
137 | Creates a set of local variables within the loop, and evaluates all nodes within the loop, returning their contents
138 | 
139 | **Kind**: global function  
140 | **Returns**: <code>function</code> - walk  Walks the tree and parses all locals within the loop  
141 | 
142 | | Param | Type | Description |
143 | | --- | --- | --- |
144 | | params | <code>Array</code> | Parameters |
145 | | p1 | <code>String</code> | Parameter 1 |
146 | | p2 | <code>String</code> | Parameter 2 |
147 | | locals | <code>Object</code> | Locals |
148 | | tree | <code>String</code> | Tree |
149 | 
150 | <a name="executeScope"></a>
151 | 
152 | ## executeScope(scope, locals, node) ⇒ <code>function</code>
153 | Runs walk function with arbitrary set of local variables
154 | 
155 | **Kind**: global function  
156 | **Returns**: <code>function</code> - walk Walks the tree and parses all locals in scope  
157 | 
158 | | Param | Type | Description |
159 | | --- | --- | --- |
160 | | scope | <code>Object</code> | Scoped Locals |
161 | | locals | <code>Object</code> | Locals |
162 | | node | <code>Object</code> | Node |
163 | 
164 | <a name="getLoopMeta"></a>
165 | 
166 | ## getLoopMeta(index, target) ⇒ <code>Object</code>
167 | Returns an object containing loop metadata
168 | 
169 | **Kind**: global function  
170 | **Returns**: <code>Object</code> - Object containing loop metadata  
171 | 
172 | | Param | Type | Description |
173 | | --- | --- | --- |
174 | | index | <code>Integer</code> \| <code>Object</code> | Current iteration |
175 | | target | <code>Object</code> | Object being iterated |
176 | 
177 | <a name="parseLoopStatement"></a>
178 | 
179 | ## parseLoopStatement(input) ⇒ <code>Object</code>
180 | Given a "loop" parameter from an "each" tag, parses out the param names and expression to be looped.
181 | 
182 | **Kind**: global function  
183 | **Returns**: <code>Object</code> - {}    Keys && Expression  
184 | 
185 | | Param | Type | Description |
186 | | --- | --- | --- |
187 | | input | <code>String</code> | Input |
188 | 
189 | <a name="escapeHTML"></a>
190 | 
191 | ## escapeHTML(unescaped) ⇒ <code>String</code>
192 | Escape HTML characters with their respective entities
193 | 
194 | **Kind**: global function  
195 | **Returns**: <code>String</code> - escaped   Save HTML  
196 | 
197 | | Param | Type | Description |
198 | | --- | --- | --- |
199 | | unescaped | <code>String</code> | Unsafe HTML |
200 | 
201 | <a name="placeholders"></a>
202 | 
203 | ## placeholders(input, ctx, settings, opts) ⇒ <code>String</code>
204 | Replace Expressions
205 | 
206 | **Kind**: global function  
207 | **Returns**: <code>String</code> - input Replaced Input  
208 | 
209 | | Param | Type | Description |
210 | | --- | --- | --- |
211 | | input | <code>String</code> | Input |
212 | | ctx | <code>Object</code> | Context |
213 | | settings | <code>Array</code> | Settings |
214 | | opts | <code>Array</code> | Options |
215 | 
216 | <a name="getNextTag"></a>
217 | 
218 | ## getNextTag(nodes, i) ⇒ <code>Array</code>
219 | Get the next tag from a node list
220 | 
221 | **Kind**: global function  
222 | **Returns**: <code>Array</code> - []    Array containing the next tag  
223 | 
224 | | Param | Type | Description |
225 | | --- | --- | --- |
226 | | nodes | <code>Array</code> | Nodes |
227 | | i | <code>Number</code> | Accumulator |
228 | 
229 | 


--------------------------------------------------------------------------------
/changelog.md:
--------------------------------------------------------------------------------
  1 | ## [1.11.4](https://github.com/posthtml/posthtml-expressions/compare/v1.11.3...v1.11.4) (2024-07-25)
  2 | 
  3 | 
  4 | 
  5 | ## [1.11.3](https://github.com/posthtml/posthtml-expressions/compare/v1.11.2...v1.11.3) (2023-11-13)
  6 | 
  7 | 
  8 | 
  9 | ## [1.11.2](https://github.com/posthtml/posthtml-expressions/compare/v1.11.1...v1.11.2) (2023-10-17)
 10 | 
 11 | 
 12 | ### Bug Fixes
 13 | 
 14 | * inline expression ignore regex ([aa83033](https://github.com/posthtml/posthtml-expressions/commit/aa8303315136652b0b07db228d0406b18fd1f79a))
 15 | * use first char of unescapedDelimiters ([48337fc](https://github.com/posthtml/posthtml-expressions/commit/48337fc710aab87880a7ed1dacfd69d70c997a2c))
 16 | 
 17 | 
 18 | 
 19 | ## [1.11.1](https://github.com/posthtml/posthtml-expressions/compare/v1.11.0...v1.11.1) (2023-06-03)
 20 | 
 21 | 
 22 | 
 23 | # [1.11.0](https://github.com/posthtml/posthtml-expressions/compare/v1.10.0...v1.11.0) (2022-12-20)
 24 | 
 25 | 
 26 | 
 27 | # [1.10.0](https://github.com/posthtml/posthtml-expressions/compare/v1.9.0...v1.10.0) (2022-09-26)
 28 | 
 29 | 
 30 | ### Features
 31 | 
 32 | * allow global script locals ([a5678f5](https://github.com/posthtml/posthtml-expressions/commit/a5678f5b37082b26b5f23d7ec43de4f0e3b3ec5c))
 33 | 
 34 | 
 35 | 
 36 | # [1.9.0](https://github.com/posthtml/posthtml-expressions/compare/v1.8.1...v1.9.0) (2021-08-23)
 37 | 
 38 | 
 39 | ### Features
 40 | 
 41 | * remove script locals, close [#120](https://github.com/posthtml/posthtml-expressions/issues/120) ([023fcb9](https://github.com/posthtml/posthtml-expressions/commit/023fcb9845939524265589d5b59741e41ea73aa4))
 42 | 
 43 | 
 44 | ### Performance Improvements
 45 | 
 46 | * default locals attr ([73dc216](https://github.com/posthtml/posthtml-expressions/commit/73dc216c2adae6de9582c1c65a83d460df836f0a))
 47 | 
 48 | 
 49 | 
 50 | ## [1.8.1](https://github.com/posthtml/posthtml-expressions/compare/v1.8.0...v1.8.1) (2021-08-10)
 51 | 
 52 | 
 53 | ### Bug Fixes
 54 | 
 55 | * tree.match is not a function ([bee5368](https://github.com/posthtml/posthtml-expressions/commit/bee5368149d7f1258833656f91355e1266f6ee4d))
 56 | 
 57 | 
 58 | 
 59 | # [1.8.0](https://github.com/posthtml/posthtml-expressions/compare/v1.7.1...v1.8.0) (2021-08-09)
 60 | 
 61 | 
 62 | ### Bug Fixes
 63 | 
 64 | * after update parser/render ([e0bafbe](https://github.com/posthtml/posthtml-expressions/commit/e0bafbeec23b18ae59c40c43dd132fc01bfbc73d))
 65 | * lost posthtml-match-helper ([350c3fd](https://github.com/posthtml/posthtml-expressions/commit/350c3fdf167ee638deb9b3c5cf5ffc98527406b8))
 66 | 
 67 | 
 68 | ### Features
 69 | 
 70 | * locals data from script tag, close [#117](https://github.com/posthtml/posthtml-expressions/issues/117) ([e730454](https://github.com/posthtml/posthtml-expressions/commit/e73045458dc90afdb4046a93c394d75800818b8d))
 71 | 
 72 | 
 73 | 
 74 | ## [1.7.1](https://github.com/posthtml/posthtml-expressions/compare/v1.7.0...v1.7.1) (2020-12-02)
 75 | 
 76 | 
 77 | ### Bug Fixes
 78 | 
 79 | * throw if strict mode ([2c0c0d1](https://github.com/posthtml/posthtml-expressions/commit/2c0c0d1a181b280ba72f76c6530a1c626ab987e6))
 80 | 
 81 | 
 82 | 
 83 | # [1.7.0](https://github.com/posthtml/posthtml-expressions/compare/v1.6.2...v1.7.0) (2020-11-24)
 84 | 
 85 | 
 86 | 
 87 | ## [1.6.2](https://github.com/posthtml/posthtml-expressions/compare/v1.6.1...v1.6.2) (2020-11-12)
 88 | 
 89 | 
 90 | ### Bug Fixes
 91 | 
 92 | * items is not defined in each, close [#107](https://github.com/posthtml/posthtml-expressions/issues/107) ([d14fbbb](https://github.com/posthtml/posthtml-expressions/commit/d14fbbb683460fad4f8b2edb649f9ef759b89038))
 93 | 
 94 | 
 95 | 
 96 | ## [1.6.1](https://github.com/posthtml/posthtml-expressions/compare/v1.6.0...v1.6.1) (2020-11-09)
 97 | 
 98 | 
 99 | ### Bug Fixes
100 | 
101 | * check if key exists in locals as text, close [#102](https://github.com/posthtml/posthtml-expressions/issues/102) ([1d7596a](https://github.com/posthtml/posthtml-expressions/commit/1d7596a8a4d12fd29a74f03637057772a9b81d09))
102 | 
103 | 
104 | 
105 | # [1.6.0](https://github.com/posthtml/posthtml-expressions/compare/v1.5.0...v1.6.0) (2020-10-30)
106 | 
107 | 
108 | ### Features
109 | 
110 | * strictMode show or not throw an exception, close [#102](https://github.com/posthtml/posthtml-expressions/issues/102) ([dbb32c9](https://github.com/posthtml/posthtml-expressions/commit/dbb32c9a9cd0c3b6468547ecea1d1d492e0ac7ce))
111 | 
112 | 
113 | 
114 | # [1.5.0](https://github.com/posthtml/posthtml-expressions/compare/v1.4.7...v1.5.0) (2020-09-21)
115 | 
116 | 
117 | ### Features
118 | 
119 | * attribute as param, close [#99](https://github.com/posthtml/posthtml-expressions/issues/99) ([74c2b32](https://github.com/posthtml/posthtml-expressions/commit/74c2b3201f1492c4115e0e4b8f71e228f0e70370))
120 | 
121 | 
122 | 
123 | ## [1.4.7](https://github.com/posthtml/posthtml-expressions/compare/v1.4.6...v1.4.7) (2020-08-28)
124 | 
125 | 
126 | ### Bug Fixes
127 | 
128 | * options for parser when nnormalize, close [#97](https://github.com/posthtml/posthtml-expressions/issues/97) ([99c0281](https://github.com/posthtml/posthtml-expressions/commit/99c02815facfcb692d52f37b3d80ad882f4756fb))
129 | 
130 | 
131 | 
132 | ## [1.4.6](https://github.com/posthtml/posthtml-expressions/compare/v1.4.5...v1.4.6) (2020-08-23)
133 | 
134 | 
135 | ### Bug Fixes
136 | 
137 | * remove node text after condition, close [#62](https://github.com/posthtml/posthtml-expressions/issues/62) ([2cefe7d](https://github.com/posthtml/posthtml-expressions/commit/2cefe7dac40b61e82752c7f03b91296870474194))
138 | 
139 | 
140 | 
141 | ## [1.4.5](https://github.com/posthtml/posthtml-expressions/compare/v1.4.4...v1.4.5) (2020-07-07)
142 | 
143 | 
144 | ### Bug Fixes
145 | 
146 | * normalize output tree, close [#93](https://github.com/posthtml/posthtml-expressions/issues/93) ([5d820e5](https://github.com/posthtml/posthtml-expressions/commit/5d820e59e0f745444015220937d3e3321071249e))
147 | 
148 | 
149 | 
150 | ## [1.4.4](https://github.com/posthtml/posthtml-expressions/compare/v1.4.3...v1.4.4) (2020-06-30)
151 | 
152 | 
153 | ### Bug Fixes
154 | 
155 | * escape custom delimiters when ignoring expressions ([53c901e](https://github.com/posthtml/posthtml-expressions/commit/53c901eb8d58e4c1d259db9963bd6817efc11ea2))
156 | 
157 | 
158 | 
159 | ## [1.4.3](https://github.com/posthtml/posthtml-expressions/compare/v1.4.2...v1.4.3) (2020-06-25)
160 | 
161 | 
162 | ### Bug Fixes
163 | 
164 | * clear raw tag after expression, close [#82](https://github.com/posthtml/posthtml-expressions/issues/82) ([2aaef58](https://github.com/posthtml/posthtml-expressions/commit/2aaef5867c0f7971358226f125b288e9de4d021c))
165 | 
166 | 
167 | 
168 | <a name="1.1.0"></a>
169 | # [1.1.0](https://github.com/posthtml/posthtml-expressions/compare/v1.0.0...v1.1.0) (2016-12-14)
170 | 
171 | 
172 | ### Bug Fixes
173 | 
174 | * **index:** comments ([553b0fa](https://github.com/posthtml/posthtml-expressions/commit/553b0fa))
175 | * **index:** copy/paste for loops ([c865969](https://github.com/posthtml/posthtml-expressions/commit/c865969))
176 | 
177 | ### Features
178 | 
179 | * **index:** add switch statement ([88058d1](https://github.com/posthtml/posthtml-expressions/commit/88058d1))
180 | 
181 | 
182 | 
183 | <a name="1.0.0"></a>
184 | # [1.0.0](https://github.com/posthtml/posthtml-expressions/compare/v0.9.0...v1.0.0) (2016-11-19)
185 | 
186 | 
187 | ### Bug Fixes
188 | 
189 | * patch to fix expressions in else/elseif blocks ([f50c36f](https://github.com/posthtml/posthtml-expressions/commit/f50c36f))
190 | * **index:** Fix issue with conditional in loops ([58b1f50](https://github.com/posthtml/posthtml-expressions/commit/58b1f50))
191 | * **index:** remove console.log, fix comment ([c5b7887](https://github.com/posthtml/posthtml-expressions/commit/c5b7887))
192 | * **lib:** add missing 'use strict' statement ([4078c90](https://github.com/posthtml/posthtml-expressions/commit/4078c90))
193 | * **placeholders:** Fix typo in "matches" ([e0d38bd](https://github.com/posthtml/posthtml-expressions/commit/e0d38bd))
194 | 
195 | ### Features
196 | 
197 | * **index:** scopes ([d3ea9ce](https://github.com/posthtml/posthtml-expressions/commit/d3ea9ce))
198 | 
199 | ### Performance Improvements
200 | 
201 | * **index:** Create a copy only for specified keys ([5239bc0](https://github.com/posthtml/posthtml-expressions/commit/5239bc0))
202 | * **index:** Make a copy of the tree only once ([ba9d706](https://github.com/posthtml/posthtml-expressions/commit/ba9d706))
203 | * **index:** Optimize scoped locals for `scope` tag ([1046bc4](https://github.com/posthtml/posthtml-expressions/commit/1046bc4))
204 | 


--------------------------------------------------------------------------------
/lib/backup.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | const cloneDeep = require('fclone')
 4 | 
 5 | /**
 6 |  * @description Creates a backup of keys values
 7 |  *
 8 |  * @method makeLocalsBackup
 9 |  *
10 |  * @param {Object} keys Keys
11 |  * @param {Object} locals Locals
12 |  *
13 |  * @return {Object} backup Backup Locals
14 |  */
15 | function makeLocalsBackup (keys, locals) {
16 |   const backup = {}
17 | 
18 |   for (let i = 0; i < keys.length; i++) {
19 |     const key = keys[i]
20 |     if (Object.prototype.hasOwnProperty.call(locals, key)) backup[key] = cloneDeep(locals[key])
21 |   }
22 | 
23 |   return backup
24 | }
25 | 
26 | /**
27 |  * @description Returns the original keys values
28 |  *
29 |  * @method revertBackupedLocals
30 |  *
31 |  * @param  {Object} keys   Keys
32 |  * @param  {Object} locals Locals
33 |  * @param  {Object} backup Backup
34 |  *
35 |  * @return {Object} locals Reverted Locals
36 |  */
37 | function revertBackupedLocals (keys, locals, backup) {
38 |   for (let i = 0; i < keys.length; i++) {
39 |     const key = keys[i]
40 |     // Remove key from locals
41 |     delete locals[key]
42 | 
43 |     // Revert copied key value
44 |     if (Object.prototype.hasOwnProperty.call(backup, key)) locals[key] = backup[key]
45 |   }
46 | 
47 |   return locals
48 | }
49 | 
50 | /**
51 |  * @module backup
52 |  *
53 |  * @requires fclone
54 |  *
55 |  * @type {Object}
56 |  *
57 |  * @prop {Function} make   Make Locals backup
58 |  * @prop {Function} revert Revert backuped Locals
59 |  */
60 | module.exports = { make: makeLocalsBackup, revert: revertBackupedLocals }
61 | 


--------------------------------------------------------------------------------
/lib/escape.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | /**
 4 |  * @description Replace String based on RegExp
 5 |  *
 6 |  * @method escapeRegexpString
 7 |  *
 8 |  * @param  {String}   input Input
 9 |  *
10 |  * @return {Function} input Replaced Input
11 |  */
12 | function escapeRegexpString (input) {
13 |   // match Operators
14 |   const match = /[|\\{}()[\]^$+*?.]/g
15 | 
16 |   return input.replace(match, '\\$&')
17 | }
18 | 
19 | /**
20 |  * @module escape
21 |  *
22 |  * @type {Function}
23 |  */
24 | module.exports = escapeRegexpString
25 | 


--------------------------------------------------------------------------------
/lib/index.d.ts:
--------------------------------------------------------------------------------
  1 | export type PostHTMLExpressions = {
  2 |   /**
  3 |   Define the starting and ending delimiters used for expressions.
  4 | 
  5 |   @default ['{{', '}}']
  6 |   */
  7 |   delimiters?: string[];
  8 | 
  9 |   /**
 10 |   Define the starting and ending delimiters used for unescaped expressions.
 11 | 
 12 |   @default ['{{{', '}}}']
 13 |   */
 14 |   unescapeDelimiters?: string[];
 15 | 
 16 |   /**
 17 |   Object containing data that will be available under the `page` object.
 18 | 
 19 |   @default {}
 20 |   */
 21 |   locals?: Record<string, unknown>;
 22 | 
 23 |   /**
 24 |   Attribute name for `<script>` tags that contain locals.
 25 | 
 26 |   @default 'locals'
 27 |   */
 28 |   localsAttr?: string;
 29 | 
 30 |   /**
 31 |   Whether to remove `<script>` tags that contain locals.
 32 | 
 33 |   @default false
 34 |   */
 35 |   removeScriptLocals?: boolean;
 36 | 
 37 |   /**
 38 |   Tag names to be used for if/else statements.
 39 | 
 40 |   @default ['if', 'elseif', 'else']
 41 |   */
 42 |   conditionalTags?: string[];
 43 | 
 44 |   /**
 45 |   Tag names to be used for switch statements.
 46 | 
 47 |   @default ['switch', 'case', 'default']
 48 |   */
 49 |   switchTags?: string[];
 50 | 
 51 |   /**
 52 |   Tag names to be used for loops.
 53 | 
 54 |   @default ['each', 'for']
 55 |   */
 56 |   loopTags?: string[];
 57 | 
 58 |   /**
 59 |   Tag names to be used for scopes.
 60 | 
 61 |   @default ['scope']
 62 |   */
 63 |   scopeTags?: string[];
 64 | 
 65 |   /**
 66 |   Name of tag inside of which expression parsing is disabled.
 67 | 
 68 |   @default 'raw'
 69 |   */
 70 |   ignoredTag?: string;
 71 | 
 72 |   /**
 73 |   Enabling strict mode will throw an error if an expression cannot be evaluated.
 74 | 
 75 |   @default false
 76 |   */
 77 |   strictMode?: boolean;
 78 | 
 79 |   /**
 80 |   What to render when referencing a value that is not defined in `locals`.
 81 | 
 82 |   By default, the string 'undefined' will be output.
 83 | 
 84 |   @default undefined
 85 | 
 86 |   @example
 87 | 
 88 |   ```
 89 |   // Output empty string if value is not defined
 90 |   missingLocal: ''
 91 | 
 92 |   // Output original reference if value is not defined
 93 |   missingLocal: '{local}'
 94 | 
 95 |   // Output custom string if value is not defined
 96 |   missingLocal: 'ERR_NO_VALUE: {local}'
 97 |   ```
 98 |   */
 99 |   missingLocal?: string;
100 | }
101 | 


--------------------------------------------------------------------------------
/lib/index.js:
--------------------------------------------------------------------------------
  1 | 'use strict'
  2 | 
  3 | const vm = require('vm')
  4 | const { parser } = require('posthtml-parser')
  5 | const { render } = require('posthtml-render')
  6 | 
  7 | const getNextTag = require('./tags')
  8 | const parseLoopStatement = require('./loops')
  9 | const escapeRegexpString = require('./escape')
 10 | const makeLocalsBackup = require('./backup').make
 11 | const revertBackupedLocals = require('./backup').revert
 12 | const placeholders = require('./placeholders')
 13 | const scriptDataLocals = require('./locals')
 14 | 
 15 | const delimitersSettings = []
 16 | let conditionals, switches, loops, scopes, ignored, delimitersReplace, unescapeDelimitersReplace
 17 | 
 18 | /**
 19 |  * @description Creates a set of local variables within the loop, and evaluates all nodes within the loop, returning their contents
 20 |  *
 21 |  * @method executeLoop
 22 |  *
 23 |  * @param  {Array}  params  Parameters
 24 |  * @param  {String} p1      Parameter 1
 25 |  * @param  {String} p2      Parameter 2
 26 |  * @param  {Object} locals  Locals
 27 |  * @param  {String} tree    Tree
 28 |  *
 29 |  * @return {Function} walk  Walks the tree and parses all locals within the loop
 30 |  */
 31 | function executeLoop (params, p1, p2, locals, tree) {
 32 |   // two loop locals are allowed
 33 |   // - for arrays it's the current value and the index
 34 |   // - for objects, it's the value and the key
 35 |   const scopes = locals
 36 | 
 37 |   scopes[params[0]] = p1
 38 | 
 39 |   if (params[1]) scopes[params[1]] = p2
 40 | 
 41 |   return walk({ locals: scopes }, JSON.parse(tree))
 42 | }
 43 | 
 44 | /**
 45 |  * @description Runs walk function with arbitrary set of local variables
 46 |  *
 47 |  * @method executeScope
 48 |  *
 49 |  * @param  {Object} scope  Scoped Locals
 50 |  * @param  {Object} locals Locals
 51 |  * @param  {Object} node   Node
 52 |  *
 53 |  * @return {Function} walk Walks the tree and parses all locals in scope
 54 |  */
 55 | function executeScope (scope, locals, node) {
 56 |   scope = Object.assign(locals, scope)
 57 | 
 58 |   return walk({ locals: scope }, node.content)
 59 | }
 60 | 
 61 | /**
 62 |  * @description Returns an object containing loop metadata
 63 |  *
 64 |  * @method getLoopMeta
 65 |  *
 66 |  * @param {Integer|Object}  index Current iteration
 67 |  * @param {Object}          target Object being iterated
 68 |  *
 69 |  * @return {Object} Object containing loop metadata
 70 |  */
 71 | function getLoopMeta (index, target) {
 72 |   index = Array.isArray(target) ? index : Object.keys(target).indexOf(index)
 73 |   const arr = Array.isArray(target) ? target : Object.keys(target)
 74 | 
 75 |   return {
 76 |     index: index,
 77 |     remaining: arr.length - index - 1,
 78 |     first: arr.indexOf(arr[index]) === 0,
 79 |     last: index + 1 === arr.length,
 80 |     length: arr.length
 81 |   }
 82 | }
 83 | 
 84 | /**
 85 |  * @author Jeff Escalante Denis (@jescalan),
 86 |  *         Denis Malinochkin (mrmlnc),
 87 |  *         Michael Ciniawsky (@michael-ciniawsky)
 88 |  * @description Expressions Plugin for PostHTML
 89 |  * @license MIT
 90 |  *
 91 |  * @module posthtml-expressions
 92 |  * @version 1.0.0
 93 |  *
 94 |  * @requires vm
 95 |  *
 96 |  * @requires ./tags
 97 |  * @requires ./loops
 98 |  * @requires ./escape
 99 |  * @requires ./backup
100 |  * @requires ./placeholders
101 |  *
102 |  * @param  {Object} options Options
103 |  *
104 |  * @return {Object} tree PostHTML Tree
105 |  */
106 | module.exports = function postHTMLExpressions (options) {
107 |   // set default options
108 |   options = Object.assign({
109 |     locals: {},
110 |     delimiters: ['{{', '}}'],
111 |     unescapeDelimiters: ['{{{', '}}}'],
112 |     conditionalTags: ['if', 'elseif', 'else'],
113 |     switchTags: ['switch', 'case', 'default'],
114 |     loopTags: ['each'],
115 |     scopeTags: ['scope'],
116 |     ignoredTag: 'raw',
117 |     strictMode: true,
118 |     localsAttr: 'locals',
119 |     removeScriptLocals: false
120 |   }, options)
121 | 
122 |   // Set tags
123 |   loops = options.loopTags
124 |   scopes = options.scopeTags
125 |   conditionals = options.conditionalTags
126 |   switches = options.switchTags
127 |   ignored = options.ignoredTag
128 | 
129 |   // Define regex to search for placeholders
130 |   let before = escapeRegexpString(options.delimiters[0])
131 |   let firstChar = escapeRegexpString(options.delimiters[0][0])
132 |   let after = escapeRegexpString(options.delimiters[1])
133 | 
134 |   const delimitersRegexp = new RegExp(`(?<!@${firstChar}?)${before}(.+?)${after}`, 'g')
135 | 
136 |   before = escapeRegexpString(options.unescapeDelimiters[0])
137 |   firstChar = escapeRegexpString(options.unescapeDelimiters[0][0])
138 |   after = escapeRegexpString(options.unescapeDelimiters[1])
139 | 
140 |   const unescapeDelimitersRegexp = new RegExp(`(?<!@${firstChar}?)${before}(.+?)${after}`, 'g')
141 | 
142 |   // Create an array of delimiters
143 |   const delimiters = [
144 |     { text: options.delimiters, regexp: delimitersRegexp, escape: true },
145 |     { text: options.unescapeDelimiters, regexp: unescapeDelimitersRegexp, escape: false }
146 |   ]
147 | 
148 |   /**
149 |    * We arrange delimiter search order by length, since it's possible that one
150 |    * delimiter could 'contain' another delimiter, like `{{{` contains `{{`.
151 |    * But if we sort by length, the longer one will always match first.
152 |    */
153 |   if (options.delimiters.join().length > options.unescapeDelimiters.join().length) {
154 |     delimitersSettings[0] = delimiters[0]
155 |     delimitersSettings[1] = delimiters[1]
156 |   } else {
157 |     delimitersSettings[0] = delimiters[1]
158 |     delimitersSettings[1] = delimiters[0]
159 |   }
160 | 
161 |   delimitersReplace = new RegExp(`@${escapeRegexpString(delimitersSettings[1].text[0])}`, 'g')
162 |   unescapeDelimitersReplace = new RegExp(`@${escapeRegexpString(delimitersSettings[0].text[0])}`, 'g')
163 | 
164 |   // Kick off the parsing
165 |   return function (tree) {
166 |     const { locals } = scriptDataLocals(tree, options)
167 | 
168 |     return normalizeTree(
169 |       clearRawTag(
170 |         walk(
171 |           {
172 |             locals: { ...options.locals, ...locals },
173 |             strictMode: options.strictMode,
174 |             missingLocal: options.missingLocal
175 |           }, tree)
176 |       ), tree.options)
177 |   }
178 | }
179 | 
180 | function walk (opts, nodes) {
181 |   // The context in which expressions are evaluated
182 |   const ctx = vm.createContext(opts.locals)
183 | 
184 |   /**
185 |    * After a conditional has been resolved, we remove the conditional elements
186 |    * from the tree. This variable determines how many to skip afterwards.
187 |    *  */
188 |   let skip
189 | 
190 |   // Loop through each node in the tree
191 |   return [].concat(nodes).reduce((m, node, i) => {
192 |     // If we're skipping this node, return immediately
193 |     if (skip) { skip--; return m }
194 | 
195 |     // Don't parse `ignoredTag` from options
196 |     if (node.tag === ignored) {
197 |       m.push(node)
198 | 
199 |       return m
200 |     }
201 | 
202 |     // If we have a string, match and replace it
203 |     if (typeof node === 'string') {
204 |       node = placeholders(node, ctx, delimitersSettings, opts)
205 |       node = node
206 |         .replace(unescapeDelimitersReplace, delimitersSettings[0].text[0])
207 |         .replace(delimitersReplace, delimitersSettings[1].text[0])
208 | 
209 |       m.push(node)
210 | 
211 |       return m
212 |     }
213 | 
214 |     // If not, we have an object, so we need to run the attributes and contents
215 |     if (node.attrs) {
216 |       for (const key in node.attrs) {
217 |         if (typeof node.attrs[key] === 'string') {
218 |           node.attrs[key] = placeholders(node.attrs[key], ctx, delimitersSettings, opts)
219 |           node.attrs[key] = node.attrs[key]
220 |             .replace(unescapeDelimitersReplace, delimitersSettings[0].text[0])
221 |             .replace(delimitersReplace, delimitersSettings[1].text[0])
222 |         }
223 | 
224 |         // If `key` is a parameter
225 |         const _key = placeholders(key, ctx, delimitersSettings, opts)
226 |         if (key !== _key) {
227 |           node.attrs[_key] = node.attrs[key]
228 |           delete node.attrs[key]
229 |         }
230 |       }
231 |     }
232 | 
233 |     // If the node has content, recurse (unless it's a loop, which we handle later)
234 |     if (node.content && loops.includes(node.tag) === false && node.tag !== scopes[0]) {
235 |       node.content = walk(opts, node.content)
236 |     }
237 | 
238 |     /**
239 |      * If we have an element matching `<if>`, we've got a conditional; this
240 |      * comes after the recursion, to correctly handle nested loops.
241 |      * */
242 |     if (node.tag === conditionals[0]) {
243 |       // Throw an error if it's missing the "condition" attribute
244 |       if (!(node.attrs && node.attrs.condition)) {
245 |         throw new Error(`the "${conditionals[0]}" tag must have a "condition" attribute`)
246 |       }
247 | 
248 |       // Calculate the first path of condition expression
249 |       let expressionIndex = 1
250 |       let expression = `if (${node.attrs.condition}) { 0 } `
251 | 
252 |       const branches = [node.content]
253 | 
254 |       /**
255 |        * Move through the nodes and collect all others that
256 |        * are part of the same conditional statement
257 |        * */
258 |       let computedNextTag = getNextTag(nodes, ++i)
259 | 
260 |       let current = computedNextTag[0]
261 |       let nextTag = computedNextTag[1]
262 | 
263 |       while (conditionals.slice(1).indexOf(nextTag.tag) > -1) {
264 |         let statement = nextTag.tag
265 |         let condition = ''
266 | 
267 |         /**
268 |          * Ensure the "else" tag is represented in our little AST as 'else',
269 |          * even if a custom tag was used.
270 |          * */
271 |         if (nextTag.tag === conditionals[2]) statement = 'else'
272 | 
273 |         // Add the condition if it's an else if
274 |         if (nextTag.tag === conditionals[1]) {
275 |           // Throw an error if an "else if" is missing a condition
276 |           if (!(nextTag.attrs && nextTag.attrs.condition)) {
277 |             throw new Error(`the "${conditionals[1]}" tag must have a "condition" attribute`)
278 |           }
279 |           condition = nextTag.attrs.condition
280 | 
281 |           // While we're here, expand "elseif" to "else if"
282 |           statement = 'else if'
283 |         }
284 |         branches.push(nextTag.content)
285 | 
286 |         // Calculate next part of condition expression
287 |         expression += statement + (condition ? ` (${condition})` : '') + ` { ${expressionIndex++} } `
288 | 
289 |         computedNextTag = getNextTag(nodes, ++current)
290 | 
291 |         current = computedNextTag[0]
292 |         nextTag = computedNextTag[1]
293 |       }
294 | 
295 |       // Evaluate the expression and get the winning condition branch
296 |       let branch
297 |       try {
298 |         branch = branches[vm.runInContext(expression, ctx)]
299 |       } catch (error) {
300 |         if (opts.strictMode) {
301 |           throw new SyntaxError(error)
302 |         }
303 |       }
304 | 
305 |       /**
306 |        * Remove all of the conditional tags from the tree.
307 |        * We subtract 1 from i as it's incremented from the initial if statement
308 |        * in order to get the next node.
309 |        *  */
310 |       skip = current - i
311 | 
312 |       // Recursive evaluate of condition branch
313 |       if (branch) Array.prototype.push.apply(m, walk(opts, branch))
314 | 
315 |       return m
316 |     }
317 | 
318 |     // Switch tag
319 |     if (node.tag === switches[0]) {
320 |       // Throw an error if it's missing the "expression" attribute
321 |       if (!(node.attrs && node.attrs.expression)) {
322 |         throw new Error(`the "${switches[0]}" tag must have a "expression" attribute`)
323 |       }
324 | 
325 |       // Calculate the first path of condition expression
326 |       let expressionIndex = 0
327 |       let expression = `switch(${node.attrs.expression}) {`
328 | 
329 |       const branches = []
330 | 
331 |       for (let i = 0; i < node.content.length; i++) {
332 |         const currentNode = node.content[i]
333 |         if (typeof currentNode === 'string') {
334 |           continue
335 |         }
336 | 
337 |         if (currentNode.tag === switches[1]) {
338 |           // Throw an error if it's missing the "n" attribute
339 |           if (!(currentNode.attrs && currentNode.attrs.n)) {
340 |             throw new Error(`the "${switches[1]}" tag must have a "n" attribute`)
341 |           }
342 |           expression += `case ${currentNode.attrs.n}: {${expressionIndex++}}; break; `
343 |         } else if (currentNode.tag === switches[2]) {
344 |           expression += `default: {${expressionIndex++}}`
345 |         } else {
346 |           throw new Error(`the "${switches[0]}" tag can contain only "${switches[1]}" tags and one "${switches[2]}" tag`)
347 |         }
348 |         branches.push(currentNode)
349 |       }
350 | 
351 |       expression += '}'
352 | 
353 |       // Evaluate the expression, get the winning switch branch
354 |       const branch = branches[vm.runInContext(expression, ctx)]
355 | 
356 |       // Recursive evaluate of branch
357 |       Array.prototype.push.apply(m, walk(opts, branch.content))
358 | 
359 |       return m
360 |     }
361 | 
362 |     // Parse loops
363 |     if (loops.includes(node.tag)) {
364 |       // Handle syntax error
365 |       if (!(node.attrs && node.attrs.loop)) {
366 |         throw new Error(`the "${node.tag}" tag must have a "loop" attribute`)
367 |       }
368 | 
369 |       // Parse the "loop" param
370 |       const loopParams = parseLoopStatement(node.attrs.loop)
371 |       let target = {}
372 |       try {
373 |         target = vm.runInContext(loopParams.expression, ctx)
374 |       } catch (error) {
375 |         if (opts.strictMode) {
376 |           throw new SyntaxError(error)
377 |         }
378 |       }
379 | 
380 |       // Handle additional syntax errors
381 |       if (typeof target !== 'object' && opts.strictMode) {
382 |         throw new Error('You must provide an array or object to loop through')
383 |       }
384 | 
385 |       if (loopParams.keys.length < 1 || loopParams.keys[0] === '') {
386 |         throw new Error('You must provide at least one loop argument')
387 |       }
388 | 
389 |       // Converts nodes to a string. These nodes will be changed within the loop
390 |       const treeString = JSON.stringify(node.content)
391 |       const keys = loopParams.keys
392 | 
393 |       // Creates a copy of the keys that will be changed within the loop
394 |       const localsBackup = makeLocalsBackup(keys, opts.locals)
395 | 
396 |       // Run the loop, different types of loops for arrays and objects
397 |       if (Array.isArray(target)) {
398 |         for (let index = 0; index < target.length; index++) {
399 |           opts.locals.loop = getLoopMeta(index, target)
400 |           m.push(executeLoop(keys, target[index], index, opts.locals, treeString))
401 |         }
402 |       } else {
403 |         for (const key in target) {
404 |           opts.locals.loop = getLoopMeta(key, target)
405 |           m.push(executeLoop(keys, target[key], key, opts.locals, treeString))
406 |         }
407 |       }
408 | 
409 |       // Returns the original keys values that was changed within the loop
410 |       opts.locals = revertBackupedLocals(keys, opts.locals, localsBackup)
411 | 
412 |       // Return directly out of the loop, which will skip the "each" tag
413 |       return m
414 |     }
415 | 
416 |     // Parse scopes
417 |     if (node.tag === scopes[0]) {
418 |       // Handle syntax error
419 |       if (!node.attrs || !node.attrs.with) {
420 |         throw new Error(`the "${scopes[0]}" tag must have a "with" attribute`)
421 |       }
422 | 
423 |       const target = vm.runInContext(node.attrs.with, ctx)
424 | 
425 |       // Handle additional syntax errors
426 |       if (typeof target !== 'object' || Array.isArray(target)) {
427 |         throw new Error('You must provide an object to make scope')
428 |       }
429 | 
430 |       const keys = Object.keys(target)
431 | 
432 |       // Creates a copy of the keys that will be changed within the loop
433 |       const localsBackup = makeLocalsBackup(keys, opts.locals)
434 | 
435 |       m.push(executeScope(target, opts.locals, node))
436 | 
437 |       // Returns the original keys values that was changed within the loop
438 |       opts.locals = revertBackupedLocals(keys, opts.locals, localsBackup)
439 | 
440 |       // Return directly out of the loop, which will skip the "scope" tag
441 |       return m
442 |     }
443 | 
444 |     // Return the node
445 |     m.push(node)
446 | 
447 |     return m
448 |   }, [])
449 | }
450 | 
451 | function clearRawTag (tree) {
452 |   return tree.reduce((m, node) => {
453 |     if (node.content) {
454 |       node.content = clearRawTag(node.content)
455 |     }
456 | 
457 |     if (node.tag === ignored) {
458 |       node.tag = false
459 |     }
460 | 
461 |     m.push(node)
462 | 
463 |     return m
464 |   }, [])
465 | }
466 | function normalizeTree (tree, options) {
467 |   return parser(render(tree), options)
468 | }
469 | 


--------------------------------------------------------------------------------
/lib/locals.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | const vm = require('vm')
 4 | const matchHelper = require('posthtml-match-helper')
 5 | const { render } = require('posthtml-render')
 6 | const { match } = require('posthtml/lib/api')
 7 | 
 8 | const ctx = vm.createContext({ module })
 9 | 
10 | /**
11 |  * @description Get the script tag with locals attribute from a node list and return locals.
12 |  *
13 |  * @method scriptDataLocals
14 |  *
15 |  * @param  {Array}   tree Nodes
16 |  *
17 |  * @return {Object}   {} Locals
18 |  */
19 | function scriptDataLocals (tree, options) {
20 |   const locals = {}
21 |   const localsAttr = options.localsAttr
22 |   const localsContext = options.locals || {}
23 | 
24 |   match.call(tree, matchHelper(`script[${localsAttr}]`), node => {
25 |     if (node.content) {
26 |       const code = render(node.content)
27 | 
28 |       try {
29 |         const parsedContext = vm.createContext({ ...ctx, locals: localsContext })
30 |         const local = vm.runInContext(code, parsedContext)
31 | 
32 |         Object.assign(locals, local)
33 |       } catch {};
34 |     }
35 | 
36 |     if (options.removeScriptLocals) {
37 |       return ''
38 |     }
39 | 
40 |     return node
41 |   })
42 | 
43 |   return {
44 |     locals
45 |   }
46 | }
47 | 
48 | module.exports = scriptDataLocals
49 | 


--------------------------------------------------------------------------------
/lib/loops.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | /**
 4 |  * @description Given a "loop" parameter from an "each" tag, parses out the param names and expression to be looped.
 5 |  *
 6 |  * @method parseLoopStatement
 7 |  *
 8 |  * @param {String}  input Input
 9 |  *
10 |  * @return {Object} {}    Keys && Expression
11 |  */
12 | function parseLoopStatement (input) {
13 |   // Try to find ` in ` keyword
14 |   const inKeywordIndex = input.search(/\sin\s/)
15 | 
16 |   // If we reach the end of the string without getting "in", it's an error
17 |   if (inKeywordIndex === -1) {
18 |     throw new Error("Loop statement lacking 'in' keyword")
19 |   }
20 | 
21 |   // Expression is always after `in` keyword
22 |   const expression = input.substr(inKeywordIndex + 4)
23 | 
24 |   // keys is always before `in` keyword
25 |   const keys = input.substr(0, inKeywordIndex).split(',')
26 | 
27 |   for (let i = 0; i < keys.length; i++) {
28 |     keys[i] = keys[i].trim()
29 |   }
30 | 
31 |   return { keys, expression }
32 | }
33 | 
34 | /**
35 |  * @module loops
36 |  *
37 |  * @type {Function}
38 |  */
39 | module.exports = parseLoopStatement
40 | 


--------------------------------------------------------------------------------
/lib/placeholders.js:
--------------------------------------------------------------------------------
  1 | 'use strict'
  2 | 
  3 | const vm = require('vm')
  4 | 
  5 | const htmlRegexp = /[&<>"']/g
  6 | const htmlSymbols = {
  7 |   '&': '&amp;',
  8 |   '<': '&lt;',
  9 |   '>': '&gt;',
 10 |   '"': '&quot;',
 11 |   '\'': '&#039;'
 12 | }
 13 | 
 14 | /**
 15 |  * @description Escape HTML characters with their respective entities
 16 |  *
 17 |  * @method escapeHTML
 18 |  *
 19 |  * @param  {String} unescaped Unsafe HTML
 20 |  *
 21 |  * @return {String} escaped   Save HTML
 22 |  */
 23 | function escapeHTML (unescaped) {
 24 |   return unescaped.replace(htmlRegexp, (match) => htmlSymbols[match])
 25 | }
 26 | 
 27 | /**
 28 |  * @description Replace Expressions
 29 |  *
 30 |  * @method placeholders
 31 |  *
 32 |  * @param  {String} input Input
 33 |  * @param  {Object} ctx Context
 34 |  * @param  {Array}  settings Settings
 35 |  * @param  {Array}  opts Options
 36 |  *
 37 |  * @return {String} input Replaced Input
 38 |  */
 39 | function placeholders (input, ctx, settings, opts) {
 40 |   /**
 41 |    * Since we are matching multiple sets of delimiters,
 42 |    * we need to run a loop here to match each one.
 43 |    */
 44 |   for (let i = 0; i < settings.length; i++) {
 45 |     const matches = input.match(settings[i].regexp)
 46 | 
 47 |     if (!matches) continue
 48 | 
 49 |     const delimiters = settings[i].text
 50 | 
 51 |     for (let j = 0; j < matches.length; j++) {
 52 |       const match = matches[j]
 53 | 
 54 |       const expression = match.substring(delimiters[0].length, match.length - delimiters[1].length).trim()
 55 | 
 56 |       // If expression has non-word characters then use VM
 57 |       let value
 58 | 
 59 |       if (/\W+/.test(expression)) {
 60 |         try {
 61 |           value = vm.runInContext(expression, ctx)
 62 |         } catch (error) {
 63 |           if (opts.strictMode) {
 64 |             throw new SyntaxError(error)
 65 |           }
 66 |         }
 67 |       } else if (Object.prototype.hasOwnProperty.call(ctx, expression)) {
 68 |         value = ctx[expression]
 69 |       }
 70 | 
 71 |       // Not found local
 72 |       if (value === null || value === undefined) {
 73 |         if (opts.missingLocal === undefined) {
 74 |           if (opts.strictMode) {
 75 |             throw new ReferenceError(`'${expression}' is not defined`)
 76 |           }
 77 |         } else if (typeof opts.missingLocal === 'string') {
 78 |           value = opts.missingLocal.replace('{local}', match)
 79 |         }
 80 |       }
 81 |       // Escape html if necessary
 82 |       if (settings[i].escape && typeof value === 'string') {
 83 |         value = escapeHTML(value)
 84 |       } else if (typeof value === 'object') { // Stringify if value object
 85 |         value = JSON.stringify(value)
 86 |       }
 87 | 
 88 |       // Replace placeholder on evaluated value
 89 |       input = input.replace(match, value)
 90 |     }
 91 |   }
 92 | 
 93 |   return input
 94 | }
 95 | 
 96 | /**
 97 |  * @module placeholders
 98 |  *
 99 |  * @requires vm
100 |  *
101 |  * @type {Function}
102 |  */
103 | module.exports = placeholders
104 | 


--------------------------------------------------------------------------------
/lib/tags.js:
--------------------------------------------------------------------------------
 1 | 'use strict'
 2 | 
 3 | /**
 4 |  * @description Get the next tag from a node list
 5 |  *
 6 |  * @method getNextTag
 7 |  *
 8 |  * @param  {Array}   nodes Nodes
 9 |  * @param  {Number}  i     Accumulator
10 |  *
11 |  * @return {Array}   []    Array containing the next tag
12 |  */
13 | function getNextTag (nodes, i) {
14 |   // Loop until we get the next tag (bypassing newlines etc)
15 |   while (i < nodes.length) {
16 |     const node = nodes[i]
17 | 
18 |     if (typeof node === 'object') {
19 |       return [i, node]
20 |     } else if (typeof node === 'string' && node.trim().length > 0) {
21 |       return [i++, node]
22 |     } else {
23 |       i++
24 |     }
25 |   }
26 | 
27 |   return [i, { tag: undefined }]
28 | }
29 | 
30 | /**
31 |  * @module tags
32 |  *
33 |  * @type {Function}
34 |  */
35 | module.exports = getNextTag
36 | 


--------------------------------------------------------------------------------
/license:
--------------------------------------------------------------------------------
 1 | License (MIT)
 2 | 
 3 | Copyright (c) PostHTML
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "posthtml-expressions",
 3 |   "version": "1.11.4",
 4 |   "description": "Expressions Plugin for PostHTML",
 5 |   "engines": {
 6 |     "node": ">=10"
 7 |   },
 8 |   "main": "lib",
 9 |   "types": "lib/index.d.ts",
10 |   "files": [
11 |     "lib"
12 |   ],
13 |   "scripts": {
14 |     "lint": "standard",
15 |     "test": "npm run lint && nyc ava --timeout=1m",
16 |     "version": "standard-changelog -i CHANGELOG.md -w && git add changelog.md",
17 |     "docs": "jsdoc2md lib/*.js > INDEX.md"
18 |   },
19 |   "dependencies": {
20 |     "fclone": "^1.0.11",
21 |     "posthtml-match-helper": "^1.0.1",
22 |     "posthtml-parser": "^0.10.0",
23 |     "posthtml": "^0.16.5",
24 |     "posthtml-render": "^3.0.0"
25 |   },
26 |   "devDependencies": {
27 |     "ava": "^3.15.0",
28 |     "jsdoc-to-markdown": "^7.0.1",
29 |     "nyc": "^15.1.0",
30 |     "posthtml-beautify": "^0.7.0",
31 |     "standard": "^16.0.3",
32 |     "standard-changelog": "^2.0.27"
33 |   },
34 |   "keywords": [
35 |     "expressions",
36 |     "posthtml",
37 |     "posthtmlplugin"
38 |   ],
39 |   "author": {
40 |     "name": "Jeff Escalante",
41 |     "email": "gh.je@mailhero.io"
42 |   },
43 |   "contributors": [
44 |     {
45 |       "name": "Michael Ciniawsky",
46 |       "email": "michael.ciniawsky@gmail.com"
47 |     },
48 |     {
49 |       "name": "Denis Malinochkin",
50 |       "email": "dmalinochkin@rambler.ru"
51 |     }
52 |   ],
53 |   "repository": {
54 |     "type": "git",
55 |     "url": "https://github.com/posthtml/posthtml-expressions"
56 |   },
57 |   "bugs": {
58 |     "url": "https://github.com/posthtml/posthtml-expressions/issues"
59 |   },
60 |   "homepage": "https://github.com/posthtml/posthtml-expressions",
61 |   "license": "MIT"
62 | }
63 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | [![npm][npm]][npm-url]
  2 | [![node][node]][node-url]
  3 | [![tests][tests]][tests-url]
  4 | [![coverage][cover]][cover-url]
  5 | [![code style][style]][style-url]
  6 | 
  7 | <div align="center">
  8 |   <img width="110" height="100" title="PostHTML Plugin" vspace="50" src="http://michael-ciniawsky.github.io/postcss-load-plugins/logo.svg">
  9 |   <img width="220" height="200" title="PostHTML" src="http://posthtml.github.io/posthtml/logo.svg">
 10 |   <h1>Expressions Plugin</h1>
 11 | </div>
 12 | 
 13 | <h2 align="center">Install</h2>
 14 | 
 15 | ```bash
 16 | npm i -D posthtml-expressions
 17 | ```
 18 | 
 19 | <h2 align="center">Usage</h2>
 20 | 
 21 | ```js
 22 | const { readFileSync } = require('fs')
 23 | 
 24 | const posthtml = require('posthtml')
 25 | const expressions = require('posthtml-expressions')
 26 | 
 27 | posthtml(expressions({ locals: { foo: 'bar' } }))
 28 |   .process(readFileSync('index.html', 'utf8'))
 29 |   .then((result) => console.log(result.html))
 30 | ```
 31 | 
 32 | This plugin provides a syntax for including local variables and expressions in your templates, and also extends custom tags to act as helpers for conditionals and looping.
 33 | 
 34 | You have full control over the delimiters used for injecting locals, as well as the tag names for the conditional and loop helpers, if you need them. All options that can be passed to the `expressions` plugin are shown below:
 35 | 
 36 | <h2 align="center">Options</h2>
 37 | 
 38 | |Option|Default|Description|
 39 | |:----:|:-----:|:----------|
 40 | | **delimiters** | `['{{', '}}']` | Array containing beginning and ending delimiters for escaped locals os [expressions](#expressions) |
 41 | | [**unescapeDelimiters**](#unescaped-locals) | `['{{{', '}}}']` | Array containing beginning and ending delimiters for unescaped locals |
 42 | | [**locals**](#locals) | `{}` | Object containing any local variables you want to be available inside your expressions |
 43 | | **localsAttr** | `locals` | Attribute name for the tag `script` which contains ***[locals](#locals)***|
 44 | | **removeScriptLocals** | `false` | Will remove tag `script` which contains ***[locals](#locals)***|
 45 | | [**conditionalTags**](#conditionals) | `['if', 'elseif', 'else']` | Array containing names for tags used for [*`if/else` statements*](#conditionals) |
 46 | | [**switchTags**](#switchtags) | `['switch', 'case', 'default']` | Array containing names for tags used for [*`switch/case/default` statements*](#switch-statement) |
 47 | | **loopTags** | `['each']` | Array containing names for `for` loops |
 48 | | **scopeTags** | `['scope']` | Array containing names for scopes |
 49 | | [**ignoredTag**](#ignored-tag) | `'raw'` | String containing name of tag inside which parsing is disabled |
 50 | | **strictMode** | `true` | Boolean value set to `false` will not throw an exception if a value in locals not found or expression could not be evaluated|
 51 | | [**missingLocal**](#missing-locals) | `undefined` | string defining the replacement value in case value not found in locals. May contain `{expression}` placeholder|
 52 | 
 53 | ### Locals
 54 | 
 55 | You can inject locals into any piece of content in your html templates, other than overwriting tag names. For example, if you passed the following config to the expressions plugin:
 56 | 
 57 | ```js
 58 | locals: { className: 'intro', name: 'Marlo', 'status': 'checked' }
 59 | ```
 60 | 
 61 | ```html
 62 | <div class="{{ className }}">
 63 |   <input type="radio" {{ status }}>
 64 |   My name is {{ name }}
 65 | </div>
 66 | ```
 67 | 
 68 | ```html
 69 | <div class="intro">
 70 |   <input type="radio" checked="">
 71 |   My name is Marlo
 72 | </div>
 73 | ```
 74 | 
 75 | You can also use the script tag with the attribute `locals` or you custome attribute containing data to interpolate in the template.
 76 | 
 77 | ```html
 78 | <script locals>
 79 |   module.exports = {
 80 |     name: 'Scrum'
 81 |   }
 82 | </script>
 83 | 
 84 | <div>My name: {{name}}</div>
 85 | ```
 86 | 
 87 | ```html
 88 | <script locals>
 89 |   module.exports = {
 90 |     name: 'Scrum'
 91 |   }
 92 | </script>
 93 | 
 94 | <div>My name: Scrum</div>
 95 | ```
 96 | 
 97 | In addition, the use of script tag allow you to use `locals` defined globally to assign data to variables.
 98 | 
 99 | ```js
100 | posthtml(expressions({ locals: { foo: 'bar' } }))
101 |   .process(readFileSync('index.html', 'utf8'))
102 |   .then((result) => console.log(result.html))
103 | ```
104 | 
105 | ```html
106 | <script locals>
107 |   module.exports = {
108 |     name: 'Scrum',
109 |     foo: locals.foo || 'empty'
110 |   }
111 | </script>
112 | 
113 | <div>My name: {{name}}</div>
114 | <div>Foo: {{foo}}</div>
115 | ```
116 | 
117 | ```html
118 | <script locals>
119 |   module.exports = {
120 |     name: 'Scrum',
121 |     foo: locals.foo || 'empty'
122 |   }
123 | </script>
124 | 
125 | <div>My name: {{name}}</div>
126 | <div>Foo: bar</div>
127 | ```
128 | #### Missing locals
129 | What to produce in case of referencing a value not in `locals` can be configured by the `missingLocal` and `strictMode` options.
130 | 
131 | When `strictMode` is true (default) and leaving the `missingLocal` option `undefined`, then "'foo' is not defined" exception is thrown.
132 | 
133 | Setting `strictMode` false and leaving the `missingLocal` option `undefined` results the string `undefined` in the output
134 | 
135 | Setting the option `missingLocal` to a string will produce that string in the output regardless the value of option `strictMode`. `missingLocal` can contain the placeholder `{local}` which will be replaced with the name of the missing local in the output. This solution allows to:
136 | 1. Silently ignore missing locals by setting `missingLocal` to `""`
137 | 2. Include the name of the missing local in the output to help detect the which value is missing in `locals` like "#Missing value: {local}"
138 | 
139 | |`missingLocal`|`strictMode`|output|
140 | |:----:|:-----:|:----------|
141 | | `undefined` (default) | `true` (default) | Error is thrown |
142 | | `undefined` (default) | `false` | 'undefined' |
143 | | `''` | `false`/`true` | `''` (not output)
144 | | `{local}` | `false`/`true` | original reference like `{{foo}}`
145 | 
146 | ### Unescaped Locals
147 | 
148 | By default, special characters will be escaped so that they show up as text, rather than html code. For example, if you had a local containing valid html as such:
149 | 
150 | ```js
151 | locals: { statement: '<strong>wow!</strong>' }
152 | ```
153 | 
154 | ```html
155 | <p>The fox said, {{ statement }}</p>
156 | ```
157 | 
158 | ```html
159 | <p>The fox said, &lt;strong&gt;wow!&lt;strong&gt;</p>
160 | ```
161 | 
162 | In your browser, you would see the angle brackets, and it would appear as intended. However, if you wanted it instead to be parsed as html, you would need to use the `unescapeDelimiters`, which by default are three curly brackets, like this:
163 | 
164 | ```html
165 | <p>The fox said, {{{ strongStatement }}}</p>
166 | ```
167 | 
168 | In this case, your code would render as html:
169 | 
170 | ```html
171 | <p>The fox said, <strong>wow!<strong></p>
172 | ```
173 | 
174 | ### Expressions
175 | 
176 | You are not limited to just directly rendering local variables either, you can include any type of javascript expressions and it will be evaluated, with the result rendered. For example:
177 | 
178 | ```html
179 | <p class="{{ env === 'production' ? 'active' : 'hidden' }}">in production!</p>
180 | ```
181 | 
182 | With this in mind, it is strongly recommended to limit the number and complexity of expressions that are run directly in your template. You can always move the logic back to your config file and provide a function to the locals object for a smoother and easier result. For example:
183 | 
184 | ```js
185 | locals: {
186 |   isProduction: (env) => env === 'production' ? 'active' : 'hidden'
187 | }
188 | ```
189 | 
190 | ```html
191 | <p class="{{ isProduction(env) }}">in production!</p>
192 | ```
193 | 
194 | #### Ignoring Expressions
195 | 
196 | Many JavaScript frameworks use `{{` and `}}` as expression delimiters. It can even happen that another framework uses the same _custom_ delimiters you have defined in this plugin.
197 | 
198 | You can tell the plugin to completely ignore an expression by prepending `@` to the delimiters:
199 | 
200 | ```html
201 | <p>The @{{ foo }} is strong with this one.</p>
202 | ```
203 | 
204 | Result:
205 | 
206 | ```html
207 | <p>The {{ foo }} is strong with this one.</p>
208 | ```
209 | 
210 | ### Conditionals
211 | 
212 | Conditional logic uses normal html tags, and modifies/replaces them with the results of the logic. If there is any chance of a conflict with other custom tag names, you are welcome to change the tag names this plugin looks for in the options. For example, given the following config:
213 | 
214 | ```js
215 | locals: { foo: 'foo' }
216 | ```
217 | 
218 | ```html
219 | <if condition="foo === 'bar'">
220 |   <p>Foo really is bar! Revolutionary!</p>
221 | </if>
222 | 
223 | <elseif condition="foo === 'wow'">
224 |   <p>Foo is wow, oh man.</p>
225 | </elseif>
226 | 
227 | <else>
228 |   <p>Foo is probably just foo in the end.</p>
229 | </else>
230 | ```
231 | 
232 | ```html
233 | <p>Foo is probably just foo in the end.</p>
234 | ```
235 | 
236 | Anything in the `condition` attribute is evaluated directly as an expressions.
237 | 
238 | It should be noted that this is slightly cleaner-looking if you are using the [SugarML parser](https://github.com/posthtml/sugarml). But then again so is every other part of html.
239 | 
240 | ```sml
241 | if(condition="foo === 'bar'")
242 |   p Foo really is bar! Revolutionary!
243 | 
244 | elseif(condition="foo === 'wow'")
245 |   p Foo is wow, oh man.
246 | 
247 | else
248 |   p Foo is probably just foo in the end.
249 | ```
250 | 
251 | #### `conditionalTags`
252 | 
253 | Type: `array`\
254 | Default: `['if', 'elseif', 'else']`
255 | 
256 | You can define custom tag names to use for creating a conditional.
257 | 
258 | Example:
259 | 
260 | ```js
261 | conditionalTags: ['when', 'elsewhen', 'otherwise']
262 | ```
263 | 
264 | ```html
265 | <when condition="foo === 'bar'">
266 |   <p>Foo really is bar! Revolutionary!</p>
267 | </when>
268 | 
269 | <elsewhen condition="foo === 'wow'">
270 |   <p>Foo is wow, oh man.</p>
271 | </elsewhen>
272 | 
273 | <otherwise>
274 |   <p>Foo is probably just foo in the end.</p>
275 | </otherwise>
276 | ```
277 | 
278 | Note: tag names must be in the exact order as the default ones.
279 | 
280 | ### Switch statement
281 | 
282 | Switch statements act like streamline conditionals. They are useful for when you want to compare a single variable against a series of constants.
283 | 
284 | ```js
285 | locals: { foo: 'foo' }
286 | ```
287 | 
288 | ```html
289 | <switch expression="foo">
290 |   <case n="'bar'">
291 |     <p>Foo really is bar! Revolutionary!</p>
292 |   </case>
293 |   <case n="'wow'">
294 |     <p>Foo is wow, oh man.</p>
295 |   </case>
296 |   <default>
297 |     <p>Foo is probably just foo in the end.</p>
298 |   </default>
299 | </switch>
300 | ```
301 | 
302 | ```html
303 | <p>Foo is probably just foo in the end.</p>
304 | ```
305 | 
306 | Anything in the `expression` attribute is evaluated directly as an expressions.
307 | 
308 | #### `switchTags`
309 | 
310 | Type: `array`\
311 | Default: `['switch', 'case', 'default']`
312 | 
313 | You can define custom tag names to use when creating a switch.
314 | 
315 | Example:
316 | 
317 | ```js
318 | switchTags: ['clause', 'when', 'fallback']
319 | ```
320 | 
321 | ```html
322 | <clause expression="foo">
323 |   <when n="'bar'">
324 |     <p>Foo really is bar! Revolutionary!</p>
325 |   </when>
326 |   <when n="'wow'">
327 |     <p>Foo is wow, oh man.</p>
328 |   </when>
329 |   <fallback>
330 |     <p>Foo is probably just foo in the end.</p>
331 |   </fallback>
332 | </clause>
333 | ```
334 | 
335 | Note: tag names must be in the exact order as the default ones.
336 | 
337 | ### Loops
338 | 
339 | You can use the `each` tag to build loops. It works with both arrays and objects. For example:
340 | 
341 | ```js
342 | locals: {
343 |   array: ['foo', 'bar'],
344 |   object: { foo: 'bar' }
345 | }
346 | ```
347 | 
348 | **Array**
349 | ```html
350 | <each loop="item, index in array">
351 |   <p>{{ index }}: {{ item }}</p>
352 | </each>
353 | ```
354 | 
355 | ```html
356 | <p>1: foo</p>
357 | <p>2: bar</p>
358 | ```
359 | 
360 | **Object**
361 | ```html
362 | <each loop="value, key in anObject">
363 |   <p>{{ key }}: {{ value }}</p>
364 | </each>
365 | ```
366 | 
367 | ```html
368 | <p>foo: bar</p>
369 | ```
370 | 
371 | The value of the `loop` attribute is not a pure expressions evaluation, and it does have a tiny and simple custom parser. Essentially, it starts with one or more variable declarations, comma-separated, followed by the word `in`, followed by an expressions.
372 | 
373 | 
374 | ```html
375 | <each loop="item in [1,2,3]">
376 |   <p>{{ item }}</p>
377 | </each>
378 | ```
379 | 
380 | So you don't need to declare all the available variables (in this case, the index is skipped), and the expressions after `in` doesn't need to be a local variable, it can be any expressions.
381 | 
382 | #### `loopTags`
383 | 
384 | Type: `array`\
385 | Default: `['each']`
386 | 
387 | You can define custom tag names to use for creating loops:
388 | 
389 | Example:
390 | 
391 | ```js
392 | loopTags: ['each', 'for']
393 | ```
394 | 
395 | You can now also use the `<for>` tag when writing a loop:
396 | 
397 | ```html
398 | <for loop="item in [1,2,3]">
399 |   <p>{{ item }}</p>
400 | </for>
401 | ```
402 | 
403 | #### Loop meta
404 | 
405 | Inside a loop, you have access to a special `loop` object, which contains information about the loop currently being executed:
406 | 
407 | - `loop.index` - the current iteration of the loop (0 indexed)
408 | - `loop.remaining` - number of iterations until the end (0 indexed)
409 | - `loop.first` - boolean indicating if it's the first iteration
410 | - `loop.last` - boolean indicating if it's the last iteration
411 | - `loop.length` - total number of items
412 | 
413 | Example:
414 | 
415 | ```html
416 | <each loop='item in [1,2,3]'>
417 |   <li>Item value: {{ item }}</li>
418 |   <li>Current iteration of the loop: {{ loop.index }}</li>
419 |   <li>Number of iterations until the end: {{ loop.remaining }} </li>
420 |   <li>This {{ loop.first ? 'is' : 'is not' }} the first iteration</li>
421 |   <li>This {{ loop.last ? 'is' : 'is not' }} the last iteration</li>
422 |   <li>Total number of items: {{ loop.length }}</li>
423 | </each>
424 | ```
425 | 
426 | ### Scopes
427 | 
428 | You can replace locals inside certain area wrapped in a `<scope>` tag. For example you can use it after [posthtml-include](https://github.com/posthtml/posthtml-include)
429 | 
430 | ```js
431 | locals: {
432 |   author: { name: 'John'},
433 |   editor: { name: 'Jeff'}
434 | }
435 | ```
436 | 
437 | ```html
438 | <scope with="author">
439 |   <include src="components/profile.html"></include>
440 | </scope>
441 | <scope with="editor">
442 |   <include src="components/profile.html"></include>
443 | </scope>
444 | ```
445 | 
446 | ```html
447 | <div class="profile">
448 |   <div class="profile__name">{{ name }}</div>
449 |   <img class="profile__avatar" src="{{ image }}" alt="{{ name }}'s avatar" />
450 |   <a class="profile__link" href="{{ link }}">more info</a>
451 | </div>
452 | ```
453 | 
454 | #### `scopeTags`
455 | 
456 | Type: `array`\
457 | Default: `['scope']`
458 | 
459 | You can define a custom tag name to use for creating scopes:
460 | 
461 | Example:
462 | 
463 | ```js
464 | scopeTags: ['context']
465 | ```
466 | 
467 | You can now also use the `<context>` tag when writing a scope:
468 | 
469 | ```html
470 | <context with="author">
471 |   <include src="components/profile.html"></include>
472 | </context>
473 | ```
474 | 
475 | ### Ignored tag
476 | 
477 | Anything inside this tag will not be parsed, allowing you to output delimiters and anything the plugin would normally parse, in their original form.
478 | 
479 | ```html
480 | <raw>
481 |   <if condition="foo === 'bar'">
482 |     <p>Output {{ foo }} as-is</p>
483 |   </if>
484 | </raw>
485 | ```
486 | 
487 | ```html
488 | <if condition="foo === 'bar'">
489 |   <p>Output {{ foo }} as-is</p>
490 | </if>
491 | ```
492 | 
493 | You can customize the name of the tag:
494 | 
495 | ```js
496 | var opts = {
497 |   ignoredTag: 'verbatim',
498 |   locals: { foo: 'bar' } }
499 | }
500 | 
501 | posthtml(expressions(opts))
502 |   .process(readFileSync('index.html', 'utf8'))
503 |   .then((result) => console.log(result.html))
504 | ```
505 | 
506 | ```html
507 | <verbatim>
508 |   <if condition="foo === 'bar'">
509 |     <p>Output {{ foo }} as-is</p>
510 |   </if>
511 | </verbatim>
512 | ```
513 | 
514 | ```html
515 | <if condition="foo === 'bar'">
516 |   <p>Output {{ foo }} as-is</p>
517 | </if>
518 | ```
519 | 
520 | <h2 align="center">Maintainers</h2>
521 | 
522 | <table>
523 |   <tbody>
524 |    <tr>
525 |     <td align="center">
526 |       <img width="150 height="150"
527 |       src="https://avatars.githubusercontent.com/u/556932?v=3&s=150">
528 |       <br>
529 |       <a href="https://github.com/jescalan">Jeff Escalante</a>
530 |     </td>
531 |     <td align="center">
532 |       <img width="150 height="150"
533 |       src="https://avatars.githubusercontent.com/u/7034281?v=3&s=150">
534 |       <br>
535 |       <a href="https://github.com/mrmlnc">Denis Malinochkin</a>
536 |     </td>
537 |    </tr>
538 |   <tbody>
539 | </table>
540 | 
541 | <h2 align="center">Contributors</h2>
542 | 
543 | <table>
544 |   <tbody>
545 |    <tr>
546 |     <td align="center">
547 |       <img width="150 height="150"
548 |       src="https://avatars.githubusercontent.com/u/5419992?v=3&s=150">
549 |       <br>
550 |       <a href="https://github.com/michael-ciniawsky">Michael Ciniawsky</a>
551 |     </td>
552 |     <td align="center">
553 |       <img width="150 height="150"
554 |       src="https://avatars.githubusercontent.com/u/17473315?v=3&s=150">
555 |       <br>
556 |       <a href="https://github.com/xakdog">Krillin</a>
557 |     </td>
558 |     <td align="center">
559 |       <img width="150 height="150"
560 |       src="https://avatars0.githubusercontent.com/u/1656595?s=150&v=4">
561 |       <br>
562 |       <a href="https://github.com/cossssmin">Cosmin Popovici</a>
563 |     </td>
564 |    </tr>
565 |   <tbody>
566 | </table>
567 | 
568 | 
569 | [npm]: https://img.shields.io/npm/v/posthtml-expressions.svg
570 | [npm-url]: https://npmjs.com/package/posthtml-expressions
571 | 
572 | [node]: https://img.shields.io/node/v/posthtml-expressions.svg
573 | [node-url]: https://nodejs.org/
574 | 
575 | [deps]: https://david-dm.org/posthtml/posthtml-expressions.svg
576 | [deps-url]: https://david-dm.org/posthtml/posthtml-expressions
577 | 
578 | [tests]: https://github.com/posthtml/posthtml-expressions/workflows/Actions%20Status/badge.svg?style=flat-square
579 | [tests-url]: https://github.com/posthtml/posthtml-expressions/actions?query=workflow%3A%22CI+tests%22
580 | 
581 | [cover]: https://coveralls.io/repos/github/posthtml/posthtml-expressions/badge.svg
582 | [cover-url]: https://coveralls.io/github/posthtml/posthtml-expressions
583 | 
584 | [style]: https://img.shields.io/badge/code%20style-standard-yellow.svg
585 | [style-url]: http://standardjs.com/
586 | 


--------------------------------------------------------------------------------
/test/expect/attr_param.html:
--------------------------------------------------------------------------------
1 | <input type="radio" checked="">


--------------------------------------------------------------------------------
/test/expect/basic.html:
--------------------------------------------------------------------------------
1 | x wow x 2 x
2 | <p class="x wow x">x wow x</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/boolean_attr.html:
--------------------------------------------------------------------------------
1 | <details open=""></details>
2 | 


--------------------------------------------------------------------------------
/test/expect/conditional.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | 
3 |   <p>it works!</p>
4 | <p>x</p>
5 | 


--------------------------------------------------------------------------------
/test/expect/conditional_customtags.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | 
3 |   <p>it works!</p>
4 | <p>x</p>
5 | 


--------------------------------------------------------------------------------
/test/expect/conditional_expression.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | 
3 |   <p>bar</p>
4 | <p>x</p>
5 | 


--------------------------------------------------------------------------------
/test/expect/conditional_if.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | 
 3 |   <p>it works!</p>
 4 | <p>x</p>
 5 | 
 6 | <p>x</p>
 7 | <p>x</p>
 8 | 
 9 | x
10 | 
11 | x


--------------------------------------------------------------------------------
/test/expect/conditional_if_key_not_exists.html:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/posthtml/posthtml-expressions/8bd4f9204cdaa6665684ac6618fef408cb550948/test/expect/conditional_if_key_not_exists.html


--------------------------------------------------------------------------------
/test/expect/conditional_nested.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | 
3 |   <p>y</p>
4 | 
5 |     <p>z</p>
6 |   <p>y</p>
7 | <p>x</p>
8 | 


--------------------------------------------------------------------------------
/test/expect/conditional_norender.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <p>x</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/conditional_tag_break.html:
--------------------------------------------------------------------------------
1 |   <p>if</p>
2 | <p>x</p>
3 | <else>
4 |   <p>else</p>
5 | </else>
6 | 


--------------------------------------------------------------------------------
/test/expect/custom_delimiters.html:
--------------------------------------------------------------------------------
1 | x wow x 2 x
2 | <p class="x wow x">x wow x</p>
3 | x&x
4 | 


--------------------------------------------------------------------------------
/test/expect/directives.html:
--------------------------------------------------------------------------------
1 | <?php echo $myVar; ?>


--------------------------------------------------------------------------------
/test/expect/escape_html.html:
--------------------------------------------------------------------------------
1 | x&amp;x
2 | x&quot;x
3 | x&lt;x
4 | x&gt;x
5 | 


--------------------------------------------------------------------------------
/test/expect/expression_custom_delimiters_ignored.html:
--------------------------------------------------------------------------------
1 | ${ foo }
2 | <p data-username="${ user.name }" data-user-id="user-${ user.id }-bar-${ bar }">
3 |   Here's one ${ variable } and here's ${ another }. And some bar.
4 | </p>
5 | 
6 | ignored: ${ leaveAsIs }
7 | ignoredUnescaped: ${{ leaveAsIs }}
8 | rendered: bar
9 | 


--------------------------------------------------------------------------------
/test/expect/expression_ignored.html:
--------------------------------------------------------------------------------
1 | {{ foo }}
2 | <p data-username="{{ user.name }}" data-user-id="user-{{ user.id }}-bar-{{ bar }}">
3 |   Here's one {{ variable }} and here's {{ another }}. And some bar.
4 | </p>
5 | 
6 | ignored: {{ leaveAsIs }}
7 | ignoredUnescaped: {{{ leaveAsIs }}}
8 | rendered: bar
9 | 


--------------------------------------------------------------------------------
/test/expect/expression_spacing.html:
--------------------------------------------------------------------------------
1 | x X x X x X x X x
2 | xXxXxXxXx
3 | 


--------------------------------------------------------------------------------
/test/expect/local_missing.html:
--------------------------------------------------------------------------------
1 | <p>undefined<b>undefined</b></p>


--------------------------------------------------------------------------------
/test/expect/local_missing_keep.html:
--------------------------------------------------------------------------------
1 | <p>{{foo}}</p>


--------------------------------------------------------------------------------
/test/expect/local_missing_remove.html:
--------------------------------------------------------------------------------
1 | <p><b></b></p>


--------------------------------------------------------------------------------
/test/expect/local_missing_replace.html:
--------------------------------------------------------------------------------
1 | <p>Error: {{foo}} undefined</p>


--------------------------------------------------------------------------------
/test/expect/loop.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | 
 3 |   <p>0: 1</p>
 4 | 
 5 |   <p>1: 2</p>
 6 | 
 7 |   <p>2: 3</p>
 8 | 
 9 | <p>x</p>
10 | 


--------------------------------------------------------------------------------
/test/expect/loop_conditional.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <ul>
 3 | 
 4 | 
 5 |       <li>1</li>
 6 | 
 7 | 
 8 |       <li>2 % 2 === 0</li>
 9 | 
10 | 
11 |       <li>3</li>
12 | 
13 | </ul>
14 | <p>x</p>
15 | 


--------------------------------------------------------------------------------
/test/expect/loop_conditional_locals.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | 
 3 | 
 4 |     <a class="selected" href="/page1">Page 1</a>
 5 | 
 6 | 
 7 |     <a href="/page2">Page 2</a>
 8 | 
 9 | 
10 |     <a href="/page3">Page 3</a>
11 | 
12 | <p>x</p>
13 | 


--------------------------------------------------------------------------------
/test/expect/loop_conflict.html:
--------------------------------------------------------------------------------
 1 | <p>bar</p>
 2 | 
 3 |   <p>0: 1</p>
 4 | 
 5 |   <p>1: 2</p>
 6 | 
 7 |   <p>2: 3</p>
 8 | 
 9 | <p>bar</p>
10 | 


--------------------------------------------------------------------------------
/test/expect/loop_customtag.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | 
 3 |   <p>0: 1</p>
 4 | 
 5 |   <p>1: 2</p>
 6 | 
 7 |   <p>2: 3</p>
 8 | 
 9 | 
10 |   <p>0: 1</p>
11 | 
12 |   <p>1: 2</p>
13 | 
14 |   <p>2: 3</p>
15 | 
16 | <p>x</p>
17 | 


--------------------------------------------------------------------------------
/test/expect/loop_locals.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | 
 3 |   <p>0, 1, bar</p>
 4 | 
 5 |   <p>1, 2, bar</p>
 6 | 
 7 |   <p>2, 3, bar</p>
 8 | 
 9 | <p>x</p>
10 | 


--------------------------------------------------------------------------------
/test/expect/loop_metadata.html:
--------------------------------------------------------------------------------
 1 | <ul>
 2 | 
 3 |   <li>Item: 1</li>
 4 |   <li>Current iteration of the loop: 0</li>
 5 |   <li>Number of iterations until the end: 2 </li>
 6 |   <li>This is the first iteration</li>
 7 |   <li>This is not the last iteration</li>
 8 |   <li>Total number of items: 3</li>
 9 | 
10 |   <li>Item: 2</li>
11 |   <li>Current iteration of the loop: 1</li>
12 |   <li>Number of iterations until the end: 1 </li>
13 |   <li>This is not the first iteration</li>
14 |   <li>This is not the last iteration</li>
15 |   <li>Total number of items: 3</li>
16 | 
17 |   <li>Item: 3</li>
18 |   <li>Current iteration of the loop: 2</li>
19 |   <li>Number of iterations until the end: 0 </li>
20 |   <li>This is not the first iteration</li>
21 |   <li>This is the last iteration</li>
22 |   <li>Total number of items: 3</li>
23 | 
24 | </ul>
25 | 


--------------------------------------------------------------------------------
/test/expect/loop_nested.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | 
 3 |   <p>c1: [1,2,3]</p>
 4 | 
 5 |     <p>1</p>
 6 | 
 7 |     <p>2</p>
 8 | 
 9 |     <p>3</p>
10 | 
11 | 
12 |   <p>c2: [4,5,6]</p>
13 | 
14 |     <p>4</p>
15 | 
16 |     <p>5</p>
17 | 
18 |     <p>6</p>
19 | 
20 | 
21 | <p>x</p>
22 | 


--------------------------------------------------------------------------------
/test/expect/loop_nested_metadata.html:
--------------------------------------------------------------------------------
 1 | <ul>
 2 | 
 3 |   <li>foo: [1,2]</li>
 4 |   <li>There are 1 iterations remaining on the foo object</li>
 5 | 
 6 |     <ul>
 7 |       <li>Nested item value: 1</li>
 8 |       <li>Current iteration of the loop: 0</li>
 9 |       <li>Number of iterations until the end: 1</li>
10 |       <li>This is the first iteration</li>
11 |       <li>This is not the last iteration</li>
12 |       <li>Total number of items: 2</li>
13 |     </ul>
14 | 
15 |     <ul>
16 |       <li>Nested item value: 2</li>
17 |       <li>Current iteration of the loop: 1</li>
18 |       <li>Number of iterations until the end: 0</li>
19 |       <li>This is not the first iteration</li>
20 |       <li>This is the last iteration</li>
21 |       <li>Total number of items: 2</li>
22 |     </ul>
23 | 
24 | 
25 |   <li>bar: [3,4]</li>
26 |   <li>There are 0 iterations remaining on the bar object</li>
27 | 
28 |     <ul>
29 |       <li>Nested item value: 3</li>
30 |       <li>Current iteration of the loop: 0</li>
31 |       <li>Number of iterations until the end: 1</li>
32 |       <li>This is the first iteration</li>
33 |       <li>This is not the last iteration</li>
34 |       <li>Total number of items: 2</li>
35 |     </ul>
36 | 
37 |     <ul>
38 |       <li>Nested item value: 4</li>
39 |       <li>Current iteration of the loop: 1</li>
40 |       <li>Number of iterations until the end: 0</li>
41 |       <li>This is not the first iteration</li>
42 |       <li>This is the last iteration</li>
43 |       <li>Total number of items: 2</li>
44 |     </ul>
45 | 
46 | 
47 | </ul>
48 | 


--------------------------------------------------------------------------------
/test/expect/loop_object.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | 
3 |   <p>a: b</p>
4 | 
5 |   <p>c: d</p>
6 | 
7 | <p>x</p>
8 | 


--------------------------------------------------------------------------------
/test/expect/raw.html:
--------------------------------------------------------------------------------
1 |   <if condition="foo === 'bar'">
2 |     <p>Output {{ foo }} as is</p>
3 |   </if>
4 |   <p class="@{{ dynamicClass }}">{{ foo }}</p>
5 | 


--------------------------------------------------------------------------------
/test/expect/raw_custom.html:
--------------------------------------------------------------------------------
1 |   <if condition="foo === 'bar'">
2 |     <p>Output {{ foo }} as is</p>
3 |   </if>
4 |   <p class="@{{ dynamicClass }}">{{ foo }}</p>
5 | 


--------------------------------------------------------------------------------
/test/expect/raw_in_condition.html:
--------------------------------------------------------------------------------
1 | 
2 |     {{ foo }}
3 | 
4 | <p class="{{ dynamicClass }}">bar</p>
5 | 
6 | 


--------------------------------------------------------------------------------
/test/expect/raw_in_switch.html:
--------------------------------------------------------------------------------
1 | Hello from Earth, {{ username }}
2 | 
3 | 
4 | 
5 |     Hello from Moscow, {{ username }}
6 | 


--------------------------------------------------------------------------------
/test/expect/scope.html:
--------------------------------------------------------------------------------
1 | <p>x Scope x</p>
2 | 
3 |   <p>Hi. I am John. I am 26 years old.</p>
4 |   <p>test</p>
5 | 
6 | <p>x Scope x</p>
7 | 


--------------------------------------------------------------------------------
/test/expect/scope_nested.html:
--------------------------------------------------------------------------------
 1 | <p>global</p>
 2 | 
 3 |   <p>scope</p>
 4 | 
 5 |     <p>one</p>
 6 | 
 7 | 
 8 |     <p>two</p>
 9 | 
10 | 
11 | <p>global</p>
12 | 


--------------------------------------------------------------------------------
/test/expect/script-locals-global-not-informed.html:
--------------------------------------------------------------------------------
 1 | <script locals="">
 2 |   module.exports = {
 3 |     name: 'Scrum',
 4 |     age: locals.displayAge ? '25' : 'not informed'
 5 |   }
 6 | </script>
 7 | 
 8 | <div>My name: Scrum</div>
 9 | <div>My age: not informed</div>
10 | 


--------------------------------------------------------------------------------
/test/expect/script-locals-global.html:
--------------------------------------------------------------------------------
 1 | <script locals="">
 2 |   module.exports = {
 3 |     name: 'Scrum',
 4 |     age: locals.displayAge ? '25' : 'not informed'
 5 |   }
 6 | </script>
 7 | 
 8 | <div>My name: Scrum</div>
 9 | <div>My age: 25</div>
10 | 


--------------------------------------------------------------------------------
/test/expect/script-locals-remove.html:
--------------------------------------------------------------------------------
1 | <div>My name: Scrum</div>
2 | 


--------------------------------------------------------------------------------
/test/expect/script-locals.html:
--------------------------------------------------------------------------------
1 | <script locals="">
2 |   module.exports = {
3 |     name: 'Scrum'
4 |   }
5 | </script>
6 | 
7 | <div>My name: Scrum</div>
8 | 


--------------------------------------------------------------------------------
/test/expect/switch.html:
--------------------------------------------------------------------------------
1 | 
2 |     <p>Hello, from Germany!</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/switch_customtag.html:
--------------------------------------------------------------------------------
1 | 
2 |     <p>Hello, from United States!</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/switch_default.html:
--------------------------------------------------------------------------------
1 | 
2 |     <p>Hello, from Earth!</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/switch_nested.html:
--------------------------------------------------------------------------------
1 | 
2 |     <p>Hello, from Russia!</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/switch_number.html:
--------------------------------------------------------------------------------
1 | 
2 |     <p>3</p>
3 | 


--------------------------------------------------------------------------------
/test/expect/unescaped.html:
--------------------------------------------------------------------------------
1 | y x&amp;x y x&x y
2 | <strong>wow</strong>
3 | 


--------------------------------------------------------------------------------
/test/fixtures/attr_param.html:
--------------------------------------------------------------------------------
1 | <input type="radio" {{param}}/>


--------------------------------------------------------------------------------
/test/fixtures/basic.html:
--------------------------------------------------------------------------------
1 | x {{ test }} x {{ 1 + 1 }} x
2 | <p class="x {{ test }} x">x {{ test }} x</p>
3 | 


--------------------------------------------------------------------------------
/test/fixtures/boolean_attr.html:
--------------------------------------------------------------------------------
1 | <details open></details>
2 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <if condition="foo === 'bar'">
 3 |   <p>it works!</p>
 4 | </if>
 5 | <elseif condition="foo === 'wow'">
 6 |   <p>it doesn't work</p>
 7 | </elseif>
 8 | <elseif condition="foo === 'snargle'">
 9 |   <p>it really doesn't work</p>
10 | </elseif>
11 | <else>
12 |   <p>it definitely doesn't work</p>
13 | </else>
14 | <p>x</p>
15 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_customtags.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <zif condition="foo === 'bar'">
 3 |   <p>it works!</p>
 4 | </zif>
 5 | <zelseif condition="foo === 'wow'">
 6 |   <p>it doesn't work</p>
 7 | </zelseif>
 8 | <zelseif condition="foo === 'snargle'">
 9 |   <p>it really doesn't work</p>
10 | </zelseif>
11 | <zelse>
12 |   <p>it definitely doesn't work</p>
13 | </zelse>
14 | <p>x</p>
15 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_elseif_error.html:
--------------------------------------------------------------------------------
1 | <if condition='true'>
2 |   <p>hi</p>
3 | </if>
4 | <elseif foo='bar'>
5 |   <p>hi</p>
6 | </if>
7 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_expression.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <if condition="false">
3 |   <p>it works!</p>
4 | </if>
5 | <else>
6 |   <p>{{ foo }}</p>
7 | </else>
8 | <p>x</p>
9 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_expression_error.html:
--------------------------------------------------------------------------------
1 | <if condition='#W$@RWF~'>
2 |   <p>hi</p>
3 | </if>
4 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_if.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <if condition="foo === 'bar'">
 3 |   <p>it works!</p>
 4 | </if>
 5 | <p>x</p>
 6 | 
 7 | <p>x</p>
 8 | <if condition="bool">
 9 |   <p>it works!</p>
10 | </if>
11 | <p>x</p>
12 | 
13 | x
14 | <if condition="bool">
15 |   it works!
16 | </if>
17 | x
18 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_if_error.html:
--------------------------------------------------------------------------------
1 | <if>
2 |   <p>hi</p>
3 | </if>
4 | <if foo='bar'>
5 |   <p>hi</p>
6 | </if>
7 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_if_key_not_exists.html:
--------------------------------------------------------------------------------
 1 | <if condition="key_not_exists">
 2 |   it works!
 3 | </if>
 4 | 
 5 | <if condition="key_not_exists">
 6 |   {{ key_not_exists.foo }}
 7 |   it works!
 8 | </if>
 9 | 
10 | <if condition="items && items.length > 0">
11 |   <each loop="item, key in items">
12 |     {{ item.text }}
13 |   </each>
14 | </if>


--------------------------------------------------------------------------------
/test/fixtures/conditional_nested.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <if condition='true'>
 3 |   <p>y</p>
 4 |   <if condition='true'>
 5 |     <p>z</p>
 6 |   </if>
 7 |   <p>y</p>
 8 | </if>
 9 | <p>x</p>
10 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_norender.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <if condition='false'>
3 |   <p>hi</p>
4 | </if>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/conditional_tag_break.html:
--------------------------------------------------------------------------------
1 | <if condition='true'>
2 |   <p>if</p>
3 | </if>
4 | <p>x</p>
5 | <else>
6 |   <p>else</p>
7 | </else>
8 | 


--------------------------------------------------------------------------------
/test/fixtures/custom_delimiters.html:
--------------------------------------------------------------------------------
1 | x %[ test ]% x %[ 1 + 1 ]% x
2 | <p class="x %[ test ]% x">x %[ test ]% x</p>
3 | %[[ 'x&x' ]]%
4 | 


--------------------------------------------------------------------------------
/test/fixtures/directives.html:
--------------------------------------------------------------------------------
1 | <?php echo $myVar; ?>


--------------------------------------------------------------------------------
/test/fixtures/escape_html.html:
--------------------------------------------------------------------------------
1 | {{ 'x&x' }}
2 | {{ 'x"x' }}
3 | x{{ lt }}x
4 | x{{ gt }}x
5 | 


--------------------------------------------------------------------------------
/test/fixtures/expression_custom_delimiters_ignored.html:
--------------------------------------------------------------------------------
1 | @${ foo }
2 | <p data-username="@${ user.name }" data-user-id="user-@${ user.id }-${ foo }-@${ bar }">
3 |   Here's one @${ variable } and here's @${ another }. And some ${ foo }.
4 | </p>
5 | 
6 | ignored: @${ leaveAsIs }
7 | ignoredUnescaped: @${{ leaveAsIs }}
8 | rendered: ${ foo }
9 | 


--------------------------------------------------------------------------------
/test/fixtures/expression_error.html:
--------------------------------------------------------------------------------
1 | {{ @#!$R }}
2 | 


--------------------------------------------------------------------------------
/test/fixtures/expression_ignored.html:
--------------------------------------------------------------------------------
1 | @{{ foo }}
2 | <p data-username="@{{ user.name }}" data-user-id="user-@{{ user.id }}-{{ foo }}-@{{ bar }}">
3 |   Here's one @{{ variable }} and here's @{{ another }}. And some {{ foo }}.
4 | </p>
5 | 
6 | ignored: @{{ leaveAsIs }}
7 | ignoredUnescaped: @{{{ leaveAsIs }}}
8 | rendered: {{ foo }}
9 | 


--------------------------------------------------------------------------------
/test/fixtures/expression_spacing.html:
--------------------------------------------------------------------------------
1 | x {{foo}} x {{ foo }} x {{{ foo }}} x {{{foo}}} x
2 | x{{foo}}x{{ foo }}x{{{ foo }}}x{{{foo}}}x
3 | 


--------------------------------------------------------------------------------
/test/fixtures/local_missing.html:
--------------------------------------------------------------------------------
1 | <p>{{foo}}<b>{{foo? "bar": ""}}</b></p>


--------------------------------------------------------------------------------
/test/fixtures/local_missing_keep.html:
--------------------------------------------------------------------------------
1 | <p>{{foo}}</p>


--------------------------------------------------------------------------------
/test/fixtures/local_missing_remove.html:
--------------------------------------------------------------------------------
1 | <p>{{foo}}</p>


--------------------------------------------------------------------------------
/test/fixtures/local_missing_replace.html:
--------------------------------------------------------------------------------
1 | <p>{{foo}}</p>


--------------------------------------------------------------------------------
/test/fixtures/loop.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop='item, index in items'>
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_conditional.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <ul>
 3 |   <each loop='number in items'>
 4 |     <if condition="number % 2 === 0">
 5 |       <li>{{ number }} % 2 === 0</li>
 6 |     </if>
 7 |     <else>
 8 |       <li>{{ number }}</li>
 9 |     </else>
10 |   </each>
11 | </ul>
12 | <p>x</p>
13 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_conditional_locals.html:
--------------------------------------------------------------------------------
 1 | <p>x</p>
 2 | <each loop="page in pages">
 3 |   <if condition="page.path === current_path">
 4 |     <a class="selected" href="{{ page.path }}">{{ page.title }}</a>
 5 |   </if>
 6 |   <else>
 7 |     <a href="{{ page.path }}">{{ page.title }}</a>
 8 |   </else>
 9 | </each>
10 | <p>x</p>
11 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_conflict.html:
--------------------------------------------------------------------------------
1 | <p>{{item}}</p>
2 | <each loop='item, index in items'>
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>{{item}}</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_customtag.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <for loop='item, index in items'>
3 |   <p>{{index}}: {{item}}</p>
4 | </for>
5 | <each loop='item, index in items'>
6 |   <p>{{index}}: {{item}}</p>
7 | </each>
8 | <p>x</p>
9 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_expression_error.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop="item in #@$%#$">
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_locals.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop='item, index in items'>
3 |   <p>{{index}}, {{item}}, {{ foo }}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_metadata.html:
--------------------------------------------------------------------------------
 1 | <ul>
 2 | <each loop='item in items'>
 3 |   <li>Item: {{ item }}</li>
 4 |   <li>Current iteration of the loop: {{ loop.index }}</li>
 5 |   <li>Number of iterations until the end: {{ loop.remaining }} </li>
 6 |   <li>This {{ loop.first ? 'is' : 'is not' }} the first iteration</li>
 7 |   <li>This {{ loop.last ? 'is' : 'is not' }} the last iteration</li>
 8 |   <li>Total number of items: {{ loop.length }}</li>
 9 | </each>
10 | </ul>
11 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_nested.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop='item_category, key in items'>
3 |   <p>{{ key }}: {{ JSON.stringify(item_category) }}</p>
4 |   <each loop='item in item_category'>
5 |     <p>{{ item }}</p>
6 |   </each>
7 | </each>
8 | <p>x</p>
9 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_nested_metadata.html:
--------------------------------------------------------------------------------
 1 | <ul>
 2 | <each loop='value, key in items'>
 3 |   <li>{{ key }}: {{ JSON.stringify(value) }}</li>
 4 |   <li>There are {{ loop.remaining }} iterations remaining on the {{ key }} object</li>
 5 |   <each loop='item in value'>
 6 |     <ul>
 7 |       <li>Nested item value: {{ item }}</li>
 8 |       <li>Current iteration of the loop: {{ loop.index }}</li>
 9 |       <li>Number of iterations until the end: {{ loop.remaining }}</li>
10 |       <li>This {{ loop.first ? 'is' : 'is not' }} the first iteration</li>
11 |       <li>This {{ loop.last ? 'is' : 'is not' }} the last iteration</li>
12 |       <li>Total number of items: {{ loop.length }}</li>
13 |     </ul>
14 |   </each>
15 | </each>
16 | </ul>
17 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_no_args.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop=" in [1,2,3]">
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_no_attr.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each>
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_no_collection.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop="item in 5">
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_no_in.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop="item, index of 5">
3 |   <p>{{index}}: {{item}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/loop_object.html:
--------------------------------------------------------------------------------
1 | <p>x</p>
2 | <each loop='value, key in items'>
3 |   <p>{{key}}: {{value}}</p>
4 | </each>
5 | <p>x</p>
6 | 


--------------------------------------------------------------------------------
/test/fixtures/raw.html:
--------------------------------------------------------------------------------
1 | <raw>
2 |   <if condition="foo === 'bar'">
3 |     <p>Output {{ foo }} as is</p>
4 |   </if>
5 |   <p class="@{{ dynamicClass }}">{{ foo }}</p>
6 | </raw>
7 | 


--------------------------------------------------------------------------------
/test/fixtures/raw_custom.html:
--------------------------------------------------------------------------------
1 | <verbatim>
2 |   <if condition="foo === 'bar'">
3 |     <p>Output {{ foo }} as is</p>
4 |   </if>
5 |   <p class="@{{ dynamicClass }}">{{ foo }}</p>
6 | </verbatim>
7 | 


--------------------------------------------------------------------------------
/test/fixtures/raw_in_condition.html:
--------------------------------------------------------------------------------
1 | <if condition="foo === 'bar'">
2 |   <raw>
3 |     {{ foo }}
4 |   </raw>
5 | </if>
6 | <p class="@{{ dynamicClass }}">{{ foo }}</p>
7 | 
8 | 


--------------------------------------------------------------------------------
/test/fixtures/raw_in_switch.html:
--------------------------------------------------------------------------------
 1 | <switch expression="country">
 2 |   <case n="'russia'">
 3 |     <p>Hello, from Russia!</p>
 4 |   </case>
 5 |   <default>
 6 |     <raw>Hello from Earth, {{ username }}</raw>
 7 |   </default>
 8 | </switch>
 9 | 
10 | <switch expression="city">
11 |   <case n="'moscow'">
12 |     <raw>Hello from Moscow, {{ username }}</raw>
13 |   </case>
14 |   <default>
15 |     <p>Hello, from Earth!</p>
16 |   </default>
17 | </switch>
18 | 


--------------------------------------------------------------------------------
/test/fixtures/scope.html:
--------------------------------------------------------------------------------
1 | <p>x {{name}} x</p>
2 | <scope with="author">
3 |   <p>Hi. I am {{name}}. I am {{age}} years old.</p>
4 |   <p>{{key}}</p>
5 | </scope>
6 | <p>x {{name}} x</p>
7 | 


--------------------------------------------------------------------------------
/test/fixtures/scope_nested.html:
--------------------------------------------------------------------------------
 1 | <p>{{key}}</p>
 2 | <scope with="scope">
 3 |   <p>{{key}}</p>
 4 |   <scope with="one">
 5 |     <p>{{key}}</p>
 6 |   </scope>
 7 |   <scope with="two">
 8 |     <p>{{key}}</p>
 9 |   </scope>
10 | </scope>
11 | <p>{{key}}</p>
12 | 


--------------------------------------------------------------------------------
/test/fixtures/script-locals-global-not-informed.html:
--------------------------------------------------------------------------------
 1 | <script locals>
 2 |   module.exports = {
 3 |     name: 'Scrum',
 4 |     age: locals.displayAge ? '25' : 'not informed'
 5 |   }
 6 | </script>
 7 | 
 8 | <div>My name: {{name}}</div>
 9 | <div>My age: {{ age }}</div>
10 | 


--------------------------------------------------------------------------------
/test/fixtures/script-locals-global.html:
--------------------------------------------------------------------------------
 1 | <script locals>
 2 |   module.exports = {
 3 |     name: 'Scrum',
 4 |     age: locals.displayAge ? '25' : 'not informed'
 5 |   }
 6 | </script>
 7 | 
 8 | <div>My name: {{name}}</div>
 9 | <div>My age: {{ age }}</div>
10 | 


--------------------------------------------------------------------------------
/test/fixtures/script-locals-remove.html:
--------------------------------------------------------------------------------
1 | <script locals>
2 |   module.exports = {
3 |     name: 'Scrum'
4 |   }
5 | </script>
6 | 
7 | <div>My name: {{name}}</div>
8 | 


--------------------------------------------------------------------------------
/test/fixtures/script-locals.html:
--------------------------------------------------------------------------------
1 | <script locals>
2 |   module.exports = {
3 |     name: 'Scrum'
4 |   }
5 | </script>
6 | 
7 | <div>My name: {{name}}</div>
8 | 


--------------------------------------------------------------------------------
/test/fixtures/switch.html:
--------------------------------------------------------------------------------
 1 | <switch expression="country">
 2 |   <case n="'russia'">
 3 |     <p>Hello, from Russia!</p>
 4 |   </case>
 5 |   <case n="'germany'">
 6 |     <p>Hello, from Germany!</p>
 7 |   </case>
 8 |   <case n="'us'">
 9 |     <p>Hello, from United States!</p>
10 |   </case>
11 |   <default>
12 |     <p>Hello, from Earth!</p>
13 |   </default>
14 | </switch>
15 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_bad_flow.html:
--------------------------------------------------------------------------------
 1 | <switch expression="country">
 2 |   <case n="'russia'">
 3 |     <p>Hello, from Russia!</p>
 4 |   </case>
 5 |   <p>What?</p>
 6 |   <default>
 7 |     <p>Hello, from Earth!</p>
 8 |   </default>
 9 | </switch>
10 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_customtag.html:
--------------------------------------------------------------------------------
 1 | <s expression="country">
 2 |   <c n="'russia'">
 3 |     <p>Hello, from Russia!</p>
 4 |   </c>
 5 |   <c n="'germany'">
 6 |     <p>Hello, from Germany!</p>
 7 |   </c>
 8 |   <c n="'us'">
 9 |     <p>Hello, from United States!</p>
10 |   </c>
11 |   <d>
12 |     <p>Hello, from Earth!</p>
13 |   </d>
14 | </s>
15 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_default.html:
--------------------------------------------------------------------------------
 1 | <switch expression="country">
 2 |   <case n="'russia'">
 3 |     <p>Hello, from Russia!</p>
 4 |   </case>
 5 |   <case n="'germany'">
 6 |     <p>Hello, from Germany!</p>
 7 |   </case>
 8 |   <case n="'us'">
 9 |     <p>Hello, from United States!</p>
10 |   </case>
11 |   <default>
12 |     <p>Hello, from Earth!</p>
13 |   </default>
14 | </switch>
15 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_nested.html:
--------------------------------------------------------------------------------
 1 | <switch expression="country_one">
 2 |   <case n="'russia'">
 3 |     <p>Hello, from Russia!</p>
 4 |   </case>
 5 |   <case n="'germany'">
 6 |     <p>Hello, from Germany!</p>
 7 |   </case>
 8 |   <case n="'us'">
 9 |     <p>Hello, from United States!</p>
10 |   </case>
11 |   <default>
12 |     <switch expression="country_two">
13 |       <case n="'russia'">
14 |         <p>Hello, from Russia!</p>
15 |       </case>
16 |       <case n="'germany'">
17 |         <p>Hello, from Germany!</p>
18 |       </case>
19 |       <case n="'us'">
20 |         <p>Hello, from United States!</p>
21 |       </case>
22 |       <default>
23 |         <p>Hello, from Earth!</p>
24 |       </default>
25 |     </switch>
26 |   </default>
27 | </switch>
28 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_no_attr.html:
--------------------------------------------------------------------------------
1 | <switch>
2 |   <case n="'russia'">
3 |     <p>Hello, from Russia!</p>
4 |   </case>
5 |   <default>
6 |     <p>Hello, from Earth!</p>
7 |   </default>
8 | </switch>
9 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_no_case_attr.html:
--------------------------------------------------------------------------------
1 | <switch expression="">
2 |   <case>
3 |     <p>Hello, from Russia!</p>
4 |   </case>
5 |   <default>
6 |     <p>Hello, from Earth!</p>
7 |   </default>
8 | </switch>
9 | 


--------------------------------------------------------------------------------
/test/fixtures/switch_number.html:
--------------------------------------------------------------------------------
 1 | <switch expression="items.length">
 2 |   <case n="2">
 3 |     <p>2</p>
 4 |   </case>
 5 |   <case n="3">
 6 |     <p>3</p>
 7 |   </case>
 8 |   <default>
 9 |     <p>default</p>
10 |   </default>
11 | </switch>
12 | 


--------------------------------------------------------------------------------
/test/fixtures/unescaped.html:
--------------------------------------------------------------------------------
1 | y {{ 'x&x' }} y {{{ 'x&x' }}} y
2 | {{{ el }}}
3 | 


--------------------------------------------------------------------------------
/test/test-conditionals.js:
--------------------------------------------------------------------------------
 1 | const test = require('ava')
 2 | 
 3 | const join = require('path').join
 4 | const readSync = require('fs').readFileSync
 5 | 
 6 | const posthtml = require('posthtml')
 7 | const expressions = require('../lib')
 8 | 
 9 | const fixture = (file) => {
10 |   return readSync(join(__dirname, 'fixtures', `${file}.html`), 'utf8')
11 | }
12 | 
13 | const expect = (file) => {
14 |   return readSync(join(__dirname, 'expect', `${file}.html`), 'utf8')
15 | }
16 | 
17 | function process (t, name, options, log = false) {
18 |   return posthtml([expressions(options)])
19 |     .process(fixture(name))
20 |     .then((result) => {
21 |       log && console.log(result.html)
22 | 
23 |       return clean(result.html)
24 |     })
25 |     .then((html) => {
26 |       t.is(html, expect(name).trim())
27 |     })
28 | }
29 | 
30 | function error (name, cb, options) {
31 |   return posthtml([expressions(options)])
32 |     .process(fixture(name))
33 |     .catch(cb)
34 | }
35 | 
36 | function clean (html) {
37 |   return html.replace(/[^\S\r\n]+$/gm, '').trim()
38 | }
39 | 
40 | test('Conditionals', (t) => {
41 |   return process(t, 'conditional', { locals: { foo: 'bar' } })
42 | })
43 | 
44 | test('Conditionals - only "if" condition', (t) => {
45 |   return process(t, 'conditional_if', { locals: { foo: 'bar', bool: '' } })
46 | })
47 | 
48 | test('Conditionals - no render', (t) => {
49 |   return process(t, 'conditional_norender', {})
50 | })
51 | 
52 | test('Conditionals - "if" tag missing condition', (t) => {
53 |   return error('conditional_if_error', (err) => {
54 |     t.is(err.toString(), 'Error: the "if" tag must have a "condition" attribute')
55 |   })
56 | })
57 | 
58 | test('Conditionals - "elseif" tag missing condition', (t) => {
59 |   return error('conditional_elseif_error', (err) => {
60 |     t.is(err.toString(), 'Error: the "elseif" tag must have a "condition" attribute')
61 |   })
62 | })
63 | 
64 | test('Conditionals - other tag in middle of statement', (t) => {
65 |   return process(t, 'conditional_tag_break', {})
66 | })
67 | 
68 | test('Conditionals - nested conditionals', (t) => {
69 |   return process(t, 'conditional_nested', {})
70 | })
71 | 
72 | test('conditional - expression error', (t) => {
73 |   return error('conditional_expression_error', (err) => {
74 |     t.is(err.name, 'SyntaxError')
75 |   })
76 | })
77 | 
78 | test('Conditionals - if key exists in locals', (t) => {
79 |   return process(t, 'conditional_if_key_not_exists', { strictMode: false })
80 | })
81 | 
82 | test('Conditionals - custom tags', (t) => {
83 |   return process(t, 'conditional_customtags', {
84 |     conditionalTags: ['zif', 'zelseif', 'zelse'],
85 |     locals: { foo: 'bar' }
86 |   })
87 | })
88 | 
89 | test('Conditionals - expression in else/elseif', (t) => {
90 |   return process(t, 'conditional_expression', {
91 |     locals: { foo: 'bar' }
92 |   })
93 | })
94 | 


--------------------------------------------------------------------------------
/test/test-core.js:
--------------------------------------------------------------------------------
  1 | const test = require('ava')
  2 | 
  3 | const join = require('path').join
  4 | const readSync = require('fs').readFileSync
  5 | 
  6 | const posthtml = require('posthtml')
  7 | const beautify = require('posthtml-beautify')
  8 | const expressions = require('../lib')
  9 | 
 10 | const fixture = (file) => {
 11 |   return readSync(join(__dirname, 'fixtures', `${file}.html`), 'utf8')
 12 | }
 13 | 
 14 | const expect = (file) => {
 15 |   return readSync(join(__dirname, 'expect', `${file}.html`), 'utf8')
 16 | }
 17 | 
 18 | function process (t, name, options, log = false, plugins = [expressions(options)], processOptions = {}) {
 19 |   return posthtml(plugins)
 20 |     .process(fixture(name), processOptions)
 21 |     .then((result) => {
 22 |       log && console.log(result.html)
 23 | 
 24 |       return clean(result.html)
 25 |     })
 26 |     .then((html) => {
 27 |       t.is(html, expect(name).trim())
 28 |     })
 29 | }
 30 | 
 31 | function error (name, cb, opts) {
 32 |   return posthtml([expressions(opts)])
 33 |     .process(fixture(name))
 34 |     .catch(cb)
 35 | }
 36 | 
 37 | function clean (html) {
 38 |   return html.replace(/[^\S\r\n]+$/gm, '').trim()
 39 | }
 40 | 
 41 | test('Basic', (t) => {
 42 |   return process(t, 'basic', { locals: { test: 'wow' } })
 43 | })
 44 | 
 45 | test('Escaped', (t) => {
 46 |   return process(t, 'escape_html', { locals: { lt: '<', gt: '>' } })
 47 | })
 48 | 
 49 | test('Unescaped', (t) => {
 50 |   return process(t, 'unescaped', {
 51 |     locals: { el: '<strong>wow</strong>' }
 52 |   })
 53 | })
 54 | 
 55 | test('Delimiters', (t) => {
 56 |   return process(t, 'custom_delimiters', {
 57 |     delimiters: ['%[', ']%'],
 58 |     unescapeDelimiters: ['%[[', ']]%'],
 59 |     locals: { test: 'wow' }
 60 |   })
 61 | })
 62 | 
 63 | test('Expressions - spacing', (t) => {
 64 |   return process(t, 'expression_spacing', { locals: { foo: 'X' } })
 65 | })
 66 | 
 67 | test('Expressions - error', (t) => {
 68 |   return error('expression_error', (err) => {
 69 |     t.is(err.message, 'SyntaxError: Invalid or unexpected token')
 70 |   })
 71 | })
 72 | 
 73 | test('Expressions - ignored', (t) => {
 74 |   return process(t, 'expression_ignored', { locals: { foo: 'bar' } })
 75 | })
 76 | 
 77 | test('Expressions with custom delimiters - ignored', (t) => {
 78 |   return process(t, 'expression_custom_delimiters_ignored', {
 79 |     delimiters: ['${', '}'],
 80 |     unescapeDelimiters: ['${{', '}}'],
 81 |     locals: { foo: 'bar' }
 82 |   })
 83 | })
 84 | 
 85 | test('Raw output', (t) => {
 86 |   return process(t, 'raw', { locals: { foo: 'bar' } })
 87 | })
 88 | 
 89 | test('Raw output - inside condition', (t) => {
 90 |   return process(t, 'raw_in_condition', { locals: { foo: 'bar' } })
 91 | })
 92 | 
 93 | test('Raw output - custom tag', (t) => {
 94 |   return process(t, 'raw_custom', { ignoredTag: 'verbatim', locals: { foo: 'bar' } })
 95 | })
 96 | 
 97 | test('Boolean attribute', (t) => {
 98 |   return process(t, 'boolean_attr', null, false, [beautify(), expressions()])
 99 | })
100 | 
101 | test('Attribute as param', (t) => {
102 |   return process(t, 'attr_param', null, false, [beautify(), expressions({ locals: { param: 'checked' } })])
103 | })
104 | 
105 | test('Directives options', (t) => {
106 |   return process(t, 'directives', null, false, [expressions()], {
107 |     directives: [{
108 |       name: '?php',
109 |       start: '<',
110 |       end: '>'
111 |     }]
112 |   })
113 | })
114 | 
115 | test('local - missing - error', (t) => {
116 |   return error('local_missing', (err) => {
117 |     t.is(err.message, "'foo' is not defined")
118 |   })
119 | })
120 | 
121 | test('local - missing - undefined', (t) => {
122 |   return process(t, 'local_missing', { strictMode: false })
123 | })
124 | 
125 | test('local - missing - keep', (t) => {
126 |   return process(t, 'local_missing_keep', { missingLocal: '{local}' })
127 | })
128 | 
129 | test('local - missing - keep / strictMode:false', (t) => {
130 |   return process(t, 'local_missing_keep', { missingLocal: '{local}', strictMode: false })
131 | })
132 | 
133 | test('local - missing - replace', (t) => {
134 |   return process(t, 'local_missing_replace', { missingLocal: 'Error: {local} undefined' })
135 | })
136 | 


--------------------------------------------------------------------------------
/test/test-locals.js:
--------------------------------------------------------------------------------
 1 | const test = require('ava')
 2 | 
 3 | const join = require('path').join
 4 | const readSync = require('fs').readFileSync
 5 | 
 6 | const posthtml = require('posthtml')
 7 | const expressions = require('../lib')
 8 | 
 9 | const fixture = (file) => {
10 |   return readSync(join(__dirname, 'fixtures', `${file}.html`), 'utf8')
11 | }
12 | 
13 | const expect = (file) => {
14 |   return readSync(join(__dirname, 'expect', `${file}.html`), 'utf8')
15 | }
16 | 
17 | function process (t, name, options, log = false, plugins = [expressions(options)], processOptions = {}) {
18 |   return posthtml(plugins)
19 |     .process(fixture(name), processOptions)
20 |     .then((result) => {
21 |       log && console.log(result.html)
22 | 
23 |       return clean(result.html)
24 |     })
25 |     .then((html) => {
26 |       t.is(html, expect(name).trim())
27 |     })
28 | }
29 | 
30 | function clean (html) {
31 |   return html.replace(/[^\S\r\n]+$/gm, '').trim()
32 | }
33 | 
34 | test('Basic', (t) => {
35 |   return process(t, 'script-locals')
36 | })
37 | 
38 | test('Global Locals - setting global locals', (t) => {
39 |   return process(t, 'script-locals-global', { locals: { displayAge: true } })
40 | })
41 | 
42 | test('Global Locals - no global locals informed', (t) => {
43 |   return process(t, 'script-locals-global-not-informed')
44 | })
45 | 
46 | test('Remove script locals', (t) => {
47 |   return process(t, 'script-locals-remove', { removeScriptLocals: true })
48 | })
49 | 


--------------------------------------------------------------------------------
/test/test-loops.js:
--------------------------------------------------------------------------------
  1 | const test = require('ava')
  2 | 
  3 | const join = require('path').join
  4 | const readSync = require('fs').readFileSync
  5 | 
  6 | const posthtml = require('posthtml')
  7 | const expressions = require('../lib')
  8 | 
  9 | const fixture = (file) => {
 10 |   return readSync(join(__dirname, 'fixtures', `${file}.html`), 'utf8')
 11 | }
 12 | 
 13 | const expect = (file) => {
 14 |   return readSync(join(__dirname, 'expect', `${file}.html`), 'utf8')
 15 | }
 16 | 
 17 | function process (t, name, options, log = false) {
 18 |   return posthtml([expressions(options)])
 19 |     .process(fixture(name))
 20 |     .then((result) => {
 21 |       log && console.log(result.html)
 22 | 
 23 |       return clean(result.html)
 24 |     })
 25 |     .then((html) => {
 26 |       t.is(html, expect(name).trim())
 27 |     })
 28 | }
 29 | 
 30 | function error (name, cbErr, cbSuccess, pluginOptions) {
 31 |   return posthtml([expressions(pluginOptions)])
 32 |     .process(fixture(name))
 33 |     .then(cbSuccess)
 34 |     .catch(cbErr)
 35 | }
 36 | 
 37 | function clean (html) {
 38 |   return html.replace(/[^\S\r\n]+$/gm, '').trim()
 39 | }
 40 | 
 41 | test('Loops', (t) => {
 42 |   return process(t, 'loop', { locals: { items: [1, 2, 3] } })
 43 | })
 44 | 
 45 | test('Loops - {Object}', (t) => {
 46 |   return process(t, 'loop_object', {
 47 |     locals: { items: { a: 'b', c: 'd' } }
 48 |   })
 49 | })
 50 | 
 51 | test('Loops - nested', (t) => {
 52 |   return process(t, 'loop_nested', {
 53 |     locals: { items: { c1: [1, 2, 3], c2: [4, 5, 6] } }
 54 |   })
 55 | })
 56 | 
 57 | test('Loops - locals included', (t) => {
 58 |   return process(t, 'loop_locals', {
 59 |     locals: { items: [1, 2, 3], foo: 'bar' }
 60 |   })
 61 | })
 62 | 
 63 | test('Loops - conditional included', (t) => {
 64 |   return process(t, 'loop_conditional', {
 65 |     locals: { items: [1, 2, 3] }
 66 |   })
 67 | })
 68 | 
 69 | test('Loops - conditional and locals included', (t) => {
 70 |   return process(t, 'loop_conditional_locals', {
 71 |     locals: {
 72 |       pages: [
 73 |         { path: '/page1', title: 'Page 1' },
 74 |         { path: '/page2', title: 'Page 2' },
 75 |         { path: '/page3', title: 'Page 3' }
 76 |       ],
 77 |       current_path: '/page1'
 78 |     }
 79 |   })
 80 | })
 81 | 
 82 | test('Loops - conflicting locals', (t) => {
 83 |   return process(t, 'loop_conflict', {
 84 |     locals: { items: [1, 2, 3], item: 'bar' }
 85 |   })
 86 | })
 87 | 
 88 | test('Loops - custom tag', (t) => {
 89 |   return process(t, 'loop_customtag', {
 90 |     loopTags: ['for', 'each'],
 91 |     locals: { items: [1, 2, 3] }
 92 |   })
 93 | })
 94 | 
 95 | test('Loops - no loop attribute', (t) => {
 96 |   return error('loop_no_attr', (err) => {
 97 |     t.is(err.message, 'the "each" tag must have a "loop" attribute')
 98 |   })
 99 | })
100 | 
101 | test('Loops - no array or object passed', (t) => {
102 |   return error('loop_no_collection', (err) => {
103 |     t.is(err.toString(), 'Error: You must provide an array or object to loop through')
104 |   })
105 | })
106 | 
107 | test('Loops - no array or object passed with disabled strict mode', (t) => {
108 |   return error('loop_no_collection', () => {}, (response) => {
109 |     t.truthy(response)
110 |   }, { strictMode: false })
111 | })
112 | 
113 | test('Loops - no loop arguments', (t) => {
114 |   return error('loop_no_args', (err) => {
115 |     t.truthy(err.toString() === 'Error: You must provide at least one loop argument')
116 |   })
117 | })
118 | 
119 | test('Loops - no "in" keyword', (t) => {
120 |   return error('loop_no_in', (err) => {
121 |     t.truthy(err.toString() === "Error: Loop statement lacking 'in' keyword")
122 |   })
123 | })
124 | 
125 | test('Loops - expression error', (t) => {
126 |   return error('loop_expression_error', (err) => {
127 |     t.is(err.message, 'SyntaxError: Invalid or unexpected token')
128 |   })
129 | })
130 | 
131 | test('Loops - metadata', (t) => {
132 |   return process(t, 'loop_metadata', {
133 |     locals: { items: [1, 2, 3] }
134 |   })
135 | })
136 | 
137 | test('Loops - nested metadata', (t) => {
138 |   return process(t, 'loop_nested_metadata', {
139 |     locals: { items: { foo: [1, 2], bar: [3, 4] } }
140 |   })
141 | })
142 | 


--------------------------------------------------------------------------------
/test/test-scopes.js:
--------------------------------------------------------------------------------
 1 | const test = require('ava')
 2 | 
 3 | const join = require('path').join
 4 | const readSync = require('fs').readFileSync
 5 | 
 6 | const posthtml = require('posthtml')
 7 | const expressions = require('../lib')
 8 | 
 9 | const fixture = (file) => {
10 |   return readSync(join(__dirname, 'fixtures', `${file}.html`), 'utf8')
11 | }
12 | 
13 | const expect = (file) => {
14 |   return readSync(join(__dirname, 'expect', `${file}.html`), 'utf8')
15 | }
16 | 
17 | function process (t, name, options, log = false) {
18 |   return posthtml([expressions(options)])
19 |     .process(fixture(name))
20 |     .then((result) => {
21 |       log && console.log(result.html)
22 | 
23 |       return clean(result.html)
24 |     })
25 |     .then((html) => {
26 |       t.is(html, expect(name).trim())
27 |     })
28 | }
29 | 
30 | function clean (html) {
31 |   return html.replace(/[^\S\r\n]+$/gm, '').trim()
32 | }
33 | 
34 | test('Scopes', (t) => {
35 |   return process(t, 'scope', {
36 |     locals: {
37 |       author: { name: 'John', age: 26 },
38 |       name: 'Scope',
39 |       key: 'test'
40 |     }
41 |   })
42 | })
43 | 
44 | test('Scopes - nested', (t) => {
45 |   return process(t, 'scope_nested', {
46 |     locals: {
47 |       key: 'global',
48 |       scope: {
49 |         key: 'scope',
50 |         one: {
51 |           key: 'one'
52 |         },
53 |         two: {
54 |           key: 'two'
55 |         }
56 |       }
57 |     }
58 |   })
59 | })
60 | 


--------------------------------------------------------------------------------
/test/test-switch.js:
--------------------------------------------------------------------------------
 1 | const test = require('ava')
 2 | 
 3 | const join = require('path').join
 4 | const readSync = require('fs').readFileSync
 5 | 
 6 | const posthtml = require('posthtml')
 7 | const expressions = require('../lib')
 8 | 
 9 | const fixture = (file) => {
10 |   return readSync(join(__dirname, 'fixtures', `${file}.html`), 'utf8')
11 | }
12 | 
13 | const expect = (file) => {
14 |   return readSync(join(__dirname, 'expect', `${file}.html`), 'utf8')
15 | }
16 | 
17 | function process (t, name, options, log = false) {
18 |   return posthtml([expressions(options)])
19 |     .process(fixture(name))
20 |     .then((result) => {
21 |       log && console.log(result.html)
22 | 
23 |       return clean(result.html)
24 |     })
25 |     .then((html) => {
26 |       t.is(html, expect(name).trim())
27 |     })
28 | }
29 | 
30 | function error (name, cb) {
31 |   return posthtml([expressions()])
32 |     .process(fixture(name))
33 |     .catch(cb)
34 | }
35 | 
36 | function clean (html) {
37 |   return html.replace(/[^\S\r\n]+$/gm, '').trim()
38 | }
39 | 
40 | test('Switch', (t) => {
41 |   return Promise.all([
42 |     process(t, 'switch', { locals: { country: 'germany' } })
43 |   ])
44 | })
45 | 
46 | test('Switch - default branch', (t) => {
47 |   return Promise.all([
48 |     process(t, 'switch_default', { locals: { country: 'venezuela' } })
49 |   ])
50 | })
51 | 
52 | test('Switch - nested', (t) => {
53 |   return Promise.all([
54 |     process(t, 'switch_nested', {
55 |       locals: {
56 |         country_one: 'venezuela',
57 |         country_two: 'russia'
58 |       }
59 |     })
60 |   ])
61 | })
62 | 
63 | test('Switch - custom tag', (t) => {
64 |   return process(t, 'switch_customtag', {
65 |     switchTags: ['s', 'c', 'd'],
66 |     locals: { country: 'us' }
67 |   })
68 | })
69 | 
70 | test('Switch - dynamic expression', (t) => {
71 |   return Promise.all([
72 |     process(t, 'switch_number', { locals: { items: [1, 2, 3] } })
73 |   ])
74 | })
75 | 
76 | test('Switch - no switch attribute', (t) => {
77 |   return error('switch_no_attr', (err) => {
78 |     t.is(err.toString(), 'Error: the "switch" tag must have a "expression" attribute')
79 |   })
80 | })
81 | 
82 | test('Switch - no case attribute', (t) => {
83 |   return error('switch_no_case_attr', (err) => {
84 |     t.is(err.message, 'the "switch" tag must have a "expression" attribute')
85 |   })
86 | })
87 | 
88 | test('Switch - bad flow', (t) => {
89 |   return error('switch_bad_flow', (err) => {
90 |     t.is(err.message, 'the "switch" tag can contain only "case" tags and one "default" tag')
91 |   })
92 | })
93 | 
94 | test('Switch - raw tag', (t) => {
95 |   return Promise.all([
96 |     process(t, 'raw_in_switch', { locals: { country: 'germany', city: 'moscow' } })
97 |   ])
98 | })
99 | 


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