From e4e74df27e519cb1050ac739a888692d49424d10 Mon Sep 17 00:00:00 2001
From: Spencer Brower <6729162+sbrow@users.noreply.github.com>
Date: Wed, 15 Jul 2026 15:07:44 -0400
Subject: [PATCH] refactor: Rewrote the `mustache` package from scratch.

---
 mustache/.gitignore                    |    9 +-
 mustache/.gitmodules                   |    4 -
 mustache/Justfile                      |   15 -
 mustache/LICENSE                       |   19 -
 mustache/PARTIAL_INDENT.md             |  137 ++
 mustache/README.md                     |  162 --
 mustache/TODOS.md                      |    2 +
 mustache/data.odin                     |  221 +++
 mustache/examples/hello/hello.mustache |   11 -
 mustache/examples/hello/hello.odin     |   28 -
 mustache/mustache.odin                 | 2141 ++++--------------------
 mustache/mustache_test.odin            | 1045 ------------
 mustache/spec_test.odin                |  127 ++
 mustache/test/data.json                |    5 -
 mustache/test/layout.txt               |    3 -
 mustache/test/template.txt             |    1 -
 mustache/tokenizer.odin                |  227 +++
 mustache_test.odin                     |   41 +-
 render.odin                            |   37 +-
 19 files changed, 1061 insertions(+), 3174 deletions(-)
 delete mode 100644 mustache/.gitmodules
 delete mode 100644 mustache/Justfile
 delete mode 100644 mustache/LICENSE
 create mode 100644 mustache/PARTIAL_INDENT.md
 delete mode 100644 mustache/README.md
 create mode 100644 mustache/TODOS.md
 create mode 100644 mustache/data.odin
 delete mode 100644 mustache/examples/hello/hello.mustache
 delete mode 100644 mustache/examples/hello/hello.odin
 delete mode 100644 mustache/mustache_test.odin
 create mode 100644 mustache/spec_test.odin
 delete mode 100644 mustache/test/data.json
 delete mode 100644 mustache/test/layout.txt
 delete mode 100644 mustache/test/template.txt
 create mode 100644 mustache/tokenizer.odin

diff --git a/mustache/.gitignore b/mustache/.gitignore
index 9a7cb7b..6dd7461 100644
--- a/mustache/.gitignore
+++ b/mustache/.gitignore
@@ -1,8 +1 @@
-*/**/.DS_Store
-.DS_Store
-tmp/
-bin/
-*/**/odin-mustache.dSYM/
-*/**/odin-mustache
-*/**/odin-mustache-test.dSYM/
-*/**/odin-mustache-test
+mustache
diff --git a/mustache/.gitmodules b/mustache/.gitmodules
deleted file mode 100644
index e032690..0000000
--- a/mustache/.gitmodules
+++ /dev/null
@@ -1,4 +0,0 @@
-[submodule "spec"]
-	path = spec
-	url = git@github.com:mustache/spec.git
-	branch = v1.4.1
diff --git a/mustache/Justfile b/mustache/Justfile
deleted file mode 100644
index b045f40..0000000
--- a/mustache/Justfile
+++ /dev/null
@@ -1,15 +0,0 @@
-flags := "-vet -show-timings -strict-style -vet-cast -vet-tabs -vet-using-param -disallow-do -vet-semicolon"
-name := "odin-mustache"
-
-build:
-	@mkdir -p bin
-	odin build . -out:bin/{{name}} -debug {{flags}}
-
-test: build
-	odin test . -out:bin/{{name}}
-
-run: build
-	bin/{{name}} test/template.txt test/data.json test/layout.txt
-
-check:
-	odin check . {{flags}}
diff --git a/mustache/LICENSE b/mustache/LICENSE
deleted file mode 100644
index 367a29a..0000000
--- a/mustache/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2025 Benjamin Block
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/mustache/PARTIAL_INDENT.md b/mustache/PARTIAL_INDENT.md
new file mode 100644
index 0000000..a6db0dc
--- /dev/null
+++ b/mustache/PARTIAL_INDENT.md
@@ -0,0 +1,137 @@
+# Partial Indentation — Problem & Solutions
+
+## Problem
+
+When a partial tag `{{> name}}` is standalone (only non-whitespace on its line), the mustache spec requires that its leading whitespace be treated as indentation and **prepended to each line of the partial source before rendering**.
+
+This is a source-level transformation, not output post-processing. The distinction matters when interpolated content contains newlines:
+
+```
+partial source:  "|\n{{{content}}}\n|\n"
+content value:   "<\n->"
+indent:          " "
+
+Expected output: " |\n <\n->\n |\n"
+```
+
+The line `->` gets NO indent — it comes from expanded content (`<\n->`), not from a partial source line. Post-processing the output would incorrectly indent it.
+
+### Spec tests that require this
+
+- **Standalone Without Previous Line** — indent at start of template
+- **Standalone Without Newline** — indent at end of template
+- **Standalone Indentation** — indent with multi-line interpolated content
+
+3 of 14 tests in `partials.json`. The other 11 (basic lookup, context, recursion, nesting, inline usage, failed lookup, padding) work without indentation handling.
+
+### thor's real usage
+
+Thor's partials (`{{> nav}}`, `{{> footer}}`, `{{>* icon}}`) are typically standalone with indentation. Without indentation handling, HTML output has wrong indentation — ugly but functional since HTML ignores whitespace.
+
+## Solution 1: Store source, re-parse with indent (Recommended)
+
+Add `source: string` to `Template`. When rendering a standalone partial with non-empty indent:
+
+1. Prepend indent to each line of `partial.source`
+2. Re-tokenize + re-parse with `context.temp_allocator`
+3. Render the re-parsed nodes
+
+When indent is empty, render the pre-parsed nodes directly (no re-parse).
+
+### Pros
+- Correct by construction — exactly matches spec ("prepended to each line before rendering")
+- ~20 lines of code
+- Nested partials accumulate indentation naturally
+- No line-start state tracking
+
+### Cons
+- Template gains a `source: string` field
+- Standalone partials with indent get re-parsed at render time (negligible for small fragments)
+
+### Implementation sketch
+
+```odin
+// tokenizer: capture indent during trim_standalone_whitespace
+// for Partial tokens, before stripping left whitespace:
+tokens[i].indent = text[nl+1:]  // capture indentation
+
+// mustache.odin: Template gains source field
+Template :: struct {
+    nodes: [dynamic]Node,
+    source: string,
+}
+
+// parse: store source
+tmpl.source = source
+
+// renderer: re-parse if indent
+case .Partial:
+    pt, found := partials[name]
+    if !found do break
+    if len(node.indent) > 0 {
+        indented := indent_lines(pt.source, node.indent)
+        reparse, err := parse(indented, context.temp_allocator, context.temp_allocator)
+        if err == nil {
+            defer delete(reparse.nodes)
+            render_nodes(reparse.nodes[:], reparse.nodes[:], ctx, partials, b)
+        }
+    } else {
+        render_nodes(pt.nodes[:], pt.nodes[:], ctx, partials, b)
+    }
+```
+
+## Solution 2: Modify text nodes during rendering
+
+Track "at line start" state while rendering the partial's nodes. Insert indent before text-node content that begins a new line. Variables/sections render normally — their output is NOT indented.
+
+### Pros
+- No source storage
+- No re-parsing
+
+### Cons
+- Complex: must track line-start state across nodes
+- Variables producing multi-line output need careful handling (their newlines don't create indented lines)
+- Trailing newline edge case (partial ending with `\n` shouldn't leave trailing indent)
+- Nested partials with accumulated indentation need extra logic
+- ~60+ lines of fiddly code
+
+### Implementation sketch
+
+```odin
+render_partial :: proc(nodes, ctx, partials, b, indent) {
+    at_line_start := true
+    for node in nodes {
+        switch node.kind {
+        case .Text:
+            // Walk text, prepend indent at line starts
+            // Insert indent after each \n
+            // Don't indent after final \n of last text node
+            ...
+            at_line_start = (text ends with \n)
+        case .Variable, .Unescaped:
+            // Render normally — no indent applied to output
+            write_value(b, val, ...)
+            at_line_start = false  // can't know if output ends with \n
+        case .Section, .Inverted:
+            // Complex: nested text nodes need indent too?
+            ...
+        }
+    }
+}
+```
+
+The "can't know if variable output ends with \n" problem makes `at_line_start` unreliable, requiring heuristics or output buffering.
+
+## Adjacent Tag Standalone Detection
+
+**Problem:** When a block-type tag and its close tag are adjacent (no text between them), like `{{<include}}{{/include}}\n`, neither tag is individually detected as standalone. The current check looks at the immediately adjacent token — if it's another tag (not text), the check fails. So the trailing `\n` isn't consumed.
+
+**Affected spec tests:**
+- `~inheritance.json`: "Inherit", "Override parent with newlines"
+- Potentially any `{{<name}}{{/name}}` or `{{#name}}{{/name}}` on its own line
+
+**Solution:** When scanning left/right for the line boundary, skip over adjacent standalone-eligible tags (they're transparent). Two helper procs replace the current inline checks:
+- `check_left(tokens, i)` — scans backwards through adjacent eligible tags until finding text or start of template
+- `check_right(tokens, i)` — scans forwards through adjacent eligible tags until finding text or end of template
+
+Both return `(ok: bool, text_idx: int)` where `text_idx` is the text token to trim (or -1 if none).
diff --git a/mustache/README.md b/mustache/README.md
deleted file mode 100644
index 335c3ea..0000000
--- a/mustache/README.md
+++ /dev/null
@@ -1,162 +0,0 @@
-# odin-mustache
-Native implementation of {{mustache}} templates in [Odin](https://odin-lang.org).
-
-https://github.com/benjamindblock/odin-mustache/assets/1155805/7d794861-e308-4132-aaa0-f800392208a4
-
-All features are implemented, except for the ability to change delimiters.
-
-All in tests in the [official mustache spec](https://github.com/mustache/spec) pass successfully (except for the delimiters spec suite).
-
-## Documentation
-
-For more information about mustache, see the [mustache project page](https://mustache.github.io) or the mustache [man](https://mustache.github.io/mustache.5.html) [pages](https://mustache.github.io/mustache.1.html).
-
-View some [example mustache files](https://github.com/mustache/mustache/tree/master/examples) to get an overview.
-
-## Spec
-
-The [mustache-spec](https://github.com/mustache/spec) repo is added as a git submodule for testing purposes. To run tests, ensure that you run `git clone --recursive` and/or `git submodule update` as needed.
-
-## Usage
-
-### CLI Usage
-```
-Usage:
-  odin-mustache [path to template] [path to JSON] [OPTIONAL - layout]
-
-Examples:
-  $ odin-mustache template.txt data.json
-```
-
-### Odin Usage
-#### 1. `render(template: string, data: any, partials: any, allocator := context.allocator)`
-
-Renders a template, provided as a `string`. `data` and `partials` should be *either* a `map[string]...` or a `struct`.
-
-All `map` arguments passed **must** be keyed with `string` type data. When parsing a Mustache template, the text inside a tag (eg. `name` inside `{{name}}`) will be parsed as a `string`.
-
-#### 2. `render_from_filename(filename: string, data: any, partials: any, allocator := context.allocator)`
-
-Renders a template stored in a text file using `data` and `partials` provided.
-
-#### 3. `render_with_json(template: string, json_filename: string, allocator := context.allocator)`
-
-Renders a template `string` using data and partials stored inside a JSON file. `odin-mustache` will handle loading the JSON into a usable format for Mustache to work with.
-
-**NOTE**: The JSON file leverages the following top-level keys:
-```
-"data":      [required]
-"partials":  [optional]
-```
-
-#### 4. `render_from_filename_with_json(filename: string, json_filename: string, allocator := context.allocator)`
-
-Renders a template stored in a text file using data and partials stored inside a JSON file. `odin-mustache` will handle loading the JSON into a usable format for Mustache to work with.
-
-#### Example
-```odin
-input := "Hello, {{name}}!"
-data: map[string]string = {
-    "name" = "St. Charles",
-}
-output, err := render(input, data, context.temp_allocator)
-// => "Hello, St. Charles!"
-```
-
-## Escaping
-`odin-mustache` follows the official mustache HTML escaping rules. That is, if you enclose a variable with two curly brackets, `{{var}}`, the contents are HTML-escaped. For instance, strings like `5 > 2` are converted to `5 &gt; 2`. To use raw characters, use three curly brackets `{{{var}}}`.
-
-## Layouts
-`odin-mustache` supports rendering templates with layouts.
-
-A layout is a regular template with a special function. It accepts **a `{{content}}` tag**. This is where the output of a child template will be inserted. Layouts have access to the same data provided to the regular template.
-
-Layouts can render content in both `{{normal}}` and `{{{literal}}}` tags.
-
-This is helpful for rendering scenarios like websites where the same elements (`<head>`, `<footer>`, etc.) are shared across all pages, each of which has their own page-specific template.
-
-```
-<html>
-  {{{head}}
-  <body>
-    {{{content}}}
-  </body>
-  {{{footer}}
-</html>
-```
-
-### CLI Usage
-```
-Usage:
-  odin-mustache [path to template] [path to JSON] [OPTIONAL - layout]
-
-Examples:
-  $ odin-mustache template.html data.json layout.html
-```
-
-### Odin Usage
-To render a layout in Odin, all four of the above render procedures have `in_layout` and `in_layout_file` variations. These methods will insert the rendered content of a template within the given layout. This is convenient for rendering HTML views inside a larger layout, amongst other use-cases.
-
-The full list of corresponding methods is:
-- `render_in_layout(template: string, data: any, layout: string, partials: any, allocator := context.allocator)`
-- `render_in_layout_file(template: string, data: any, layout_filename: string, partials: any, allocator := context.allocator)`
-- `render_from_filename_in_layout(filename: string, data: any, layout: string, partials: any, allocator := context.allocator)`
-- `render_from_filename_in_layout_file(filename: string, data: any, layout_filename: string, partials: any, allocator := context.allocator)`
-- `render_with_json_in_layout(template: string, json_filename: string, layout: string, allocator := context.allocator)`
-- `render_with_json_in_layout_file(template: string, json_filename: string, layout_filename: string, allocator := context.allocator)`
-- `render_from_filename_with_json_in_layout(filename: string, json_filename: string, layout: string, allocator := context.allocator)`
-- `render_from_filename_with_json_in_layout_file(filename: string, json_filename: string, layout_filename: string, allocator := context.allocator)`
-
-#### Example
-```odin
-template := "Hello, {{name}}."
-data := map[string]string{"name" = "Kilgarvan"}
-layout := `Above >>
-{{content}}
-<< Below`
-
-output, _ := render_in_layout(template, data, layout, allocator := context.temp_allocator)
-fmt.println(output)
-
-// Above >>
-// Hello, Kilgarvan.
-// << Below
-```
-
-## Precompiled Templates
-`odin-mustache` works in two steps:
-1. Lexing and parsing
-2. Rendering with data
-
-If you are rendering the same template multiple times (ex: sending out personalized emails to subscribers), the lexing+parsing step can be performed once to create a compiled template. This compiled template can then be used multiple times with different data.
-
-### Example
-```odin
-src := "Hello, {{name}}!"
-template: Template
-output: string
-data: map[string]string
-partials: map[string]string
-
-lexer := Lexer{src=src, delim=CORE_DEF}
-lexer_parse(&lexer)
-
-data = {"name" = "St. Charles"}
-template = Template{lexer=lexer, data=data, partials=partials}
-output, _ = template_render(&template)
-// => Hello, St. Charles!
-
-data = {"name" = "Edouard"}
-template = Template{lexer=lexer, data=data, partials=partials}
-output, _ = template_render(&template)
-// => Hello, Edouard!
-```
-
-## Future Work
-- Validate JSON keys
-- Better CLI argument parsing
-- Improve error handling and reporting
-- Add optional logging for debugging and performance work
-- Configurable precision for floating point types
-- Add support for changing delimiters
-- Special loop conditionals (eg., checking for the first iteration or last iteration)
diff --git a/mustache/TODOS.md b/mustache/TODOS.md
new file mode 100644
index 0000000..74d61a3
--- /dev/null
+++ b/mustache/TODOS.md
@@ -0,0 +1,2 @@
+- [ ] Initialize string builder size based on filesize?
+- [ ] Review [whitespace handling code](./tokenizer.odin)
diff --git a/mustache/data.odin b/mustache/data.odin
new file mode 100644
index 0000000..6314480
--- /dev/null
+++ b/mustache/data.odin
@@ -0,0 +1,221 @@
+package mustache
+
+import "base:runtime"
+import "core:fmt"
+import "core:reflect"
+import "core:strconv"
+import "core:strings"
+
+// effective unwraps union variants and strips Named/Distinct layers,
+// returning the "peeled" any value and its base type info.
+effective :: proc(a: any) -> (val: any, info: ^runtime.Type_Info) {
+	val = a
+	info = nil
+	if val == nil do return
+
+	ti := type_info_of(val.id)
+	if ti == nil do return
+
+	base := runtime.type_info_base(ti)
+
+	if _, ok := base.variant.(runtime.Type_Info_Union); ok {
+		variant := reflect.get_union_variant(val)
+		if variant == nil do return {}, nil
+		return effective(variant)
+	}
+
+	info = base
+	return
+}
+
+// lookup_in resolves a single key in a container (struct or map).
+// Returns found=false if the key doesn't exist or the container is not a struct/map.
+lookup_in :: proc(container: any, key: string) -> (result: any, found: bool) {
+	if container == nil do return nil, false
+
+	val, info := effective(container)
+	if info == nil do return nil, false
+
+	#partial switch v in info.variant {
+	case runtime.Type_Info_Struct:
+		result = reflect.struct_field_value_by_name(val, key, allow_using = true)
+		found = result != nil
+		return
+
+	case runtime.Type_Info_Map:
+		mi := v
+		rm_ptr := (^runtime.Raw_Map)(val.data)
+		if rm_ptr.len == 0 do return nil, false
+
+		k := key
+		seed := runtime.map_seed(rm_ptr^)
+		h := mi.map_info.key_hasher(&k, seed)
+		value_ptr := runtime.__dynamic_map_get(rm_ptr, mi.map_info, h, &k)
+		if value_ptr == nil do return nil, false
+
+		result = any{value_ptr, mi.value.id}
+		found = true
+		return
+
+	case:
+		return nil, false
+	}
+	return
+}
+
+// resolve_name resolves a (possibly dotted) name from the context stack.
+// The first segment walks the stack top-to-bottom; remaining segments
+// resolve against the prior result only.
+resolve_name :: proc(name: string, ctx: []any) -> any {
+	if name == "." {
+		if len(ctx) > 0 do return ctx[len(ctx) - 1]
+		return nil
+	}
+
+	parts: [16]string
+	part_count := 0
+	start := 0
+	for i in 0 ..< len(name) {
+		if name[i] == '.' {
+			if part_count < len(parts) {
+				parts[part_count] = name[start:i]
+				part_count += 1
+			}
+			start = i + 1
+		}
+	}
+	if part_count < len(parts) {
+		parts[part_count] = name[start:]
+		part_count += 1
+	}
+
+	if part_count == 0 do return nil
+	dot_parts := parts[:part_count]
+
+	result: any = nil
+	found := false
+	for i := len(ctx) - 1; i >= 0; i -= 1 {
+		result, found = lookup_in(ctx[i], dot_parts[0])
+		if found do break
+	}
+
+	if !found do return nil
+	if len(dot_parts) == 1 do return result
+
+	for i := 1; i < len(dot_parts); i += 1 {
+		result, found = lookup_in(result, dot_parts[i])
+		if !found do return nil
+	}
+
+	return result
+}
+
+// is_truthy checks mustache truthiness.
+is_truthy :: proc(a: any) -> bool {
+	if a == nil do return false
+
+	val, info := effective(a)
+	if info == nil do return false
+	if reflect.is_nil(val) do return false
+
+	#partial switch _ in info.variant {
+	case runtime.Type_Info_Slice, runtime.Type_Info_Dynamic_Array, runtime.Type_Info_Map:
+		return reflect.length(val) > 0
+	case:
+		return true
+	}
+}
+
+// list_info returns element type info, count, and data pointer for a list value.
+// Returns elem_info=nil if the value is not a list.
+list_info :: proc(a: any) -> (elem_info: ^runtime.Type_Info, count: int, data: rawptr) {
+	val, info := effective(a)
+	if info == nil do return nil, 0, nil
+
+	#partial switch v in info.variant {
+	case runtime.Type_Info_Slice:
+		raw := (^runtime.Raw_Slice)(val.data)^
+		return v.elem, raw.len, raw.data
+	case runtime.Type_Info_Dynamic_Array:
+		raw := (^runtime.Raw_Dynamic_Array)(val.data)^
+		return v.elem, raw.len, raw.data
+	case runtime.Type_Info_Array:
+		return v.elem, v.count, val.data
+	case:
+		return nil, 0, nil
+	}
+}
+
+// any_to_string converts a scalar value to a string using the temp allocator.
+any_to_string :: proc(a: any) -> string {
+	if a == nil do return ""
+	val, _ := effective(a)
+
+	switch v in val {
+	case string:
+		return v
+	case bool:
+		return "true" if v else "false"
+	case i64:
+		return fmt.tprintf("%d", v)
+	case f64:
+		// return fmt.tprintf("%.3f", v)
+		return format_f64(v)
+	case int:
+		return fmt.tprintf("%d", v)
+	case:
+		return ""
+	}
+}
+
+// format_f64 produces the shortest string that round-trips to the same f64.
+// Works around Odin's strconv not implementing shortest representation.
+format_f64 :: proc(v: f64) -> string {
+	buf: [64]byte
+	for prec in 1 ..= 17 {
+		s := strconv.write_float(buf[:], v, 'g', prec, 64)
+		if len(s) > 0 && s[0] == '+' do s = s[1:]
+		parsed, ok := strconv.parse_f64(s)
+		if ok && parsed == v {
+			return strings.clone(s, context.temp_allocator)
+		}
+	}
+	s := strconv.write_float(buf[:], v, 'g', -1, 64)
+	if len(s) > 0 && s[0] == '+' do s = s[1:]
+	return strings.clone(s, context.temp_allocator)
+}
+
+// write_value stringifies a value and writes it to the builder,
+// optionally HTML-escaped.
+write_value :: proc(b: ^strings.Builder, a: any, escape: bool) {
+	s := any_to_string(a)
+	if len(s) == 0 do return
+
+	if !escape {
+		strings.write_string(b, s)
+		return
+	}
+
+	start := 0
+	for i in 0 ..< len(s) {
+		switch s[i] {
+		case '&', '<', '>', '"':
+			if i > start do strings.write_string(b, s[start:i])
+			switch s[i] {
+			case '&':
+				strings.write_string(b, "&amp;")
+			case '<':
+				strings.write_string(b, "&lt;")
+			case '>':
+				strings.write_string(b, "&gt;")
+			case '"':
+				strings.write_string(b, "&quot;")
+			}
+			start = i + 1
+		}
+	}
+	if start < len(s) {
+		strings.write_string(b, s[start:])
+	}
+}
+
diff --git a/mustache/examples/hello/hello.mustache b/mustache/examples/hello/hello.mustache
deleted file mode 100644
index aef51b5..0000000
--- a/mustache/examples/hello/hello.mustache
+++ /dev/null
@@ -1,11 +0,0 @@
-Hello, {{name}}!
-
-Languages you know:
-{{#languages}}
-  - {{.}}
-{{/languages}}
-
-{{#show_footer}}
----
-Rendered with odin-mustache.
-{{/show_footer}}
diff --git a/mustache/examples/hello/hello.odin b/mustache/examples/hello/hello.odin
deleted file mode 100644
index 48dad74..0000000
--- a/mustache/examples/hello/hello.odin
+++ /dev/null
@@ -1,28 +0,0 @@
-package main
-
-import "core:fmt"
-import "core:os"
-
-import mustache "../.."
-
-Person :: struct {
-	name:        string,
-	languages:   []string,
-	show_footer: bool,
-}
-
-main :: proc() {
-	data := Person{
-		name      = "World",
-		languages = {"Odin", "C", "Rust"},
-		show_footer = true,
-	}
-
-	result, err := mustache.render_from_filename("hello.mustache", data)
-	if err != nil {
-		fmt.eprintfln("render error: %v", err)
-		os.exit(1)
-	}
-
-	fmt.print(result)
-}
diff --git a/mustache/mustache.odin b/mustache/mustache.odin
index f4e85d8..a065847 100644
--- a/mustache/mustache.odin
+++ b/mustache/mustache.odin
@@ -1,1904 +1,371 @@
 package mustache
 
-import "base:runtime"
-
-import "core:encoding/json"
 import "core:fmt"
-import "core:mem"
-import "core:os"
-import "core:reflect"
-import "core:slice"
 import "core:strings"
 
-TRUE :: "true"
-FALSEY :: "false"
+// ---------------------------------------------------------------------------
+// Error types
+// ---------------------------------------------------------------------------
 
-// Special characters that will receive HTML-escaping
-// treatment, if necessary.
-HTML_LESS_THAN :: "&lt;"
-HTML_GREATER_THAN :: "&gt;"
-HTML_QUOTE :: "&quot;"
-HTML_AMPERSAND :: "&amp;"
+Syntax_Error :: struct {
+	msg: string,
+	pos: int,
+}
+Data_Error :: struct {
+	msg: string,
+}
+Partial_Error :: struct {
+	name: string,
+	msg:  string,
+}
 
 Render_Error :: union {
-	Lexer_Error,
-	Template_Error,
-	File_Not_Found_Error,
-	json.Error,
+	Syntax_Error,
+	Data_Error,
+	Partial_Error,
 }
 
-File_Not_Found_Error :: struct {
-	filename: string,
-}
+// ---------------------------------------------------------------------------
+// Node tree
+// ---------------------------------------------------------------------------
 
-Lexer_Error :: union {
-	Unbalanced_Tags,
-}
-
-Unbalanced_Tags :: struct {}
-
-Token_Delimiters :: struct {
-	otag: string,
-	ctag: string,
-	otag_lit: string,
-	ctag_lit: string,
-	otag_section_open: string,
-	otag_section_close: string,
-	otag_literal: string,
-	otag_comment: string,
-	otag_inverted: string,
-	otag_partial: string,
-	otag_parent: string,
-	otag_block: string,
-	otag_delim: string,
-	ctag_delim: string,
-}
-
-CORE_DEF :: Token_Delimiters {
-	otag = "{{",
-	ctag = "}}",
-	otag_lit = "{{{",
-	ctag_lit = "}}}",
-	otag_section_open = "{{#",
-	otag_section_close = "{{/",
-	otag_literal = "{{&",
-	otag_comment = "{{!",
-	otag_inverted = "{{^",
-	otag_partial = "{{>",
-	otag_parent = "{{<",
-	otag_block = "{{$",
-	otag_delim = "{{=",
-	ctag_delim = "=}}",
-}
-
-Token :: struct {
-	type: Token_Type,
-	value: string,
-	pos: Pos,
-	iters: int,
-	start_i: int,
-}
-
-Token_Type :: enum {
+Node_Kind :: enum {
 	Text,
-	Tag,
-	Section_Open_Inverted,
-	Tag_Literal,
-	Tag_Literal_Triple,
-	Section_Open,
-	Section_Close,
-	Comment,
+	Variable,
+	Unescaped,
+	Section,
+	Inverted,
 	Partial,
 	Parent,
-	Block_Open,
-	Newline,
-	Skip,
-	EOF, // The last token parsed, caller should not call again.
+	Block,
 }
 
-Pos :: struct {
-	start: int,
-	end: int,
-	line: int,
-}
-
-Lexer :: struct {
-	src: string,
-	cursor: int,
-	line: int,
-	tokens: [dynamic]Token,
-	cur_token_type: Token_Type,
-	cur_token_start_pos: int,
-	tag_stack: [dynamic]rune,
-	delim: Token_Delimiters,
-}
-
-Data_Error :: enum {
-	None,
-	Unsupported_Type,
-	Map_Key_Not_Found,
-}
-
-Template_Error :: union {
-	Data_Error,
+Node :: struct {
+	kind:        Node_Kind,
+	text:        string,
+	key:         string,
+	is_dynamic:  bool,
+	indent:      string,
+	first_child: int,
+	child_count: int,
 }
 
 Template :: struct {
-	lexer: ^Lexer,
-	data: any,
-	partials: any,
-	context_stack: [dynamic]Context_Stack_Entry,
-	layout: string,
-	block_overrides: map[string][]Token,
+	nodes: [dynamic]Node,
 }
 
-Context_Stack_Entry :: struct {
-	data: any,
-	label: string,
+Block_Override :: struct {
+	all_nodes: []Node,
+	first:     int,
+	count:     int,
 }
 
-Data_Type :: enum {
-	Map,
-	Struct,
-	List,
-	Value,
-	Null,
-}
-
-// Returns true if the value is one of the "falsey" values
-// for a context.
-@(private)
-_falsey_context: map[string]bool
-
-// Returns true if the value is one of the "falsey" values
-// for a context.
-@(private)
-_whitespace: map[rune]bool
-
-
-/*
-	UTILITY PROCEDURES
-*/
-
-trim_decimal_string :: proc(s: string, allocator := context.allocator) -> string {
-	if len(s) == 0 || s[len(s)-1] != '0' {
-		return strings.clone(s[:], allocator)
-	}
-
-	// We have at least one trailing zero. Search backwards and find the rest.
-	trailing_start_idx := len(s)-1
-	for i := len(s) - 2; i >= 0 ; i -= 1 {
-		switch s[i] {
-		case '0':
-			if trailing_start_idx == i + 1 {
-				trailing_start_idx = i
-			}
-		case '.':
-			if trailing_start_idx == i + 1 {
-				// Removes point completely for numbers like 0.000
-				trailing_start_idx = i
-			}
-			return strings.clone(s[:trailing_start_idx], allocator)
-		}
-	}
-
-	return strings.clone(s[:], allocator)
-}
-
-escape_html_string :: proc(s: string, allocator := context.allocator) -> string {
-	escaped := s
-	// Ampersand escaping goes first.
-	escaped, _ = strings.replace_all(escaped, "&", HTML_AMPERSAND, allocator = allocator)
-	escaped, _ = strings.replace_all(escaped, "<", HTML_LESS_THAN, allocator = allocator)
-	escaped, _ = strings.replace_all(escaped, ">", HTML_GREATER_THAN, allocator = allocator)
-	escaped, _ = strings.replace_all(escaped, "\"", HTML_QUOTE, allocator = allocator)
-	return escaped
-}
-
-// Gets the value of a struct field.
-struct_get :: proc(obj: any, key: string) -> any {
-	if !is_struct(obj) {
-		return nil
-	}
-
-	obj := obj
-	if is_union(obj) {
-		obj = reflect.get_union_variant(obj)
-	}
-
-	val := reflect.struct_field_value_by_name(obj, key)
-	if !reflect.is_nil(val) {
-		return val
-	}
-
-	// Fallback: check using/embedded struct fields
-	for f in reflect.struct_field_names(obj.id) {
-		field_val := reflect.struct_field_value_by_name(obj, f)
-		if is_struct(field_val) {
-			nested := struct_get(field_val, key)
-			if !reflect.is_nil(nested) {
-				return nested
-			}
-		}
-	}
-
-	return val
-}
-
-// Retrieves a value from a map. In mustache.odin, all map keys must be
-// string values because we do not know the type of value inside a tag.
-//
-// Eg., {{name}} -- we assume "name" is either a string key to a map,
-// or the name of a field on a struct.
-map_get :: proc(v: any, map_key: string) -> (dug: any, err: Template_Error) {
-	if !is_map(v) {
-		return nil, .Unsupported_Type
-	}
-
-	m := (^mem.Raw_Map)(v.data)
-	if m == nil {
-		return nil, .Unsupported_Type
-	}
-
-	v := v
-	if is_union(v) {
-		v = reflect.get_union_variant(v)
-	}
-
-	// Use type_info_base to ensure we get the underlying data structure
-	// of a named type if we run into one. Like Map, List, etc.
-	base_tinfo := runtime.type_info_base(type_info_of(v.id))
-	tinfo := base_tinfo.variant.(runtime.Type_Info_Map)
-	map_info := tinfo.map_info
-
-	if map_info == nil {
-		return nil, .Unsupported_Type
-	}
-
-	map_cap := uintptr(runtime.map_cap(m^))
-	ks, vs, hs, _, _ := runtime.map_kvh_data_dynamic(m^, map_info)
-
-	for bucket_index in 0..<map_cap {
-		runtime.map_hash_is_valid(hs[bucket_index]) or_continue
-
-		// Accessing the map key.
-		key_ptr := rawptr(runtime.map_cell_index_dynamic(ks, map_info.ks, bucket_index))
-		key_any := any{key_ptr, tinfo.key.id}
-		key_info := runtime.type_info_base(type_info_of(key_any.id))
-		key_info_any := any{key_any.data, key_info.id}
-		key: string
-
-		// Keys can only be of a string type.
-		#partial switch tinfo in key_info.variant {
-		case runtime.Type_Info_String:
-			switch s in key_info_any {
-			case string:
-				key = s
-			case cstring:
-				key = string(s)
-			}
-		case:
-			return nil, .Unsupported_Type
-		}
-
-		// Access the value.
-		value_ptr := rawptr(runtime.map_cell_index_dynamic(vs, map_info.vs, bucket_index))
-		value_any := any{value_ptr, tinfo.value.id}
-		value_info := runtime.type_info_base(type_info_of(value_any.id))
-		value_info_any := any{value_any.data, value_info.id}
-		value := value_info_any
-
-		if map_key == key {
-			// Unwrap 'any' values stored in map[string]any to avoid double-wrapping
-			if tinfo.value.id == typeid_of(any) {
-				inner := (^any)(value_ptr)
-				return inner^, nil
-			}
-			return value, nil
-		}
-	}
-
-	return nil, .Map_Key_Not_Found
-}
-
-// Checks if an 'any' object is a struct of some kind.
-is_struct :: proc(obj: any) -> bool {
-	tid: typeid
-	tinfo: ^runtime.Type_Info
-
-	if is_union(obj) {
-		tid = reflect.union_variant_typeid(obj)
-	} else {
-		tid = obj.id
-	}
-
-	tinfo = type_info_of(tid)
-	return reflect.is_struct(tinfo)
-}
-
-// Checks if an 'any' object is a union of some kind.
-is_union :: proc(obj: any) -> bool {
-	tinfo: ^runtime.Type_Info
-	base_tinfo: ^runtime.Type_Info
-
-	tinfo = type_info_of(obj.id)
-	base_tinfo = runtime.type_info_base(tinfo)
-	return reflect.type_kind(base_tinfo.id) == reflect.Type_Kind.Union
-}
-
-// Checks if an 'any' object is a map of some kind.
-is_map :: proc(obj: any) -> bool {
-	tinfo: ^runtime.Type_Info
-	id: typeid
-
-	if is_union(obj) {
-		id = reflect.union_variant_typeid(obj)
-	} else {
-		id = obj.id
-	}
-
-	tinfo = type_info_of(id)
-	return reflect.is_dynamic_map(tinfo)
-}
-
-// Checks if an 'any' object is a list of some kind.
-is_list :: proc(obj: any) -> bool {
-	tinfo: ^runtime.Type_Info
-	id: typeid
-
-	if is_union(obj) {
-		id = reflect.union_variant_typeid(obj)
-	} else {
-		id = obj.id
-	}
-
-	tinfo = type_info_of(id)
-	return reflect.is_array(tinfo) || reflect.is_dynamic_array(tinfo) || reflect.is_slice(tinfo)
-}
-
-// Checks if a string is plain whitespace.
-is_text_blank :: proc(s: string) -> (res: bool) {
-	for r in s {
-		if !_whitespace[r] {
-			return false
-		}
-	}
-
-	return true
-}
-
-// Retrieves an element from a list (can be of any type -- array,
-// dynamic array, slice) at a given index.
-list_at :: proc(obj: any, i: int) -> any {
-	obj := obj
-
-	if is_union(obj) {
-		obj = reflect.get_union_variant(obj)
-	}
-
-	if !is_list(obj) {
-		return nil
-	}
-
-	return reflect.index(obj, i)
-}
-
-// Checks if a map has a given key.
-map_has_key :: proc(v: any, map_key: string) -> (has: bool) {
-	if !is_map(v) {
-		return false
-	}
-
-	m := (^mem.Raw_Map)(v.data)
-	if m == nil {
-		return false
-	}
-
-	v := v
-	if is_union(v) {
-		v = reflect.get_union_variant(v)
-	}
-
-	// Use type_info_base to ensure we get the underlying data structure
-	// of a named type if we run into one. Like Map, List, etc.
-	base_tinfo := runtime.type_info_base(type_info_of(v.id))
-	tinfo := base_tinfo.variant.(runtime.Type_Info_Map)
-	map_info := tinfo.map_info
-
-	if map_info == nil {
-		return false
-	}
-
-	map_cap := uintptr(runtime.map_cap(m^))
-	ks, _, hs, _, _ := runtime.map_kvh_data_dynamic(m^, map_info)
-
-	for bucket_index in 0..<map_cap {
-		runtime.map_hash_is_valid(hs[bucket_index]) or_continue
-
-		// Accessing string type in key
-		key_ptr := rawptr(runtime.map_cell_index_dynamic(ks, map_info.ks, bucket_index))
-		key_any := any{key_ptr, tinfo.key.id}
-		key_info := runtime.type_info_base(type_info_of(key_any.id))
-		key_info_any := any{key_any.data, key_info.id}
-		key: string
-
-		// Validate that the map keys must be of a string or cstring type.
-		#partial switch tinfo in key_info.variant {
-		case runtime.Type_Info_String:
-			switch s in key_info_any {
-			case string:
-				key = s
-			case cstring:
-				key = string(s)
-			}
-		case:
-			return false
-		}
-
-		if map_key == key {
-			return true
-		}
-	}
-
-	return false
-}
-
-/*
-	LEXER-RELATED PROCEDURES
-*/
-
-lexer_make :: proc(allocator := context.allocator) -> ^Lexer {
-	l := new(Lexer, allocator)
-	l.tokens = make([dynamic]Token, 0, allocator)
-	l.tag_stack = make([dynamic]rune, 0, allocator)
-	return l
-}
-
-lexer_peek :: proc(l: ^Lexer, s: string, offset := 0) -> (bool) {
-	peek_i: int
-	peeked: rune
-
-	if l.cursor + offset + len(s) >= len(l.src) {
-		return false
-	}
-
-	for i := 0; i < len(s); i += 1 {
-		peek_i = l.cursor + offset + i
-		peeked = rune(l.src[peek_i])
-		if peeked != rune(s[i]) {
-			return false
-		}
-	}
-
-	return true
-}
-
-// Used AFTER a new Token is inserted into the tokens dynamic
-// array. In the case of a .Tag_Literal ('{{{...}}}'), we need
-// to advance the next start position by three instead of two,
-// to account for the additional brace.
-lexer_start :: proc(l: ^Lexer, new_type: Token_Type) {
-	cur_type := l.cur_token_type
-
-	switch {
-	// Moving from text into a tag.
-	case cur_type == .Text:
-		switch new_type {
-		case .Section_Open:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_section_open)
-		case .Section_Close:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_section_close)
-		case .Section_Open_Inverted:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_inverted)
-		case .Partial:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_partial)
-		case .Parent:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_parent)
-		case .Block_Open:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_block)
-		case .Comment:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_comment)
-		case .Tag_Literal:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_literal)
-		case .Tag_Literal_Triple:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag_lit)
-		case .Tag:
-			l.cur_token_start_pos = l.cursor + len(l.delim.otag)
-		case .Text, .Newline, .EOF, .Skip:
-		}
-	// Moving from a tag back into text.
-	case new_type == .Text:
-		switch cur_type {
-		case .Newline:
-			l.cur_token_start_pos = l.cursor + len("\n")
-		case .Tag, .Section_Open_Inverted, .Tag_Literal, .Section_Close, .Section_Open, .Comment, .Partial, .Parent, .Block_Open:
-			l.cur_token_start_pos = l.cursor + len(l.delim.ctag)
-		case .Tag_Literal_Triple:
-			l.cur_token_start_pos = l.cursor + len(l.delim.ctag_lit)
-		case .Text, .EOF, .Skip:
-		}
-	}
-
-	// Update the current type to the new type.
-	l.cur_token_type = new_type
-}
-
-// Adds a new token to our list.
-lexer_append :: proc(l: ^Lexer, allocator := context.allocator) {
-	switch l.cur_token_type {
-	case .Text:
-		lexer_append_text(l)
-	case .Newline:
-		lexer_append_newline(l)
-	case .Tag, .Tag_Literal, .Tag_Literal_Triple, .Comment, .Partial, .Section_Open, .Section_Open_Inverted, .Section_Close, .Parent, .Block_Open:
-		lexer_append_tag(l, l.cur_token_type, allocator)
-	case .EOF, .Skip:
+template_free :: proc(tmpl: ^Template) {
+	if tmpl != nil && len(tmpl.nodes) > 0 {
+		delete(tmpl.nodes)
 	}
 }
 
-lexer_append_tag :: proc(
-	l: ^Lexer,
-	token_type: Token_Type,
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+parse :: proc(
+	source: string,
 	allocator := context.allocator,
+	tokens_allocator := context.temp_allocator,
+) -> (
+	tmpl: Template,
+	err: Render_Error,
 ) {
-	pos := Pos {
-		start=l.cur_token_start_pos,
-		end=l.cursor,
-		line=l.line,
+	tokens, terr := tokenize(source, tokens_allocator)
+	if terr != nil {
+		return {}, terr
 	}
 
-	if pos.end > pos.start {
-		// Remove all empty whitespace inside a valid tag so that we don't
-		// mess up our access of the data.
-		token_text := l.src[pos.start:pos.end]
-		token_text, _ = strings.remove_all(token_text, " ", allocator = allocator)
-		token := Token{type=token_type, value=token_text, pos=pos}
-		append(&l.tokens, token)
-	}
-}
-
-lexer_append_text :: proc(l: ^Lexer) {
-	pos := Pos {
-		start=l.cur_token_start_pos,
-		end=l.cursor,
-		line=l.line,
-	}
-
-	if pos.end > pos.start {
-		text := l.src[pos.start:pos.end]
-		token := Token{type=.Text, value=text, pos=pos}
-		append(&l.tokens, token)
-	}
-}
-
-lexer_append_newline :: proc(l: ^Lexer) {
-	pos := Pos {
-		start=l.cur_token_start_pos,
-		end=l.cursor + 1,
-		line=l.line,
-	}
-
-	newline := Token{type=.Newline, value="\n", pos=pos}
-	append(&l.tokens, newline)
-}
-
-lexer_parse :: proc(l: ^Lexer, allocator := context.allocator) -> (err: Lexer_Error) {
-	for l.cursor < len(l.src) {
-		ch := rune(l.src[l.cursor])
-		defer { l.cursor += 1 }
-
-		switch {
-		// When we hit a newline (and we are not inside a .Comment, as multi-line
-		// comments are permitted), add the current chunk as a new Token, insert
-		// a special .Newline token, and then begin as a new .Text Token.
-		case ch == '\n' && l.cur_token_type != .Comment:
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Newline)
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Text)
-			l.line += 1
-		case lexer_peek(l, l.delim.otag_lit):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Tag_Literal_Triple)
-		case lexer_peek(l, l.delim.otag_section_open):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Section_Open)
-		case lexer_peek(l, l.delim.otag_section_close):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Section_Close)
-		case lexer_peek(l, l.delim.otag_inverted):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Section_Open_Inverted)
-		case lexer_peek(l, l.delim.otag_partial):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Partial)
-		case lexer_peek(l, l.delim.otag_parent):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Parent)
-		case lexer_peek(l, l.delim.otag_block):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Block_Open)
-		case lexer_peek(l, l.delim.otag_literal):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Tag_Literal)
-		case lexer_peek(l, l.delim.otag_comment):
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Comment)
-		// Be careful with checking for "{{" -- it could be a substring of "{{{"
-		case lexer_peek(l, l.delim.otag) && l.cur_token_type != .Tag_Literal_Triple:
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Tag)
-		case lexer_peek(l, "}") && l.cur_token_type != .Text:
-			lexer_append(l, allocator = allocator)
-			lexer_start(l, .Text)
-		}
-	}
-
-	// Add the last tag and mark that we hit the end of the file.
-	lexer_append(l, allocator = allocator)
-	l.cur_token_type = .EOF
-	return nil
-}
-
-lexer_print_tokens :: proc(l: ^Lexer) {
-	for t, i in l.tokens {
-		fmt.println(i, "    ", t)
-	}
-}
-
-lexer_token_should_skip :: proc(l: ^Lexer, t: Token) -> (skip: bool) {
-	switch t.type {
-	case .Newline:
-		skip = lexer_should_skip_newline_token(l, t)
-	case .Text:
-		skip = lexer_should_skip_text_token(l, t)
-	case .Tag, .Tag_Literal, .Tag_Literal_Triple, .Partial, .Section_Open, .Section_Close, .Section_Open_Inverted, .Parent, .Block_Open:
-		skip = false
-	case .EOF, .Skip, .Comment:
-		skip = true
-	}
-
-	return skip
-}
-
-// Retrieves all the tokens that are on a given line of the input text.
-lexer_tokens_on_same_line :: proc(l: ^Lexer, line: int) -> (tokens: []Token) {
-	on_line := false
-	start_i: int
-	end_i: int
-
-	for t, i in l.tokens {
-		if t.pos.line == line && !on_line {
-			on_line = true
-			start_i = i
-		} else if t.pos.line != line && on_line {
-			on_line = false
-			end_i = i
-			break
-		}
-	}
-
-	if on_line {
-		end_i = len(l.tokens)
-	}
-
-	if start_i <= end_i {
-		return l.tokens[start_i:end_i]
-	} else {
-		return l.tokens[0:0]
-	}
-}
-
-
-// Skip a newline if we are on a line that has either a
-// non-blank .Text token OR any valid tags.
-lexer_should_skip_newline_token :: proc(l: ^Lexer, token: Token) -> bool {
-	on_line := lexer_tokens_on_same_line(l, token.pos.line)
-
-	// If the newline is the only token present, do not skip it.
-	if len(on_line) == 1 {
-		return false
-	}
-
-	for t in on_line {
-		switch t.type {
-		case .Text:
-			if !is_text_blank(t.value) {
-				return false
-			}
-		case .Tag, .Tag_Literal, .Tag_Literal_Triple:
-			return false
-		case .Section_Open, .Section_Close, .Section_Open_Inverted, .Comment,
-				 .Partial, .Parent, .Block_Open, .Newline, .Skip, .EOF:
-		}
-	}
-
-	return true
-}
-
-// If we are rendering a .Text tag, we should NOT render it if it is:
-//  - On a line with one .Section tag, AND
-//  - comprised of only whitespace, along with all the other .Text tokens
-lexer_should_skip_text_token :: proc(l: ^Lexer, token: Token) -> bool {
-	on_line := lexer_tokens_on_same_line(l, token.pos.line)
-
-	standalone_tag_count := 0
-	for t in on_line {
-		switch t.type {
-		case .Text:
-			if !is_text_blank(t.value) {
-				return false
-			}
-		case .Tag, .Tag_Literal, .Tag_Literal_Triple, .Partial:
-			return false
-		case .Section_Open, .Section_Open_Inverted, .Section_Close, .Comment, .Parent, .Block_Open:
-			standalone_tag_count += 1
-		case .Newline, .Skip, .EOF:
-		}
-	}
-
-	// If we have gotten to the end, that means all the .Text
-	// tags on this line are blank. If we also only have a single
-	// section or comment tag, that means that tag is standalone.
-	return standalone_tag_count == 1
-}
-
-// Checks if a given .Partial Token is "standalone."
-lexer_token_is_standalone_partial :: proc(l: ^Lexer, token: Token) -> bool {
-	on_line := lexer_tokens_on_same_line(l, token.pos.line)
-
-	standalone_tag_count := 0
-	for t in on_line {
-		switch t.type {
-		case .Text:
-			if !is_text_blank(t.value) {
-				return false
-			}
-		case .Tag, .Tag_Literal, .Tag_Literal_Triple:
-			return false
-		case .Section_Open, .Section_Open_Inverted, .Section_Close, .Comment, .Partial, .Parent, .Block_Open:
-			standalone_tag_count += 1
-		case .Newline, .Skip, .EOF:
-		}
-	}
-
-	// If we have gotten to the end, that means all the .Text
-	// tags on this line are blank. If we also only have a single
-	// section or comment tag, that means that tag is standalone.
-	return standalone_tag_count == 1
-}
-
-/*
-	TEMPLATE-RELATED PROCEDURES
-*/
-
-template_make :: proc(l: ^Lexer, allocator := context.allocator) -> ^Template {
-	t := new(Template, allocator)
-	t.lexer = l
-	t.context_stack = make([dynamic]Context_Stack_Entry, 0, allocator)
-	return t
-}
-
-// Sections can have false-y values in their corresponding data. When this
-// is the case, the section should not be rendered. Example:
-// input := "\"{{#boolean}}This should not be rendered.{{/boolean}}\""
-// data := Map {
-//   "boolean" = "false"
-// }
-// Valid contexts are:
-//   - Map with at least one key
-//   - List with at least one element
-//   - string NOT in the _falsey_context mapping
-template_token_is_valid :: proc(tmpl: ^Template, token: Token) -> (bool) {
-	stack_entry := tmpl.context_stack[0]
-
-	// The root stack is always valid.
-	if stack_entry.label == "ROOT" {
-		return true
-	}
-
-	switch data_type(stack_entry.data) {
-	case .Map, .List, .Struct:
-		return data_len(stack_entry.data) > 0
-	case .Value:
-		s := fmt.tprintf("%v", stack_entry.data)
-		return !_falsey_context[s]
-	case .Null:
-		return false
-	}
-
-	return false
-}
-
-template_string_from_key :: proc(
-	tmpl: ^Template,
-	key: string,
-	allocator := context.allocator,
-) -> (s: string) {
-	resolved: any
-
-	if key == "." {
-		resolved = tmpl.context_stack[0].data
-	} else {
-		// If the top of the stack is a string and we need to access a hash of data,
-		// dig from the layer beneath the top.
-		ids := strings.split(key, ".", allocator = allocator)
-		for ctx in tmpl.context_stack {
-			resolved = dig(ctx.data, ids[0:1])
-			if resolved != nil {
-				break
-			}
-		}
-
-		// Apply "dotted name resolution" if we have parts after the core ID.
-		if len(ids[1:]) > 0 {
-			last := slice.last(ids[:])
-			last_slice := ids[len(ids)-1:]
-			resolved = dig(resolved, ids[1:])
-			if is_map(resolved) || is_struct(resolved) && has_key(resolved, last) {
-				resolved = dig(resolved, last_slice)
-			}
-		}
-	}
-
-	s, _ = any_to_string(resolved)
-	return s
-}
-
-template_print_stack :: proc(tmpl: ^Template) {
-	fmt.println("Current stack")
-	for c, i in tmpl.context_stack {
-		fmt.printf("\t[%v] %v: %v\n", i, c.label, c.data)
-	}
-}
-
-// Retrieves data to place on the context stack.
-template_get_data_for_stack :: proc(
-	tmpl: ^Template,
-	data_id: string,
-	allocator := context.allocator,
-) -> (data: any) {
-	ids := strings.split(data_id, ".", allocator = allocator)
-	defer delete(ids)
-
-	// New stack entries always need to resolve against the current top
-	// of the stack entry.
-	data = dig(tmpl.context_stack[0].data, ids)
-
-	// If we couldn't resolve against the top of the stack, add from the root.
-	if data == nil {
-		root_stack_entry := tmpl.context_stack[len(tmpl.context_stack)-1]
-		data = dig(root_stack_entry.data, ids)
-	}
-
-	// If we still can't find anything, mark this section as false-y.
-	if reflect.is_nil(data) {
-		return runtime.new_clone(FALSEY, allocator = allocator)^
-	} else {
-		return data
-	}
-}
-
-// Adds a new entry to the Template's context_stack. This occurs
-// when we encounter a .Section_Open tag.
-template_add_to_context_stack :: proc(
-	tmpl: ^Template,
-	t: Token,
-	offset: int,
-	allocator := context.allocator,
-) {
-	data_id := t.value
-	data := template_get_data_for_stack(tmpl, data_id, allocator)
-
-	if t.type == .Section_Open_Inverted {
-		stack_entry := Context_Stack_Entry{
-			data=invert_data(data, allocator),
-			label=data_id,
-		}
-		inject_at(&tmpl.context_stack, 0, stack_entry)
-	} else {
-		switch data_type(data) {
-		case .Map, .Struct, .Value:
-			stack_entry := Context_Stack_Entry{data=data, label=data_id}
-			inject_at(&tmpl.context_stack, 0, stack_entry)
-		case .List:
-			template_inject_list_into_context_stack(tmpl, data, offset)
-		case .Null:
-			stack_entry := Context_Stack_Entry{data=nil, label=data_id}
-			inject_at(&tmpl.context_stack, 0, stack_entry)
-		}
-	}
-}
-
-template_inject_list_into_context_stack :: proc(tmpl: ^Template, list: any, offset: int) {
-	section_open := tmpl.lexer.tokens[offset]
-	section_name := section_open.value
-	start_chunk := offset + 1
-	end_chunk := template_find_section_close_tag_index(tmpl, section_name, offset)
-
-	// Remove the original chunk from the token list if the list is empty.
-	// We treat empty lists as false-y values.
-	if data_len(list) == 0 {
-		for _ in start_chunk..<end_chunk {
-			ordered_remove(&tmpl.lexer.tokens, start_chunk)
-		}
-		return
-	}
-
-	// If we have a list with contents, update the closing tag with:
-	// 1. The number of iterations to perform
-	// 2. The position of the start of the loop (eg., .Section_Open tag)
-	section_close := tmpl.lexer.tokens[end_chunk]
-	section_close.iters = data_len(list) - 1
-	section_close.start_i = offset
-	tmpl.lexer.tokens[end_chunk] = section_close
-
-	// Add each element of the list to the context stack. Add the data in
-	// reverse order of the list, so that the first entry is at the top.
-	for i := section_close.iters; i >= 0; i -= 1 {
-		el := list_at(list, i)
-		stack_entry := Context_Stack_Entry{data=el, label="TEMP LIST"}
-		inject_at(&tmpl.context_stack, 0, stack_entry)
-	}
-}
-
-// Finds the closing tag with a given value after
-// the given offset.
-template_find_section_close_tag_index :: proc(
-	tmpl: ^Template,
-	label: string,
-	offset: int,
-) -> (int) {
-	for t, i in tmpl.lexer.tokens[offset:] {
-		if t.type == .Section_Close && t.value == label {
-			return i + offset
-		}
-	}
-
-	return -1
-}
-
-template_pop_from_context_stack :: proc(tmpl: ^Template) {
-	if len(tmpl.context_stack) > 1 {
-		ordered_remove(&tmpl.context_stack, 0)
-	}
-}
-
-token_content :: proc(tmpl: ^Template, t: Token, allocator := context.allocator) -> (s: string) {
-	switch t.type {
-	case .Text:
-		// NOTE: Carriage returns causing some wonkiness with .concatenate.
-		if t.value != "\r" {
-			s = t.value
-		}
-	case .Tag:
-		s = template_string_from_key(tmpl, t.value, allocator)
-		s = escape_html_string(s, allocator = allocator)
-	case .Tag_Literal, .Tag_Literal_Triple:
-		s = template_string_from_key(tmpl, t.value, allocator)
-	case .Newline:
-		s = "\n"
-	case .Section_Open, .Section_Open_Inverted, .Section_Close,
-		 .Comment, .Skip, .EOF, .Partial, .Parent, .Block_Open:
-	}
-
-	return s
-}
-
-token_is_tag :: proc(t: Token) -> bool {
-	switch t.type {
-	case .Tag, .Tag_Literal, .Tag_Literal_Triple:
-		return true
-	case .Text, .Newline, .Section_Open, .Section_Open_Inverted, .Section_Close,
-		 .Comment, .Skip, .EOF, .Partial, .Parent, .Block_Open:
-		return false
-	}
-
-	return false
-}
-
-template_render_partial :: proc(
-	tmpl: ^Template,
-	token: Token,
-	offset: int,
-	sb: ^strings.Builder,
-	allocator := context.allocator,
-) {
-	partial_name := strings.trim_space(token.value)
-
-	// Dynamic Names: {{>*key}} — resolve key from context to get partial name.
-	if len(partial_name) > 0 && partial_name[0] == '*' {
-		dynamic_key := strings.trim_space(partial_name[1:])
-		resolved := template_get_data_for_stack(tmpl, dynamic_key, allocator)
-		if resolved == nil || reflect.is_nil(resolved) {
-			return
-		}
-		resolved_str, _ := any_to_string(resolved)
-		if resolved_str == "" {
-			return
-		}
-		partial_name = strings.trim_space(resolved_str)
-	}
-
-	// Look up partial content.
-	partial_content := dig(tmpl.partials, []string{partial_name})
-	partial_str, _ := any_to_string(partial_content)
-	if partial_str == "" {
-		return
-	}
-
-	// Handle standalone indentation — indent each line of the partial source
-	// (except the first line, which follows the preceding whitespace, and
-	// trailing empty lines).
-	standalone := lexer_token_is_standalone_partial(tmpl.lexer, token)
-	indent := ""
-	if standalone && offset > 0 {
-		prev_token := tmpl.lexer.tokens[offset - 1]
-		if prev_token.type == .Text && is_text_blank(prev_token.value) {
-			indent = prev_token.value
-		}
-	}
-
-	if indent != "" {
-		lines := strings.split(partial_str, "\n", allocator)
-		defer delete(lines)
-
-		indented := strings.builder_make(allocator)
-		for line, i in lines {
-			if i > 0 {
-				strings.write_string(&indented, "\n")
-				if i < len(lines) - 1 || line != "" {
-					strings.write_string(&indented, indent)
-				}
-			}
-			strings.write_string(&indented, line)
-		}
-		partial_str = strings.to_string(indented)
-	}
-
-	// Lex the partial (after applying indentation).
-	partial_lexer := lexer_make(allocator)
-	partial_lexer.src = partial_str
-	partial_lexer.line = token.pos.line
-	partial_lexer.delim = CORE_DEF
-	err := lexer_parse(partial_lexer, allocator = allocator)
+	tmpl.nodes, err = parse_tokens(tokens[:], allocator)
 	if err != nil {
-		return
+		delete(tmpl.nodes)
 	}
-
-	// Apply skip rules to partial tokens.
-	for &pt in partial_lexer.tokens {
-		if lexer_token_should_skip(partial_lexer, pt) {
-			pt.type = .Skip
-		}
-	}
-
-	// Swap lexer to process partial tokens with shared context stack.
-	saved_lexer := tmpl.lexer
-	tmpl.lexer = partial_lexer
-
-	template_process_tokens(tmpl, sb, allocator)
-
-	// Restore original lexer.
-	tmpl.lexer = saved_lexer
+	return tmpl, err
 }
 
-// Inject a chunk of text into the token list of the larger layout template.
-template_insert_content_into_layout :: proc(
-	tmpl: ^Template,
-	token: Token,
-	offset: int,
-	content: string,
-	allocator := context.allocator,
-) -> (err: Lexer_Error) {
-	lexer := lexer_make(allocator)
-	lexer.src = content
-	lexer.line = token.pos.line
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Performs indentation on the content.
-	if offset > 0 {
-		prev_token := tmpl.lexer.tokens[offset-1]
-		if prev_token.type == .Text && is_text_blank(prev_token.value) {
-			cur_line := lexer.tokens[len(lexer.tokens)-1].pos.line
-			#reverse for t, i in lexer.tokens {
-				// Do not indent the top line.
-				if cur_line == 0 {
-					break
-				}
-
-				// When moving back up a line, insert the indentation.
-				if cur_line != t.pos.line {
-					inject_at(&lexer.tokens, i+1, prev_token)
-				}
-
-				cur_line = t.pos.line
-			}
-		}
-	}
-
-	// Inject tokens from the partial into the primary template.
-	#reverse for t in lexer.tokens {
-		inject_at(&tmpl.lexer.tokens, offset+1, t)
-	}
-
-	return nil
-}
-
-// Find the index of a Section_Close token matching the given name,
-// respecting nesting depth across all open tag types.
-find_matching_close :: proc(tokens: []Token, start: int, name: string) -> int {
-	depth := 1
-	for i in start+1..<len(tokens) {
-		t := tokens[i]
-		if t.value == name && (t.type == .Section_Open || t.type == .Section_Open_Inverted ||
-		    t.type == .Block_Open || t.type == .Parent) {
-			depth += 1
-		}
-		if t.type == .Section_Close && t.value == name {
-			depth -= 1
-			if depth == 0 {
-				return i
-			}
-		}
-	}
-	return start
-}
-
-// Handle {{<parent}} inheritance: collect block overrides, load parent template,
-// resolve blocks, and render the parent's structure.
-template_handle_parent :: proc(
-	tmpl: ^Template,
-	parent_token: Token,
-	start_i: int,
-	sb: ^strings.Builder,
+render :: proc(
+	tmpl: Template,
+	data: any,
+	partials: map[string]Template = nil,
 	allocator := context.allocator,
+) -> (
+	result: string,
+	err: Render_Error,
 ) {
-	parent_name := parent_token.value
-	close_i := find_matching_close(tmpl.lexer.tokens[:], start_i, parent_name)
+	builder: strings.Builder
+	strings.builder_init(&builder, allocator)
+	defer strings.builder_destroy(&builder)
 
-	// Collect block overrides from child template
-	overrides := make(map[string][]Token, allocator)
-	j := start_i + 1
-	for j < close_i {
-		t := tmpl.lexer.tokens[j]
-		if t.type == .Block_Open {
-			block_close := find_matching_close(tmpl.lexer.tokens[:], j, t.value)
-			if block_close > j + 1 {
-				overrides[t.value] = tmpl.lexer.tokens[j+1:block_close]
-			} else {
-				overrides[t.value] = {}
-			}
-			j = block_close + 1
-		} else {
-			j += 1
-		}
+	ctx := make([dynamic]any, 0, 4, allocator)
+	defer delete(ctx)
+	append(&ctx, data)
+
+	all_nodes := tmpl.nodes[:]
+	err = render_nodes(all_nodes, all_nodes, &ctx, partials, &builder)
+	if err != nil {
+		return result, err
 	}
 
-	// Load parent template from partials
-	partials_map, ok := tmpl.partials.(map[string]string)
-	if !ok {
-		return
-	}
-	parent_src, has_parent := partials_map[parent_name]
-	if !has_parent {
-		return
-	}
+	temp := strings.to_string(builder)
+	result = strings.clone(temp, allocator)
 
-	// Lex parent template
-	parent_lexer := lexer_make(allocator)
-	parent_lexer.src = parent_src
-	parent_lexer.delim = CORE_DEF
-	if lexer_parse(parent_lexer, allocator = allocator) != nil {
-		return
-	}
-
-	// Build resolved token list: replace blocks with overrides where applicable
-	resolved := make([dynamic]Token, allocator)
-	defer delete(resolved)
-	pi := 0
-	for pi < len(parent_lexer.tokens) {
-		pt := parent_lexer.tokens[pi]
-		if pt.type == .Block_Open {
-			block_close := find_matching_close(parent_lexer.tokens[:], pi, pt.value)
-			if override, has_override := overrides[pt.value]; has_override {
-				for ot in override {
-					append(&resolved, ot)
-				}
-			} else {
-				for di in pi+1..<block_close {
-					append(&resolved, parent_lexer.tokens[di])
-				}
-			}
-			pi = block_close + 1
-		} else {
-			append(&resolved, pt)
-			pi += 1
-		}
-	}
-
-	// Create template with resolved tokens and render
-	resolved_lexer := lexer_make(allocator)
-	for t in resolved {
-		append(&resolved_lexer.tokens, t)
-	}
-	resolved_lexer.src = parent_lexer.src
-
-	parent_tmpl := template_make(resolved_lexer, allocator)
-	parent_tmpl.data = tmpl.data
-	parent_tmpl.partials = tmpl.partials
-
-	template_eat_tokens(parent_tmpl, sb, allocator)
+	return result, err
 }
 
-template_eat_tokens :: proc(
-	tmpl: ^Template,
-	sb: ^strings.Builder,
+// ---------------------------------------------------------------------------
+// Parser — flat token list → flat node array with child indices
+// ---------------------------------------------------------------------------
+
+parse_tokens :: proc(
+	tokens: []Token,
 	allocator := context.allocator,
+) -> (
+	nodes: [dynamic]Node,
+	err: Render_Error,
 ) {
-	root: Context_Stack_Entry
-	root.label = "ROOT"
-	root.data = tmpl.data
-	inject_at(&tmpl.context_stack, 0, root)
-
-	// First pass to find all the whitespace/newline elements that should be skipped.
-	for &t in tmpl.lexer.tokens {
-		if lexer_token_should_skip(tmpl.lexer, t) {
-			t.type = .Skip
-		}
-	}
-
-	template_process_tokens(tmpl, sb, allocator)
+	nodes = make([dynamic]Node, 0, len(tokens), allocator)
+	pos := 0
+	err = parse_section(tokens, &pos, &nodes, "")
+	return
 }
 
-template_process_tokens :: proc(
-	tmpl: ^Template,
-	sb: ^strings.Builder,
-	allocator := context.allocator,
-) {
-	i := 0
-	for i < len(tmpl.lexer.tokens) {
-		defer { i += 1 }
-		t := tmpl.lexer.tokens[i]
+parse_section :: proc(
+	tokens: []Token,
+	pos: ^int,
+	nodes: ^[dynamic]Node,
+	end_tag: string,
+) -> Render_Error {
+	for pos^ < len(tokens) {
+		tok := tokens[pos^]
+
+		switch tok.kind {
+		case .Text:
+			append(nodes, Node{kind = .Text, text = tok.value, first_child = -1})
+			pos^ += 1
+
+		case .Variable:
+			append(nodes, Node{kind = .Variable, key = tok.value, first_child = -1})
+			pos^ += 1
+
+		case .Unescaped:
+			append(nodes, Node{kind = .Unescaped, key = tok.value, first_child = -1})
+			pos^ += 1
+
+		case .Comment:
+			pos^ += 1
+
+		case .Section_Open:
+			pos^ += 1
+			idx := len(nodes)
+			append(nodes, Node{kind = .Section, key = tok.value, first_child = -1})
+			err := parse_section(tokens, pos, nodes, tok.value)
+			if err != nil do return err
+			nodes[idx].first_child = idx + 1
+			nodes[idx].child_count = len(nodes) - idx - 1
+
+		case .Inverted_Open:
+			pos^ += 1
+			idx := len(nodes)
+			append(nodes, Node{kind = .Inverted, key = tok.value, first_child = -1})
+			err := parse_section(tokens, pos, nodes, tok.value)
+			if err != nil do return err
+			nodes[idx].first_child = idx + 1
+			nodes[idx].child_count = len(nodes) - idx - 1
 
-		switch t.type {
-		case .Newline, .Text, .Tag, .Tag_Literal, .Tag_Literal_Triple:
-			if template_token_is_valid(tmpl, t) {
-				strings.write_string(sb, token_content(tmpl, t, allocator))
-			}
-		case .Section_Open, .Section_Open_Inverted:
-			template_add_to_context_stack(tmpl, t, i, allocator)
 		case .Section_Close:
-			template_pop_from_context_stack(tmpl)
-			// If we are in a loop and have iterations remaining, jump back to
-			// the token at the start of the loop.
-			if t.iters > 0 {
-				t.iters -= 1
-				tmpl.lexer.tokens[i] = t
-				i = t.start_i
-			}
-		case .Partial:
-			template_render_partial(tmpl, t, i, sb, allocator)
-		case .Parent:
-			template_handle_parent(tmpl, t, i, sb, allocator)
-			close_i := find_matching_close(tmpl.lexer.tokens[:], i, t.value)
-			i = close_i
-		case .Block_Open:
-			close_i := find_matching_close(tmpl.lexer.tokens[:], i, t.value)
-			i = close_i
-		// Do nothing for these tags.
-		case .Comment, .Skip, .EOF:
-		}
-	}
-}
-
-template_render :: proc(
-	tmpl: ^Template,
-	allocator := context.allocator,
-) -> (output: string, err: Render_Error) {
-	sb := strings.builder_make(allocator)
-
-	template_eat_tokens(tmpl, &sb, allocator)
-	rendered := strings.to_string(sb)
-
-	if tmpl.layout != "" {
-		sbl := strings.builder_make(allocator)
-
-		layout_lexer := lexer_make(allocator)
-		layout_lexer.src = tmpl.layout
-		layout_lexer.delim = CORE_DEF
-		lexer_parse(layout_lexer, allocator = allocator) or_return
-
-		layout_template := template_make(layout_lexer, allocator)
-		layout_template.data = tmpl.data
-		layout_template.partials = tmpl.partials
-
-		for t, i in layout_lexer.tokens {
-			if token_is_tag(t) && t.value == "content" {
-				template_insert_content_into_layout(layout_template, t, i, rendered, allocator)
-			}
-		}
-
-		template_eat_tokens(layout_template, &sbl, allocator)
-		rendered = strings.to_string(sbl)
-	}
-
-	return rendered, nil
-}
-
-/*
-	DATA-SPECIFIC PROCEDURES
-*/
-
-// Gets the length of a given object.
-data_len :: proc(obj: any) -> (l: int) {
-	obj := obj
-
-	if is_union(obj) {
-		obj = reflect.get_union_variant(obj)
-	}
-
-	switch data_type(obj) {
-	case .Struct:
-		l = len(reflect.struct_field_names(obj.id))
-	case .Map, .List, .Value:
-		l = reflect.length(obj)
-	case .Null:
-	}
-
-	return l
-}
-
-// Given a list of keys, access nested data inside any combination of
-// maps, structs, and lists.
-dig :: proc(d: any, keys: []string) -> any {
-	d := d
-
-	if len(keys) == 0 {
-		return d
-	}
-
-	for key in keys {
-		switch data_type(d) {
-		case .Struct:
-			d = struct_get(d, key)
-		case .Map:
-			d, _ = map_get(d, key)
-		case .List:
-			d = d
-		case .Value:
-			if key == "." {
-				d = fmt.tprintf("%v", d) 
-			} else {
+			if end_tag != "" && tok.value == end_tag {
+				pos^ += 1
 				return nil
 			}
-		case .Null:
-			return nil
+			if end_tag == "" {
+				return Syntax_Error {
+					msg = fmt.tprintf("unexpected {{/%s}}", tok.value),
+					pos = tok.pos,
+				}
+			}
+			return Syntax_Error {
+				msg = fmt.tprintf("expected {{/%s}}, got {{/%s}}", end_tag, tok.value),
+				pos = tok.pos,
+			}
+
+		case .Partial:
+			append(
+				nodes,
+				Node {
+					kind = .Partial,
+					key = tok.value,
+					is_dynamic = tok.is_dynamic,
+					first_child = -1,
+				},
+			)
+			pos^ += 1
+
+		case .Parent:
+			pos^ += 1
+			idx := len(nodes)
+			append(nodes, Node{kind = .Parent, key = tok.value, first_child = -1})
+			err := parse_section(tokens, pos, nodes, tok.value)
+			if err != nil do return err
+			nodes[idx].first_child = idx + 1
+			nodes[idx].child_count = len(nodes) - idx - 1
+
+		case .Block_Open:
+			pos^ += 1
+			idx := len(nodes)
+			append(nodes, Node{kind = .Block, key = tok.value, first_child = -1})
+			err := parse_section(tokens, pos, nodes, tok.value)
+			if err != nil do return err
+			nodes[idx].first_child = idx + 1
+			nodes[idx].child_count = len(nodes) - idx - 1
 		}
 	}
 
-	return d
-}
-
-any_to_string :: proc(obj: any) -> (s: string, err: Render_Error) {
-	switch data_type(obj) {
-	case .Struct, .Map, .List:
-		fmt.println("Could not convert", obj, "to printable content.")
-		return s, Template_Error {}
-	case .Value:
-		s = fmt.tprintf("%v", obj)
-	case .Null:
-		s = ""
+	if end_tag != "" {
+		return Syntax_Error{msg = fmt.tprintf("unclosed section '{{#%s}}'", end_tag)}
 	}
-
-	return s, nil
+	return nil
 }
 
-has_key :: proc(obj: any, key: string) -> (has: bool) {
-	obj := obj
+// ---------------------------------------------------------------------------
+// Renderer — walk node array against context stack, write to builder
+// ---------------------------------------------------------------------------
 
-	switch data_type(obj) {
-	case .Map:
-		return map_has_key(obj, key)
-	case .Struct:
-		if is_union(obj) {
-			obj = reflect.get_union_variant(obj)
+render_nodes :: proc(
+	all_nodes: []Node,
+	nodes: []Node,
+	ctx: ^[dynamic]any,
+	partials: map[string]Template,
+	b: ^strings.Builder,
+	blocks: map[string]Block_Override = nil,
+) -> Render_Error {
+	i := 0
+	for i < len(nodes) {
+		node := nodes[i]
+		switch node.kind {
+		case .Text:
+			strings.write_string(b, node.text)
+			i += 1
+
+		case .Variable:
+			val := resolve_name(node.key, ctx[:])
+			write_value(b, val, escape = true)
+			i += 1
+
+		case .Unescaped:
+			val := resolve_name(node.key, ctx[:])
+			write_value(b, val, escape = false)
+			i += 1
+
+		case .Section:
+			val := resolve_name(node.key, ctx[:])
+			if is_truthy(val) {
+				children := all_nodes[node.first_child:node.first_child + node.child_count]
+				elem_info, count, data := list_info(val)
+				if elem_info != nil {
+					for j in 0..<count {
+						elem_ptr := rawptr(uintptr(data) + uintptr(j) * uintptr(elem_info.size))
+						append(ctx, any{elem_ptr, elem_info.id})
+						err := render_nodes(all_nodes, children, ctx, partials, b, blocks)
+						pop(ctx)
+						if err != nil do return err
+					}
+				} else {
+					append(ctx, val)
+					err := render_nodes(all_nodes, children, ctx, partials, b, blocks)
+					pop(ctx)
+					if err != nil do return err
+				}
+			}
+			i += 1 + node.child_count
+
+		case .Inverted:
+			val := resolve_name(node.key, ctx[:])
+			if !is_truthy(val) {
+				children := all_nodes[node.first_child:node.first_child + node.child_count]
+				err := render_nodes(all_nodes, children, ctx, partials, b, blocks)
+				if err != nil do return err
+			}
+			i += 1 + node.child_count
+
+		case .Partial:
+			name := node.key
+			if node.is_dynamic {
+				val := resolve_name(node.key, ctx[:])
+				name = any_to_string(val)
+			}
+			pt, found := partials[name]
+			if found {
+				err := render_nodes(pt.nodes[:], pt.nodes[:], ctx, partials, b)
+				if err != nil do return err
+			}
+			i += 1
+
+		case .Block:
+			rendered_override := false
+			if blocks != nil {
+				if o, ok := blocks[node.key]; ok {
+					children := o.all_nodes[o.first:o.first + o.count]
+					err := render_nodes(o.all_nodes, children, ctx, partials, b)
+					if err != nil do return err
+					rendered_override = true
+				}
+			}
+			if !rendered_override {
+				children := all_nodes[node.first_child:node.first_child + node.child_count]
+				err := render_nodes(all_nodes, children, ctx, partials, b, blocks)
+				if err != nil do return err
+			}
+			i += 1 + node.child_count
+
+		case .Parent:
+			parent_children := all_nodes[node.first_child:node.first_child + node.child_count]
+			merged := merge_block_overrides(parent_children, all_nodes, blocks)
+			pt, found := partials[node.key]
+			if found {
+				err := render_nodes(pt.nodes[:], pt.nodes[:], ctx, partials, b, merged)
+				if err != nil do return err
+			}
+			i += 1 + node.child_count
 		}
-		fields := reflect.struct_field_names(obj.id)
-		return slice.contains(fields, key)
-	case .List, .Value, .Null:
-		return false
 	}
-
-	return has
+	return nil
 }
 
-// Get the data type of an object.
-data_type :: proc(obj: any) -> Data_Type {
-	// Unwrap nested 'any' values (e.g. from map[string]any)
-	if obj.id == typeid_of(any) && obj.data != nil {
-		inner := (^any)(obj.data)
-		return data_type(inner^)
+merge_block_overrides :: proc(
+	children: []Node,
+	all_nodes: []Node,
+	existing: map[string]Block_Override,
+) -> map[string]Block_Override {
+	result := make(map[string]Block_Override, context.temp_allocator)
+
+	for name, override in existing {
+		result[name] = override
 	}
 
-	if reflect.is_nil(obj) {
-		return .Null
-	} else if is_struct(obj) {
-		return .Struct
-	} else if is_map(obj) {
-		return .Map
-	} else if is_list(obj) {
-		return .List
-	} else {
-		return .Value
-	}
-}
-
-// Inverts a piece of data. If it has any content, then return a
-// falsey value. Otherwise, a truthful value.
-invert_data :: proc(data: any, allocator := context.allocator) -> any {
-	s: string
-
-	switch data_type(data) {
-	case .Struct, .Map, .List:
-		if data_len(data) > 0 {
-			s = FALSEY
+	i := 0
+	for i < len(children) {
+		child := children[i]
+		if child.kind == .Block {
+			if _, exists := result[child.key]; !exists {
+				result[child.key] = Block_Override{
+					all_nodes = all_nodes,
+					first = child.first_child,
+					count = child.child_count,
+				}
+			}
+			i += 1 + child.child_count
 		} else {
-			s = TRUE
-		}
-	case .Value:
-		if _falsey_context[fmt.tprintf("%v", data)] {
-			s = TRUE
-		} else {
-			s = FALSEY
-		}
-	case .Null:
-		s = TRUE
-	}
-
-	if s == "" {
-		s = FALSEY
-	}
-
-	return runtime.new_clone(s, allocator = allocator)^
-}
-
-/*
-	PRIMARY RENDER PROCEDURES
-*/
-render :: proc(
-	template: string,
-	data: any,
-	partials: any = map[string]string {},
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = template
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template
-	template := template_make(lexer, allocator)
-	template.data = data
-	template.partials = partials
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_in_layout :: proc(
-	template: string,
-	data: any,
-	layout: string,
-	partials: any = map[string]string {},
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	lexer := lexer_make(allocator)
-	lexer.src = template
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = data
-	template.partials = partials
-	template.layout = layout
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_in_layout_file :: proc(
-	template: string,
-	data: any,
-	layout_filename: string,
-	partials: any = map[string]string {},
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Read layout file.
-	layout, _ := os.read_entire_file_from_path(layout_filename, allocator)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = template
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template
-	tmpl := template_make(lexer, allocator)
-	tmpl.lexer = lexer
-	tmpl.data = data
-	tmpl.partials = partials
-	tmpl.layout = string(layout)
-
-	s = template_render(tmpl, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_from_filename :: proc(
-	filename: string,
-	data: any,
-	partials: any = map[string]string {},
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Read template file.
-	src, _ := os.read_entire_file_from_path(filename, allocator)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = string(src)
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.lexer = lexer
-	template.data = data
-	template.partials = partials
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_from_filename_in_layout :: proc(
-	filename: string,
-	data: any,
-	layout: string,
-	partials: any = map[string]string {},
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-
-	// Read template file and trim the trailing newline.
-	src, _ := os.read_entire_file_from_path(filename, allocator)
-	if rune(src[len(src)-1]) == '\n' {
-		src = src[0:len(src)-1]
-	}
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = string(src)
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = data
-	template.partials = partials
-	template.layout = layout
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_from_filename_in_layout_file :: proc(
-	filename: string,
-	data: any,
-	layout_filename: string,
-	partials: any = map[string]string {},
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-
-	// Read template file and trim the trailing newline.
-	src, _ := os.read_entire_file_from_path(filename, allocator)
-	if rune(src[len(src)-1]) == '\n' {
-		src = src[0:len(src)-1]
-	}
-
-	// Read layout file.
-	layout, _ := os.read_entire_file_from_path(layout_filename, allocator)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = string(src)
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template
-	template := template_make(lexer, allocator)
-	template.data = data
-	template.partials = partials
-	template.layout = string(layout)
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_with_json :: proc(
-	template: string,
-	json_filename: string,
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Load JSON.
-	json_src, _ := os.read_entire_file_from_path(json_filename, allocator)
-	json_data := json.parse(json_src, allocator = allocator) or_return
-	json_root := json_data.(json.Object)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = template
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = json_root["data"]
-	template.partials = json_root["partials"]
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_with_json_in_layout :: proc(
-	template: string,
-	json_filename: string,
-	layout: string,
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Load JSON.
-	json_src, _ := os.read_entire_file_from_path(json_filename, allocator)
-	json_data := json.parse(json_src, allocator = allocator) or_return
-	json_root := json_data.(json.Object)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = template
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = json_root["data"]
-	template.partials = json_root["partials"]
-	template.layout = layout
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_with_json_in_layout_file :: proc(
-	template: string,
-	json_filename: string,
-	layout_filename: string,
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Read layout file.
-	layout, _ := os.read_entire_file_from_path(layout_filename, allocator)
-
-	// Load JSON.
-	json_src, _ := os.read_entire_file_from_path(json_filename, allocator)
-	json_data := json.parse(json_src, allocator = allocator) or_return
-	json_root := json_data.(json.Object)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = template
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = json_root["data"]
-	template.partials = json_root["partials"]
-	template.layout = string(layout)
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_from_filename_with_json :: proc(
-	filename: string,
-	json_filename: string,
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Read template file.
-	src, _ := os.read_entire_file_from_path(filename, allocator)
-
-	// Load JSON.
-	json_src, _ := os.read_entire_file_from_path(json_filename, allocator)
-	json_data := json.parse(json_src) or_return
-	defer json.destroy_value(json_data)
-	json_root := json_data.(json.Object)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = string(src)
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = json_root["data"]
-	template.partials = json_root["partials"]
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_from_filename_with_json_in_layout :: proc(
-	filename: string,
-	json_filename: string,
-	layout: string,
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Read template file and trim the trailing newline.
-	src, _ := os.read_entire_file_from_path(filename, allocator)
-	if rune(src[len(src)-1]) == '\n' {
-		src = src[0:len(src)-1]
-	}
-
-	// Load JSON.
-	json_src, _ := os.read_entire_file_from_path(json_filename, allocator)
-	json_data := json.parse(json_src, allocator = allocator) or_return
-	json_root := json_data.(json.Object)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = string(src)
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = json_root["data"]
-	template.partials = json_root["partials"]
-	template.layout = layout
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-render_from_filename_with_json_in_layout_file :: proc(
-	filename: string,
-	json_filename: string,
-	layout_filename: string,
-	allocator := context.allocator,
-) -> (s: string, err: Render_Error) {
-	// Read template file and trim the trailing newline.
-	src, _ := os.read_entire_file_from_path(filename, allocator)
-	if rune(src[len(src)-1]) == '\n' {
-		src = src[0:len(src)-1]
-	}
-
-	// Read layout file.
-	layout, _ := os.read_entire_file_from_path(layout_filename, allocator)
-
-	// Load JSON.
-	json_src, _ := os.read_entire_file_from_path(json_filename, allocator)
-	json_data := json.parse(json_src, allocator = allocator) or_return
-	json_root := json_data.(json.Object)
-
-	// Parse template.
-	lexer := lexer_make(allocator)
-	lexer.src = string(src)
-	lexer.delim = CORE_DEF
-	lexer_parse(lexer, allocator = allocator) or_return
-
-	// Render template.
-	template := template_make(lexer, allocator)
-	template.data = json_root["data"]
-	template.partials = json_root["partials"]
-	template.layout = string(layout)
-
-	s = template_render(template, allocator) or_return
-	return strings.clone(s, allocator), nil
-}
-
-error :: proc(msg: string, args: ..any) -> ! {
-	fmt.eprint("\x1b[0;31modin-mustache Error:\x1b[0m ")
-	fmt.eprintf(msg, ..args)
-	fmt.eprint("\n")
-	os.exit(1)
-}
-
-_main :: proc(
-	template_filename: string,
-	json_filename: string,
-	layout_filename: string = "",
-) -> (output: string, err: Render_Error) {
-	if !os.is_file(template_filename) {
-		return "", File_Not_Found_Error{filename=template_filename}
-	}
-
-	if !os.is_file(json_filename) {
-		return "", File_Not_Found_Error{filename=json_filename}
-	}
-
-	if layout_filename != "" && !os.is_file(layout_filename) {
-		return "", File_Not_Found_Error{filename=layout_filename}
-	}
-
-	if layout_filename != "" {
-		output = render_from_filename_with_json_in_layout_file(
-			template_filename,
-			json_filename,
-			layout_filename,
-			context.temp_allocator,
-		) or_return
-	} else {
-		output = render_from_filename_with_json(
-			template_filename,
-			json_filename,
-			context.temp_allocator,
-		) or_return
-	}
-
-	return output, nil
-}
-
-/*
-	Setup global vars.
-*/
-@(init)
-init :: proc "contextless" () {
-	// Returns true if the value is one of the "falsey" values
-	// for a context.
-	_falsey_context[FALSEY] = true
-	_falsey_context["null"] = true
-	_falsey_context[""] = true
-
-	// Returns true if the value is one of the "falsey" values
-	// for a context.
-	_whitespace[' '] = true
-	_whitespace['\t'] = true
-	_whitespace['\r'] = true
-}
-
-main :: proc() {
-	defer free_all(context.temp_allocator)
-
-	when ODIN_DEBUG {
-		track: mem.Tracking_Allocator
-		mem.tracking_allocator_init(&track, context.allocator)
-		defer mem.tracking_allocator_destroy(&track)
-		context.allocator = mem.tracking_allocator(&track)
-	}
-
-	if len(os.args) < 3 {
-		error("You need to pass at least paths to the template and JSON data.")
-	}
-
-	// If a third argument was provided, this is the layout file.
-	layout_file: string
-	if len(os.args) == 4 {
-		layout_file = os.args[3]
-	}
-
-	if output, err := _main(os.args[1], os.args[2], layout_file); err != nil {
-		fmt.printf("Err: %v\n", err)
-		os.exit(1)
-	} else {
-		fmt.eprint(output)
-	}
-
-	when ODIN_DEBUG {
-		for _, entry in track.allocation_map {
-			fmt.eprintf("%m leaked at %v\n", entry.location, entry.size)
-		}
-
-		for entry in track.bad_free_array {
-			fmt.eprintf("%v allocation %p was freed badly\n", entry.location, entry.memory)
+			i += 1
 		}
 	}
+
+	return result
 }
+
diff --git a/mustache/mustache_test.odin b/mustache/mustache_test.odin
deleted file mode 100644
index 50ae53d..0000000
--- a/mustache/mustache_test.odin
+++ /dev/null
@@ -1,1045 +0,0 @@
-#+feature dynamic-literals
-
-package mustache
-
-import "core:encoding/json"
-import "core:fmt"
-import "core:os"
-import "core:reflect"
-import "core:slice"
-import "core:testing"
-
-COMMENTS_SPEC :: "mustache/spec/specs/comments.json"
-DELIMITERS_SPEC :: "mustache/spec/specs/delimiters.json"
-DYNAMIC_NAMES_SPEC :: "mustache/spec/specs/dynamic-names.json"
-INTERPOLATION_SPEC :: "mustache/spec/specs/interpolation.json"
-INVERTED_SPEC :: "mustache/spec/specs/inverted.json"
-PARTIALS_SPEC :: "mustache/spec/specs/partials.json"
-SECTIONS_SPEC :: "mustache/spec/specs/sections.json"
-
-Test_Struct :: struct {
-	name: string,
-	email: string,
-}
-Test_Map :: map[string]string
-Test_List :: [dynamic]string
-Test_Data :: union {
-	Test_Struct,
-	Test_Map,
-	Test_List,
-	string,
-}
-
-// 1. A map from string => JSON_Data
-// 2. A list of JSON_Data
-// 3. A value of some kind (string, int, etc.)
-JSON_Map :: distinct map[string]JSON_Data
-JSON_List :: distinct [dynamic]JSON_Data
-JSON_Data :: union {
-	JSON_Map,
-	JSON_List,
-	string,
-}
-
-load_json :: proc(val: json.Value) -> (loaded: JSON_Data) {
-	context.allocator = context.temp_allocator
-
-	switch _val in val {
-	case bool, string:
-		v := fmt.tprintf("%v", _val)
-		loaded = v
-	case i64, f64:
-		str := fmt.tprintf("%.2f", val)
-		decimal_str := trim_decimal_string(str)
-		loaded = decimal_str
-	case json.Object:
-		data := make(JSON_Map)
-		for k, v in _val {
-			new_k := fmt.tprintf("%v", k)
-			data[new_k] = load_json(v)
-		}
-		loaded = data
-	case json.Array:
-		data := make(JSON_List)
-		for v in _val {
-			append(&data, load_json(v))
-		}
-		loaded = data
-	case json.Null:
-	}
-
-	return loaded
-}
-
-load_spec :: proc(filename: string) -> (json.Value) {
-	context.allocator = context.temp_allocator
-
-	data, read_err := os.read_entire_file_from_path(filename, context.allocator)
-	if read_err != nil {
-		fmt.println("Failed to load the file!")
-		os.exit(1)
-	}
-
-	json_data, err := json.parse(data)
-	if err != .None {
-		fmt.println("Failed to parse the .json file")
-		fmt.println("Error:", err)
-		os.exit(1)
-	}
-
-	return json_data
-}
-
-assert :: proc(
-	t: ^testing.T,
-	actual: bool,
-	msg: string,
-	exp := #caller_expression(actual),
-	loc := #caller_location,
-) {
-	testing.expect(t, actual, msg, exp, loc)
-}
-
-assert_not :: proc(
-	t: ^testing.T,
-	actual: bool,
-	msg: string,
-	exp := #caller_expression(actual),
-	loc := #caller_location,
-) {
-	testing.expect(t, !actual, msg, exp, loc)
-}
-
-assert_mustache :: proc(
-	t: ^testing.T,
-	input: string,
-	data: any,
-	exp_output: string,
-	partials: any = map[string]string{},
-	loc := #caller_location,
-) {
-	output, _ := render(input, data, partials)
-	testing.expect_value(t, output, exp_output, loc)
-
-	delete(output)
-}
-
-@(test)
-test_render :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{x}}, nice to meet you. My name is {{y}}."
-
-	data := make(Test_Map, 2)
-	data["x"] = "Vincent"
-	data["y"] = "R2D2"
-
-	exp_output := "Hello, Vincent, nice to meet you. My name is R2D2."
-	output, _ := render(template, data)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_in_layout :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{x}}, nice to meet you. My name is {{y}}."
-
-	data := make(Test_Map, 2)
-	data["x"] = "Vincent"
-	data["y"] = "R2D2"
-
-	layout := "\nAbove.\n{{content}}\nBelow."
-
-	exp_output := "\nAbove.\nHello, Vincent, nice to meet you. My name is R2D2.\nBelow."
-	output, _ := render_in_layout(template, data, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_in_layout_with_data_for_layout :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello"
-
-	data := make(Test_Map, 1, context.temp_allocator)
-	data["x"] = "42"
-
-	layout := "\n{{x}}\n{{content}}\n"
-
-	exp_output := "\n42\nHello\n"
-	output, _ := render_in_layout(template, data, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_in_layout_file :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}."
-	data := make(Test_Map, 1, context.temp_allocator)
-	data["name"] = "Vincent"
-	layout := "mustache/test/layout.txt"
-
-	exp_output := "Begin layout >>\nHello, Vincent.\n<< End layout\n"
-	output, _ := render_in_layout_file(template, data, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_from_filename :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "mustache/test/template.txt"
-	data := make(Test_Map, 1, context.temp_allocator)
-	data["name"] = "Vincent"
-
-	exp_output := "Hello, this is Vincent.\n"
-	output, _ := render_from_filename(template, data)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_from_filename_in_layout :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "mustache/test/template.txt"
-	data := make(Test_Map, 1, context.temp_allocator)
-	data["name"] = "Vincent"
-	layout := "\nAbove.\n{{content}}\nBelow."
-
-	exp_output := "\nAbove.\nHello, this is Vincent.\nBelow."
-	output, _ := render_from_filename_in_layout(template, data, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_from_filename_in_layout_file :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "mustache/test/template.txt"
-	data := make(Test_Map, 1, context.temp_allocator)
-	data["name"] = "Vincent"
-	layout := "mustache/test/layout.txt"
-
-	exp_output := "Begin layout >>\nHello, this is Vincent.\n<< End layout\n"
-	output, _ := render_from_filename_in_layout_file(template, data, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_with_json :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}."
-	json := "mustache/test/data.json"
-
-	exp_output := "Hello, Kilgarvan."
-	output, _ := render_with_json(template, json)
-	testing.expect_value(t, output, exp_output)
-
-	defer(delete(output))
-}
-
-@(test)
-test_render_with_json_in_layout :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}."
-	json := "mustache/test/data.json"
-	layout := "\nAbove.\n{{content}}\nBelow."
-
-	exp_output := "\nAbove.\nHello, Kilgarvan.\nBelow."
-	output, _ := render_with_json_in_layout(template, json, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_with_json_in_layout_file :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}."
-	json := "mustache/test/data.json"
-	layout := "mustache/test/layout.txt"
-
-	exp_output := "Begin layout >>\nHello, Kilgarvan.\n<< End layout\n"
-	output, _ := render_with_json_in_layout_file(template, json, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_from_filename_with_json_in_layout :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "mustache/test/template.txt"
-	json := "mustache/test/data.json"
-	layout := "\nAbove.\n{{content}}\nBelow."
-
-	exp_output := "\nAbove.\nHello, this is Kilgarvan.\nBelow."
-	output, _ := render_from_filename_with_json_in_layout(template, json, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_render_from_filename_with_json_in_layout_file :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "mustache/test/template.txt"
-	json := "mustache/test/data.json"
-	layout := "mustache/test/layout.txt"
-
-	exp_output := "Begin layout >>\nHello, this is Kilgarvan.\n<< End layout\n"
-	output, _ := render_from_filename_with_json_in_layout_file(template, json, layout)
-	testing.expect_value(t, output, exp_output)
-
-	delete(output)
-}
-
-@(test)
-test_struct :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}. Send an email to {{email}}."
-	data := Test_Struct {"Vincent", "foo@example.com"}
-	exp_output := "Hello, Vincent. Send an email to foo@example.com."
-	assert_mustache(t, template, data, exp_output)
-}
-
-@(test)
-test_struct_union :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}. Send an email to {{email}}."
-	data: Test_Data
-	data = Test_Struct {"Vincent", "foo@example.com"}
-	exp_output := "Hello, Vincent. Send an email to foo@example.com."
-	assert_mustache(t, template, data, exp_output)
-}
-
-@(test)
-test_struct_inside_map :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{name}}. Send an email to {{#email}}{{address}}{{/email}}."
-
-	data := make(map[string]Test_Data, 2, context.temp_allocator)
-	data["name"] = "Vincent"
-	data["email"] = make(Test_Map, 1, context.temp_allocator)
-	email := data["email"].(Test_Map)
-	email["address"] = "foo@example.com"
-	data["email"] = email
-
-	exp_output := "Hello, Vincent. Send an email to foo@example.com."
-	assert_mustache(t, template, data, exp_output)
-}
-
-@(test)
-test_list :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "{{#names}}{{.}}{{/names}}"
-
-	data := make(map[string][dynamic]string, 1, context.temp_allocator)
-	names := make([dynamic]string, 2, context.temp_allocator)
-	append(&names, "Helena", " Bloomington")
-	data["names"] = names
-
-	exp_output := "Helena Bloomington"
-	assert_mustache(t, template, data, exp_output)
-}
-
-@(test)
-test_no_interpolation :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {Mustache}!"
-	data := ""
-	exp_output := "Hello, {Mustache}!"
-	assert_mustache(t, template, data, exp_output)
-}
-
-@(test)
-test_literal_tag :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "Hello, {{{verb1}}}."
-	data := Test_Map {
-		"verb1" = "I like < >",
-	}
-	defer(delete(data))
-
-	exp_output := "Hello, I like < >."
-	assert_mustache(t, template, data, exp_output)
-}
-
-@(test)
-test_interpolation_spec :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	spec := load_spec(INTERPOLATION_SPEC)
-	defer json.destroy_value(spec)
-
-	root := spec.(json.Object)
-	tests := root["tests"].(json.Array)
-
-	for test in tests {
-		test_obj := test.(json.Object)
-		template := test_obj["template"].(string)
-		exp_output := test_obj["expected"].(string)
-		data := test_obj["data"]
-		input := load_json(data)
-
-		assert_mustache(t, template, input, exp_output)
-	}
-}
-
-@(test)
-test_comments_spec :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	spec := load_spec(COMMENTS_SPEC)
-	defer json.destroy_value(spec)
-
-	root := spec.(json.Object)
-	tests := root["tests"].(json.Array)
-
-	for test in tests {
-		test_obj := test.(json.Object)
-		template := test_obj["template"].(string)
-		exp_output := test_obj["expected"].(string)
-		data := test_obj["data"]
-		input := load_json(data)
-
-		assert_mustache(t, template, input, exp_output)
-	}
-}
-
-@(test)
-test_sections_spec :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	spec := load_spec(SECTIONS_SPEC)
-	defer json.destroy_value(spec)
-
-	root := spec.(json.Object)
-	tests := root["tests"].(json.Array)
-
-	for test in tests {
-		test_obj := test.(json.Object)
-		template := test_obj["template"].(string)
-		exp_output := test_obj["expected"].(string)
-		data := test_obj["data"]
-		input := load_json(data)
-
-		assert_mustache(t, template, input, exp_output)
-	}
-}
-
-@(test)
-test_inverted_spec :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	spec := load_spec(INVERTED_SPEC)
-	defer json.destroy_value(spec)
-
-	root := spec.(json.Object)
-	tests := root["tests"].(json.Array)
-
-	for test in tests {
-		test_obj := test.(json.Object)
-		template := test_obj["template"].(string)
-		exp_output := test_obj["expected"].(string)
-		data := test_obj["data"]
-		input := load_json(data)
-
-		assert_mustache(t, template, input, exp_output)
-	}
-}
-
-@(test)
-test_partials_spec :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	spec := load_spec(PARTIALS_SPEC)
-	defer json.destroy_value(spec)
-
-	root := spec.(json.Object)
-	tests := root["tests"].(json.Array)
-
-	for test in tests {
-		test_obj := test.(json.Object)
-		template := test_obj["template"].(string)
-		exp_output := test_obj["expected"].(string)
-		data := test_obj["data"]
-		input := load_json(data)
-		partials := test_obj["partials"]
-		partials_input := load_json(partials).(JSON_Map)
-
-		assert_mustache(t, template, input, exp_output, partials_input)
-	}
-}
-
-@(test)
-test_dynamic_names_spec :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	spec := load_spec(DYNAMIC_NAMES_SPEC)
-	defer json.destroy_value(spec)
-
-	root := spec.(json.Object)
-	tests := root["tests"].(json.Array)
-
-	for test in tests {
-		test_obj := test.(json.Object)
-		template := test_obj["template"].(string)
-		exp_output := test_obj["expected"].(string)
-		data := test_obj["data"]
-		input := load_json(data)
-		partials := test_obj["partials"]
-		partials_input := load_json(partials).(JSON_Map)
-
-		assert_mustache(t, template, input, exp_output, partials_input)
-	}
-}
-
-// TODO: Someday.
-// @(test)
-// test_delimiters_spec :: proc(t: ^testing.T) {
-//   spec := load_spec(DELIMITERS_SPEC)
-//   defer json.destroy_value(spec)
-
-//   root := spec.(json.Object)
-//   tests := root["tests"].(json.Array)
-
-//   for test, i in tests {
-//     if i > 0 do break
-
-//     test_obj := test.(json.Object)
-//     test_name := test_obj["name"].(string)
-//     test_desc := test_obj["desc"].(string)
-//     template := test_obj["template"].(string)
-//     exp_output := test_obj["expected"].(string)
-//     data := test_obj["data"]
-//     input := load_json(data)
-
-//     // Not all the test cases have partials.
-//     partials := test_obj["partials"]
-//     partials_input, ok := load_json(partials).(Map)
-//     if !ok {
-//       partials_input = Map{}
-//     }
-
-//     assert_mustache(t, template, input, exp_output, partials_input)
-//   }
-// }
-
-@(test)
-test_map_get :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	// Get the value in a map with one key.
-	output: any
-	mss := make(map[string]string)
-	mcs := make(map[cstring]string)
-	msi := make(map[string]int)
-	mis := make(map[int]string)
-
-	tm := make(Test_Map)
-	mtm := make(map[string]Test_Map)
-
-	u: Test_Data
-	u = make(Test_Map)
-
-	// Simple map
-	delete(mss)
-	mss["name"] = "George"
-	output, _ = map_get(mss, "name")
-	testing.expect_value(t, output.(string), "George")
-
-	// Get the value in a map with one key when key is cstring.
-	delete(mcs)
-	mcs["name"] = "George"
-	output, _ = map_get(mcs, "name")
-	testing.expect_value(t, output.(string), "George")
-
-	// Get the first value in a map with multiple keys.
-	delete(mss)
-	mss["name"] = "George"
-	mss["hometown"] = "Helena"
-	output, _ = map_get(mss, "name")
-	testing.expect_value(t, output.(string), "George")
-
-	// Get the second value in a map with multiple keys.
-	delete(mss)
-	mss["name"] = "George"
-	mss["hometown"] = "Helena"
-	output, _ = map_get(mss, "hometown")
-	testing.expect_value(t, output.(string), "Helena")
-
-	// Get an int
-	delete(msi)
-	msi["phone_number"] = 5555555555
-	output, _ = map_get(msi, "phone_number")
-	testing.expect_value(t, output.(int), 5555555555)
-
-	// Nested, named map.
-	delete(tm)
-	delete(mtm)
-	tm["name"] = "Lee"
-	mtm["person"] = tm
-	output, _ = map_get(mtm, "person")
-	testing.expect_value(t, output.(Test_Map)["name"], tm["name"])
-
-	// Extract from a map type inside a union.
-	delete(u.(Test_Map))
-	(&u.(Test_Map))["name"] = "St. Charles"
-	output, _ = map_get(u, "name")
-	testing.expect_value(t, output.(string), u.(Test_Map)["name"])
-
-	// Return nil when the map is NOT keyed by string, cstring
-	delete(mis)
-	mis[1] = "Customer 1"
-	output, _ = map_get(mis, "1")
-	testing.expect(t, reflect.is_nil(output))
-}
-
-@(test)
-test_struct_get :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	output: any
-
-	data := Test_Struct{"Vincent", "foo@example.com"}
-	output = struct_get(data, "name")
-	testing.expect_value(t, output.(string), "Vincent")
-
-	output = struct_get(data, "email")
-	testing.expect_value(t, output.(string), "foo@example.com")
-
-	output = struct_get("foo", "email")
-	testing.expect(
-		t,
-		reflect.is_nil(output),
-		"String argument that is NOT a Struct returns nil",
-	)
-
-	test_map := make(Test_Map)
-	test_map["name"] = "Lee"
-	output = struct_get(test_map, "name")
-	testing.expect(
-		t,
-		reflect.is_nil(output),
-		"Map argument that is NOT a Struct returns nil",
-	)
-
-	// Extract from a map type inside a union.
-	u_struct: Test_Data
-	u_struct = Test_Struct{"St. Charles", "foo@example.com"}
-	output = struct_get(u_struct, "name")
-	testing.expect_value(t, output.(string), u_struct.(Test_Struct).name)
-}
-
-@(test)
-test_is_map :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	m := map[string]string{"Vincent" = "Edgar"}
-	assert(t, is_map(m), "Regular map should return true")
-	delete(m)
-
-	m = Test_Map{"name" = "Lee"}
-	assert(t, is_map(m), "Named map should return true")
-	delete(m)
-
-	data: Test_Data
-	data = Test_Map{ "name" = "Vincent" }
-	assert(
-		t,
-		is_map(data),
-		"Union with Map variant should be considered a Map",
-	)
-	delete(data.(Test_Map))
-
-	data = Test_List{ "foo", "bar", "baz" }
-	assert_not(
-		t,
-		is_map(data),
-		"Union with list variant should not be considered a Map",
-	)
-	delete(data.(Test_List))
-
-	assert_not(
-		t,
-		is_map(Test_Struct{"Vincent", "foo@example.com"}),
-		"Struct should not be a map",
-	)
-
-	u: Test_Data
-	u = Test_Struct{"Vincent", "foo@example.com"}
-	assert_not(
-		t,
-		is_map(u),
-		"Struct variant of a Union should not be considered a Map",
-	)
-}
-
-@(test)
-test_is_list :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	arr := [1]string{"element1"}
-	assert(t, is_list(arr), "Array should be considered a list")
-	assert(t, is_list(arr[:]), "Slice should be considered a list")
-
-	dyn_arr := make([dynamic]string, 1, 1)
-	append(&dyn_arr, "element1")
-	assert(t, is_list(dyn_arr), "Dynamic array should be considered a list")
-
-	u_arr: Test_Data
-	u_arr = make(Test_List, 1, 1)
-	append(&u_arr.(Test_List), "element1")
-	assert(t, is_list(u_arr), "Dynamic array in a union should be considered a list")
-
-	assert_not(t, is_list("foo"), "string should not be considered a list")
-	assert_not(t, is_list(1), "int should not be considered a list")
-
-	u_map: Test_Data
-	u_map = make(Test_Map, 1)
-	assert_not(
-		t,
-		is_list(u_map),
-		"Map in union that has list type should not be considered a list",
-	)
-}
-
-@(test)
-test_is_struct :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	assert(
-		t,
-		is_struct(Test_Struct{"Vincent", "foo@example.com"}),
-		"Struct should be considered a Struct",
-	)
-
-	u: Test_Data
-	u = Test_Struct{"Vincent", "foo@example.com"}
-	assert(
-		t,
-		is_struct(u),
-		"Struct variant of a union should be considered a Struct",
-	)
-
-	data: Test_Data
-	data = make(Test_Map)
-	assert_not(
-		t,
-		is_struct(data),
-		"Union with map variant should not be considered a Struct",
-	)
-
-	data = make(Test_List)
-	append(&data.(Test_List), "foo", "bar", "baz")
-	assert_not(
-		t,
-		is_struct(data),
-		"Union with list variant should not be considered a Struct",
-	)
-}
-
-@(test)
-test_is_union :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	u: Test_Data
-	u = make(Test_Map)
-	assert(
-		t,
-		is_union(u),
-		"Union is union",
-	)
-
-
-	tm := make(Test_Map)
-	assert_not(
-		t,
-		is_union(tm),
-		"Union member with a type is not a union",
-	)
-
-	tl := make(Test_List)
-	assert_not(
-		t,
-		is_union(tl),
-		"Union member with a type is not a union",
-	)
-
-	m := make(map[string]string)
-	assert_not(
-		t,
-		is_union(m),
-		"Map should not be a union",
-	)
-
-	ts := Test_Struct{"Vincent", "foo@example.com"}
-	assert_not(
-		t,
-		is_union(ts),
-		"Struct should not be a union",
-	)
-}
-
-@(test)
-test_data_len :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	data: any
-
-	data = make([dynamic]string)
-	testing.expect_value(t, data_len(data), 0)
-
-	data = make([dynamic]string)
-	append(&data.([dynamic]string), "Vincent")
-	testing.expect_value(t, data_len(data), 1)
-
-	data = "FooBar"
-	testing.expect_value(t, data_len(data), 6)
-
-	data = Test_Struct{"Vincent", "foo@example.com"}
-	testing.expect_value(t, data_len(data), 2)
-
-	u: Test_Data
-	u = Test_Struct{"Vincent", "foo@example.com"}
-	testing.expect_value(t, data_len(u), 2)
-
-	u = make(Test_Map)
-	(&u.(Test_Map))["name"] = "St. Charles"
-	testing.expect_value(t, data_len(u), 1)
-}
-
-@(test)
-test_has_key :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	data: any
-
-	data = Test_Struct{"St. Charles", "foo@example.com"}
-	assert(t, has_key(data, "name"), "Should return true if stuct has field")
-
-	data = make(map[string]int)
-	(&data.(map[string]int))["A1"] = 1
-	assert(t, has_key(data, "A1"), "Should return true if map has key")
-	assert_not(t, has_key(data, "B2"), "Should return false if map does not have key")
-
-	u: Test_Data
-	u = make(Test_Map)
-	(&u.(Test_Map))["name"] = "St. Charles"
-	assert(t, has_key(u, "name"), "Should return true if union-map has key")
-	assert_not(t, has_key(u, "email"), "Should return false if union-map does not have key")
-
-	u = Test_Struct{"St. Charles", "foo@example.com"}
-	assert(t, has_key(u, "name"), "Should return true if union-struct has key")
-	assert_not(t, has_key(u, "XXX"), "Should return false if union-struct does not have key")
-}
-
-@(test)
-test_list_at :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	arr := [2]string{"foo", "bar"}
-	testing.expect_value(t, list_at(arr, 0).(string), "foo")
-	testing.expect_value(t, list_at(arr, 1).(string), "bar")
-
-	testing.expect_value(t, list_at(arr[:], 0).(string), "foo")
-	testing.expect_value(t, list_at(arr[:], 1).(string), "bar")
-
-	dyn := slice.clone_to_dynamic(arr[:])
-	testing.expect_value(t, list_at(dyn, 0).(string), "foo")
-	testing.expect_value(t, list_at(dyn, 1).(string), "bar")
-}
-
-@(test)
-test_dig :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	output: any
-	keys := make([dynamic]string)
-
-	// Pull out a struct value
-	d1: any
-	d1 = Test_Struct{"Vincent", "foo@example.com"}
-	append(&keys, "name")
-	output = dig(d1, keys[:])
-	testing.expect_value(t, output.(string), "Vincent")
-	delete(keys)
-
-	// Pull out a map value
-	d2: any
-	d2 = make(map[string]string)
-	(&d2.(map[string]string))["name"] = "Edgar"
-	keys = {"name"}
-	output = dig(d2, keys[:])
-	testing.expect_value(t, output.(string), "Edgar")
-	delete(keys)
-
-	// Pull out a nested map value
-	d3: any
-	d3 = make(map[string]map[string]string)
-	c1 := make(map[string]string)
-	c1["name"] = "Kurt"
-	c1["email"] = "test@example.com"
-	(&d3.(map[string]map[string]string))["customer1"] = c1
-	keys = {"customer1", "email"}
-	output = dig(d3, keys[:])
-	testing.expect_value(t, output.(string), "test@example.com")
-	delete(keys)
-
-	// Pull out a nested map
-	d4 := make(map[string]map[string]string)
-	c2 := make(map[string]string)
-	c2["name"] = "Kurt"
-	c2["email"] = "test@example.com"
-	d4["customer1"] = c2
-	keys = {"customer1"}
-	output = dig(d4, keys[:])
-	testing.expect_value(t, output.(map[string]string)["name"], "Kurt")
-	testing.expect_value(t, output.(map[string]string)["email"], "test@example.com")
-	delete(keys)
-
-	// Pull out a list
-	d5: any
-	d5 = Test_List{"El1", "El2"}
-	keys = {"key1"}
-	output = dig(d5, keys[:])
-	testing.expect_value(t, output.(Test_List)[0], d5.(Test_List)[0])
-	testing.expect_value(t, output.(Test_List)[1], d5.(Test_List)[1])
-	delete(d5.(Test_List))
-	delete(keys)
-
-	// Pull out a struct inside a map
-	d6: any
-	d6 = make(map[string]Test_Struct)
-	c3 := Test_Struct{"Vincent", "foo@example.com"}
-	(&d6.(map[string]Test_Struct))["customer1"] = c3
-	keys = {"customer1", "email"}
-	output = dig(d6, keys[:])
-	testing.expect_value(t, output.(string), "foo@example.com")
-	delete(keys)
-
-	// Pull out a string with dot notation
-	d7 := "Hello, world!"
-	keys = {"."}
-	output = dig(d7, keys[:])
-	testing.expect_value(t, output.(string), "Hello, world!")
-	delete(keys)
-
-	// Return nil when string and not dot notation.
-	d8 := "Hello, world!"
-	keys = {"XXX"}
-	output = dig(d8, keys[:])
-	assert(t, reflect.is_nil(output), "Nil string when a key that is not '.' is provided.")
-	delete(keys)
-
-	// Pull out a nil struct value
-	d9 := Test_Struct{"Vincent", "foo@example.com"}
-	keys = {"XXX"}
-	output = dig(d9, keys[:])
-	assert(t, reflect.is_nil(output), "Struct without a matching field should be nil")
-	delete(keys)
-
-	// Pull out a nil struct value with multiple keys
-	d10 := Test_Struct{"Vincent", "foo@example.com"}
-	keys = {"XXX", "YYY"}
-	output = dig(d10, keys[:])
-	assert(t, reflect.is_nil(output), "Struct without a matching field should be nil")
-	delete(keys)
-
-	// Pull out a nil struct value
-	d11 := make(map[string]string)
-	d11["name"] = "Vincent"
-	keys = {"XXX"}
-	output = dig(d11, keys[:])
-	assert(t, reflect.is_nil(output), "Map without a matching field should be nil")
-	delete(keys)
-}
-
-@(test)
-test_partial_in_section :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "{{#items}}{{> item }}{{/items}}"
-
-	data := make(map[string][dynamic]string, 1, context.temp_allocator)
-	items := make([dynamic]string, 0, context.temp_allocator)
-	append(&items, "A", "B", "C")
-	data["items"] = items
-
-	partials := map[string]string{
-		"item" = "[{{.}}]",
-	}
-
-	assert_mustache(t, template, data, "[A][B][C]", partials)
-}
-
-@(test)
-test_dynamic_partial_in_section :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "{{#items}}{{>*tpl}}{{/items}}"
-
-	items := make([dynamic]Test_Map, 0, context.temp_allocator)
-	item1 := make(Test_Map)
-	item1["tpl"] = "a"
-	item1["v"] = "1"
-	append(&items, item1)
-	item2 := make(Test_Map)
-	item2["tpl"] = "b"
-	item2["v"] = "2"
-	append(&items, item2)
-
-	data := make(map[string][dynamic]Test_Map, 1, context.temp_allocator)
-	data["items"] = items
-
-	partials := map[string]string{
-		"a" = "A:{{v}}",
-		"b" = "B:{{v}}",
-	}
-
-	assert_mustache(t, template, data, "A:1B:2", partials)
-}
-
-@(test)
-test_nested_partials :: proc(t: ^testing.T) {
-	context.allocator = context.temp_allocator
-
-	template := "{{> outer }}"
-	data := make(Test_Map)
-	data["x"] = "hello"
-
-	partials := map[string]string{
-		"outer" = "[{{> inner }}]",
-		"inner" = "{{x}}",
-	}
-
-	assert_mustache(t, template, data, "[hello]", partials)
-}
diff --git a/mustache/spec_test.odin b/mustache/spec_test.odin
new file mode 100644
index 0000000..a60ca40
--- /dev/null
+++ b/mustache/spec_test.odin
@@ -0,0 +1,127 @@
+#+test
+package mustache
+
+import "core:encoding/json"
+import "core:fmt"
+import "core:os"
+import "core:testing"
+
+run_spec_file :: proc(t: ^testing.T, path: string) {
+	raw_data, err := os.read_entire_file(path, context.allocator)
+	if err != nil {
+		testing.expectf(t, false, "Failed to read %s", path)
+		return
+	}
+	defer delete(raw_data)
+
+	value, jerr := json.parse(raw_data)
+	if jerr != .None {
+		testing.expectf(t, false, "JSON parse error in %s: %v", path, jerr)
+		return
+	}
+	defer json.destroy_value(value)
+
+	root := value.(json.Object)
+	tests := root["tests"].(json.Array)
+
+	passed := 0
+	failed := 0
+
+	for tv in tests {
+		test := tv.(json.Object)
+		name := test["name"].(string)
+		template_src := test["template"].(string)
+		expected := test["expected"].(string)
+
+		if run_one_test(t, test, name, template_src, expected) {
+			passed += 1
+		} else {
+			failed += 1
+		}
+	}
+
+	if failed > 0 {
+		testing.fail(t)
+	}
+	fmt.printfln("  %s: %d/%d passed", path, passed, passed + failed)
+}
+
+run_one_test :: proc(
+	t: ^testing.T,
+	test: json.Object,
+	name, template_src, expected: string,
+) -> bool {
+	partials := make_map(map[string]Template, context.temp_allocator)
+
+	if "partials" in test {
+		p_obj, ok := test["partials"].(json.Object)
+		assert(ok)
+		for pname, pval in p_obj {
+			psrc, ok := pval.(string)
+			assert(ok)
+
+			pt, perr := parse(psrc, context.temp_allocator)
+			if perr != nil {
+				testing.expectf(t, false, "[%s] partial '%s' parse error", name, pname)
+				return false
+			}
+			partials[pname] = pt
+		}
+	}
+
+	tmpl, terr := parse(template_src, context.temp_allocator)
+	if terr != nil {
+		testing.expectf(t, false, "[%s] template parse error", name)
+		return false
+	}
+	defer delete(tmpl.nodes)
+
+	result, rerr := render(tmpl, test["data"], partials)
+	if rerr != nil {
+		testing.expectf(t, false, "[%s] render error", name)
+		return false
+	}
+	defer delete(result)
+
+	if result != expected {
+		testing.expectf(t, false, "[%s]\n  got:      %q\n  expected: %q", name, result, expected)
+		return false
+	}
+	return true
+}
+
+@(test)
+spec_interpolation :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/interpolation.json")
+}
+
+@(test)
+spec_sections :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/sections.json")
+}
+
+@(test)
+spec_inverted :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/inverted.json")
+}
+
+@(test)
+spec_comments :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/comments.json")
+}
+
+@(test)
+spec_partials :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/partials.json")
+}
+
+@(test)
+spec_dynamic_names :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/dynamic-names.json")
+}
+
+@(test)
+spec_inheritance :: proc(t: ^testing.T) {
+	run_spec_file(t, "spec/specs/~inheritance.json")
+}
+
diff --git a/mustache/test/data.json b/mustache/test/data.json
deleted file mode 100644
index 6bf2bab..0000000
--- a/mustache/test/data.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  data: {
-    name: "Kilgarvan"
-  }
-}
diff --git a/mustache/test/layout.txt b/mustache/test/layout.txt
deleted file mode 100644
index 491fdca..0000000
--- a/mustache/test/layout.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Begin layout >>
-{{content}}
-<< End layout
diff --git a/mustache/test/template.txt b/mustache/test/template.txt
deleted file mode 100644
index 30a55bd..0000000
--- a/mustache/test/template.txt
+++ /dev/null
@@ -1 +0,0 @@
-Hello, this is {{name}}.
diff --git a/mustache/tokenizer.odin b/mustache/tokenizer.odin
new file mode 100644
index 0000000..6710982
--- /dev/null
+++ b/mustache/tokenizer.odin
@@ -0,0 +1,227 @@
+package mustache
+
+import "core:strings"
+
+Token_Kind :: enum {
+	Text,
+	Variable,
+	Unescaped,
+	Section_Open,
+	Inverted_Open,
+	Section_Close,
+	Comment,
+	Partial,
+	Parent,
+	Block_Open,
+}
+
+Token :: struct {
+	kind:       Token_Kind,
+	value:      string,
+	is_dynamic: bool,
+	pos:        int,
+}
+
+tokenize :: proc(
+	src: string,
+	allocator := context.allocator,
+) -> (
+	tokens: [dynamic]Token,
+	err: Render_Error,
+) {
+	tokens = make([dynamic]Token, 0, 8, allocator)
+
+	i := 0
+	text_start := 0
+
+	for i < len(src) {
+		if src[i] == '{' && i + 1 < len(src) && src[i + 1] == '{' {
+			if i > text_start {
+				append(&tokens, Token{kind = .Text, value = src[text_start:i], pos = text_start})
+			}
+
+			tag_pos := i
+
+			if i + 2 < len(src) && src[i + 2] == '{' {
+				content_start := i + 3
+				idx := strings.index(src[content_start:], "}}}")
+				if idx < 0 {
+					return tokens, Syntax_Error {
+						msg = "unclosed triple mustache '{{{'",
+						pos = tag_pos,
+					}
+				}
+				close := content_start + idx
+				key := strings.trim_space(src[content_start:close])
+				append(&tokens, Token{kind = .Unescaped, value = key, pos = tag_pos})
+				i = close + 3
+				text_start = i
+			} else {
+				content_start := i + 2
+				sigil: byte = 0
+				if content_start < len(src) {
+					sigil = src[content_start]
+				}
+
+				kind: Token_Kind
+				key_start := content_start
+
+				switch sigil {
+				case '&':
+					kind = .Unescaped; key_start = content_start + 1
+				case '#':
+					kind = .Section_Open; key_start = content_start + 1
+				case '^':
+					kind = .Inverted_Open; key_start = content_start + 1
+				case '/':
+					kind = .Section_Close; key_start = content_start + 1
+				case '!':
+					kind = .Comment; key_start = content_start + 1
+				case '>':
+					kind = .Partial; key_start = content_start + 1
+				case '<':
+					kind = .Parent; key_start = content_start + 1
+				case '$':
+					kind = .Block_Open; key_start = content_start + 1
+				case:
+					kind = .Variable
+				}
+
+				close_idx := strings.index(src[key_start:], "}}")
+				if close_idx < 0 {
+					return tokens, Syntax_Error{msg = "unclosed tag '{{'", pos = tag_pos}
+				}
+				close := key_start + close_idx
+
+				content := src[key_start:close]
+
+				if kind == .Comment {
+					append(&tokens, Token{kind = .Comment, value = content, pos = tag_pos})
+				} else if kind == .Partial {
+					trimmed := strings.trim_space(content)
+					is_dyn := false
+					if len(trimmed) > 0 && trimmed[0] == '*' {
+						is_dyn = true
+						trimmed = strings.trim_space(trimmed[1:])
+					}
+					append(
+						&tokens,
+						Token {
+							kind = .Partial,
+							value = trimmed,
+							is_dynamic = is_dyn,
+							pos = tag_pos,
+						},
+					)
+				} else {
+					append(
+						&tokens,
+						Token{kind = kind, value = strings.trim_space(content), pos = tag_pos},
+					)
+				}
+
+				i = close + 2
+				text_start = i
+			}
+		} else {
+			i += 1
+		}
+	}
+
+	if i > text_start {
+		append(&tokens, Token{kind = .Text, value = src[text_start:i], pos = text_start})
+	}
+
+	trim_standalone_whitespace(&tokens)
+	return tokens, nil
+}
+
+// ---------------------------------------------------------------------------
+// Standalone whitespace handling
+// ---------------------------------------------------------------------------
+
+trim_standalone_whitespace :: proc(tokens: ^[dynamic]Token) {
+	for i := 0; i < len(tokens); i += 1 {
+		if !should_trim_whitespace(tokens[i].kind) do continue
+
+		left_ok, left_idx := check_left(tokens[:], i)
+		right_ok, right_idx := check_right(tokens[:], i)
+
+		if !left_ok || !right_ok do continue
+
+		if left_idx >= 0 {
+			text := tokens[left_idx].value
+			nl := strings.last_index_byte(text, '\n')
+			tokens[left_idx].value = text[:nl+1] if nl >= 0 else ""
+		}
+
+		if right_idx >= 0 {
+			text := tokens[right_idx].value
+			nl := strings.index_byte(text, '\n')
+			tokens[right_idx].value = text[nl+1:] if nl >= 0 else ""
+		}
+	}
+}
+
+check_left :: proc(tokens: []Token, i: int) -> (ok: bool, text_idx: int) {
+	j := i - 1
+	for j >= 0 {
+		if tokens[j].kind == .Text {
+			text := tokens[j].value
+			if len(text) == 0 {
+				j -= 1
+				continue
+			}
+			nl := strings.last_index_byte(text, '\n')
+			if nl >= 0 {
+				return strings.trim_space(text[nl+1:]) == "", j
+			}
+			if j == 0 {
+				return strings.trim_space(text) == "", j
+			}
+			return false, -1
+		} else if should_trim_whitespace(tokens[j].kind) {
+			j -= 1
+		} else {
+			return false, -1
+		}
+	}
+	return true, -1
+}
+
+check_right :: proc(tokens: []Token, i: int) -> (ok: bool, text_idx: int) {
+	j := i + 1
+	for j < len(tokens) {
+		if tokens[j].kind == .Text {
+			text := tokens[j].value
+			if len(text) == 0 {
+				j += 1
+				continue
+			}
+			nl := strings.index_byte(text, '\n')
+			if nl >= 0 {
+				return strings.trim_space(text[:nl]) == "", j
+			}
+			if j == len(tokens) - 1 {
+				return strings.trim_space(text) == "", j
+			}
+			return false, -1
+		} else if should_trim_whitespace(tokens[j].kind) {
+			j += 1
+		} else {
+			return false, -1
+		}
+	}
+	return true, -1
+}
+
+should_trim_whitespace :: proc(kind: Token_Kind) -> bool {
+	switch kind {
+	case .Section_Open, .Inverted_Open, .Section_Close, .Comment, .Partial, .Parent, .Block_Open:
+		return true
+	case .Text, .Variable, .Unescaped:
+		return false
+	}
+	return false
+}
+
diff --git a/mustache_test.odin b/mustache_test.odin
index 768f33e..49f3453 100644
--- a/mustache_test.odin
+++ b/mustache_test.odin
@@ -10,7 +10,8 @@ test_simple_substitution :: proc(t: ^testing.T) {
 	data := map[string]string {
 		"name" = "World",
 	}
-	result, err := mustache.render("Hello, {{name}}!", data)
+	tpl, _ := mustache.parse("Hello, {{name}}!")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "Hello, World!")
 }
@@ -20,7 +21,8 @@ test_bool_section :: proc(t: ^testing.T) {
 	data := map[string]bool {
 		"show" = true,
 	}
-	result, err := mustache.render("{{#show}}visible{{/show}}", data)
+	tpl, _ := mustache.parse("{{#show}}visible{{/show}}")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "visible")
 }
@@ -30,7 +32,8 @@ test_inverted_section :: proc(t: ^testing.T) {
 	data := map[string]bool {
 		"show" = false,
 	}
-	result, err := mustache.render("{{^show}}hidden{{/show}}", data)
+	tpl, _ := mustache.parse("{{^show}}hidden{{/show}}")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "hidden")
 }
@@ -40,7 +43,8 @@ test_unescaped :: proc(t: ^testing.T) {
 	data := map[string]string {
 		"html" = "<b>bold</b>",
 	}
-	result, err := mustache.render("{{{html}}}", data)
+	tpl, _ := mustache.parse("{{{html}}}")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "<b>bold</b>")
 }
@@ -55,7 +59,8 @@ test_array_iteration :: proc(t: ^testing.T) {
 	data := map[string][dynamic]map[string]string {
 		"items" = items,
 	}
-	result, err := mustache.render("{{#items}}{{name}} {{/items}}", data)
+	tpl, _ := mustache.parse("{{#items}}{{name}} {{/items}}")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "Alice Bob ")
 }
@@ -65,10 +70,12 @@ test_partial :: proc(t: ^testing.T) {
 	data := map[string]string {
 		"name" = "Test",
 	}
-	partials := map[string]string {
-		"greeting" = "Hello, {{name}}!",
+	greeting_tpl, _ := mustache.parse("Hello, {{name}}!")
+	partials := map[string]mustache.Template {
+		"greeting" = greeting_tpl,
 	}
-	result, err := mustache.render("{{>greeting}}", data, partials)
+	main_tpl, _ := mustache.parse("{{>greeting}}")
+	result, err := mustache.render(main_tpl, data, partials)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "Hello, Test!")
 }
@@ -81,7 +88,8 @@ test_mixed_types :: proc(t: ^testing.T) {
 		"date"       = "17 Jul 2025",
 	}
 
-	result, err := mustache.render("{{site_title}}: {{#has_date}}{{date}}{{/has_date}}", data)
+	tpl, _ := mustache.parse("{{site_title}}: {{#has_date}}{{date}}{{/has_date}}")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "One Idiot Developer: 17 Jul 2025")
 }
@@ -96,19 +104,8 @@ test_nested_context :: proc(t: ^testing.T) {
 		"page"       = page,
 	}
 
-	result, err := mustache.render("{{site_title}}: {{#page}}{{title}}{{/page}}", data)
+	tpl, _ := mustache.parse("{{site_title}}: {{#page}}{{title}}{{/page}}")
+	result, err := mustache.render(tpl, data)
 	testing.expect(t, err == nil)
 	testing.expect(t, result == "One Idiot Developer: My Post")
 }
-
-@(test)
-test_layout :: proc(t: ^testing.T) {
-	layout := `<html><body>{{{content}}}</body></html>`
-	template := "<p>Hello!</p>"
-	data := map[string]string{}
-
-	result, err := mustache.render_in_layout(template, data, layout)
-	testing.expect(t, err == nil)
-	testing.expect(t, result == "<html><body><p>Hello!</p></body></html>")
-}
-
diff --git a/render.odin b/render.odin
index 7ccc825..dfe9b7d 100644
--- a/render.odin
+++ b/render.odin
@@ -5,6 +5,7 @@ import "mustache"
 
 import "core:encoding/json"
 import "core:fmt"
+import "core:log"
 import "core:os"
 import "core:strings"
 import "core:time"
@@ -103,18 +104,22 @@ og_type :: proc(is_article: bool) -> string {
 	return "website"
 }
 
-load_template :: proc(layouts_dir: string, name: string) -> string {
+load_template :: proc(layouts_dir: string, name: string) -> mustache.Template {
 	data, _ := os.read_entire_file_from_path(
 		fmt.tprintf("%s/%s", layouts_dir, name),
 		context.allocator,
 	)
-	return string(data)
+	tpl, err := mustache.parse(string(data))
+	if err != nil {
+		log.warnf("thor: failed to parse template %s: %v", name, err)
+	}
+	return tpl
 }
 
 render_template :: proc(
-	content_tpl: string,
+	content_tpl: mustache.Template,
 	data: any,
-	partials: map[string]string,
+	partials: map[string]mustache.Template,
 ) -> string {
 	result, err := mustache.render(content_tpl, data, partials)
 	if err != nil {
@@ -211,8 +216,8 @@ render_site :: proc(pages: []Page, config: Site) {
 render_page_html :: proc(
 	page: Page,
 	config: Site,
-	content_tpl: string,
-	partials: map[string]string,
+	content_tpl: mustache.Template,
+	partials: map[string]mustache.Template,
 	base: Base_Data,
 ) -> string {
 	is_article := page.type == .Post
@@ -239,8 +244,8 @@ render_home_html :: proc(
 	home: Page,
 	pages: []Page,
 	config: Site,
-	content_tpl: string,
-	partials: map[string]string,
+	content_tpl: mustache.Template,
+	partials: map[string]mustache.Template,
 	base: Base_Data,
 ) -> string {
 	list_pages := make([dynamic]Page_Context)
@@ -268,8 +273,8 @@ render_home_html :: proc(
 render_posts_html :: proc(
 	pages: []Page,
 	config: Site,
-	content_tpl: string,
-	partials: map[string]string,
+	content_tpl: mustache.Template,
+	partials: map[string]mustache.Template,
 	base: Base_Data,
 ) -> string {
 	year_sections := make([dynamic]Year_Section)
@@ -299,15 +304,15 @@ render_posts_html :: proc(
 	return render_template(content_tpl, data, partials)
 }
 
-load_partials :: proc(layouts_dir: string) -> map[string]string {
-	partials: map[string]string
+load_partials :: proc(layouts_dir: string) -> map[string]mustache.Template {
+	partials: map[string]mustache.Template
 	partials_dir := fmt.tprintf("%s/partials", layouts_dir)
 	load_partials_recursive(&partials, partials_dir, "")
 	return partials
 }
 
 load_partials_recursive :: proc(
-	partials: ^map[string]string,
+	partials: ^map[string]mustache.Template,
 	base_dir: string,
 	rel_prefix: string,
 ) {
@@ -331,7 +336,11 @@ load_partials_recursive :: proc(
 			}
 			data, ok := os.read_entire_file_from_path(entry.fullpath, context.allocator)
 			if ok == nil {
-				partials[key] = string(data)
+				tpl, perr := mustache.parse(string(data))
+				if perr != nil {
+					log.warnf("thor: failed to parse partial %s: %v", key, perr)
+				}
+				partials[key] = tpl
 			}
 		case .Directory:
 			sub_prefix := entry.name