bump version to v3.0.0.rc1

2026-10-02 00:25:12 -07:00 · 2014-07-24 15:04:39 +00:00
197 changed files with 4018 additions and 18422 deletions
@@ -1,22 +0,0 @@
-name: Contributor License Agreement (CLA)
-
-on:
-  pull_request_target:
-    types: [opened, synchronize]
-  issue_comment:
-    types: [created]
-
-jobs:
-  cla:
-    runs-on: ubuntu-latest
-    if: |
-      (github.event.issue.pull_request 
-        && !github.event.issue.pull_request.merged_at
-        && contains(github.event.comment.body, 'signed')
-      ) 
-      || (github.event.pull_request && !github.event.pull_request.merged)
-    steps:
-      - uses: Shopify/shopify-cla-action@v1
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          cla-token: ${{ secrets.CLA_TOKEN }}
@@ -1,52 +0,0 @@
-name: Liquid
-on: [push, pull_request]
-
-env:
-  BUNDLE_JOBS: 4
-  BUNDLE_RETRY: 3
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        entry:
-          - { ruby: 3.0, allowed-failure: false } # minimum supported
-          - { ruby: 3.2, allowed-failure: false }
-          - { ruby: 3.3, allowed-failure: false }
-          - { ruby: 3.3, allowed-failure: false }
-          - { ruby: 3.4, allowed-failure: false } # latest
-          - {
-              ruby: 3.4,
-              allowed-failure: false,
-              rubyopt: "--enable-frozen-string-literal",
-            }
-          - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
-          - { ruby: ruby-head, allowed-failure: false }
-          - {
-              ruby: ruby-head,
-              allowed-failure: false,
-              rubyopt: "--enable-frozen-string-literal",
-            }
-          - { ruby: ruby-head, allowed-failure: false, rubyopt: "--yjit" }
-    name: Test Ruby ${{ matrix.entry.ruby }}
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.entry.ruby }}
-          bundler-cache: true
-          bundler: latest
-      - run: bundle exec rake
-        continue-on-error: ${{ matrix.entry.allowed-failure }}
-        env:
-          RUBYOPT: ${{ matrix.entry.rubyopt }}
-
-  memory_profile:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: ruby/setup-ruby@v1
-        with:
-          bundler-cache: true
-      - run: bundle exec rake memory_profile:run
@@ -4,6 +4,5 @@
 pkg
 *.rbc
 .rvmrc
-.bundle
-.byebug_history
+.ruby-version
 Gemfile.lock
@@ -1,28 +0,0 @@
-inherit_gem:
-  rubocop-shopify: rubocop.yml
-
-inherit_from:
-  - .rubocop_todo.yml
-
-require: rubocop-performance
-
-Performance:
-  Enabled: true
-
-AllCops:
-  NewCops: disable
-  SuggestExtensions: false
-  Exclude:
-    - 'vendor/bundle/**/*'
-
-Naming/MethodName:
-  Exclude:
-    - 'example/server/liquid_servlet.rb'
-
-Style/ClassMethodsDefinitions:
-  Enabled: false
-
-# liquid filter calls were being mistaken to be calls on arrays
-Style/ConcatArrayLiterals:
-  Exclude:
-    - 'test/integration/standard_filter_test.rb'
@@ -1,180 +0,0 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2022-05-18 19:25:47 UTC using RuboCop version 1.29.1.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.
-
-# Offense count: 1
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: TreatCommentsAsGroupSeparators, ConsiderPunctuation, Include.
-# Include: **/*.gemspec
-Gemspec/OrderedDependencies:
-  Exclude:
-    - 'liquid.gemspec'
-
-# Offense count: 6
-# This cop supports safe auto-correction (--auto-correct).
-Layout/ClosingHeredocIndentation:
-  Exclude:
-    - 'test/integration/tags/for_tag_test.rb'
-
-# Offense count: 34
-# This cop supports safe auto-correction (--auto-correct).
-Layout/EmptyLineAfterGuardClause:
-  Exclude:
-    - 'lib/liquid/block.rb'
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/context.rb'
-    - 'lib/liquid/drop.rb'
-    - 'lib/liquid/lexer.rb'
-    - 'lib/liquid/parser.rb'
-    - 'lib/liquid/profiler/hooks.rb'
-    - 'lib/liquid/standardfilters.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/utils.rb'
-    - 'lib/liquid/variable.rb'
-    - 'lib/liquid/variable_lookup.rb'
-    - 'performance/shopify/money_filter.rb'
-    - 'performance/shopify/paginate.rb'
-
-# Offense count: 8
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: AllowAliasSyntax, AllowedMethods.
-# AllowedMethods: alias_method, public, protected, private
-Layout/EmptyLinesAroundAttributeAccessor:
-  Exclude:
-    - 'lib/liquid/template.rb'
-    - 'test/integration/filter_test.rb'
-    - 'test/integration/tags/include_tag_test.rb'
-    - 'test/unit/strainer_template_unit_test.rb'
-
-# Offense count: 17
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: aligned, indented
-Layout/LineEndStringConcatenationIndentation:
-  Exclude:
-    - 'test/integration/tags/for_tag_test.rb'
-    - 'test/integration/tags/increment_tag_test.rb'
-
-# Offense count: 1
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyle, IndentationWidth.
-# SupportedStyles: aligned, indented
-Layout/MultilineOperationIndentation:
-  Exclude:
-    - 'lib/liquid/expression.rb'
-
-# Offense count: 9
-Lint/MissingSuper:
-  Exclude:
-    - 'lib/liquid/forloop_drop.rb'
-    - 'lib/liquid/tablerowloop_drop.rb'
-    - 'test/integration/assign_test.rb'
-    - 'test/integration/context_test.rb'
-    - 'test/integration/filter_test.rb'
-    - 'test/integration/standard_filter_test.rb'
-    - 'test/integration/tags/for_tag_test.rb'
-    - 'test/integration/tags/table_row_test.rb'
-
-# Offense count: 44
-Naming/ConstantName:
-  Exclude:
-    - 'lib/liquid.rb'
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/tags/assign.rb'
-    - 'lib/liquid/tags/capture.rb'
-    - 'lib/liquid/tags/case.rb'
-    - 'lib/liquid/tags/cycle.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/tags/table_row.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/shopify/comment_form.rb'
-    - 'performance/shopify/paginate.rb'
-    - 'test/integration/tags/include_tag_test.rb'
-
-# Offense count: 9
-# Configuration parameters: CheckIdentifiers, CheckConstants, CheckVariables, CheckStrings, CheckSymbols, CheckComments, CheckFilepaths, FlaggedTerms.
-Naming/InclusiveLanguage:
-  Exclude:
-    - 'lib/liquid/drop.rb'
-    - 'lib/liquid/parse_context.rb'
-    - 'test/integration/drop_test.rb'
-    - 'test/integration/tags/if_else_tag_test.rb'
-
-# Offense count: 2
-Style/ClassVars:
-  Exclude:
-    - 'lib/liquid/condition.rb'
-
-# Offense count: 3
-# This cop supports safe auto-correction (--auto-correct).
-Style/ExplicitBlockArgument:
-  Exclude:
-    - 'test/integration/context_test.rb'
-    - 'test/integration/tag/disableable_test.rb'
-    - 'test/integration/tags/for_tag_test.rb'
-
-# Offense count: 2982
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyle, ConsistentQuotesInMultiline.
-# SupportedStyles: single_quotes, double_quotes
-Style/StringLiterals:
-  Enabled: false
-
-# Offense count: 20
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: single_quotes, double_quotes
-Style/StringLiteralsInInterpolation:
-  Exclude:
-    - 'lib/liquid/condition.rb'
-    - 'lib/liquid/strainer_template.rb'
-    - 'lib/liquid/tag/disableable.rb'
-    - 'performance/shopify/shop_filter.rb'
-    - 'performance/shopify/tag_filter.rb'
-
-# Offense count: 6
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyleForMultiline.
-# SupportedStylesForMultiline: comma, consistent_comma, no_comma
-Style/TrailingCommaInArrayLiteral:
-  Exclude:
-    - 'example/server/example_servlet.rb'
-    - 'lib/liquid/condition.rb'
-    - 'test/integration/context_test.rb'
-    - 'test/integration/standard_filter_test.rb'
-    - 'test/unit/parse_tree_visitor_test.rb'
-
-# Offense count: 1
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyleForMultiline.
-# SupportedStylesForMultiline: comma, consistent_comma, no_comma
-Style/TrailingCommaInHashLiteral:
-  Exclude:
-    - 'lib/liquid/expression.rb'
-
-# Offense count: 19
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: EnforcedStyle, MinSize, WordRegex.
-# SupportedStyles: percent, brackets
-Style/WordArray:
-  Exclude:
-    - 'lib/liquid/tags/if.rb'
-    - 'liquid.gemspec'
-    - 'test/integration/assign_test.rb'
-    - 'test/integration/context_test.rb'
-    - 'test/integration/drop_test.rb'
-    - 'test/integration/standard_filter_test.rb'
-
-# Offense count: 117
-# This cop supports safe auto-correction (--auto-correct).
-# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns, IgnoredPatterns.
-# URISchemes: http, https
-Layout/LineLength:
-  Max: 260
@@ -1 +0,0 @@
-3.4.1
@@ -0,0 +1,16 @@
+rvm:
+  - 1.9
+  - 2.0
+  - 2.1
+  - jruby-19mode
+  - jruby-head
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: rbx-2
+    - rvm: jruby-head
+
+script: "rake test"
+
+notifications:
+  disable: true
@@ -4,33 +4,23 @@

 * Bugfixes
 * Performance improvements
-* Features that are likely to be useful to the majority of Liquid users
-* Documentation updates that are concise and likely to be useful to the majority of Liquid users
+* Features which are likely to be useful to the majority of Liquid users

 ## Things we won't merge

-* Code that introduces considerable performance degrations
-* Code that touches performance-critical parts of Liquid and comes without benchmarks
-* Features that are not important for most people (we want to keep the core Liquid code small and tidy)
-* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
-* Code that breaks existing tests
-* Documentation changes that are verbose, incorrect or not important to most people (we want to keep it simple and easy to understand)
+* Code which introduces considerable performance degrations
+* Code which touches performance critical parts of Liquid and comes without benchmarks
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Code which comes without tests
+* Code which breaks existing tests

 ## Workflow

-* [Sign the CLA](https://cla.shopify.com/) if you haven't already
 * Fork the Liquid repository
 * Create a new branch in your fork
-  * For updating [Liquid documentation](https://shopify.github.io/liquid/), create it from `gh-pages` branch. (You can skip tests.)
-* If it makes sense, add tests for your code and/or run a performance benchmark
-* Make sure all tests pass (`bundle exec rake`)
+* If it makes sense, add tests for your code and run a performance benchmark
+* Make sure all tests pass
 * Create a pull request
-
-## Releasing
-
-* Bump the version in `lib/liquid/version.rb`
-* Update the `History.md` file
-* Open a PR like [this one](https://github.com/Shopify/liquid/pull/1894) and merge it to `main`
-* Create a new release using the [GitHub UI](https://github.com/Shopify/liquid/releases/new)
+* In the description, ping one of [@boourns](https://github.com/boourns), [@fw42](https://github.com/fw42), [@camilo](https://github.com/camilo), [@dylanahsmith](https://github.com/dylanahsmith), or [@arthurnn](https://github.com/arthurnn) and ask for a code review.

@@ -1,31 +1,8 @@
-# frozen_string_literal: true
-
 source 'https://rubygems.org'
-git_source(:github) do |repo_name|
-  "https://github.com/#{repo_name}.git"
-end

 gemspec
-
-gem "base64"
-
-group :benchmark, :test do
-  gem 'benchmark-ips'
-  gem 'memory_profiler'
-  gem 'terminal-table'
-  gem "lru_redux"
-
-  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
-    gem 'stackprof'
-  end
-end
-
-group :development do
-  gem "webrick"
-end
+gem 'stackprof', platforms: :mri_21

 group :test do
-  gem 'rubocop', '~> 1.61.0'
-  gem 'rubocop-shopify', '~> 2.12.0', require: false
-  gem 'rubocop-performance', require: false
+  gem 'spy', '0.4.1'
 end
@@ -1,334 +1,42 @@
-# Liquid Change Log
-
-## 5.8.1 (unreleased)
-
-## 5.8.1
-
-* Fix `{% doc %}` tag to be visitable [Guilherme Carreiro]
-
-## 5.8.0
-
-* Introduce the new `{% doc %}` tag [Guilherme Carreiro]
-
-## 5.7.3
-
-* Raise Liquid::SyntaxError when parsing invalidly encoded strings [Chris AtLee]
-
-## 5.7.2 2025-01-31
-
-* Fix array filters to not support nested properties [Guilherme Carreiro]
-
-## 5.7.1 2025-01-24
-
-* Fix the `find` and `find_index`filters to return `nil` when filtering empty arrays [Guilherme Carreiro]
-* Fix the `has` filter to return `false` when filtering empty arrays [Guilherme Carreiro]
-
-## 5.7.0 2025-01-16
-
-### Features
-
-* Add `find`, `find_index`, `has`, and `reject` filters to arrays [Guilherme Carreiro]
-* Compatibility with Ruby 3.4 [Ian Ker-Seymer]
-
-## 5.6.4 2025-01-14
-
-### Fixes
-* Add a default `string_scanner` to avoid errors with `Liquid::VariableLookup.parse("foo.bar")` [Ian Ker-Seymer]
-
-## 5.6.3 2025-01-13
-* Remove `lru_redux` dependency [Michael Go]
-
-## 5.6.2 2025-01-13
-
-### Fixes
-* Preserve the old behavior of requiring floats to start with a digit [Michael Go]
-
-## 5.6.1 2025-01-13
-
-### Performance improvements
-* Faster Expression parser / Tokenizer with StringScanner [Michael Go]
-
-## 5.6.0 2024-12-19
-
-### Architectural changes
-* Added new `Environment` class to manage configuration and state that was previously stored in `Template` [Ian Ker-Seymer]
-* Moved tag registration from `Template` to `Environment` [Ian Ker-Seymer]
-* Removed `StrainerFactory` in favor of `Environment`-based strainer creation [Ian Ker-Seymer]
-* Consolidated standard tags into a new `Tags` module with `STANDARD_TAGS` constant [Ian Ker-Seymer]
-
-### Performance improvements
-* Optimized `Lexer` with a new `Lexer2` implementation using jump tables for faster tokenization, requires Ruby 3.4 [Ian Ker-Seymer]
-* Improved variable rendering with specialized handling for different types [Michael Go]
-* Reduced array allocations by using frozen empty constants [Michael Go]
-
-### API changes
-* Deprecated several `Template` class methods in favor of `Environment` methods [Ian Ker-Seymer]
-* Added deprecation warnings system [Ian Ker-Seymer]
-* Changed how filters and tags are registered to use Environment [Ian Ker-Seymer]
-
-### Fixes
-* Fixed table row handling of break interrupts [Alex Coco]
-* Improved variable output handling for arrays [Ian Ker-Seymer]
-* Fix Tokenizer to handle null source value (#1873) [Bahar Pourazar]
-
-## 5.5.0 2024-03-21
-
-Please reference the GitHub release for more information.
-
-## 5.4.0 2022-07-29
-
-### Breaking Changes
-* Drop support for end-of-life Ruby versions (2.5 and 2.6) (#1578) [Andy Waite]
-
-### Features
-* Allow `#` to be used as an inline comment tag (#1498) [CP Clermont]
-
-### Fixes
-* `PartialCache` now shares snippet cache with subcontexts by default (#1553) [Chris AtLee]
-* Hash registers no longer leak into subcontexts as static registers (#1564) [Chris AtLee]
-* Fix `ParseTreeVisitor` for `with` variable expressions in `Render` tag (#1596) [CP Clermont]
-
-### Changed
-* Liquid::Context#registers now always returns a Liquid::Registers object, though supports the most used Hash functions for compatibility (#1553)
-
-## 5.3.0 2022-03-22
-
-### Fixes
-* StandardFilter: Fix missing @context on iterations (#1525) [Thierry Joyal]
-* Fix warning about block and default value in `static_registers.rb` (#1531) [Peter Zhu]
-
-### Deprecation
-* Condition#evaluate to require mandatory context argument in Liquid 6.0.0 (#1527) [Thierry Joyal]
-
-## 5.2.0 2022-03-01
-
-### Features
-* Add `remove_last`, and `replace_last` filters (#1422) [Anders Hagbard]
-* Eagerly cache global filters (#1524) [Jean Boussier]
-
-### Fixes
-* Fix some internal errors in filters from invalid input (#1476) [Dylan Thacker-Smith]
-* Allow dash in filter kwarg name for consistency with Liquid::C (#1518) [CP Clermont]
-
-## 5.1.0 / 2021-09-09
-
-### Features
-* Add `base64_encode`, `base64_decode`, `base64_url_safe_encode`, and `base64_url_safe_decode` filters (#1450) [Daniel Insley]
-* Introduce `to_liquid_value` in `Liquid::Drop` (#1441) [Michael Go]
-
-### Fixes
-* Fix support for using a String subclass for the liquid source (#1421) [Dylan Thacker-Smith]
-* Add `ParseTreeVisitor` to `RangeLookup` (#1470) [CP Clermont]
-* Translate `RangeError` to `Liquid::Error` for `truncatewords` with large int (#1431) [Dylan Thacker-Smith]
-
-## 5.0.1 / 2021-03-24
-
-### Fixes
-* Add ParseTreeVisitor to Echo tag (#1414) [CP Clermont]
-* Test with ruby 3.0 as the latest ruby version (#1398) [Dylan Thacker-Smith]
-* Handle carriage return in newlines_to_br (#1391) [Unending]
-
-### Performance Improvements
-* Use split limit in truncatewords (#1361) [Dylan Thacker-Smith]
-
-## 5.0.0 / 2021-01-06
-
-### Features
-* Add new `{% render %}` tag (#1122) [Samuel Doiron]
-* Add support for `as` in `{% render %}` and `{% include %}` (#1181) [Mike Angell]
-* Add `{% liquid %}` and `{% echo %}` tags (#1086) [Justin Li]
-* Add [usage tracking](README.md#usage-tracking) [Mike Angell]
-* Add `Tag.disable_tags` for disabling tags that prepend `Tag::Disableable` at render time (#1162, #1274, #1275) [Mike Angell]
-* Support using a profiler for multiple renders (#1365, #1366) [Dylan Thacker-Smith]
-
-### Fixes
-* Fix catastrophic backtracking in `RANGES_REGEX` regular expression (#1357) [Dylan Thacker-Smith]
-* Make sure the for tag's limit and offset are integers (#1094) [David Cornu]
-* Invokable methods for enumerable reject include (#1151) [Thierry Joyal]
-* Allow `default` filter to handle `false` as value (#1144) [Mike Angell]
-* Fix render length resource limit so it doesn't multiply nested output (#1285) [Dylan Thacker-Smith]
-* Fix duplication of text in raw tags (#1304) [Peter Zhu]
-* Fix strict parsing of find variable with a name expression (#1317) [Dylan Thacker-Smith]
-* Use monotonic time to measure durations in Liquid::Profiler (#1362) [Dylan Thacker-Smith]
-
-### Breaking Changes
-* Require Ruby >= 2.5 (#1131, #1310) [Mike Angell, Dylan Thacker-Smith]
-* Remove support for taint checking (#1268) [Dylan Thacker-Smith]
-* Split Strainer class into StrainerFactory and StrainerTemplate (#1208) [Thierry Joyal]
-* Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
-* Handle `BlockBody#blank?` at parse time (#1287) [Dylan Thacker-Smith]
-* Pass the tag markup and tokenizer to `Document#unknown_tag` (#1290) [Dylan Thacker-Smith]
-* And several internal changes
-
-### Performance Improvements
-* Reduce allocations (#1073, #1091, #1115, #1099, #1117, #1141, #1322, #1341) [Richard Monette, Florian Weingarten, Ashwin Maroli]
-* Improve resources limits performance (#1093, #1323) [Florian Weingarten, Dylan Thacker-Smith]
-
-## 4.0.3 / 2019-03-12
-
-### Fixed
-* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
-
-## 4.0.2 / 2019-03-08
-
-### Changed
-* Add `where` filter (#1026) [Samuel Doiron]
-* Add `ParseTreeVisitor` to iterate the Liquid AST (#1025) [Stephen Paul Weber]
-* Improve `strip_html` performance (#1032) [printercu]
-
-### Fixed
-* Add error checking for invalid combinations of inputs to sort, sort_natural, where, uniq, map, compact filters (#1059) [Garland Zhang]
-* Validate the character encoding in url_decode (#1070) [Clayton Smith]
-
-## 4.0.1 / 2018-10-09
-
-### Changed
-* Add benchmark group in Gemfile (#855) [Jerry Liu]
-* Allow benchmarks to benchmark render by itself (#851) [Jerry Liu]
-* Avoid calling `line_number` on String node when rescuing a render error. (#860) [Dylan Thacker-Smith]
-* Avoid duck typing to detect whether to call render on a node. [Dylan Thacker-Smith]
-* Clarify spelling of `reversed` on `for` block tag (#843) [Mark Crossfield]
-* Replace recursion with loop to avoid potential stack overflow from malicious input (#891, #892) [Dylan Thacker-Smith]
-* Limit block tag nesting to 100 (#894) [Dylan Thacker-Smith]
-* Replace `assert_equal nil` with `assert_nil` (#895) [Dylan Thacker-Smith]
-* Remove Spy Gem (#896) [Dylan Thacker-Smith]
-* Add `collection_name` and `variable_name` reader to `For` block (#909)
-* Symbols render as strings (#920) [Justin Li]
-* Remove default value from Hash objects (#932) [Maxime Bedard]
-* Remove one level of nesting (#944) [Dylan Thacker-Smith]
-* Update Rubocop version (#952) [Justin Li]
-* Add `at_least` and `at_most` filters (#954, #958) [Nithin Bekal]
-* Add a regression test for a liquid-c trim mode bug (#972) [Dylan Thacker-Smith]
-* Use https rather than git protocol to fetch liquid-c [Dylan Thacker-Smith]
-* Add tests against Ruby 2.4 (#963) and 2.5 (#981)
-* Replace RegExp literals with constants (#988) [Ashwin Maroli]
-* Replace unnecessary `#each_with_index` with `#each` (#992) [Ashwin Maroli]
-* Improve the unexpected end delimiter message for block tags. (#1003) [Dylan Thacker-Smith]
-* Refactor and optimize rendering (#1005) [Christopher Aue]
-* Add installation instruction (#1006) [Ben Gift]
-* Remove Circle CI (#1010)
-* Rename deprecated `BigDecimal.new` to `BigDecimal` (#1024) [Koichi ITO]
-* Rename deprecated Rubocop name (#1027) [Justin Li]
-
-### Fixed
-* Handle `join` filter on non String joiners (#857) [Richard Monette]
-* Fix duplicate inclusion condition logic error of `Liquid::Strainer.add_filter` method (#861)
-* Fix `escape`, `url_encode`, `url_decode` not handling non-string values (#898) [Thierry Joyal]
-* Fix raise when variable is defined but nil when using `strict_variables` [Pascal Betz]
-* Fix `sort` and `sort_natural` to handle arrays with nils (#930) [Eric Chan]
-
-## 4.0.0 / 2016-12-14 / branch "4-0-stable"
-
-### Changed
-* Render an opaque internal error by default for non-Liquid::Error (#835) [Dylan Thacker-Smith]
-* Ruby 2.0 support dropped (#832) [Dylan Thacker-Smith]
-* Add to_number Drop method to allow custom drops to work with number filters (#731)
-* Add strict_variables and strict_filters options to detect undefined references (#691)
-* Improve loop performance (#681) [Florian Weingarten]
-* Rename Drop method `before_method` to `liquid_method_missing` (#661) [Thierry Joyal]
-* Add url_decode filter to invert url_encode (#645) [Larry Archer]
-* Add global_filter to apply a filter to all output (#610) [Loren Hale]
-* Add compact filter (#600) [Carson Reinke]
-* Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
-* Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
-* Add sort_natural filter (#554) [Martin Hanzel]
-* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li]
-* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith]
-* Add concat filter to concatenate arrays (#429) [Diogo Beato]
-* Ruby 1.9 support dropped (#491) [Justin Li]
-* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
-* Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
-* Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
-
-### Fixed
-
-* Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
-* Fix include tag used with strict_variables (#828) [QuickPay]
-* Fix map filter when value is a Proc (#672) [Guillaume Malette]
-* Fix truncate filter when value is not a string (#672) [Guillaume Malette]
-* Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]
-* Fix sort filter behaviour with empty array input (#652) [Marcel Cary]
-* Fix test failure under certain timezones (#631) [Dylan Thacker-Smith]
-* Fix bug in uniq filter (#595) [Florian Weingarten]
-* Fix bug when "blank" and "empty" are used as variable names (#592) [Florian Weingarten]
-* Fix condition parse order in strict mode (#569) [Justin Li]
-* Fix naming of the "context variable" when dynamically including a template (#559) [Justin Li]
-* Gracefully accept empty strings in the date filter (#555) [Loren Hale]
-* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten]
-* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds]
-* Disallow filters with no variable in strict mode (#475) [Justin Li]
-* Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li]
-* Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li]
-
-## 3.0.5 / 2015-07-23 / branch "3-0-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 3.0.4 / 2015-07-17
-
-* Fix chained access to multi-dimensional hashes [Florian Weingarten]
-
-## 3.0.3 / 2015-05-28
-
-* Fix condition parse order in strict mode (#569) [Justin Li]
-
-## 3.0.2 / 2015-04-24
-
-* Expose VariableLookup private members (#551) [Justin Li]
-* Documentation fixes
-
-## 3.0.1 / 2015-01-23
-
-* Remove duplicate `index0` key in TableRow tag (#502) [Alfred Xing]
-
-## 3.0.0 / 2014-11-12
-
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith]
-* Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer]
-* Add uniq to standard filters [Florian Weingarten]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, Florian Weingarten]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge]
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten]
-* Remove ActionView template handler [Dylan Thacker-Smith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten]
-* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith]
-* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev]
-* Add a to_s default for liquid drops (#306) [Adam Doeler]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten]
-* Add default filter to standard filters (#267) [Derrick Reimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume]
-* Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten]
-
-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 2.6.2 / 2015-01-23
-
-* Remove duplicate hash key [Parker Moore]
-
-## 2.6.1 / 2014-01-10
+# Liquid Version History
+
+## 3.0.0 / not yet released / branch "master"
+
+* ...
+* Add exception_handler feature, see #397 and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
+* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
+* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
+* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
+* Fix broken rendering of variables which are equal to false, see #345 [Florian Weingarten, fw42]
+* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
+* Freeze lots of string literals for new Ruby 2.1 optimization, see #297 [Florian Weingarten, fw42]
+* Allow newlines in tags and variables, see #324 [Dylan Thacker-Smith, dylanahsmith]
+* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
+* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
+* Add a to_s default for liquid drops, see #306 [Adam Doeler, releod]
+* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
+* Make if, for & case tags return complete and consistent nodelists, see #250 [Nick Jones, dntj]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Fix resource counting bug with respond_to?(:length), see #263 [Florian Weingarten, fw42]
+* Allow specifying custom patterns for template filenames, see #284 [Andrei Gladkyi, agladkyi]
+* Allow drops to optimize loading a slice of elements, see #282 [Tom Burns, boourns]
+* Support for passing variables to snippets in subdirs, see #271 [Joost Hietbrink, joost]
+* Add a class cache to avoid runtime extend calls, see #249 [James Tucker, raggi]
+* Remove some legacy Ruby 1.8 compatibility code, see #276 [Florian Weingarten, fw42]
+* Add default filter to standard filters, see #267 [Derrick Reimer, djreimer]
+* Add optional strict parsing and warn parsing, see #235 [Tristan Hume, trishume]
+* Add I18n syntax error translation, see #241 [Simon Hørup Eskildsen, Sirupsen]
+* Make sort filter work on enumerable drops, see #239 [Florian Weingarten, fw42]
+* Fix clashing method names in enumerable drops, see #238 [Florian Weingarten, fw42]
+* Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
+* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
+
+## 2.6.1 / 2014-01-10 / branch "2-6-stable"

 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]

 ## 2.6.0 / 2013-11-25

@@ -336,37 +44,37 @@ IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains
 The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.

 * Bugfix for #106: fix example servlet [gnowoel]
-* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
-* Resource limits [Florian Weingarten]
-* Add reverse filter [Jay Strybis]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
+* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
+* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup, ndwebgroup]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
+* Resource limits [Florian Weingarten, fw42]
+* Add reverse filter [Jay Strybis, unreal]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
-* Cache tokenized partial templates [Tom Burns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
+* Cache tokenized partial templates [Tom Burns, boourns]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
+* Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
+* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]

 ## 2.5.5 / 2014-01-10 / branch "2-5-stable"

 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]

 ## 2.5.4 / 2013-11-11

-* Fix "can't convert Fixnum into String" for "replace" (#173), [jsw0528]
+* Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]

 ## 2.5.3 / 2013-10-09

-* #232, #234, #237: Fix map filter bugs [Florian Weingarten]
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]

 ## 2.5.2 / 2013-09-03 / deleted

@@ -374,7 +82,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.

 ## 2.5.1 / 2013-07-24

-* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten]
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten, fw42]

 ## 2.5.0 / 2013-03-06

@@ -1,11 +1,11 @@
-[![Build status](https://github.com/Shopify/liquid/actions/workflows/liquid.yml/badge.svg)](https://github.com/Shopify/liquid/actions/workflows/liquid.yml)
-[![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![Inline docs](http://inch-ci.org/github/Shopify/liquid.png)](http://inch-ci.org/github/Shopify/liquid)

 # Liquid template engine

 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
-* [Liquid documentation from Shopify](https://shopify.dev/docs/api/liquid)
+* [Liquid documentation from Shopify](http://docs.shopify.com/themes/liquid-basics)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)

@@ -42,8 +42,6 @@ Liquid is a template engine which was written with very specific requirements:

 ## How to use Liquid

-Install Liquid by adding `gem 'liquid'` to your gemfile.
-
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.

@@ -52,105 +50,26 @@ For standard use you can just pass it the content of a file and call render with
@template.render('name' => 'tobi')                # => "hi tobi"
 ```

-### Concept of Environments
-
-In Liquid, a "Environment" is a scoped environment that encapsulates custom tags, filters, and other configurations. This allows you to define and isolate different sets of functionality for different contexts, avoiding global overrides that can lead to conflicts and unexpected behavior.
-
-By using environments, you can:
-
-1. **Encapsulate Logic**: Keep the logic for different parts of your application separate.
-2. **Avoid Conflicts**: Prevent custom tags and filters from clashing with each other.
-3. **Improve Maintainability**: Make it easier to manage and understand the scope of customizations.
-4. **Enhance Security**: Limit the availability of certain tags and filters to specific contexts.
-
-We encourage the use of Environments over globally overriding things because it promotes better software design principles such as modularity, encapsulation, and separation of concerns.
-
-Here's an example of how you can define and use Environments in Liquid:
-
-```ruby
-user_environment = Liquid::Environment.build do |environment|
-  environment.register_tag("renderobj", RenderObjTag)
-end
-
-Liquid::Template.parse(<<~LIQUID, environment: user_environment)
-  {% renderobj src: "path/to/model.obj" %}
-LIQUID
-```
-
-In this example, `RenderObjTag` is a custom tag that is only available within the `user_environment`.
-
-Similarly, you can define another environment for a different context, such as email templates:
-
-```ruby
-email_environment = Liquid::Environment.build do |environment|
-  environment.register_tag("unsubscribe_footer", UnsubscribeFooter)
-end
-
-Liquid::Template.parse(<<~LIQUID, environment: email_environment)
-  {% unsubscribe_footer %}
-LIQUID
-```
-
-By using Environments, you ensure that custom tags and filters are only available in the contexts where they are needed, making your Liquid templates more robust and easier to manage. For smaller projects, a global environment is available via `Liquid::Environment.default`.
-
 ### Error Modes

 Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
 Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour.
+it very hard to debug and can lead to unexpected behaviour. 

 Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
 when templates are invalid. You can enable this new parser like this:

 ```ruby
-Liquid::Environment.default.error_mode = :strict
-Liquid::Environment.default.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-Liquid::Environment.default.error_mode = :warn # Adds strict errors to template.errors but continues as normal
-Liquid::Environment.default.error_mode = :lax # The default mode, accepts almost anything.
+Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
+Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
+Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
 ```

 If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
 ```ruby
-Liquid::Template.parse(source, error_mode: :strict)
+Liquid::Template.parse(source, :error_mode => :strict)
 ```
 This is useful for doing things like enabling strict mode only in the theme editor.

 It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
 It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
-
-### Undefined variables and filters
-
-By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
-You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
-When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
-Here are some examples:
-
-```ruby
-template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
-template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
-#=> '1  2 ' # when a variable is undefined, it's rendered as nil
-template.errors
-#=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
-```
-
-```ruby
-template = Liquid::Template.parse("{{x | filter1 | upcase}}")
-template.render({ 'x' => 'foo' }, { strict_filters: true })
-#=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
-template.errors
-#=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
-```
-
-If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
-
-```ruby
-template = Liquid::Template.parse("{{x}} {{y}}")
-template.render!({ 'x' => 1}, { strict_variables: true })
-#=> Liquid::UndefinedVariable: Liquid error: undefined variable y
-```
-
-### Usage tracking
-
-To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
-
-Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.
@@ -1,68 +1,42 @@
-# frozen_string_literal: true
-
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"

-task(default: [:test, :rubocop])
+task :default => 'test'

-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
-  t.libs << 'lib' << 'test'
+  t.libs << '.' << 'lib' << 'test'
  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
-  t.verbose    = false
+  t.verbose = false
 end

-Rake::TestTask.new(:integration_test) do |t|
-  t.libs << 'lib' << 'test'
-  t.test_files = FileList['test/integration/**/*_test.rb']
-  t.verbose    = false
-end
-
-desc('run test suite with warn error mode')
+desc 'run test suite with warn error mode'
 task :warn_test do
  ENV['LIQUID_PARSER_MODE'] = 'warn'
  Rake::Task['base_test'].invoke
 end

-task :rubocop do
-  if RUBY_ENGINE == 'ruby'
-    require 'rubocop/rake_task'
-    RuboCop::RakeTask.new
-  end
-end
-
-desc('runs test suite with both strict and lax parsers')
+desc 'runs test suite with both strict and lax parsers'
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
-
  ENV['LIQUID_PARSER_MODE'] = 'strict'
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke
-
-  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
-    ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
-
-    ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['integration_test'].reenable
-    Rake::Task['integration_test'].invoke
-  end
 end

-task(gem: :build)
+task :gem => :build
 task :build do
  system "gem build liquid.gemspec"
 end

-task install: :build do
+task :install => :build do
  system "gem install liquid-#{Liquid::VERSION}.gem"
 end

-task release: :build do
+task :release => :build do
  system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
  system "git push --tags"
  system "gem push liquid-#{Liquid::VERSION}.gem"
@@ -70,8 +44,9 @@ task release: :build do
 end

 namespace :benchmark do
+
  desc "Run the liquid benchmark with lax parsing"
-  task :lax do
+  task :run do
    ruby "./performance/benchmark.rb lax"
  end

@@ -79,36 +54,11 @@ namespace :benchmark do
  task :strict do
    ruby "./performance/benchmark.rb strict"
  end
-
-  desc "Run the liquid benchmark with both lax and strict parsing"
-  task run: [:lax, :strict]
-
-  desc "Run unit benchmarks"
-  namespace :unit do
-    task :all do
-      Dir["./performance/unit/*_benchmark.rb"].each do |file|
-        puts "🧪 Running #{file}"
-        ruby file
-      end
-    end
-
-    task :lexer do
-      Dir["./performance/unit/lexer_benchmark.rb"].each do |file|
-        puts "🧪 Running #{file}"
-        ruby file
-      end
-    end
-
-    task :expression do
-      Dir["./performance/unit/expression_benchmark.rb"].each do |file|
-        puts "🧪 Running #{file}"
-        ruby file
-      end
-    end
-  end
 end

+
 namespace :profile do
+
  desc "Run the liquid profile/performance coverage"
  task :run do
    ruby "./performance/profile.rb"
@@ -118,20 +68,10 @@ namespace :profile do
  task :strict do
    ruby "./performance/profile.rb strict"
  end
+
 end

-namespace :memory_profile do
-  desc "Run memory profiler"
-  task :run do
-    ruby "./performance/memory_profile.rb"
-  end
-end
-
-desc("Run example")
+desc "Run example"
 task :example do
  ruby "-w -d -Ilib example/server/server.rb"
 end
-
-task :console do
-  exec 'irb -I lib -r liquid'
-end
@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 module ProductsFilter
  def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
  end

  def prettyprint(text)
-    text.gsub(/\*(.*)\*/, '<b>\1</b>')
+    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
  end

  def count(array)
@@ -19,32 +17,25 @@ module ProductsFilter
 end

 class Servlet < LiquidServlet
+
  def index
    { 'date' => Time.now }
  end

  def products
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
+    { 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
  end

  private

  def products_list
-    [
-      { 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-      { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
-      { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }
-    ]
-  end
-
-  def more_products_list
-    [
-      { 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-      { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }
-    ]
+    [{'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+    {'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling'},
+    {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
  end

  def description
    "List of Products ~ This is a list of products with price and description."
  end
+
 end
@@ -1,6 +1,5 @@
-# frozen_string_literal: true
-
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
+
  def do_GET(req, res)
    handle(:get, req, res)
  end
@@ -11,20 +10,19 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet

  private

-  def handle(_type, req, res)
-    @request  = req
-    @response = res
+  def handle(type, req, res)
+    @request, @response = req, res

    @request.path_info =~ /(\w+)\z/
-    @action  = Regexp.last_match(1) || 'index'
+    @action = $1 || 'index'
    @assigns = send(@action) if respond_to?(@action)

    @response['Content-Type'] = "text/html"
    @response.status = 200
-    @response.body   = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body = Liquid::Template.parse(read_template).render(@assigns, :filters => [ProductsFilter])
  end

  def read_template(filename = @action)
-    File.read("#{__dir__}/templates/#{filename}.liquid")
+    File.read( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
  end
 end
@@ -1,14 +1,14 @@
-# frozen_string_literal: true
-
 require 'webrick'
 require 'rexml/document'

-require_relative '../../lib/liquid'
-require_relative 'liquid_servlet'
-require_relative 'example_servlet'
+DIR = File.expand_path(File.dirname(__FILE__))
+
+require DIR + '/../../lib/liquid'
+require DIR + '/liquid_servlet'
+require DIR + '/example_servlet'

 # Setup webrick
-server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
+server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
 server.mount('/', Servlet)
-trap("INT") { server.shutdown }
+trap("INT"){ server.shutdown }
 server.start
@@ -16,12 +16,12 @@
  </head>

  <body>
-    {% assign all_products = products | concat: more_products  %}
+
    <h1>{{ description | split: '~' | first }}</h1>

    <h2>{{ description | split: '~' | last }}</h2>

-    <h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
+    <h2>There are currently {{products | count}} products in the {{section}} catalog</h2>

    {% if cool_products %}
      Cool products :)
@@ -31,7 +31,7 @@

    <ul id="products">

-      {% for product in all_products %}
+      {% for product in products %}
        <li>
          <h2>{{product.name}}</h2>
          Only {{product.price | price }}
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -21,17 +19,13 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

-require "strscan"
-
 module Liquid
  FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'
-  WhitespaceControl           = '-'
+  ArgumentSeparator           = ','.freeze
+  FilterArgumentSeparator     = ':'.freeze
+  VariableAttributeSeparator  = '.'.freeze
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
-  TagName                     = /#|\w+/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
  VariableSegment             = /[\w\-]/
  VariableStart               = /\{\{/
@@ -39,54 +33,37 @@ module Liquid
  VariableIncompleteEnd       = /\}\}?/
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  TagAttributes               = /(\w[\w-]*)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
+  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
+  AnyStartingTag              = /\{\{|\{\%/
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o

-  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
-  HAS_STRING_SCANNER_SCAN_BYTE = StringScanner.instance_methods.include?(:scan_byte)
+  singleton_class.send(:attr_accessor, :cache_classes)
+  self.cache_classes = true
 end

 require "liquid/version"
-require "liquid/deprecations"
-require "liquid/const"
-require 'liquid/standardfilters'
-require 'liquid/file_system'
-require 'liquid/parser_switching'
-require 'liquid/tag'
-require 'liquid/block'
-require 'liquid/parse_tree_visitor'
-require 'liquid/interrupts'
-require 'liquid/tags'
-require "liquid/environment"
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
 require 'liquid/drop'
-require 'liquid/tablerowloop_drop'
-require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer_template'
+require 'liquid/strainer'
 require 'liquid/context'
 require 'liquid/tag'
-require 'liquid/block_body'
+require 'liquid/block'
 require 'liquid/document'
 require 'liquid/variable'
-require 'liquid/variable_lookup'
-require 'liquid/range_lookup'
-require 'liquid/resource_limits'
-require 'liquid/expression'
+require 'liquid/file_system'
 require 'liquid/template'
+require 'liquid/standardfilters'
 require 'liquid/condition'
+require 'liquid/module_ex'
 require 'liquid/utils'
-require 'liquid/tokenizer'
-require 'liquid/parse_context'
-require 'liquid/partial_cache'
-require 'liquid/usage'
-require 'liquid/registers'
-require 'liquid/template_factory'
-require 'liquid/box'
+
+# Load all the tags of the standard library
+#
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
@@ -1,59 +1,94 @@
-# frozen_string_literal: true
-
 module Liquid
  class Block < Tag
-    MAX_DEPTH = 100
-
-    def initialize(tag_name, markup, options)
-      super
-      @blank = true
-    end
-
-    def parse(tokens)
-      @body = new_body
-      while parse_body(@body, tokens)
-      end
-      @body.freeze
-    end
-
-    # For backwards compatibility
-    def render(context)
-      @body.render(context)
-    end
+    FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze

    def blank?
      @blank
    end

-    def nodelist
-      @body.nodelist
-    end
+    def parse(tokens)
+      @blank = true
+      @nodelist ||= []
+      @nodelist.clear

-    def unknown_tag(tag_name, _markup, _tokenizer)
-      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
-    end
+      # All child tags of the current block.
+      @children = []

-    # @api private
-    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
-      if tag == 'else'
-        raise SyntaxError, parse_context.locale.t(
-          "errors.syntax.unexpected_else",
-          block_name: block_name,
-        )
-      elsif tag.start_with?('end')
-        raise SyntaxError, parse_context.locale.t(
-          "errors.syntax.invalid_delimiter",
-          tag: tag,
-          block_name: block_name,
-          block_delimiter: block_delimiter,
-        )
-      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
+      while token = tokens.shift
+        unless token.empty?
+          case
+          when token.start_with?(TAGSTART)
+            if token =~ FullToken
+
+              # if we found the proper block delimiter just end parsing here and let the outer block
+              # proceed
+              if block_delimiter == $1
+                end_tag
+                return
+              end
+
+              # fetch the tag from registered blocks
+              if tag = Template.tags[$1]
+                new_tag = tag.parse($1, $2, tokens, @options)
+                @blank &&= new_tag.blank?
+                @nodelist << new_tag
+                @children << new_tag
+              else
+                # this tag is not registered with the system
+                # pass it to the current block for special handling or error reporting
+                unknown_tag($1, $2, tokens)
+              end
+            else
+              raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
+            end
+          when token.start_with?(VARSTART)
+            new_var = create_variable(token)
+            @nodelist << new_var
+            @children << new_var
+            @blank = false
+          else
+            @nodelist << token
+            @blank &&= (token =~ /\A\s*\z/)
+          end
+        end
      end
+
+      # Make sure that it's ok to end parsing in the current block.
+      # Effectively this method will throw an exception unless the current block is
+      # of type Document
+      assert_missing_delimitation!
    end

-    def raise_tag_never_closed(block_name)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+    # warnings of this block and all sub-tags
+    def warnings
+      all_warnings = []
+      all_warnings.concat(@warnings) if @warnings
+
+      (@children || []).each do |node|
+        all_warnings.concat(node.warnings || [])
+      end
+
+      all_warnings
+    end
+
+    def end_tag
+    end
+
+    def unknown_tag(tag, params, tokens)
+      case tag
+      when 'else'.freeze
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
+                                                 :block_name => block_name))
+      when 'end'.freeze
+        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
+                                                 :block_name => block_name,
+                                                 :block_delimiter => block_delimiter))
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
+      end
    end

    def block_name
@@ -64,35 +99,58 @@ module Liquid
      @block_delimiter ||= "end#{block_name}"
    end

-    private
-
-    # @api public
-    def new_body
-      parse_context.new_block_body
+    def create_variable(token)
+      token.scan(ContentOfVariable) do |content|
+        return Variable.new(content.first, @options)
+      end
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
    end

-    # @api public
-    def parse_body(body, tokens)
-      if parse_context.depth >= MAX_DEPTH
-        raise StackLevelError, "Nesting too deep"
-      end
-      parse_context.depth += 1
-      begin
-        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
-          @blank &&= body.blank?
+    def render(context)
+      render_all(@nodelist, context)
+    end

-          return false if end_tag_name == block_delimiter
-          raise_tag_never_closed(block_name) unless end_tag_name
+    protected

-          # this tag is not registered with the system
-          # pass it to the current block for special handling or error reporting
-          unknown_tag(end_tag_name, end_tag_params, tokens)
+    def assert_missing_delimitation!
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+    end
+
+    def render_all(list, context)
+      output = []
+      context.resource_limits[:render_length_current] = 0
+      context.resource_limits[:render_score_current] += list.length
+
+      list.each do |token|
+        # Break out if we have any unhanded interrupts.
+        break if context.has_interrupt?
+
+        begin
+          # If we get an Interrupt that means the block must stop processing. An
+          # Interrupt is any command that stops block execution such as {% break %}
+          # or {% continue %}
+          if token.is_a? Continue or token.is_a? Break
+            context.push_interrupt(token.interrupt)
+            break
+          end
+
+          token_output = (token.respond_to?(:render) ? token.render(context) : token)
+          context.increment_used_resources(:render_length_current, token_output)
+          if context.resource_limits_reached?
+            context.resource_limits[:reached] = true
+            raise MemoryError.new("Memory limits exceeded".freeze)
+          end
+          unless token.is_a?(Block) && token.blank?
+            output << token_output
+          end
+        rescue MemoryError => e
+          raise e
+        rescue ::StandardError => e
+          output << (context.handle_error(e))
        end
-      ensure
-        parse_context.depth -= 1
      end

-      true
+      output.join
    end
  end
 end
@@ -1,273 +0,0 @@
-# frozen_string_literal: true
-
-require 'English'
-
-module Liquid
-  class BlockBody
-    LiquidTagToken      = /\A\s*(#{TagName})\s*(.*?)\z/o
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(#{TagName})(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*)?#{WhitespaceControl}?#{TagEnd}\z/om
-    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
-    WhitespaceOrNothing = /\A\s*\z/
-    TAGSTART            = "{%"
-    VARSTART            = "{{"
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank    = true
-    end
-
-    def parse(tokenizer, parse_context, &block)
-      raise FrozenError, "can't modify frozen Liquid::BlockBody" if frozen?
-
-      parse_context.line_number = tokenizer.line_number
-
-      if tokenizer.for_liquid_tag
-        parse_for_liquid_tag(tokenizer, parse_context, &block)
-      else
-        parse_for_document(tokenizer, parse_context, &block)
-      end
-    end
-
-    def freeze
-      @nodelist.freeze
-      super
-    end
-
-    private def parse_for_liquid_tag(tokenizer, parse_context)
-      while (token = tokenizer.shift)
-        unless token.empty? || token.match?(WhitespaceOrNothing)
-          unless token =~ LiquidTagToken
-            # line isn't empty but didn't match tag syntax, yield and let the
-            # caller raise a syntax error
-            return yield token, token
-          end
-          tag_name = Regexp.last_match(1)
-          markup   = Regexp.last_match(2)
-
-          if tag_name == 'liquid'
-            parse_context.line_number -= 1
-            next parse_liquid_tag(markup, parse_context)
-          end
-
-          unless (tag = parse_context.environment.tag_for_name(tag_name))
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        end
-        parse_context.line_number = tokenizer.line_number
-      end
-
-      yield nil, nil
-    end
-
-    # @api private
-    def self.unknown_tag_in_liquid_tag(tag, parse_context)
-      Block.raise_unknown_tag(tag, 'liquid', '%}', parse_context)
-    end
-
-    # @api private
-    def self.raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
-    end
-
-    # @api private
-    def self.raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
-    end
-
-    # @api private
-    def self.render_node(context, output, node)
-      node.render_to_output_buffer(context, output)
-    rescue => exc
-      blank_tag = !node.instance_of?(Variable) && node.blank?
-      rescue_render_node(context, output, node.line_number, exc, blank_tag)
-    end
-
-    # @api private
-    def self.rescue_render_node(context, output, line_number, exc, blank_tag)
-      case exc
-      when MemoryError
-        raise
-      when UndefinedVariable, UndefinedDropMethod, UndefinedFilter
-        context.handle_error(exc, line_number)
-      else
-        error_message = context.handle_error(exc, line_number)
-        unless blank_tag # conditional for backwards compatibility
-          output << error_message
-        end
-      end
-    end
-
-    private def parse_liquid_tag(markup, parse_context)
-      liquid_tag_tokenizer = parse_context.new_tokenizer(
-        markup, start_line_number: parse_context.line_number, for_liquid_tag: true
-      )
-      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, _end_tag_markup|
-        if end_tag_name
-          BlockBody.unknown_tag_in_liquid_tag(end_tag_name, parse_context)
-        end
-      end
-    end
-
-    private def handle_invalid_tag_token(token, parse_context)
-      if token.end_with?('%}')
-        yield token, token
-      else
-        BlockBody.raise_missing_tag_terminator(token, parse_context)
-      end
-    end
-
-    private def parse_for_document(tokenizer, parse_context, &block)
-      while (token = tokenizer.shift)
-        next if token.empty?
-        case
-        when token.start_with?(TAGSTART)
-          whitespace_handler(token, parse_context)
-          unless token =~ FullToken
-            return handle_invalid_tag_token(token, parse_context, &block)
-          end
-          tag_name = Regexp.last_match(2)
-          markup   = Regexp.last_match(4)
-
-          if parse_context.line_number
-            # newlines inside the tag should increase the line number,
-            # particularly important for multiline {% liquid %} tags
-            parse_context.line_number += Regexp.last_match(1).count("\n") + Regexp.last_match(3).count("\n")
-          end
-
-          if tag_name == 'liquid'
-            parse_liquid_tag(markup, parse_context)
-            next
-          end
-
-          unless (tag = parse_context.environment.tag_for_name(tag_name))
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        when token.start_with?(VARSTART)
-          whitespace_handler(token, parse_context)
-          @nodelist << create_variable(token, parse_context)
-          @blank = false
-        else
-          if parse_context.trim_whitespace
-            token.lstrip!
-          end
-          parse_context.trim_whitespace = false
-          @nodelist << token
-          @blank &&= token.match?(WhitespaceOrNothing)
-        end
-        parse_context.line_number = tokenizer.line_number
-      end
-
-      yield nil, nil
-    end
-
-    def whitespace_handler(token, parse_context)
-      if token[2] == WhitespaceControl
-        previous_token = @nodelist.last
-        if previous_token.is_a?(String)
-          first_byte = previous_token.getbyte(0)
-          previous_token.rstrip!
-          if previous_token.empty? && parse_context[:bug_compatible_whitespace_trimming] && first_byte
-            previous_token << first_byte
-          end
-        end
-      end
-      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-    end
-
-    def blank?
-      @blank
-    end
-
-    # Remove blank strings in the block body for a control flow tag (e.g. `if`, `for`, `case`, `unless`)
-    # with a blank body.
-    #
-    # For example, in a conditional assignment like the following
-    #
-    # ```
-    # {% if size > max_size %}
-    #   {% assign size = max_size %}
-    # {% endif %}
-    # ```
-    #
-    # we assume the intention wasn't to output the blank spaces in the `if` tag's block body, so this method
-    # will remove them to reduce the render output size.
-    #
-    # Note that it is now preferred to use the `liquid` tag for this use case.
-    def remove_blank_strings
-      raise "remove_blank_strings only support being called on a blank block body" unless @blank
-      @nodelist.reject! { |node| node.instance_of?(String) }
-    end
-
-    def render(context)
-      render_to_output_buffer(context, +'')
-    end
-
-    def render_to_output_buffer(context, output)
-      freeze unless frozen?
-
-      context.resource_limits.increment_render_score(@nodelist.length)
-
-      idx = 0
-      while (node = @nodelist[idx])
-        if node.instance_of?(String)
-          output << node
-        else
-          render_node(context, output, node)
-          # If we get an Interrupt that means the block must stop processing. An
-          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}. These tags may also occur through Block or Include tags.
-          break if context.interrupt? # might have happened in a for-block
-        end
-        idx += 1
-
-        context.resource_limits.increment_write_score(output)
-      end
-
-      output
-    end
-
-    private
-
-    def render_node(context, output, node)
-      BlockBody.render_node(context, output, node)
-    end
-
-    def create_variable(token, parse_context)
-      if token.end_with?("}}")
-        i = 2
-        i = 3 if token[i] == "-"
-        parse_end = token.length - 3
-        parse_end -= 1 if token[parse_end] == "-"
-        markup_end = parse_end - i + 1
-        markup = markup_end <= 0 ? "" : token.slice(i, markup_end)
-
-        return Variable.new(markup, parse_context)
-      end
-
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
-    end
-
-    # @deprecated Use {.raise_missing_tag_terminator} instead
-    def raise_missing_tag_terminator(token, parse_context)
-      BlockBody.raise_missing_tag_terminator(token, parse_context)
-    end
-
-    # @deprecated Use {.raise_missing_variable_terminator} instead
-    def raise_missing_variable_terminator(token, parse_context)
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
-    end
-  end
-end
@@ -1,493 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid::Box - Secure sandboxed execution environment for compiled Liquid templates
-#
-# On Ruby 4.0+, this uses the native Ruby::Box for true isolation.
-# On earlier Ruby versions, this provides a polyfill that WARNS about insecurity.
-#
-# == SECURITY WARNING
-#
-# The polyfill on Ruby < 4.0 provides NO REAL SECURITY. It's a compatibility shim
-# that allows code to run, but malicious templates could potentially escape.
-# Use Ruby 4.0+ in production for actual sandboxing.
-#
-# == Usage
-#
-#   template = Liquid::Template.parse("Hello {{ name }}!")
-#   compiled = template.compile_to_ruby
-#
-#   # compiled is a Liquid::CompiledTemplate which wraps a Box
-#   result = compiled.render({ "name" => "World" })
-#   # => "Hello World!"
-#
-#   # Access the generated Ruby code:
-#   puts compiled.source
-#
-
-module Liquid
-  # Check if we have Ruby 4.0's native Box AND it's enabled
-  # Ruby::Box may be defined but disabled (requires RUBY_BOX=1 env var before Ruby starts)
-  RUBY_BOX_AVAILABLE = begin
-    if defined?(Ruby::Box)
-      # Try to create a box to see if it's actually enabled
-      test_box = Ruby::Box.new
-      true
-    else
-      false
-    end
-  rescue RuntimeError => e
-    # Ruby::Box exists but is disabled
-    false
-  end
-
-  unless RUBY_BOX_AVAILABLE
-    # Warn once on load that we're using the insecure polyfill
-    warn "[Liquid::Box] WARNING: Ruby::Box not available or disabled. " \
-         "Using INSECURE polyfill. Compiled templates are NOT sandboxed! " \
-         "(Ruby 4.0+ with RUBY_BOX=1 required for secure execution)" if $VERBOSE
-  end
-
-  # Polyfill for Ruby::Box when not available (Ruby < 4.0)
-  # This provides the same API but NO SECURITY - it just evals code in the main environment.
-  module BoxPolyfill
-    class Box
-      def initialize
-        @constants = {}
-        @binding = TOPLEVEL_BINDING.dup
-      end
-
-      def eval(code)
-        ::Kernel.eval(code, @binding)
-      end
-
-      def const_get(name)
-        ::Object.const_get(name)
-      end
-    end
-  end
-
-  # Liquid::Box wraps either Ruby::Box (secure) or BoxPolyfill::Box (insecure)
-  #
-  # This provides a secure sandboxed environment for executing compiled Liquid templates.
-  # On Ruby 4.0+, templates run in true isolation with dangerous methods removed.
-  # On Ruby < 4.0, templates run without sandboxing (development/testing only).
-  #
-  class Box
-    attr_reader :box
-
-    class << self
-      # Returns true if we have real sandboxing (Ruby 4.0+)
-      def secure?
-        RUBY_BOX_AVAILABLE
-      end
-
-      # Create a pre-configured box for Liquid template execution.
-      # This is the recommended way to get a Box instance.
-      def create_for_liquid
-        box = new
-        box.load_liquid_runtime!
-        box.lock!
-        box
-      end
-    end
-
-    def initialize
-      @box = RUBY_BOX_AVAILABLE ? Ruby::Box.new : BoxPolyfill::Box.new
-      @locked = false
-      @user_constants = []
-      @warned_insecure = false
-    end
-
-    # Load code into the sandbox before locking.
-    # Use this to define filters, helpers, and the Liquid runtime.
-    def load_runtime(code)
-      raise "Cannot load runtime after lock!" if @locked
-      before = @box.eval("Object.constants")
-      @box.eval(code)
-      after = @box.eval("Object.constants")
-      @user_constants += (after - before).map(&:to_s)
-    end
-
-    # Load the standard Liquid runtime helpers (LR module).
-    # Call this before lock! to set up the execution environment.
-    # The runtime provides all helper methods that compiled templates use.
-    def load_liquid_runtime!
-      raise "Cannot load runtime after lock!" if @locked
-
-      if RUBY_BOX_AVAILABLE
-        # Add gem paths to box's load_path so it can find base64, bigdecimal, etc.
-        # These are safe, side-effect-free libs that only provide pure functions
-        setup_gem_load_paths!
-
-        # Load dependencies INTO the box - we need the actual libraries,
-        # not reimplementations, to handle all edge cases correctly
-        @box.require('cgi')
-        @box.require('base64')
-        @box.require('bigdecimal')
-        @box.require('bigdecimal/util')  # For String#to_d etc.
-
-        # Now load the runtime which captures method references from these
-        @box.require(RUNTIME_PATH)
-      else
-        # Polyfill: just require it normally
-        require 'cgi'
-        require 'base64'
-        require 'bigdecimal'
-        require 'bigdecimal/util'
-        require RUNTIME_PATH
-      end
-
-      # Track constants to preserve after lock
-      @user_constants << "LR"
-      @user_constants << "LiquidRuntime"
-      @user_constants << "CGI"
-      @user_constants << "Base64"
-      @user_constants << "BigDecimal"
-    end
-
-    # Add gem paths to the box's load_path so require works for gems
-    def setup_gem_load_paths!
-      return unless RUBY_BOX_AVAILABLE
-
-      # Find gem paths from the main environment's $LOAD_PATH
-      # and from Gem.path if available
-      gem_lib_paths = []
-
-      # Method 1: Find from $LOAD_PATH entries containing "gems"
-      $LOAD_PATH.each do |path|
-        gem_lib_paths << path if path.include?('/gems/')
-      end
-
-      # Method 2: Use Gem.path if available
-      if defined?(Gem) && Gem.respond_to?(:path)
-        Gem.path.each do |gem_path|
-          Dir.glob("#{gem_path}/gems/*/lib").each do |lib_path|
-            gem_lib_paths << lib_path
-          end
-        end
-      end
-
-      # Add unique paths to box's load_path
-      gem_lib_paths.uniq.each do |path|
-        @box.load_path << path unless @box.load_path.include?(path)
-      end
-    end
-
-    # Lock the sandbox. After this:
-    # - No more runtime can be loaded
-    # - Dangerous methods are removed (on Ruby 4.0+)
-    # - Templates can be compiled and executed
-    def lock!
-      return if @locked
-
-      if RUBY_BOX_AVAILABLE
-        apply_sandbox!
-      else
-        warn_insecure!
-      end
-
-      @locked = true
-    end
-
-    def locked?
-      @locked
-    end
-
-    # Returns true if this box provides real security (Ruby 4.0+)
-    def secure?
-      RUBY_BOX_AVAILABLE
-    end
-
-    # Evaluate code in the sandbox.
-    # Use this to compile templates into the sandbox.
-    def eval(code)
-      raise "Must call lock! before eval" unless @locked
-      warn_insecure! unless RUBY_BOX_AVAILABLE
-      @box.eval(code)
-    end
-
-    # Get a constant from the sandbox by name.
-    def const_get(name)
-      @box.const_get(name)
-    end
-
-    def [](name)
-      const_get(name)
-    end
-
-    private
-
-    def warn_insecure!
-      return if @warned_insecure
-      @warned_insecure = true
-
-      $stderr.puts <<~WARNING
-        ╔══════════════════════════════════════════════════════════════════════════════╗
-        ║ SECURITY WARNING: Liquid::Box running WITHOUT sandboxing                     ║
-        ║                                                                              ║
-        ║ Ruby::Box requires Ruby 4.0+. On earlier versions, compiled Liquid templates ║
-        ║ execute with FULL Ruby capabilities. This is NOT SECURE for untrusted input. ║
-        ║                                                                              ║
-        ║ For production use with untrusted templates, upgrade to Ruby 4.0+.           ║
-        ╚══════════════════════════════════════════════════════════════════════════════╝
-      WARNING
-    end
-
-    # Apply sandbox restrictions (Ruby 4.0+ only)
-    def apply_sandbox!
-      neuter_file_system!
-      neuter_process_control!
-      neuter_concurrency!
-      neuter_introspection!
-      neuter_serialization!
-      neuter_time!
-      neuter_environment!
-      neuter_kernel!
-      neuter_basic_object!
-      neuter_object!
-      neuter_main_singleton!
-      neuter_module!
-      cleanup_globals!
-      remove_dangerous_constants!
-    end
-
-    def neuter_file_system!
-      @box.eval(<<~'RUBY')
-        class << File
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-        class << IO
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-        class << Dir
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-        class IO
-          [:read, :write, :gets, :puts, :print, :readline, :readlines, :getc, :getbyte,
-           :sysread, :syswrite, :close, :eof, :eof?, :rewind, :seek].each do |m|
-            undef_method(m) rescue nil
-          end
-        end
-      RUBY
-    end
-
-    def neuter_process_control!
-      @box.eval(<<~'RUBY')
-        class << Process
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-        class << Signal
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_concurrency!
-      @box.eval(<<~'RUBY')
-        class << Thread
-          [:new, :start, :fork, :kill, :exit, :pass, :stop, :main, :current, :list,
-           :abort_on_exception, :abort_on_exception=].each { |m| undef_method(m) rescue nil }
-        end
-        class << Fiber
-          [:new, :yield, :current].each { |m| undef_method(m) rescue nil }
-        end
-        if defined?(Ractor)
-          class << Ractor
-            instance_methods(false).each { |m| undef_method(m) rescue nil }
-          end
-        end
-      RUBY
-    end
-
-    def neuter_introspection!
-      @box.eval(<<~'RUBY')
-        class << ObjectSpace
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-        class << GC
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-        if defined?(RubyVM)
-          class << RubyVM
-            instance_methods(false).each { |m| undef_method(m) rescue nil }
-          end
-          if defined?(RubyVM::InstructionSequence)
-            class << RubyVM::InstructionSequence
-              instance_methods(false).each { |m| undef_method(m) rescue nil }
-            end
-          end
-        end
-        class << TracePoint
-          [:new, :stat, :trace].each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_serialization!
-      @box.eval(<<~'RUBY')
-        class << Marshal
-          [:dump, :load, :restore].each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_time!
-      # Time is neutered by default for security.
-      # Templates that need time should receive it via assigns.
-      @box.eval(<<~'RUBY')
-        class << Time
-          [:now, :new, :at, :mktime, :local, :utc, :gm].each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_environment!
-      @box.eval(<<~'RUBY')
-        ENV.clear rescue nil
-        class << ENV
-          instance_methods(false).each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_kernel!
-      @box.eval(<<~'RUBY')
-        module Kernel
-          [:eval, :`, :system, :exec, :spawn, :fork, :binding,
-           :open, :require, :require_relative, :load, :autoload, :autoload?,
-           :gets, :readline, :readlines, :select, :test,
-           :trap, :exit, :exit!, :abort, :at_exit, :syscall, :sleep,
-           :puts, :print, :printf, :putc, :p, :pp, :warn,
-           :caller, :caller_locations, :set_trace_func, :trace_var, :untrace_var,
-           :global_variables, :local_variables,
-           :gem, :gem_original_require, :Pathname,
-          ].each { |m| undef_method(m) rescue nil }
-        end
-
-        class << Kernel
-          [:eval, :`, :system, :exec, :spawn, :fork, :binding,
-           :open, :require, :require_relative, :load,
-           :puts, :print, :p, :pp, :warn,
-          ].each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_basic_object!
-      @box.eval(<<~'RUBY')
-        class BasicObject
-          undef_method(:instance_eval) rescue nil
-          undef_method(:instance_exec) rescue nil
-          undef_method(:__send__) rescue nil
-        end
-      RUBY
-    end
-
-    def neuter_object!
-      @box.eval(<<~'RUBY')
-        class Object
-          [:gem, :gem_original_require, :require, :require_relative, :load,
-           :display, :define_singleton_method,
-           :instance_variable_set, :remove_instance_variable,
-           :extend, :send, :public_send,
-          ].each { |m| undef_method(m) rescue nil }
-        end
-      RUBY
-    end
-
-    def neuter_main_singleton!
-      # 'using' is defined on main's singleton class, must remove before undef_method is gone
-      @box.eval(<<~'RUBY')
-        class << self
-          undef_method(:using) rescue nil
-        end
-      RUBY
-    end
-
-    def neuter_module!
-      @box.eval(<<~'RUBY')
-        class Module
-          undef_method(:refine) rescue nil
-          undef_method(:using) rescue nil
-          undef_method(:const_set) rescue nil
-          undef_method(:remove_const) rescue nil
-          undef_method(:include) rescue nil
-          undef_method(:prepend) rescue nil
-          undef_method(:extend) rescue nil
-          undef_method(:class_eval) rescue nil
-          undef_method(:module_eval) rescue nil
-          undef_method(:class_exec) rescue nil
-          undef_method(:module_exec) rescue nil
-          undef_method(:define_method) rescue nil
-          undef_method(:alias_method) rescue nil
-          undef_method(:module_function) rescue nil
-          undef_method(:prepend_features) rescue nil
-          undef_method(:append_features) rescue nil
-          undef_method(:extend_object) rescue nil
-          undef_method(:public) rescue nil
-          undef_method(:private) rescue nil
-          undef_method(:protected) rescue nil
-          undef_method(:attr) rescue nil
-          undef_method(:attr_reader) rescue nil
-          undef_method(:attr_writer) rescue nil
-          undef_method(:attr_accessor) rescue nil
-          # Remove escape hatches LAST
-          undef_method(:remove_method) rescue nil
-          undef_method(:undef_method) rescue nil
-          undef_method(:send) rescue nil
-          undef_method(:public_send) rescue nil
-        end
-
-        class Class
-          undef_method(:send) rescue nil
-          undef_method(:public_send) rescue nil
-        end
-      RUBY
-    end
-
-    def cleanup_globals!
-      @box.eval(<<~'RUBY')
-        $stdin = nil
-        $stdout = nil
-        $stderr = nil
-        $LOAD_PATH.clear rescue nil
-        $LOAD_PATH.freeze rescue nil
-        $LOADED_FEATURES.clear rescue nil
-        $LOADED_FEATURES.freeze rescue nil
-        ARGV.clear rescue nil
-        ARGV.freeze rescue nil
-      RUBY
-    end
-
-    def remove_dangerous_constants!
-      keep = %w[
-        BasicObject Object Module Class Kernel
-        String Integer Float Numeric Rational Complex
-        Array Hash Range Set
-        Symbol Regexp MatchData
-        TrueClass FalseClass NilClass
-        Proc Method UnboundMethod
-        Struct Data
-        Comparable Enumerable Enumerator
-        StandardError RuntimeError ArgumentError TypeError NameError
-        NoMethodError KeyError IndexError StopIteration FrozenError
-        ZeroDivisionError RangeError FloatDomainError LocalJumpError
-        Math Random
-        Exception SystemStackError
-      ] + @user_constants
-
-      @box.eval(<<~RUBY)
-        _keep = #{keep.inspect}
-        (Object.constants.map(&:to_s) - _keep).each do |c|
-          Object.send(:remove_const, c.to_sym) rescue nil
-        end
-        (Kernel.constants.map(&:to_s) - _keep).each do |c|
-          Kernel.send(:remove_const, c.to_sym) rescue nil
-        end
-      RUBY
-    end
-
-    # Path to the runtime file that gets loaded into the sandbox
-    RUNTIME_PATH = File.expand_path('compile/runtime.rb', __dir__)
-  end
-end
@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-# Liquid Ruby Compiler
-#
-# This module provides the ability to compile Liquid templates to pure Ruby code.
-# The compiled code can be eval'd to create a proc that renders the template
-# without needing the Liquid library at runtime.
-#
-# ## Usage
-#
-#   template = Liquid::Template.parse("Hello, {{ name }}!")
-#   ruby_code = template.compile_to_ruby
-#   render_proc = eval(ruby_code)
-#   result = render_proc.call({ "name" => "World" })
-#   # => "Hello, World!"
-#
-# ## Optimization Opportunities
-#
-# The compiled Ruby code has several significant advantages over interpreted Liquid:
-#
-# 1. **No Context Object**: Variables are extracted directly from the assigns hash
-#    and accessed without the Context abstraction layer.
-#
-# 2. **No Filter Invocation Overhead**: Filters are compiled to direct Ruby method
-#    calls rather than going through context.invoke().
-#
-# 3. **No Resource Limits Tracking**: The compiled code doesn't track render
-#    scores, write scores, or assign scores, eliminating per-node overhead.
-#
-# 4. **No Stack-based Scoping**: Ruby's native block scoping is used instead
-#    of manually managing scope stacks.
-#
-# 5. **Direct String Concatenation**: Output is built with direct << operations.
-#
-# 6. **Native Control Flow**: break/continue use Ruby's throw/catch mechanism.
-#
-# 7. **No to_liquid Calls**: Values are used directly without conversion.
-#
-# 8. **No Profiling Hooks**: No profiler overhead in the generated code.
-#
-# 9. **No Exception Rendering**: Errors propagate naturally.
-#
-# ## Limitations
-#
-# - {% render %} and {% include %} tags require runtime support
-# - Custom tags need explicit compiler implementations
-# - Custom filters need to be available at runtime
-#
-module Liquid
-  module Compile
-    autoload :CompiledTemplate, 'liquid/compile/compiled_template'
-    autoload :CompiledContext, 'liquid/compile/compiled_context'
-    autoload :CodeGenerator, 'liquid/compile/code_generator'
-    autoload :RubyCompiler, 'liquid/compile/ruby_compiler'
-    autoload :ExpressionCompiler, 'liquid/compile/expression_compiler'
-    autoload :FilterCompiler, 'liquid/compile/filter_compiler'
-    autoload :VariableCompiler, 'liquid/compile/variable_compiler'
-    autoload :BlockBodyCompiler, 'liquid/compile/block_body_compiler'
-    autoload :ConditionCompiler, 'liquid/compile/condition_compiler'
-    autoload :SourceMapper, 'liquid/compile/source_mapper'
-
-    module Tags
-      autoload :IfCompiler, 'liquid/compile/tags/if_compiler'
-      autoload :UnlessCompiler, 'liquid/compile/tags/unless_compiler'
-      autoload :CaseCompiler, 'liquid/compile/tags/case_compiler'
-      autoload :ForCompiler, 'liquid/compile/tags/for_compiler'
-      autoload :AssignCompiler, 'liquid/compile/tags/assign_compiler'
-      autoload :CaptureCompiler, 'liquid/compile/tags/capture_compiler'
-      autoload :CycleCompiler, 'liquid/compile/tags/cycle_compiler'
-      autoload :IncrementCompiler, 'liquid/compile/tags/increment_compiler'
-      autoload :DecrementCompiler, 'liquid/compile/tags/decrement_compiler'
-      autoload :RawCompiler, 'liquid/compile/tags/raw_compiler'
-      autoload :EchoCompiler, 'liquid/compile/tags/echo_compiler'
-      autoload :BreakCompiler, 'liquid/compile/tags/break_compiler'
-      autoload :ContinueCompiler, 'liquid/compile/tags/continue_compiler'
-      autoload :CommentCompiler, 'liquid/compile/tags/comment_compiler'
-      autoload :TableRowCompiler, 'liquid/compile/tags/tablerow_compiler'
-      autoload :RenderCompiler, 'liquid/compile/tags/render_compiler'
-      autoload :IncludeCompiler, 'liquid/compile/tags/include_compiler'
-      autoload :IfchangedCompiler, 'liquid/compile/tags/ifchanged_compiler'
-    end
-  end
-end
@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # BlockBodyCompiler compiles a BlockBody (a list of nodes) to Ruby code.
-    #
-    # A BlockBody contains:
-    # - String literals (text to output)
-    # - Variable expressions ({{ ... }})
-    # - Tags ({% ... %})
-    class BlockBodyCompiler
-      # Compile a BlockBody to Ruby code
-      # @param body [Liquid::BlockBody] The block body
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @param code [CodeGenerator] The code generator
-      def self.compile(body, compiler, code)
-        return if body.nil?
-
-        nodelist = body.nodelist
-        return if nodelist.nil? || nodelist.empty?
-
-        nodelist.each do |node|
-          compile_node(node, compiler, code)
-        end
-      end
-
-      # Compile a single node
-      def self.compile_node(node, compiler, code)
-        case node
-        when String
-          compile_string(node, code)
-        when Variable
-          VariableCompiler.compile(node, compiler, code)
-        when Tag
-          compiler.send(:compile_tag, node, code)
-        else
-          raise CompileError, "Unknown node type in BlockBody: #{node.class}"
-        end
-      end
-
-      private
-
-      def self.compile_string(str, code)
-        return if str.empty?
-        code.line "__output__ << #{str.inspect}"
-      end
-    end
-  end
-end
@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # CodeGenerator provides a clean interface for building Ruby code strings
-    # with proper indentation and formatting.
-    class CodeGenerator
-      INDENT_SIZE = 2
-
-      def initialize
-        @lines = []
-        @indent_level = 0
-      end
-
-      # Add a line of code at the current indentation level
-      # @param text [String] The code to add
-      def line(text)
-        @lines << ("  " * @indent_level) + text
-      end
-
-      # Add a blank line
-      def blank_line
-        @lines << ""
-      end
-
-      # Add multiple lines (useful for multi-line strings)
-      # @param text [String] Multi-line string to add
-      def lines(text)
-        text.each_line do |l|
-          line(l.chomp)
-        end
-      end
-
-      # Increase indentation for a block
-      def indent
-        @indent_level += 1
-        yield
-        @indent_level -= 1
-      end
-
-      # Get the current indentation string
-      def current_indent
-        "  " * @indent_level
-      end
-
-      # Add raw code without indentation adjustment
-      def raw(text)
-        @lines << text
-      end
-
-      # Convert to final Ruby code string
-      def to_s
-        @lines.join("\n")
-      end
-
-      # Generate an inline expression (doesn't add to lines, returns string)
-      # @param expr [String] The expression
-      # @return [String] The expression wrapped appropriately
-      def self.inline(expr)
-        expr
-      end
-
-      # Generate a string literal
-      # @param str [String] The string to escape
-      # @return [String] Ruby string literal
-      def self.string_literal(str)
-        str.inspect
-      end
-
-      # Generate a safe variable name from a Liquid variable name
-      # @param name [String] The Liquid variable name
-      # @return [String] A safe Ruby variable name
-      def self.safe_var_name(name)
-        # Replace invalid characters with underscores
-        safe = name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
-        # Ensure it starts with a letter or underscore
-        safe = "_#{safe}" if safe =~ /\A\d/
-        safe
-      end
-    end
-  end
-end
@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # CompiledContext is a lightweight context-like object for compiled templates.
-    #
-    # It duck-types to Liquid::Context well enough for Drops to work, providing:
-    # - Variable lookup via [] and find_variable
-    # - strict_variables flag
-    # - registers hash
-    # - evaluate method for expressions
-    #
-    # This allows Drops to access other variables and use context features
-    # while still running in compiled mode.
-    class CompiledContext
-      attr_reader :assigns, :registers
-      attr_accessor :strict_variables, :strict_filters
-
-      def initialize(assigns, registers: {}, strict_variables: false, strict_filters: false)
-        @assigns = assigns
-        @registers = registers.is_a?(Liquid::Registers) ? registers : Liquid::Registers.new(registers)
-        @strict_variables = strict_variables
-        @strict_filters = strict_filters
-      end
-
-      # Variable lookup - used by Drops to access other variables
-      def [](key)
-        @assigns[key.to_s]
-      end
-
-      # Find a variable by name
-      def find_variable(key)
-        result = @assigns[key.to_s]
-        result = result.to_liquid if result.respond_to?(:to_liquid)
-        result.context = self if result.respond_to?(:context=)
-        result
-      end
-
-      # Evaluate an expression (for Drops that need to evaluate sub-expressions)
-      def evaluate(expr)
-        case expr
-        when String, Integer, Float, TrueClass, FalseClass, NilClass
-          expr
-        when Liquid::VariableLookup
-          expr.evaluate(self)
-        else
-          expr
-        end
-      end
-
-      # Lookup and evaluate - handles Procs in assigns
-      def lookup_and_evaluate(obj, key)
-        value = obj[key]
-        value = value.call(self) if value.is_a?(Proc)
-        value
-      end
-
-      # Handle errors (simplified - just return message)
-      def handle_error(error, _line_number = nil)
-        error.message
-      end
-
-      # Check if execution should be interrupted
-      def interrupt?
-        false
-      end
-
-      # Stub for resource limits (no-op in compiled mode)
-      def resource_limits
-        @resource_limits ||= ResourceLimitStub.new
-      end
-    end
-
-    # Stub for resource limits in compiled mode
-    class ResourceLimitStub
-      def increment_render_score(_score); end
-      def increment_write_score(_output); end
-      def reached?; false; end
-    end
-  end
-end
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # Represents a compiled Liquid template ready for execution.
-    #
-    # Contains the Ruby source code and any external tags/filters that need to be
-    # passed to the generated lambda at runtime.
-    #
-    # Usage:
-    #   compiled = template.compile_to_ruby
-    #   result = compiled.call({ "name" => "World" })
-    #
-    #   # With custom filters:
-    #   compiled.filter_handler = MyFilterModule
-    #   result = compiled.call({ "name" => "World" })
-    #
-    class CompiledTemplate
-      attr_reader :code, :external_tags
-      attr_accessor :filter_handler
-
-      # @param code [String] The generated Ruby code
-      # @param external_tags [Hash] Map of variable names to Tag objects for runtime delegation
-      # @param has_external_filters [Boolean] Whether external filters are used
-      def initialize(code, external_tags = {}, has_external_filters = false)
-        @code = code
-        @external_tags = external_tags
-        @has_external_filters = has_external_filters
-        @filter_handler = nil
-        @proc = nil
-      end
-
-      # Returns true if this template has external tags that need runtime delegation
-      def has_external_tags?
-        !@external_tags.empty?
-      end
-
-      # Returns true if this template uses external filters
-      def has_external_filters?
-        @has_external_filters
-      end
-
-      # Returns the compiled proc, caching it after first compilation
-      def to_proc
-        @proc ||= eval(@code)
-      end
-
-      # Execute the compiled template with the given assigns
-      # @param assigns [Hash] The variable assignments
-      # @param filter_handler [Object] Optional filter handler to override the default
-      # @param registers [Hash] Optional registers for context
-      # @param strict_variables [Boolean] Raise on undefined variables
-      # @param strict_filters [Boolean] Raise on undefined filters
-      # @return [String] The rendered output
-      def call(assigns = {}, filter_handler: nil, registers: {}, strict_variables: false, strict_filters: false)
-        proc = to_proc
-        handler = filter_handler || @filter_handler
-
-        # Create a context for Drop support
-        context = CompiledContext.new(
-          assigns,
-          registers: registers,
-          strict_variables: strict_variables,
-          strict_filters: strict_filters
-        )
-
-        # Build arguments based on what the lambda expects
-        args = [assigns]
-        args << @external_tags if has_external_tags?
-        args << handler if has_external_filters?
-        args << context  # Always pass context as last arg
-
-        proc.call(*args)
-      end
-
-      # Returns the Ruby code as a string
-      def to_s
-        @code
-      end
-    end
-  end
-
-  # Make CompiledTemplate available at the top level for convenience
-  CompiledTemplate = Compile::CompiledTemplate
-end
@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # ConditionCompiler compiles Liquid conditions to Ruby boolean expressions.
-    #
-    # Handles:
-    # - Simple truthiness: {% if variable %}
-    # - Comparisons: {% if a == b %}, {% if a > b %}
-    # - Logical operators: {% if a and b %}, {% if a or b %}
-    # - Special checks: {% if a == blank %}, {% if a == empty %}
-    class ConditionCompiler
-      # Operator mappings from Liquid to Ruby
-      OPERATORS = {
-        '==' => '==',
-        '!=' => '!=',
-        '<>' => '!=',
-        '<' => '<',
-        '>' => '>',
-        '<=' => '<=',
-        '>=' => '>=',
-        'contains' => :contains,
-      }.freeze
-
-      # Compile a Condition to a Ruby boolean expression
-      # @param condition [Liquid::Condition] The condition
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @return [String] Ruby code expression that evaluates to true/false
-      def self.compile(condition, compiler)
-        if condition.is_a?(ElseCondition)
-          return "true"
-        end
-
-        compile_condition_chain(condition, compiler)
-      end
-
-      private
-
-      def self.compile_condition_chain(condition, compiler)
-        # Compile the current condition
-        current = compile_single_condition(condition, compiler)
-
-        # Check for chained conditions (and/or)
-        if condition.child_condition
-          child = compile_condition_chain(condition.child_condition, compiler)
-          child_relation = condition.send(:child_relation)
-
-          case child_relation
-          when :and
-            "(#{current} && #{child})"
-          when :or
-            "(#{current} || #{child})"
-          else
-            current
-          end
-        else
-          current
-        end
-      end
-
-      def self.compile_single_condition(condition, compiler)
-        left = condition.left
-        op = condition.operator
-        right = condition.right
-
-        # If no operator, just check truthiness
-        if op.nil?
-          left_expr = ExpressionCompiler.compile(left, compiler)
-          return "__truthy__(#{left_expr})"
-        end
-
-        # Compile left and right expressions
-        left_expr = compile_condition_value(left, compiler)
-        right_expr = compile_condition_value(right, compiler)
-
-        # Handle special operators
-        case OPERATORS[op]
-        when :contains
-          compile_contains(left_expr, right_expr, compiler)
-        when '=='
-          compile_equality(left, right, left_expr, right_expr, compiler)
-        when '!='
-          "!(#{compile_equality(left, right, left_expr, right_expr, compiler)})"
-        else
-          # Standard comparison
-          ruby_op = OPERATORS[op] || op
-          "(#{left_expr} #{ruby_op} #{right_expr} rescue false)"
-        end
-      end
-
-      def self.compile_condition_value(expr, compiler)
-        if expr.is_a?(Condition::MethodLiteral)
-          # For blank/empty checks, we return a special marker
-          # The equality handler will deal with this
-          ":__method_literal_#{expr.method_name}__"
-        else
-          ExpressionCompiler.compile(expr, compiler)
-        end
-      end
-
-      def self.compile_equality(left, right, left_expr, right_expr, compiler)
-        # Handle blank/empty method literals
-        if left.is_a?(Condition::MethodLiteral)
-          method_name = left.method_name
-          "(#{right_expr}.respond_to?(:#{method_name}) ? #{right_expr}.#{method_name} : nil)"
-        elsif right.is_a?(Condition::MethodLiteral)
-          method_name = right.method_name
-          "(#{left_expr}.respond_to?(:#{method_name}) ? #{left_expr}.#{method_name} : nil)"
-        else
-          "(#{left_expr} == #{right_expr})"
-        end
-      end
-
-      def self.compile_contains(left_expr, right_expr, compiler)
-        # The contains operator checks if left includes right
-        # For strings, right is converted to a string
-        "(lambda { |left, right| " \
-          "return false if left.nil? || right.nil? || !left.respond_to?(:include?); " \
-          "right = right.to_s if left.is_a?(String); " \
-          "left.include?(right) rescue false " \
-          "}.call(#{left_expr}, #{right_expr}))"
-      end
-    end
-  end
-end
@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # ExpressionCompiler compiles Liquid expressions to Ruby code.
-    #
-    # Expressions include:
-    # - Literals: nil, true, false, strings, numbers
-    # - Variable lookups: foo, foo.bar, foo[0], foo["key"]
-    # - Ranges: (1..10), (start..end)
-    class ExpressionCompiler
-      # Compile an expression to a Ruby code string
-      # @param expr [Object] The parsed expression
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @return [String] Ruby code that evaluates to the expression value
-      def self.compile(expr, compiler)
-        case expr
-        when nil
-          "nil"
-        when true
-          "true"
-        when false
-          "false"
-        when String
-          expr.inspect
-        when Integer, Float
-          expr.inspect
-        when Range
-          "(#{expr.begin.inspect}..#{expr.end.inspect})"
-        when VariableLookup
-          compile_variable_lookup(expr, compiler)
-        when RangeLookup
-          compile_range_lookup(expr, compiler)
-        when Condition::MethodLiteral
-          # Handle blank/empty method literals
-          compile_method_literal(expr, compiler)
-        else
-          raise CompileError, "Unknown expression type: #{expr.class} (#{expr.inspect})"
-        end
-      end
-
-      # Compile a variable lookup expression
-      # @param lookup [VariableLookup] The variable lookup
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @return [String] Ruby code that evaluates to the variable value
-      def self.compile_variable_lookup(lookup, compiler)
-        # Start with the base variable
-        name = lookup.name
-
-        # Handle dynamic name (expression in brackets)
-        base = if name.is_a?(VariableLookup) || name.is_a?(RangeLookup)
-          # Dynamic name like [expr].foo
-          "assigns[#{compile(name, compiler)}]"
-        elsif name.is_a?(String)
-          "assigns[#{name.inspect}]"
-        elsif name.is_a?(Integer)
-          "assigns[#{name.inspect}]"
-        else
-          compile(name, compiler)
-        end
-
-        # Apply each lookup in the chain
-        lookup.lookups.each_with_index do |key, index|
-          if key.is_a?(VariableLookup) || key.is_a?(RangeLookup)
-            # Dynamic key like foo[expr]
-            base = "__lookup__.call(#{base}, #{compile(key, compiler)})"
-          elsif key.is_a?(Integer)
-            # Numeric index like foo[0]
-            base = "__lookup__.call(#{base}, #{key})"
-          elsif key.is_a?(String)
-            # Always use __lookup__ which tries key access first,
-            # then falls back to method call for command methods (first, last, size)
-            base = "__lookup__.call(#{base}, #{key.inspect})"
-          else
-            base = "__lookup__.call(#{base}, #{compile(key, compiler)})"
-          end
-        end
-
-        base
-      end
-
-      # Compile a range lookup expression
-      # @param range [RangeLookup] The range lookup
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @return [String] Ruby code that evaluates to the range
-      def self.compile_range_lookup(range, compiler)
-        start_expr = compile(range.start_obj, compiler)
-        end_expr = compile(range.end_obj, compiler)
-
-        # Convert to integers and create range
-        "(__to_integer__(#{start_expr})...__to_integer__(#{end_expr})).to_a"
-      end
-
-      # Compile a method literal (blank/empty)
-      def self.compile_method_literal(literal, compiler)
-        # These are used in conditions like `if foo == blank`
-        # They represent special method calls
-        literal.to_s.inspect
-      end
-
-      # Compile an expression for use in a condition
-      # @param expr [Object] The expression
-      # @param compiler [RubyCompiler] The main compiler
-      # @return [String] Ruby code for the condition value
-      def self.compile_for_condition(expr, compiler)
-        if expr.is_a?(Condition::MethodLiteral)
-          # Return the method name symbol for special handling
-          ":#{expr.method_name}"
-        else
-          compile(expr, compiler)
-        end
-      end
-    end
-  end
-end
@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # FilterCompiler compiles Liquid filter chains to Ruby code.
-    #
-    # Filters are applied in sequence: {{ value | filter1: arg1 | filter2: arg2 }}
-    # becomes a chain of method calls on the value.
-    class FilterCompiler
-      # Standard filters that map directly to Ruby methods or simple expressions
-      SIMPLE_FILTERS = {
-        'size' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:size) ? #{input}.size : 0)" },
-        'downcase' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).downcase" },
-        'upcase' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).upcase" },
-        'capitalize' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).capitalize" },
-        'strip' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).strip" },
-        'lstrip' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).lstrip" },
-        'rstrip' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).rstrip" },
-        'reverse' => ->(input, _args, _kwargs, _compiler) { "(#{input}.is_a?(Array) ? #{input}.reverse : __to_s__(#{input}).reverse)" },
-        'first' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:first) ? #{input}.first : nil)" },
-        'last' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:last) ? #{input}.last : nil)" },
-        'uniq' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:uniq) ? #{input}.uniq : #{input})" },
-        'compact' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:compact) ? #{input}.compact : #{input})" },
-        'flatten' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:flatten) ? #{input}.flatten : #{input})" },
-        'sort' => ->(input, _args, _kwargs, _compiler) { "(#{input}.respond_to?(:sort) ? #{input}.sort : #{input})" },
-        'abs' => ->(input, _args, _kwargs, _compiler) { "__to_number__(#{input}).abs" },
-        'ceil' => ->(input, _args, _kwargs, _compiler) { "__to_number__(#{input}).ceil.to_i" },
-        'floor' => ->(input, _args, _kwargs, _compiler) { "__to_number__(#{input}).floor.to_i" },
-        'escape' => ->(input, _args, _kwargs, _compiler) { "(#{input}.nil? ? nil : CGI.escapeHTML(__to_s__(#{input})))" },
-        'h' => ->(input, _args, _kwargs, _compiler) { "(#{input}.nil? ? nil : CGI.escapeHTML(__to_s__(#{input})))" },
-        'url_encode' => ->(input, _args, _kwargs, _compiler) { "(#{input}.nil? ? nil : CGI.escape(__to_s__(#{input})))" },
-        'url_decode' => ->(input, _args, _kwargs, _compiler) { "(#{input}.nil? ? nil : CGI.unescape(__to_s__(#{input})))" },
-        'base64_encode' => ->(input, _args, _kwargs, _compiler) { "Base64.strict_encode64(__to_s__(#{input}))" },
-        'base64_decode' => ->(input, _args, _kwargs, _compiler) { "Base64.strict_decode64(__to_s__(#{input}))" },
-        'base64_url_safe_encode' => ->(input, _args, _kwargs, _compiler) { "Base64.urlsafe_encode64(__to_s__(#{input}))" },
-        'base64_url_safe_decode' => ->(input, _args, _kwargs, _compiler) { "Base64.urlsafe_decode64(__to_s__(#{input}))" },
-        'strip_html' => ->(input, _args, _kwargs, _compiler) {
-          "__to_s__(#{input}).gsub(%r{<script.*?</script>|<!--.*?-->|<style.*?</style>}m, '').gsub(/<.*?>/m, '')"
-        },
-        'strip_newlines' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).gsub(/\\r?\\n/, '')" },
-        'newline_to_br' => ->(input, _args, _kwargs, _compiler) { "__to_s__(#{input}).gsub(/\\r?\\n/, \"<br />\\n\")" },
-      }.freeze
-
-      # Filters with arguments that need special handling
-      PARAMETERIZED_FILTERS = {
-        'append' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "__to_s__(#{input}) + __to_s__(#{arg})"
-        },
-        'prepend' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "__to_s__(#{arg}) + __to_s__(#{input})"
-        },
-        'plus' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "(__to_number__(#{input}) + __to_number__(#{arg}))"
-        },
-        'minus' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "(__to_number__(#{input}) - __to_number__(#{arg}))"
-        },
-        'times' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "(__to_number__(#{input}) * __to_number__(#{arg}))"
-        },
-        'divided_by' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "(__to_number__(#{input}) / __to_number__(#{arg}))"
-        },
-        'modulo' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "(__to_number__(#{input}) % __to_number__(#{arg}))"
-        },
-        'round' => ->(input, args, _kwargs, compiler) {
-          if args.empty?
-            "__to_number__(#{input}).round.to_i"
-          else
-            arg = compile_arg(args[0], compiler)
-            "__to_number__(#{input}).round(__to_number__(#{arg}))"
-          end
-        },
-        'at_least' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "[__to_number__(#{input}), __to_number__(#{arg})].max"
-        },
-        'at_most' => ->(input, args, _kwargs, compiler) {
-          arg = compile_arg(args[0], compiler)
-          "[__to_number__(#{input}), __to_number__(#{arg})].min"
-        },
-        'default' => ->(input, args, kwargs, compiler) {
-          default_val = args.empty? ? "''" : compile_arg(args[0], compiler)
-          allow_false = kwargs && kwargs['allow_false'] ? compile_arg(kwargs['allow_false'], compiler) : 'false'
-          "(if #{allow_false} then (#{input}.nil? || (#{input}.respond_to?(:empty?) && #{input}.empty?)) else (!__truthy__(#{input}) || (#{input}.respond_to?(:empty?) && #{input}.empty?)) end) ? #{default_val} : #{input}"
-        },
-        'split' => ->(input, args, _kwargs, compiler) {
-          pattern = args.empty? ? "' '" : compile_arg(args[0], compiler)
-          "__to_s__(#{input}).split(__to_s__(#{pattern}))"
-        },
-        'join' => ->(input, args, _kwargs, compiler) {
-          glue = args.empty? ? "' '" : compile_arg(args[0], compiler)
-          "(#{input}.is_a?(Array) ? #{input}.map { |i| __to_s__(i) }.join(__to_s__(#{glue})) : __to_s__(#{input}))"
-        },
-        'replace' => ->(input, args, _kwargs, compiler) {
-          string = compile_arg(args[0], compiler)
-          replacement = args.length > 1 ? compile_arg(args[1], compiler) : "''"
-          "__to_s__(#{input}).gsub(__to_s__(#{string}), __to_s__(#{replacement}))"
-        },
-        'replace_first' => ->(input, args, _kwargs, compiler) {
-          string = compile_arg(args[0], compiler)
-          replacement = args.length > 1 ? compile_arg(args[1], compiler) : "''"
-          "__to_s__(#{input}).sub(__to_s__(#{string}), __to_s__(#{replacement}))"
-        },
-        'remove' => ->(input, args, _kwargs, compiler) {
-          string = compile_arg(args[0], compiler)
-          "__to_s__(#{input}).gsub(__to_s__(#{string}), '')"
-        },
-        'remove_first' => ->(input, args, _kwargs, compiler) {
-          string = compile_arg(args[0], compiler)
-          "__to_s__(#{input}).sub(__to_s__(#{string}), '')"
-        },
-        'truncate' => ->(input, args, _kwargs, compiler) {
-          length = args.empty? ? "50" : compile_arg(args[0], compiler)
-          ellipsis = args.length > 1 ? compile_arg(args[1], compiler) : "'...'"
-          var = compiler.generate_var_name("trunc")
-          "(lambda { |#{var}_input, #{var}_len, #{var}_ell| #{var}_str = __to_s__(#{var}_input); #{var}_ell_str = __to_s__(#{var}_ell); #{var}_l = [#{var}_len.to_i - #{var}_ell_str.length, 0].max; #{var}_str.length > #{var}_len.to_i ? #{var}_str[0, #{var}_l] + #{var}_ell_str : #{var}_str }).call(#{input}, #{length}, #{ellipsis})"
-        },
-        'truncatewords' => ->(input, args, _kwargs, compiler) {
-          words = args.empty? ? "15" : compile_arg(args[0], compiler)
-          ellipsis = args.length > 1 ? compile_arg(args[1], compiler) : "'...'"
-          "(lambda { |input, num_words, ell| words = __to_s__(input).split(' ', [num_words.to_i, 1].max + 1); words.length > [num_words.to_i, 1].max ? words[0, [num_words.to_i, 1].max].join(' ') + __to_s__(ell) : input.to_s }).call(#{input}, #{words}, #{ellipsis})"
-        },
-        'slice' => ->(input, args, _kwargs, compiler) {
-          offset = compile_arg(args[0], compiler)
-          length = args.length > 1 ? compile_arg(args[1], compiler) : "1"
-          "(#{input}.is_a?(Array) ? (#{input}.slice(__to_integer__(#{offset}), __to_integer__(#{length})) || []) : (__to_s__(#{input}).slice(__to_integer__(#{offset}), __to_integer__(#{length})) || ''))"
-        },
-        'map' => ->(input, args, _kwargs, compiler) {
-          property = compile_arg(args[0], compiler)
-          "(#{input}.is_a?(Array) ? #{input}.map { |item| item.respond_to?(:[]) ? item[#{property}] : nil } : [])"
-        },
-        'where' => ->(input, args, _kwargs, compiler) {
-          property = compile_arg(args[0], compiler)
-          if args.length > 1
-            target = compile_arg(args[1], compiler)
-            "(#{input}.is_a?(Array) ? #{input}.select { |item| item.respond_to?(:[]) && item[#{property}] == #{target} } : [])"
-          else
-            "(#{input}.is_a?(Array) ? #{input}.select { |item| item.respond_to?(:[]) && __truthy__(item[#{property}]) } : [])"
-          end
-        },
-        'reject' => ->(input, args, _kwargs, compiler) {
-          property = compile_arg(args[0], compiler)
-          if args.length > 1
-            target = compile_arg(args[1], compiler)
-            "(#{input}.is_a?(Array) ? #{input}.reject { |item| item.respond_to?(:[]) && item[#{property}] == #{target} } : [])"
-          else
-            "(#{input}.is_a?(Array) ? #{input}.reject { |item| item.respond_to?(:[]) && __truthy__(item[#{property}]) } : [])"
-          end
-        },
-        'concat' => ->(input, args, _kwargs, compiler) {
-          arr = compile_arg(args[0], compiler)
-          "(#{input}.is_a?(Array) ? #{input} + (#{arr}.respond_to?(:to_ary) ? #{arr}.to_ary : []) : [])"
-        },
-        'sort_natural' => ->(input, args, _kwargs, compiler) {
-          if args.empty?
-            "(#{input}.is_a?(Array) ? #{input}.sort_by { |a| a.to_s.downcase } : #{input})"
-          else
-            property = compile_arg(args[0], compiler)
-            "(#{input}.is_a?(Array) ? #{input}.sort_by { |a| a.respond_to?(:[]) ? a[#{property}].to_s.downcase : '' } : #{input})"
-          end
-        },
-        'date' => ->(input, args, _kwargs, compiler) {
-          format = compile_arg(args[0], compiler)
-          # This is a simplified version - full date parsing is complex
-          "(lambda { |input, fmt| return input if fmt.to_s.empty?; d = case input; when Time, Date, DateTime then input; when 'now', 'today' then Time.now; when /\\A\\d+\\z/, Integer then Time.at(input.to_i); when String then (Time.parse(input) rescue input); else input; end; d.respond_to?(:strftime) ? d.strftime(fmt.to_s) : input }.call(#{input}, #{format}))"
-        },
-        'escape_once' => ->(input, _args, _kwargs, _compiler) {
-          "__to_s__(#{input}).gsub(/[\"><']|&(?!([a-zA-Z]+|(#\\d+));)/) { |c| {'&'=>'&amp;', '>'=>'&gt;', '<'=>'&lt;', '\"'=>'&quot;', \"'\"=>'&#39;'}[c] || c }"
-        },
-      }.freeze
-
-      # Compile a filter chain
-      # @param input_expr [String] Ruby expression for the input value
-      # @param filters [Array] Array of filter definitions [name, args, kwargs]
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @return [String] Ruby code that applies all filters
-      def self.compile(input_expr, filters, compiler)
-        result = input_expr
-
-        filters.each do |filter_name, filter_args, filter_kwargs|
-          result = compile_filter(result, filter_name, filter_args || [], filter_kwargs, compiler)
-        end
-
-        result
-      end
-
-      # Compile a single filter application
-      def self.compile_filter(input, name, args, kwargs, compiler)
-        if SIMPLE_FILTERS.key?(name)
-          SIMPLE_FILTERS[name].call(input, args, kwargs, compiler)
-        elsif PARAMETERIZED_FILTERS.key?(name)
-          PARAMETERIZED_FILTERS[name].call(input, args, kwargs, compiler)
-        else
-          # Fall back to a generic filter call
-          compile_generic_filter(input, name, args, kwargs, compiler)
-        end
-      end
-
-      # Compile a filter that's not built-in
-      # Uses __call_filter__ helper which must be provided by the runtime
-      def self.compile_generic_filter(input, name, args, kwargs, compiler)
-        # Mark that we're using external filters
-        compiler.register_external_filter
-
-        compiled_args = args.map { |arg| compile_arg(arg, compiler) }
-
-        if kwargs && !kwargs.empty?
-          kwargs_hash = kwargs.map { |k, v| "#{k.inspect} => #{compile_arg(v, compiler)}" }.join(", ")
-          compiled_args << "{ #{kwargs_hash} }"
-        end
-
-        args_str = compiled_args.empty? ? "[]" : "[#{compiled_args.join(', ')}]"
-
-        # Call through the filter helper which delegates to registered filters
-        "__call_filter__.call(#{name.inspect}, #{input}, #{args_str})"
-      end
-
-      # Compile a filter argument
-      def self.compile_arg(arg, compiler)
-        ExpressionCompiler.compile(arg, compiler)
-      end
-    end
-  end
-end
@@ -1,534 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # RubyCompiler transforms a parsed Liquid template into pure Ruby code.
-    #
-    # The compiled code is a string that can be eval'd to create a proc/lambda
-    # that takes an assigns hash and returns the rendered output string.
-    #
-    # ## Optimization Opportunities
-    #
-    # The compiled Ruby code has several significant advantages over interpreted Liquid:
-    #
-    # 1. **No Context Object**: Instead of using a Context for variable lookups,
-    #    variables are extracted directly from the assigns hash and stored in
-    #    local Ruby variables. This eliminates hash lookups on every access.
-    #
-    # 2. **No Filter Invocation Overhead**: Filters are compiled to direct Ruby
-    #    method calls rather than going through context.invoke().
-    #
-    # 3. **No Resource Limits Tracking**: The compiled code doesn't track render
-    #    scores, write scores, or assign scores, eliminating per-node overhead.
-    #
-    # 4. **No Stack-based Scoping**: Ruby's native block scoping is used instead
-    #    of manually managing scope stacks with push/pop operations.
-    #
-    # 5. **Direct String Concatenation**: Output is built with direct << operations
-    #    rather than through render_to_output_buffer abstractions.
-    #
-    # 6. **Native Control Flow**: break/continue become Ruby's break/next,
-    #    eliminating interrupt objects and checks.
-    #
-    # 7. **No to_liquid Calls**: Values are used directly without conversion.
-    #
-    # 8. **Potential for Constant Folding**: Expressions with only literals
-    #    could be evaluated at compile time (future enhancement).
-    #
-    # 9. **Potential for Dead Code Elimination**: Unreachable branches like
-    #    `{% if false %}` could be removed (future enhancement).
-    #
-    # 10. **No Profiling Hooks**: No profiler overhead in the generated code.
-    #
-    # 11. **No Exception Rendering**: Errors propagate naturally rather than
-    #     being caught and rendered inline.
-    #
-    # ## Usage
-    #
-    #   template = Liquid::Template.parse("Hello, {{ name }}!")
-    #   ruby_code = template.compile_to_ruby
-    #   render_proc = eval(ruby_code)
-    #   result = render_proc.call({ "name" => "World" })
-    #   # => "Hello, World!"
-    #
-    class RubyCompiler
-      attr_reader :template, :options
-
-      # @param template [Liquid::Template] The parsed template to compile
-      # @param options [Hash] Compilation options
-      # @option options [Boolean] :strict_variables Raise on undefined variables (default: false)
-      # @option options [Boolean] :include_filters Include filter helper methods (default: true)
-      # @option options [Boolean] :debug Emit source comments for debugging (default: false)
-      # @option options [Object] :file_system File system for loading partials (default: template's environment)
-      def initialize(template, options = {})
-        @template = template
-        @options = {
-          strict_variables: false,
-          include_filters: true,
-          debug: false,
-          file_system: nil,
-        }.merge(options)
-        @var_counter = 0
-        @partials = {}        # Registered partials: name => method_name
-        @partial_sources = {} # Partial sources: name => source code
-        @partial_counter = 0
-        @external_tags = {}   # External tags: var_name => tag object
-        @external_tag_counter = 0
-        @has_external_filters = false  # Whether we need the filter helper
-      end
-
-      # Mark that we have external filters
-      def register_external_filter
-        @has_external_filters = true
-      end
-
-      # Check if external filters are used
-      def has_external_filters?
-        @has_external_filters
-      end
-
-      # Register an external tag that will be called at runtime
-      # @param tag [Liquid::Tag] The tag to register
-      # @return [String] The variable name for this tag
-      def register_external_tag(tag)
-        @external_tag_counter += 1
-        var_name = "__ext_tag_#{@external_tag_counter}__"
-        @external_tags[var_name] = tag
-        var_name
-      end
-
-      # Get all registered external tags
-      # @return [Hash] Map of variable names to tag objects
-      def external_tags
-        @external_tags
-      end
-
-      # Get the file system for loading partials
-      def file_system
-        @options[:file_system] || @template.instance_variable_get(:@environment)&.file_system
-      end
-
-      # Load a partial source from the file system
-      # @param name [String] The partial name
-      # @return [String, nil] The partial source or nil if not found
-      def load_partial(name)
-        return @partial_sources[name] if @partial_sources.key?(name)
-
-        fs = file_system
-        return nil unless fs && fs.respond_to?(:read_template_file)
-
-        begin
-          source = fs.read_template_file(name)
-          @partial_sources[name] = source
-          source
-        rescue Liquid::FileSystemError
-          nil
-        end
-      end
-
-      # Register a partial and return its method name
-      # @param name [String] The partial name
-      # @param source [String] The partial source
-      # @return [String] The method name for this partial
-      def register_partial(name, source)
-        return @partials[name] if @partials.key?(name)
-
-        @partial_counter += 1
-        method_name = "__partial_#{@partial_counter}__"
-        @partials[name] = method_name
-        method_name
-      end
-
-      # Get all registered partials
-      def registered_partials
-        @partials
-      end
-
-      # Check if debug mode is enabled
-      def debug?
-        @options[:debug]
-      end
-
-      # Emit a debug comment with source location info
-      # This creates a lightweight source map that allows tracing errors
-      # back to the original Liquid source
-      def emit_debug_comment(code, node, description = nil)
-        return unless debug?
-
-        line_number = node.respond_to?(:line_number) ? node.line_number : nil
-        raw_markup = extract_raw_markup(node)
-
-        comment_parts = []
-        comment_parts << "LIQUID"
-        comment_parts << "L#{line_number}" if line_number
-        comment_parts << description if description
-        comment_parts << raw_markup.inspect if raw_markup && raw_markup.length < 80
-
-        code.line "# #{comment_parts.join(' | ')}"
-      end
-
-      # Extract the raw markup from a node for debug output
-      def extract_raw_markup(node)
-        case node
-        when Variable
-          "{{ #{node.raw} }}"
-        when Tag
-          if node.respond_to?(:raw)
-            "{% #{node.tag_name} #{node.raw} %}"
-          elsif node.respond_to?(:markup)
-            "{% #{node.tag_name} #{node.markup} %}"
-          else
-            "{% #{node.class.name.split('::').last.downcase} %}"
-          end
-        else
-          nil
-        end
-      end
-
-      # Compile the template to a Ruby code string
-      # @return [String] Ruby code that can be eval'd to create a render proc
-      # @return [Hash] If external tags are used, returns { code: String, external_tags: Hash }
-      def compile
-        code = CodeGenerator.new
-
-        # Add debug header if enabled
-        if debug?
-          code.line "# Compiled from Liquid template: #{@template.name || '(unnamed)'}"
-          code.line "# Debug mode enabled - comments contain source locations"
-          code.line "# Format: # LIQUID | L<line> | <description> | <source>"
-          code.blank_line
-        end
-
-        # First pass: compile the document body to discover partials and external tags
-        main_code = CodeGenerator.new
-        compile_node(@template.root, main_code)
-
-        # Determine lambda parameters based on external dependencies
-        params = ["assigns = {}"]
-        params << "__external_tags__ = {}" unless @external_tags.empty?
-        params << "__filter_handler__ = nil" if @has_external_filters
-        params << "__context__ = nil"
-
-        code.line "->(#{params.join(', ')}) do"
-
-        code.indent do
-          # Initialize the output buffer
-          code.line '__output__ = +""'
-          code.blank_line
-
-          # Create a compiled context if not provided (for Drop support)
-          code.line "# Create context for Drop support"
-          code.line "__context__ ||= Liquid::Compile::CompiledContext.new(assigns)"
-          code.blank_line
-
-          # Compile helper methods if needed
-          if @options[:include_filters]
-            compile_helper_methods(code)
-            code.blank_line
-          end
-
-          # Add external tag runtime helper if needed
-          unless @external_tags.empty?
-            compile_external_tag_helper(code)
-            code.blank_line
-          end
-
-          # Add external filter helper if needed
-          if @has_external_filters
-            compile_filter_helper(code)
-            code.blank_line
-          end
-
-          # Compile partial methods (before main body so they're available)
-          compile_partials(code)
-
-          # Add the main body code
-          code.raw(main_code.to_s)
-
-          code.blank_line
-          code.line "__output__"
-        end
-        code.line "end"
-
-        code.to_s
-      end
-
-      # Compile helper for calling external tags at runtime
-      def compile_external_tag_helper(code)
-        code.line "# Helper for calling external (unknown) tags at runtime"
-        code.line "__call_external_tag__ = ->(tag_var, tag_assigns) {"
-        code.indent do
-          code.line "tag = __external_tags__[tag_var]"
-          code.line "next '' unless tag"
-          code.line "# Create a context using the default environment (which has filters registered)"
-          code.line "ctx = Liquid::Context.new([tag_assigns], {}, {}, false, nil, {}, Liquid::Environment.default)"
-          code.line "output = +''"
-          code.line "# Use render_to_output_buffer to ensure block tags work correctly"
-          code.line "tag.render_to_output_buffer(ctx, output)"
-          code.line "output"
-        end
-        code.line "}"
-      end
-
-      # Compile helper for calling external filters at runtime
-      def compile_filter_helper(code)
-        code.line "# Helper for calling external (unknown) filters at runtime"
-        code.line "__call_filter__ = ->(name, input, args) {"
-        code.indent do
-          code.line "if __filter_handler__&.respond_to?(name)"
-          code.indent do
-            code.line "__filter_handler__.send(name, input, *args)"
-          end
-          code.line "else"
-          code.indent do
-            code.line "input # Return input unchanged if filter not found"
-          end
-          code.line "end"
-        end
-        code.line "}"
-      end
-
-      # Compile all registered partials as inner methods
-      def compile_partials(code)
-        @partials.each do |name, method_name|
-          source = @partial_sources[name]
-          next unless source
-
-          code.line "# Partial: #{name}"
-          code.line "#{method_name} = ->(partial_assigns) do"
-          code.indent do
-            code.line "__partial_output__ = +''"
-            code.line "# Merge partial assigns with parent assigns"
-            code.line "__assigns_backup__ = assigns.dup"
-            code.line "assigns.merge!(partial_assigns)"
-            code.blank_line
-
-            # Parse and compile the partial
-            # Note: We need to handle this carefully to avoid circular references
-            begin
-              compile_partial_source(source, code)
-            rescue => e
-              code.line "# Error compiling partial: #{e.message.inspect}"
-              code.line "__partial_output__ << '[PARTIAL ERROR: ' + #{name.inspect} + ']'"
-            end
-
-            code.blank_line
-            code.line "# Restore assigns"
-            code.line "assigns.replace(__assigns_backup__)"
-            code.line "__partial_output__"
-          end
-          code.line "end"
-          code.blank_line
-        end
-      end
-
-      # Compile a partial source string
-      def compile_partial_source(source, code)
-        # Parse the partial source using the same environment
-        environment = @template.instance_variable_get(:@environment) || Liquid::Environment.default
-        parse_context = Liquid::ParseContext.new(environment: environment)
-        tokenizer = parse_context.new_tokenizer(source)
-        document = Liquid::Document.parse(tokenizer, parse_context)
-
-        # Compile the partial's body, but swap output variable
-        code.line "__saved_output__ = __output__"
-        code.line "__output__ = __partial_output__"
-
-        # Compile the document
-        BlockBodyCompiler.compile(document.body, self, code)
-
-        code.line "__output__ = __saved_output__"
-      end
-
-      # Generate a unique variable name for internal use
-      def generate_var_name(prefix = "v")
-        @var_counter += 1
-        "__#{prefix}#{@var_counter}__"
-      end
-
-      # Compile a single node
-      def compile_node(node, code)
-        case node
-        when Document
-          BlockBodyCompiler.compile(node.body, self, code)
-        when BlockBody
-          BlockBodyCompiler.compile(node, self, code)
-        when String
-          compile_string(node, code)
-        when Variable
-          emit_debug_comment(code, node, "variable")
-          VariableCompiler.compile(node, self, code)
-        when Tag
-          emit_debug_comment(code, node, node.class.name.split('::').last.downcase)
-          compile_tag(node, code)
-        else
-          raise CompileError, "Unknown node type: #{node.class}"
-        end
-      end
-
-      private
-
-      def compile_string(str, code)
-        return if str.empty?
-        if debug? && str.length < 40
-          code.line "# LIQUID | text | #{str.inspect}"
-        end
-        code.line "__output__ << #{str.inspect}"
-      end
-
-      def compile_tag(tag, code)
-        compiler_class = find_tag_compiler(tag)
-        if compiler_class
-          compiler_class.compile(tag, self, code)
-        else
-          # Unknown tag - delegate to the original tag's render method at runtime
-          compile_external_tag(tag, code)
-        end
-      end
-
-      def compile_external_tag(tag, code)
-        tag_var = register_external_tag(tag)
-        tag_name = tag.class.name.split('::').last
-        if debug?
-          code.line "# External tag: #{tag_name} (delegated to runtime)"
-          code.line "$stderr.puts '* WARN: Liquid external tag call - #{tag_name} (not compiled, delegated to runtime)' if $VERBOSE"
-        end
-        code.line "__output__ << __call_external_tag__.call(#{tag_var.inspect}, assigns)"
-      end
-
-      def find_tag_compiler(tag)
-        case tag
-        when Liquid::Unless  # Check Unless before If since Unless < If
-          Tags::UnlessCompiler
-        when Liquid::If
-          Tags::IfCompiler
-        when Liquid::Case
-          Tags::CaseCompiler
-        when Liquid::For
-          Tags::ForCompiler
-        when Liquid::Assign
-          Tags::AssignCompiler
-        when Liquid::Capture
-          Tags::CaptureCompiler
-        when Liquid::Cycle
-          Tags::CycleCompiler
-        when Liquid::Increment
-          Tags::IncrementCompiler
-        when Liquid::Decrement
-          Tags::DecrementCompiler
-        when Liquid::Raw
-          Tags::RawCompiler
-        when Liquid::Echo
-          Tags::EchoCompiler
-        when Liquid::Break
-          Tags::BreakCompiler
-        when Liquid::Continue
-          Tags::ContinueCompiler
-        when Liquid::Comment, Liquid::InlineComment, Liquid::Doc
-          Tags::CommentCompiler
-        when Liquid::TableRow
-          Tags::TableRowCompiler
-        when Liquid::Render
-          Tags::RenderCompiler
-        when Liquid::Include
-          Tags::IncludeCompiler
-        when Liquid::Ifchanged
-          Tags::IfchangedCompiler
-        else
-          nil
-        end
-      end
-
-      def compile_helper_methods(code)
-        code.line "# Helper methods for filters and utilities"
-
-        # to_s helper that handles arrays and hashes like Liquid does
-        code.line "def __to_s__(obj)"
-        code.indent do
-          code.line "case obj"
-          code.line "when NilClass then ''"
-          code.line "when Array then obj.join"
-          code.line "else obj.to_s"
-          code.line "end"
-        end
-        code.line "end"
-        code.blank_line
-
-        # to_number helper
-        code.line "def __to_number__(obj)"
-        code.indent do
-          code.line "case obj"
-          code.line "when Numeric then obj"
-          code.line "when String"
-          code.indent do
-            code.line "obj.strip =~ /\\A-?\\d+\\.\\d+\\z/ ? BigDecimal(obj) : obj.to_i"
-          end
-          code.line "else 0"
-          code.line "end"
-        end
-        code.line "end"
-        code.blank_line
-
-        # to_integer helper
-        code.line "def __to_integer__(obj)"
-        code.indent do
-          code.line "return obj if obj.is_a?(Integer)"
-          code.line "Integer(obj.to_s)"
-        end
-        code.line "end"
-        code.blank_line
-
-        # Liquid truthiness helper
-        code.line "def __truthy__(obj)"
-        code.indent do
-          code.line "obj != nil && obj != false"
-        end
-        code.line "end"
-        code.blank_line
-
-        # Variable lookup helper - handles hash/array access, method calls, to_liquid, and drop context
-        code.line "__lookup__ = ->(obj, key) {"
-        code.indent do
-          code.line "return nil if obj.nil?"
-          code.line "# Set context on Drops BEFORE accessing their methods"
-          code.line "obj = obj.to_liquid if obj.respond_to?(:to_liquid)"
-          code.line "obj.context = __context__ if obj.respond_to?(:context=)"
-          code.line "# Now perform the lookup"
-          code.line "result = if obj.respond_to?(:[]) && (obj.respond_to?(:key?) && obj.key?(key) || obj.respond_to?(:fetch) && key.is_a?(Integer))"
-          code.indent do
-            code.line "obj[key]"
-          end
-          code.line "elsif obj.respond_to?(key)"
-          code.indent do
-            code.line "obj.send(key)"
-          end
-          code.line "else"
-          code.indent do
-            code.line "nil"
-          end
-          code.line "end"
-          code.line "# Convert result to liquid and set context for nested Drops"
-          code.line "result = result.to_liquid if result.respond_to?(:to_liquid)"
-          code.line "result.context = __context__ if result.respond_to?(:context=)"
-          code.line "result"
-        end
-        code.line "}"
-        code.blank_line
-
-        # Output helper that handles nil and arrays
-        code.line "def __output_value__(obj)"
-        code.indent do
-          code.line "case obj"
-          code.line "when NilClass then ''"
-          code.line "when Array then obj.map { |o| __output_value__(o) }.join"
-          code.line "else obj.to_s"
-          code.line "end"
-        end
-        code.line "end"
-      end
-    end
-
-    # Custom error for compilation issues
-    class CompileError < StandardError; end
-  end
-end
@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # SourceMapper provides utilities for mapping errors in compiled Ruby code
-    # back to the original Liquid source.
-    #
-    # When code is compiled with debug: true, comments are embedded that contain
-    # source location information. This class can parse those comments and
-    # help trace errors back to the original Liquid template.
-    #
-    # ## Usage
-    #
-    #   template = Liquid::Template.parse(source, line_numbers: true)
-    #   ruby_code = template.compile_to_ruby(debug: true)
-    #   render_proc = eval(ruby_code)
-    #
-    #   begin
-    #     result = render_proc.call(assigns)
-    #   rescue => e
-    #     location = SourceMapper.find_source_location(ruby_code, e)
-    #     puts "Error at Liquid line #{location[:liquid_line]}: #{location[:source]}"
-    #   end
-    #
-    class SourceMapper
-      # Pattern to match LIQUID debug comments
-      LIQUID_COMMENT_PATTERN = /^(\s*)# LIQUID(?: \| L(\d+))?(?: \| ([^|]+))?(?: \| (.+))?$/
-
-      # Parse compiled Ruby code and extract source mapping entries
-      # @param ruby_code [String] The compiled Ruby code with debug comments
-      # @return [Array<Hash>] Array of source mapping entries
-      def self.parse(ruby_code)
-        entries = []
-        ruby_line = 0
-
-        ruby_code.each_line do |line|
-          ruby_line += 1
-
-          if line =~ LIQUID_COMMENT_PATTERN
-            entries << {
-              ruby_line: ruby_line,
-              liquid_line: $2&.to_i,
-              type: $3&.strip,
-              source: parse_source_string($4),
-            }
-          end
-        end
-
-        entries
-      end
-
-      # Find the source location for an error based on Ruby line number
-      # @param ruby_code [String] The compiled Ruby code
-      # @param error [Exception] The exception that was raised
-      # @return [Hash, nil] Source location info or nil if not found
-      def self.find_source_location(ruby_code, error)
-        # Extract the line number from the error
-        ruby_line = extract_error_line(error)
-        return nil unless ruby_line
-
-        find_source_for_ruby_line(ruby_code, ruby_line)
-      end
-
-      # Find the source location for a specific Ruby line number
-      # @param ruby_code [String] The compiled Ruby code
-      # @param target_line [Integer] The Ruby line number
-      # @return [Hash, nil] Source location info or nil if not found
-      def self.find_source_for_ruby_line(ruby_code, target_line)
-        entries = parse(ruby_code)
-
-        # Find the closest LIQUID comment at or before the target line
-        closest = nil
-        entries.each do |entry|
-          break if entry[:ruby_line] > target_line
-          closest = entry
-        end
-
-        closest
-      end
-
-      # Format an error message with source location info
-      # @param ruby_code [String] The compiled Ruby code
-      # @param error [Exception] The exception
-      # @return [String] Formatted error message
-      def self.format_error(ruby_code, error)
-        location = find_source_location(ruby_code, error)
-
-        message = "#{error.class}: #{error.message}"
-
-        if location
-          liquid_line = location[:liquid_line] ? "line #{location[:liquid_line]}" : "unknown line"
-          source = location[:source] || location[:type] || "unknown"
-          message += "\n  in Liquid template at #{liquid_line}"
-          message += "\n  source: #{source}" if location[:source]
-        end
-
-        message
-      end
-
-      private
-
-      def self.extract_error_line(error)
-        # Look for (eval):N in backtrace
-        error.backtrace&.each do |frame|
-          if frame =~ /\(eval.*?\):(\d+)/
-            return $1.to_i
-          end
-        end
-        nil
-      end
-
-      def self.parse_source_string(str)
-        return nil unless str
-
-        # Remove surrounding quotes if present
-        str = str.strip
-        if str.start_with?('"') && str.end_with?('"')
-          # Unescape the string
-          begin
-            eval(str)
-          rescue
-            str[1..-2]
-          end
-        else
-          str
-        end
-      end
-    end
-  end
-end
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% assign var = expression %} tags
-      class AssignCompiler
-        def self.compile(tag, compiler, code)
-          var_name = tag.to
-          # Use VariableCompiler to get the expression with filters applied
-          value_expr = VariableCompiler.compile_to_expression(tag.from, compiler)
-
-          # Store in the assigns hash
-          code.line "assigns[#{var_name.inspect}] = #{value_expr}"
-        end
-      end
-    end
-  end
-end
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% break %} tags
-      #
-      # Breaks out of a for loop
-      class BreakCompiler
-        def self.compile(_tag, _compiler, code)
-          # We use throw/catch in the for loop to handle break
-          # This allows break to work from nested blocks
-          code.line "throw :__loop__break__"
-        end
-      end
-    end
-  end
-end
@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% capture var %}...{% endcapture %} tags
-      #
-      # Captures the output of the block into a variable
-      class CaptureCompiler
-        def self.compile(tag, compiler, code)
-          var_name = tag.instance_variable_get(:@to)
-          capture_var = compiler.generate_var_name("capture")
-
-          # Save current output, create new buffer for capture
-          code.line "#{capture_var} = __output__"
-          code.line "__output__ = +''"
-
-          # Compile the body - access the @body BlockBody directly
-          body = tag.instance_variable_get(:@body)
-          if body
-            BlockBodyCompiler.compile(body, compiler, code)
-          end
-
-          # Save captured content and restore output buffer
-          code.line "assigns[#{var_name.inspect}] = __output__"
-          code.line "__output__ = #{capture_var}"
-        end
-      end
-    end
-  end
-end
@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% case %} / {% when %} / {% else %} / {% endcase %} tags
-      class CaseCompiler
-        def self.compile(tag, compiler, code)
-          # Compile the case expression and store it in a variable
-          # to avoid evaluating it multiple times
-          case_var = compiler.generate_var_name("case")
-          case_expr = ExpressionCompiler.compile(tag.left, compiler)
-          code.line "#{case_var} = #{case_expr}"
-
-          blocks = tag.blocks
-          is_first = true
-          has_else = false
-
-          blocks.each do |block|
-            if block.else?
-              has_else = true
-              code.line "else"
-            else
-              # 'when' condition - compare case expression with the when value
-              when_expr = ExpressionCompiler.compile(block.right, compiler)
-
-              if is_first
-                code.line "if #{case_var} == #{when_expr}"
-                is_first = false
-              else
-                code.line "elsif #{case_var} == #{when_expr}"
-              end
-            end
-
-            code.indent do
-              if block.attachment
-                BlockBodyCompiler.compile(block.attachment, compiler, code)
-              end
-            end
-          end
-
-          code.line "end" unless blocks.empty?
-        end
-      end
-    end
-  end
-end
@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% comment %}...{% endcomment %} tags
-      # Also handles inline_comment (#) and doc tags
-      #
-      # Comments produce no output
-      class CommentCompiler
-        def self.compile(_tag, _compiler, code)
-          # Comments produce no output
-          code.line "# (liquid comment)"
-        end
-      end
-    end
-  end
-end
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% continue %} tags
-      #
-      # Skips to the next iteration of a for loop
-      class ContinueCompiler
-        def self.compile(_tag, _compiler, code)
-          # We use throw/catch in the for loop to handle continue
-          code.line "throw :__loop__continue__"
-        end
-      end
-    end
-  end
-end
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% cycle 'a', 'b', 'c' %} tags
-      #
-      # Cycles through a list of values, outputting the next one each iteration
-      class CycleCompiler
-        def self.compile(tag, compiler, code)
-          variables = tag.variables
-          name_expr = ExpressionCompiler.compile(tag.instance_variable_get(:@name), compiler)
-          is_named = tag.named?
-
-          cycle_var = compiler.generate_var_name("cycle")
-          key_var = compiler.generate_var_name("cycle_key")
-
-          # Initialize cycle storage if needed
-          code.line "assigns[:__cycle__] ||= {}"
-
-          # Get the cycle key
-          if is_named
-            code.line "#{key_var} = #{name_expr}"
-          else
-            code.line "#{key_var} = #{variables.object_id}"
-          end
-
-          # Get current index
-          code.line "#{cycle_var} = assigns[:__cycle__][#{key_var}].to_i"
-
-          # Get the value at current index
-          code.line "case #{cycle_var} % #{variables.size}"
-          variables.each_with_index do |var, idx|
-            var_expr = ExpressionCompiler.compile(var, compiler)
-            code.line "when #{idx} then __output__ << __to_s__(#{var_expr})"
-          end
-          code.line "end"
-
-          # Increment counter
-          code.line "assigns[:__cycle__][#{key_var}] = #{cycle_var} + 1"
-        end
-      end
-    end
-  end
-end
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% decrement var %} tags
-      #
-      # Decrements a counter and outputs its value.
-      # Uses a separate namespace from regular assigns (shares with increment).
-      class DecrementCompiler
-        def self.compile(tag, compiler, code)
-          var_name = tag.variable_name
-
-          # Initialize counter storage if needed
-          code.line "assigns[:__counters__] ||= {}"
-
-          # Get current value (default 0), decrement it, output, then store
-          dec_var = compiler.generate_var_name("dec")
-          code.line "#{dec_var} = (assigns[:__counters__][#{var_name.inspect}] || 0) - 1"
-          code.line "assigns[:__counters__][#{var_name.inspect}] = #{dec_var}"
-          code.line "__output__ << #{dec_var}.to_s"
-        end
-      end
-    end
-  end
-end
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% echo expression %} tags
-      #
-      # Same as {{ expression }} but usable in {% liquid %} blocks
-      class EchoCompiler
-        def self.compile(tag, compiler, code)
-          variable = tag.variable
-          VariableCompiler.compile(variable, compiler, code)
-        end
-      end
-    end
-  end
-end
@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% for %} / {% else %} / {% endfor %} tags
-      #
-      # Supports:
-      # - Iteration: {% for item in collection %}
-      # - Limit/Offset: {% for item in collection limit:3 offset:2 %}
-      # - Reversed: {% for item in collection reversed %}
-      # - Forloop object: forloop.index, forloop.first, forloop.last, etc.
-      # - Else block: {% for item in collection %}...{% else %}empty{% endfor %}
-      class ForCompiler
-        def self.compile(tag, compiler, code)
-          var_name = tag.variable_name
-          collection_expr = ExpressionCompiler.compile(tag.collection_name, compiler)
-
-          # Generate unique variable names for this loop
-          coll_var = compiler.generate_var_name("coll")
-          idx_var = compiler.generate_var_name("idx")
-          len_var = compiler.generate_var_name("len")
-
-          # Evaluate the collection
-          code.line "#{coll_var} = #{collection_expr}"
-          code.line "#{coll_var} = #{coll_var}.to_a if #{coll_var}.is_a?(Range)"
-
-          # Handle limit and offset
-          if tag.from || tag.limit
-            compile_slice(tag, coll_var, compiler, code)
-          end
-
-          # Handle reversed
-          if tag.instance_variable_get(:@reversed)
-            code.line "#{coll_var} = #{coll_var}.reverse"
-          end
-
-          # Check if collection is empty for else block
-          for_block = tag.instance_variable_get(:@for_block)
-          else_block = tag.instance_variable_get(:@else_block)
-
-          if else_block
-            code.line "if #{coll_var}.nil? || (#{coll_var}.respond_to?(:empty?) && #{coll_var}.empty?)"
-            code.indent do
-              BlockBodyCompiler.compile(else_block, compiler, code)
-            end
-            code.line "else"
-            code.indent do
-              compile_loop(tag, var_name, coll_var, idx_var, len_var, for_block, compiler, code)
-            end
-            code.line "end"
-          else
-            compile_loop(tag, var_name, coll_var, idx_var, len_var, for_block, compiler, code)
-          end
-        end
-
-        private
-
-        def self.compile_slice(tag, coll_var, compiler, code)
-          from_expr = if tag.from == :continue
-            # Continue from previous offset - we'd need register tracking for this
-            # For now, default to 0
-            "0"
-          elsif tag.from
-            ExpressionCompiler.compile(tag.from, compiler)
-          else
-            "0"
-          end
-
-          if tag.limit
-            limit_expr = ExpressionCompiler.compile(tag.limit, compiler)
-            code.line "#{coll_var} = (#{coll_var}.respond_to?(:slice) ? #{coll_var}.slice(__to_integer__(#{from_expr}), __to_integer__(#{limit_expr})) : #{coll_var}) || []"
-          else
-            code.line "#{coll_var} = (#{coll_var}.respond_to?(:drop) ? #{coll_var}.drop(__to_integer__(#{from_expr})) : #{coll_var}) || []"
-          end
-        end
-
-        def self.compile_loop(tag, var_name, coll_var, idx_var, len_var, for_block, compiler, code)
-          # Calculate length for forloop
-          code.line "#{len_var} = #{coll_var}.respond_to?(:length) ? #{coll_var}.length : 0"
-          code.line "#{idx_var} = 0"
-
-          # The loop itself - use catch/throw for break support across nested blocks
-          code.line "catch(:__loop__break__) do"
-          code.indent do
-            code.line "(#{coll_var}.respond_to?(:each) ? #{coll_var} : []).each do |__item__|"
-            code.indent do
-              # Wrap each iteration in a catch for continue support
-              code.line "catch(:__loop__continue__) do"
-              code.indent do
-                # Set the loop variable
-                code.line "assigns[#{var_name.inspect}] = __item__"
-
-                # Build the forloop object as a hash
-                code.line "assigns['forloop'] = {"
-                code.indent do
-                  code.line "'name' => #{tag.instance_variable_get(:@name).inspect},"
-                  code.line "'length' => #{len_var},"
-                  code.line "'index' => #{idx_var} + 1,"
-                  code.line "'index0' => #{idx_var},"
-                  code.line "'rindex' => #{len_var} - #{idx_var},"
-                  code.line "'rindex0' => #{len_var} - #{idx_var} - 1,"
-                  code.line "'first' => #{idx_var} == 0,"
-                  code.line "'last' => #{idx_var} == #{len_var} - 1,"
-                end
-                code.line "}"
-
-                # Compile the loop body
-                BlockBodyCompiler.compile(for_block, compiler, code)
-              end
-              code.line "end"
-
-              # Increment index (runs even after continue)
-              code.line "#{idx_var} += 1"
-            end
-            code.line "end"
-          end
-          code.line "end"
-
-          # Clean up
-          code.line "assigns.delete(#{var_name.inspect})"
-          code.line "assigns.delete('forloop')"
-        end
-      end
-    end
-  end
-end
@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% if %} / {% elsif %} / {% else %} / {% endif %} tags
-      class IfCompiler
-        def self.compile(tag, compiler, code)
-          blocks = tag.blocks
-
-          blocks.each_with_index do |block, index|
-            condition_expr = ConditionCompiler.compile(block, compiler)
-
-            if index == 0
-              code.line "if #{condition_expr}"
-            elsif block.else?
-              code.line "else"
-            else
-              code.line "elsif #{condition_expr}"
-            end
-
-            code.indent do
-              if block.attachment
-                BlockBodyCompiler.compile(block.attachment, compiler, code)
-              end
-            end
-          end
-
-          code.line "end"
-        end
-      end
-    end
-  end
-end
@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% ifchanged %}...{% endifchanged %} tags
-      #
-      # Only outputs if the content has changed since last render
-      class IfchangedCompiler
-        def self.compile(tag, compiler, code)
-          capture_var = compiler.generate_var_name("ifchanged")
-
-          # Capture the block output
-          code.line "#{capture_var} = +''"
-          code.line "begin"
-          code.indent do
-            code.line "__saved_output__ = __output__"
-            code.line "__output__ = #{capture_var}"
-
-            # Compile the body
-            tag.nodelist.each do |body|
-              BlockBodyCompiler.compile(body, compiler, code)
-            end
-
-            code.line "__output__ = __saved_output__"
-          end
-          code.line "end"
-
-          # Only output if changed
-          code.line "if #{capture_var} != assigns[:__ifchanged__]"
-          code.indent do
-            code.line "assigns[:__ifchanged__] = #{capture_var}"
-            code.line "__output__ << #{capture_var}"
-          end
-          code.line "end"
-        end
-      end
-    end
-  end
-end
@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% include 'partial' %} tags
-      #
-      # Include is deprecated in favor of render, but we support it for compatibility.
-      # Unlike render, include shares the outer scope with the partial.
-      #
-      # For static template names, the partial is loaded and inlined at compile time.
-      # For dynamic template names, a runtime fallback is generated.
-      class IncludeCompiler
-        def self.compile(tag, compiler, code)
-          template_name_expr = tag.template_name_expr
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          alias_name = tag.instance_variable_get(:@alias_name)
-
-          # Check if the template name is a static string
-          if template_name_expr.is_a?(String)
-            compile_static_include(tag, template_name_expr, compiler, code)
-          else
-            compile_dynamic_include(tag, compiler, code)
-          end
-        end
-
-        private
-
-        def self.compile_static_include(tag, template_name, compiler, code)
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          alias_name = tag.instance_variable_get(:@alias_name)
-
-          # Try to load the partial at compile time
-          partial_source = compiler.load_partial(template_name)
-
-          if partial_source
-            if compiler.debug?
-              code.line "# Inlined partial #{template_name.inspect} at compile time"
-              code.line "$stderr.puts '* WARN: Liquid file system access - inlined partial ' + #{template_name.inspect} + ' at compile time' if $VERBOSE"
-            end
-            # Generate a unique method name for this partial
-            method_name = compiler.register_partial(template_name, partial_source)
-            context_var_name = alias_name || template_name.split('/').last
-
-            # Include shares scope, so we just set variables directly
-            code.line "# Include: #{template_name}"
-
-            # Set attributes
-            attributes.each do |key, value|
-              value_expr = ExpressionCompiler.compile(value, compiler)
-              code.line "assigns[#{key.inspect}] = #{value_expr}"
-            end
-
-            # Set the context variable
-            if variable_name_expr
-              var_expr = ExpressionCompiler.compile(variable_name_expr, compiler)
-              var_var = compiler.generate_var_name("incvar")
-              code.line "#{var_var} = #{var_expr}"
-
-              # If it's an array, loop through it
-              code.line "if #{var_var}.is_a?(Array)"
-              code.indent do
-                code.line "#{var_var}.each do |__include_item__|"
-                code.indent do
-                  code.line "assigns[#{context_var_name.inspect}] = __include_item__"
-                  code.line "__output__ << #{method_name}({})"
-                end
-                code.line "end"
-              end
-              code.line "else"
-              code.indent do
-                code.line "assigns[#{context_var_name.inspect}] = #{var_var}"
-                code.line "__output__ << #{method_name}({})"
-              end
-              code.line "end"
-            else
-              # Try to find a variable with the same name as the template
-              code.line "assigns[#{context_var_name.inspect}] = assigns[#{template_name.inspect}] if assigns.key?(#{template_name.inspect})"
-              code.line "__output__ << #{method_name}({})"
-            end
-          else
-            # Partial not found at compile time
-            code.line "# Partial '#{template_name}' not found at compile time"
-            compile_dynamic_include(tag, compiler, code)
-          end
-        end
-
-        def self.compile_dynamic_include(tag, compiler, code)
-          template_name_expr = tag.template_name_expr
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          alias_name = tag.instance_variable_get(:@alias_name)
-
-          if compiler.debug?
-            code.line "# Dynamic include (template name from variable)"
-            code.line "$stderr.puts '* WARN: Liquid runtime file system access - dynamic include (template name from variable)' if $VERBOSE"
-          end
-
-          name_expr = ExpressionCompiler.compile(template_name_expr, compiler)
-
-          # Build attributes hash
-          attrs_var = compiler.generate_var_name("attrs")
-          code.line "#{attrs_var} = {}"
-          attributes.each do |key, value|
-            value_expr = ExpressionCompiler.compile(value, compiler)
-            code.line "#{attrs_var}[#{key.inspect}] = #{value_expr}"
-          end
-
-          var_expr = variable_name_expr ? ExpressionCompiler.compile(variable_name_expr, compiler) : "nil"
-          alias_expr = alias_name ? alias_name.inspect : "nil"
-
-          # Call the runtime dynamic include method
-          code.line "if defined?(__include_dynamic__)"
-          code.indent do
-            code.line "__output__ << __include_dynamic__(#{name_expr}, #{var_expr}, #{attrs_var}, #{alias_expr}, assigns)"
-          end
-          code.line "else"
-          code.indent do
-            code.line "raise RuntimeError, 'Dynamic include requires __include_dynamic__ method: ' + #{name_expr}.inspect"
-          end
-          code.line "end"
-        end
-      end
-    end
-  end
-end
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% increment var %} tags
-      #
-      # Outputs the current counter value, then increments it.
-      # Uses a separate namespace from regular assigns (shares with decrement).
-      class IncrementCompiler
-        def self.compile(tag, compiler, code)
-          var_name = tag.variable_name
-
-          # Initialize counter storage if needed
-          code.line "assigns[:__counters__] ||= {}"
-
-          # Get current value (default 0), output it, then increment
-          inc_var = compiler.generate_var_name("inc")
-          code.line "#{inc_var} = assigns[:__counters__][#{var_name.inspect}] || 0"
-          code.line "__output__ << #{inc_var}.to_s"
-          code.line "assigns[:__counters__][#{var_name.inspect}] = #{inc_var} + 1"
-        end
-      end
-    end
-  end
-end
@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% raw %}...{% endraw %} tags
-      #
-      # Outputs the content as-is without parsing Liquid syntax
-      class RawCompiler
-        def self.compile(tag, compiler, code)
-          body = tag.instance_variable_get(:@body)
-          return if body.nil? || body.empty?
-
-          code.line "__output__ << #{body.inspect}"
-        end
-      end
-    end
-  end
-end
@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% render 'partial' %} tags
-      #
-      # For static template names (string literals), the partial is loaded at
-      # compile time and inlined as a method.
-      #
-      # For dynamic template names (variables), a runtime fallback is generated
-      # that calls __render_dynamic__ which must be provided by the runtime.
-      class RenderCompiler
-        def self.compile(tag, compiler, code)
-          template_name_expr = tag.template_name_expr
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          alias_name = tag.alias_name
-          is_for_loop = tag.for_loop?
-
-          # Check if the template name is a static string
-          if template_name_expr.is_a?(String)
-            compile_static_render(tag, template_name_expr, compiler, code)
-          else
-            compile_dynamic_render(tag, compiler, code)
-          end
-        end
-
-        private
-
-        def self.compile_static_render(tag, template_name, compiler, code)
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          alias_name = tag.alias_name
-          is_for_loop = tag.for_loop?
-
-          # Try to load the partial at compile time
-          partial_source = compiler.load_partial(template_name)
-
-          if partial_source
-            if compiler.debug?
-              code.line "# Inlined partial #{template_name.inspect} at compile time"
-              code.line "$stderr.puts '* WARN: Liquid file system access - inlined partial ' + #{template_name.inspect} + ' at compile time' if $VERBOSE"
-            end
-            # Generate a unique method name for this partial
-            method_name = compiler.register_partial(template_name, partial_source)
-            context_var_name = alias_name || template_name.split('/').last
-
-            if is_for_loop && variable_name_expr
-              # Render for each item in collection
-              compile_for_loop_render(tag, method_name, context_var_name, compiler, code)
-            else
-              # Single render
-              compile_single_render(tag, method_name, context_var_name, compiler, code)
-            end
-          else
-            # Partial not found at compile time - generate runtime fallback
-            code.line "# Partial '#{template_name}' not found at compile time"
-            compile_dynamic_render(tag, compiler, code)
-          end
-        end
-
-        def self.compile_single_render(tag, method_name, context_var_name, compiler, code)
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-
-          # Build the inner assigns hash
-          inner_assigns_var = compiler.generate_var_name("inner")
-          code.line "#{inner_assigns_var} = {}"
-
-          # Copy attributes
-          attributes.each do |key, value|
-            value_expr = ExpressionCompiler.compile(value, compiler)
-            code.line "#{inner_assigns_var}[#{key.inspect}] = #{value_expr}"
-          end
-
-          # Set the context variable if provided
-          if variable_name_expr
-            var_expr = ExpressionCompiler.compile(variable_name_expr, compiler)
-            code.line "#{inner_assigns_var}[#{context_var_name.inspect}] = #{var_expr}"
-          end
-
-          # Call the partial method
-          code.line "__output__ << #{method_name}(#{inner_assigns_var})"
-        end
-
-        def self.compile_for_loop_render(tag, method_name, context_var_name, compiler, code)
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          template_name = tag.template_name_expr
-
-          coll_var = compiler.generate_var_name("coll")
-          coll_expr = ExpressionCompiler.compile(variable_name_expr, compiler)
-          code.line "#{coll_var} = #{coll_expr}"
-
-          code.line "if #{coll_var}.respond_to?(:each) && #{coll_var}.respond_to?(:count)"
-          code.indent do
-            len_var = compiler.generate_var_name("len")
-            idx_var = compiler.generate_var_name("idx")
-            code.line "#{len_var} = #{coll_var}.count"
-            code.line "#{idx_var} = 0"
-
-            code.line "#{coll_var}.each do |__item__|"
-            code.indent do
-              inner_assigns_var = compiler.generate_var_name("inner")
-              code.line "#{inner_assigns_var} = {}"
-
-              # Copy attributes
-              attributes.each do |key, value|
-                value_expr = ExpressionCompiler.compile(value, compiler)
-                code.line "#{inner_assigns_var}[#{key.inspect}] = #{value_expr}"
-              end
-
-              # Set the context variable
-              code.line "#{inner_assigns_var}[#{context_var_name.inspect}] = __item__"
-
-              # Set forloop
-              code.line "#{inner_assigns_var}['forloop'] = {"
-              code.indent do
-                code.line "'name' => #{template_name.inspect},"
-                code.line "'length' => #{len_var},"
-                code.line "'index' => #{idx_var} + 1,"
-                code.line "'index0' => #{idx_var},"
-                code.line "'rindex' => #{len_var} - #{idx_var},"
-                code.line "'rindex0' => #{len_var} - #{idx_var} - 1,"
-                code.line "'first' => #{idx_var} == 0,"
-                code.line "'last' => #{idx_var} == #{len_var} - 1,"
-              end
-              code.line "}"
-
-              # Call the partial method
-              code.line "__output__ << #{method_name}(#{inner_assigns_var})"
-
-              code.line "#{idx_var} += 1"
-            end
-            code.line "end"
-          end
-          code.line "else"
-          code.indent do
-            # Single render if not a collection
-            compile_single_render(tag, method_name, context_var_name, compiler, code)
-          end
-          code.line "end"
-        end
-
-        def self.compile_dynamic_render(tag, compiler, code)
-          template_name_expr = tag.template_name_expr
-          variable_name_expr = tag.variable_name_expr
-          attributes = tag.attributes
-          alias_name = tag.alias_name
-          is_for_loop = tag.for_loop?
-
-          if compiler.debug?
-            code.line "# Dynamic render (template name from variable)"
-            code.line "$stderr.puts '* WARN: Liquid runtime file system access - dynamic render (template name from variable)' if $VERBOSE"
-          end
-
-          name_expr = ExpressionCompiler.compile(template_name_expr, compiler)
-
-          # Build attributes hash
-          attrs_var = compiler.generate_var_name("attrs")
-          code.line "#{attrs_var} = {}"
-          attributes.each do |key, value|
-            value_expr = ExpressionCompiler.compile(value, compiler)
-            code.line "#{attrs_var}[#{key.inspect}] = #{value_expr}"
-          end
-
-          var_expr = variable_name_expr ? ExpressionCompiler.compile(variable_name_expr, compiler) : "nil"
-          alias_expr = alias_name ? alias_name.inspect : "nil"
-
-          # Call the runtime dynamic render method
-          code.line "if defined?(__render_dynamic__)"
-          code.indent do
-            code.line "__output__ << __render_dynamic__(#{name_expr}, #{var_expr}, #{attrs_var}, #{alias_expr}, #{is_for_loop})"
-          end
-          code.line "else"
-          code.indent do
-            code.line "raise RuntimeError, 'Dynamic render requires __render_dynamic__ method: ' + #{name_expr}.inspect"
-          end
-          code.line "end"
-        end
-      end
-    end
-  end
-end
@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% tablerow %} tags
-      #
-      # Creates HTML table rows from a collection
-      class TableRowCompiler
-        def self.compile(tag, compiler, code)
-          var_name = tag.variable_name
-          collection_expr = ExpressionCompiler.compile(tag.collection_name, compiler)
-          attributes = tag.attributes
-
-          # Generate unique variable names
-          coll_var = compiler.generate_var_name("coll")
-          idx_var = compiler.generate_var_name("idx")
-          len_var = compiler.generate_var_name("len")
-          cols_var = compiler.generate_var_name("cols")
-          row_var = compiler.generate_var_name("row")
-          col_var = compiler.generate_var_name("col")
-
-          # Get parameters from attributes hash
-          cols = attributes['cols']
-          cols_expr = cols ? ExpressionCompiler.compile(cols, compiler) : "nil"
-
-          # Evaluate the collection
-          code.line "#{coll_var} = #{collection_expr}"
-          code.line "#{coll_var} = #{coll_var}.to_a if #{coll_var}.is_a?(Range)"
-
-          # Handle limit and offset from attributes
-          offset = attributes['offset']
-          limit = attributes['limit']
-          if offset || limit
-            if offset
-              offset_expr = ExpressionCompiler.compile(offset, compiler)
-              if limit
-                limit_expr = ExpressionCompiler.compile(limit, compiler)
-                code.line "#{coll_var} = #{coll_var}.slice(__to_integer__(#{offset_expr}), __to_integer__(#{limit_expr})) || []"
-              else
-                code.line "#{coll_var} = #{coll_var}.drop(__to_integer__(#{offset_expr}))"
-              end
-            elsif limit
-              limit_expr = ExpressionCompiler.compile(limit, compiler)
-              code.line "#{coll_var} = #{coll_var}.first(__to_integer__(#{limit_expr}))"
-            end
-          end
-
-          # Setup loop variables
-          code.line "#{len_var} = #{coll_var}.respond_to?(:length) ? #{coll_var}.length : 0"
-          code.line "#{cols_var} = #{cols_expr} || #{len_var}"
-          code.line "#{idx_var} = 0"
-          code.line "#{row_var} = 1"
-          code.line "#{col_var} = 0"
-
-          body = tag.instance_variable_get(:@body)
-
-          # Output initial row (matches interpreter behavior: outputs before loop)
-          code.line "__output__ << \"<tr class=\\\"row1\\\">\\n\""
-
-          # The loop
-          code.line "(#{coll_var}.respond_to?(:each) ? #{coll_var} : []).each do |__item__|"
-          code.indent do
-            code.line "#{col_var} += 1"
-
-            # Output cell start
-            code.line "__output__ << \"<td class=\\\"col\#{#{col_var}}\\\">\""
-
-            # Set loop variables
-            code.line "assigns[#{var_name.inspect}] = __item__"
-            code.line "assigns['tablerowloop'] = {"
-            code.indent do
-              code.line "'length' => #{len_var},"
-              code.line "'index' => #{idx_var} + 1,"
-              code.line "'index0' => #{idx_var},"
-              code.line "'rindex' => #{len_var} - #{idx_var},"
-              code.line "'rindex0' => #{len_var} - #{idx_var} - 1,"
-              code.line "'first' => #{idx_var} == 0,"
-              code.line "'last' => #{idx_var} == #{len_var} - 1,"
-              code.line "'col' => #{col_var},"
-              code.line "'col0' => #{col_var} - 1,"
-              code.line "'row' => #{row_var},"
-              code.line "'col_first' => #{col_var} == 1,"
-              code.line "'col_last' => #{col_var} == #{cols_var},"
-            end
-            code.line "}"
-
-            # Compile the body
-            BlockBodyCompiler.compile(body, compiler, code)
-
-            # Output cell end
-            code.line "__output__ << '</td>'"
-
-            # End row and start new row if needed (but not on last item)
-            code.line "if #{col_var} == #{cols_var} && #{idx_var} != #{len_var} - 1"
-            code.indent do
-              code.line "__output__ << \"</tr>\\n<tr class=\\\"row\#{#{row_var} + 1}\\\">\""
-              code.line "#{col_var} = 0"
-              code.line "#{row_var} += 1"
-            end
-            code.line "end"
-
-            code.line "#{idx_var} += 1"
-          end
-          code.line "end"
-
-          # Close the final row
-          code.line "__output__ << \"</tr>\\n\""
-
-          # Clean up
-          code.line "assigns.delete(#{var_name.inspect})"
-          code.line "assigns.delete('tablerowloop')"
-        end
-      end
-    end
-  end
-end
@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    module Tags
-      # Compiles {% unless %} / {% elsif %} / {% else %} / {% endunless %} tags
-      #
-      # Unless is like if, but the first condition is negated
-      class UnlessCompiler
-        def self.compile(tag, compiler, code)
-          blocks = tag.blocks
-
-          blocks.each_with_index do |block, index|
-            condition_expr = ConditionCompiler.compile(block, compiler)
-
-            if index == 0
-              # First block is negated (unless = if not)
-              code.line "unless #{condition_expr}"
-            elsif block.else?
-              code.line "else"
-            else
-              # Subsequent blocks (elsif) are normal
-              code.line "elsif #{condition_expr}"
-            end
-
-            code.indent do
-              if block.attachment
-                BlockBodyCompiler.compile(block.attachment, compiler, code)
-              end
-            end
-          end
-
-          code.line "end"
-        end
-      end
-    end
-  end
-end
@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Compile
-    # VariableCompiler compiles Liquid variable expressions ({{ ... }}) to Ruby code.
-    #
-    # A Variable consists of:
-    # - A name expression (the value to output)
-    # - Zero or more filters to apply
-    class VariableCompiler
-      # Compile a Variable node and append the result to the output buffer
-      # @param variable [Liquid::Variable] The variable node
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @param code [CodeGenerator] The code generator
-      def self.compile(variable, compiler, code)
-        value_expr = compile_to_expression(variable, compiler)
-        code.line "__output__ << __output_value__(#{value_expr})"
-      end
-
-      # Compile a Variable node to a Ruby expression (without output)
-      # @param variable [Liquid::Variable] The variable node
-      # @param compiler [RubyCompiler] The main compiler instance
-      # @return [String] Ruby code expression
-      def self.compile_to_expression(variable, compiler)
-        # Compile the base name expression
-        base_expr = ExpressionCompiler.compile(variable.name, compiler)
-
-        # Apply filters if any
-        if variable.filters && !variable.filters.empty?
-          FilterCompiler.compile(base_expr, variable.filters, compiler)
-        else
-          base_expr
-        end
-      end
-    end
-  end
-end
@@ -1,96 +1,55 @@
-# frozen_string_literal: true
-
 module Liquid
  # Container for liquid nodes which conveniently wraps decision making logic
  #
  # Example:
  #
-  #   c = Condition.new(1, '==', 1)
+  #   c = Condition.new('1', '==', '1')
  #   c.evaluate #=> true
  #
-  class Condition # :nodoc:
+  class Condition #:nodoc:
    @@operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<' => :<,
-      '>' => :>,
-      '>=' => :>=,
-      '<=' => :<=,
-      'contains' => lambda do |_cond, left, right|
-        if left && right && left.respond_to?(:include?)
-          right = right.to_s if left.is_a?(String)
-          left.include?(right)
-        else
-          false
-        end
-      rescue Encoding::CompatibilityError
-        # "✅".b.include?("✅") raises Encoding::CompatibilityError despite being materially equal
-        left.b.include?(right.b)
-      end,
-    }
-
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-    end
-
-    @@method_literals = {
-      'blank' => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => MethodLiteral.new(:empty?, '').freeze,
+      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<'.freeze  => :<,
+      '>'.freeze  => :>,
+      '>='.freeze => :>=,
+      '<='.freeze => :<=,
+      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
    }

    def self.operators
      @@operators
    end

-    def self.parse_expression(parse_context, markup)
-      @@method_literals[markup] || parse_context.parse_expression(markup)
-    end
-
-    attr_reader :attachment, :child_condition
+    attr_reader :attachment
    attr_accessor :left, :operator, :right

    def initialize(left = nil, operator = nil, right = nil)
-      @left     = left
-      @operator = operator
-      @right    = right
-
+      @left, @operator, @right = left, operator, right
      @child_relation  = nil
      @child_condition = nil
    end

-    def evaluate(context = deprecated_default_context)
-      condition = self
-      result = nil
-      loop do
-        result = interpret_condition(condition.left, condition.right, condition.operator, context)
+    def evaluate(context = Context.new)
+      result = interpret_condition(left, right, operator, context)

-        case condition.child_relation
-        when :or
-          break if Liquid::Utils.to_liquid_value(result)
-        when :and
-          break unless Liquid::Utils.to_liquid_value(result)
-        else
-          break
-        end
-        condition = condition.child_condition
+      case @child_relation
+      when :or
+        result || @child_condition.evaluate(context)
+      when :and
+        result && @child_condition.evaluate(context)
+      else
+        result
      end
-      result
    end

    def or(condition)
-      @child_relation  = :or
-      @child_condition = condition
+      @child_relation, @child_condition = :or, condition
    end

    def and(condition)
-      @child_relation  = :and
-      @child_condition = condition
+      @child_relation, @child_condition = :and, condition
    end

    def attach(attachment)
@@ -102,27 +61,23 @@ module Liquid
    end

    def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
    end

-    protected
-
-    attr_reader :child_relation
-
    private

    def equal_variables(left, right)
-      if left.is_a?(MethodLiteral)
-        if right.respond_to?(left.method_name)
-          return right.send(left.method_name)
+      if left.is_a?(Symbol)
+        if right.respond_to?(left)
+          return right.send(left.to_s)
        else
          return nil
        end
      end

-      if right.is_a?(MethodLiteral)
-        if left.respond_to?(right.method_name)
-          return left.send(right.method_name)
+      if right.is_a?(Symbol)
+        if left.respond_to?(right)
+          return left.send(right.to_s)
        else
          return nil
        end
@@ -135,49 +90,35 @@ module Liquid
      # If the operator is empty this means that the decision statement is just
      # a single variable. We can just poll this variable from the context and
      # return this as the result.
-      return context.evaluate(left) if op.nil?
+      return context[left] if op == nil

-      left  = Liquid::Utils.to_liquid_value(context.evaluate(left))
-      right = Liquid::Utils.to_liquid_value(context.evaluate(right))
+      left, right = context[left], context[right]

-      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))

      if operation.respond_to?(:call)
        operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
        begin
          left.send(operation, right)
        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError, e.message
+          raise Liquid::ArgumentError.new(e.message)
        end
-      end
-    end
-
-    def deprecated_default_context
-      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
-        " and will be removed from Liquid 6.0.0.")
-      Context.new
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.left,
-          @node.right,
-          @node.child_condition,
-          @node.attachment
-        ].compact
+      else
+        nil
      end
    end
  end

+
  class ElseCondition < Condition
    def else?
      true
    end

-    def evaluate(_context)
+    def evaluate(context)
      true
    end
  end
+
 end
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Const
-    EMPTY_HASH = {}.freeze
-    EMPTY_ARRAY = [].freeze
-  end
-end
@@ -1,6 +1,5 @@
-# frozen_string_literal: true
-
 module Liquid
+
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
  #   context['variable'] = 'testing'
@@ -14,58 +13,44 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters, :environment
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_accessor :exception_handler

-    # rubocop:disable Metrics/ParameterLists
-    def self.build(environment: Environment.default, environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {}, &block)
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, environment, &block)
-    end
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m

-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
-      @environment = environment
-      @environments = [environments]
-      @environments.flatten!
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
+      @environments    = [environments].flatten
+      @scopes          = [(outer_scope || {})]
+      @registers       = registers
+      @errors          = []
+      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
+      squash_instance_assigns_with_environments

-      @static_environments = [static_environments].flatten(1).freeze
-      @scopes              = [outer_scope || {}]
-      @registers           = registers.is_a?(Registers) ? registers : Registers.new(registers)
-      @errors              = []
-      @partial             = false
-      @strict_variables    = false
-      @resource_limits     = resource_limits || ResourceLimits.new(environment.default_resource_limits)
-      @base_scope_depth    = 0
-      @interrupts          = []
-      @filters             = []
-      @global_filter       = nil
-      @disabled_tags       = {}
-
-      # Instead of constructing new StringScanner objects for each Expression parse,
-      # we recycle the same one.
-      @string_scanner = StringScanner.new("")
-
-      @registers.static[:cached_partials] ||= {}
-      @registers.static[:file_system] ||= environment.file_system
-      @registers.static[:template_factory] ||= Liquid::TemplateFactory.new
-
-      self.exception_renderer = environment.exception_renderer
      if rethrow_errors
-        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
+        self.exception_handler = ->(e) { true }
      end

-      yield self if block_given?
-
-      # Do this last, since it could result in this object being passed to a Proc in the environment
-      squash_instance_assigns_with_environments
+      @interrupts = []
+      @filters = []
+      @parsed_variables = Hash.new{ |cache, markup| cache[markup] = variable_parse(markup) } 
    end
-    # rubocop:enable Metrics/ParameterLists

-    def warnings
-      @warnings ||= []
+    def increment_used_resources(key, obj)
+      @resource_limits[key] += if obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
+        obj.length
+      else
+        1
+      end
+    end
+
+    def resource_limits_reached?
+      (@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
+      (@resource_limits[:render_score_limit]  && @resource_limits[:render_score_current]  > @resource_limits[:render_score_limit] ) ||
+      (@resource_limits[:assign_score_limit]  && @resource_limits[:assign_score_current]  > @resource_limits[:assign_score_limit] )
    end

    def strainer
-      @strainer ||= @environment.create_strainer(self, @filters)
+      @strainer ||= Strainer.create(self, @filters)
    end

    # Adds filters to this context.
@@ -74,16 +59,25 @@ module Liquid
    # for that
    def add_filters(filters)
      filters = [filters].flatten.compact
-      @filters += filters
-      @strainer = nil
-    end
+      filters.each do |f|
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+        Strainer.add_known_filter(f)
+      end

-    def apply_global_filter(obj)
-      global_filter.nil? ? obj : global_filter.call(obj)
+      # If strainer is already setup then there's no choice but to use a runtime
+      # extend call. If strainer is not yet created, we can utilize strainers
+      # cached class based API, which avoids busting the method cache.
+      if @strainer
+        filters.each do |f|
+          strainer.extend(f)
+        end
+      else
+        @filters.concat filters
+      end
    end

    # are there any not handled interrupts?
-    def interrupt?
+    def has_interrupt?
      !@interrupts.empty?
    end

@@ -97,22 +91,27 @@ module Liquid
      @interrupts.pop
    end

-    def handle_error(e, line_number = nil)
-      e = internal_error unless e.is_a?(Liquid::Error)
-      e.template_name ||= template_name
-      e.line_number   ||= line_number
+    def handle_error(e)
      errors.push(e)
-      exception_renderer.call(e).to_s
+
+      raise if exception_handler && exception_handler.call(e)
+
+      case e
+      when SyntaxError
+        "Liquid syntax error: #{e.message}"
+      else
+        "Liquid error: #{e.message}"
+      end
    end

    def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+      strainer.invoke(method, *args)
    end

    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope = {})
+    def push(new_scope={})
      @scopes.unshift(new_scope)
-      check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
    end

    # Merge a hash of variables in the current local scope
@@ -133,35 +132,14 @@ module Liquid
    #      context['var'] = 'hi'
    #   end
    #
-    #   context['var']  #=> nil
-    def stack(new_scope = {})
+    #   context['var]  #=> nil
+    def stack(new_scope={})
      push(new_scope)
      yield
    ensure
      pop
    end

-    # Creates a new context inheriting resource limits, filters, environment etc.,
-    # but with an isolated scope.
-    def new_isolated_subcontext
-      check_overflow
-
-      self.class.build(
-        environment: @environment,
-        resource_limits: resource_limits,
-        static_environments: static_environments,
-        registers: Registers.new(registers),
-      ).tap do |subcontext|
-        subcontext.base_scope_depth   = base_scope_depth + 1
-        subcontext.exception_renderer = exception_renderer
-        subcontext.filters  = @filters
-        subcontext.strainer = nil
-        subcontext.errors   = errors
-        subcontext.warnings = warnings
-        subcontext.disabled_tags = @disabled_tags
-      end
-    end
-
    def clear_instance_assigns
      @scopes[0] = {}
    end
@@ -171,125 +149,158 @@ module Liquid
      @scopes[0][key] = value
    end

-    # Look up variable, either resolve directly after considering the name. We can directly handle
-    # Strings, digits, floats and booleans (true,false).
-    # If no match is made we lookup the variable in the current scope and
-    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-    #
-    # Example:
-    #   products == empty #=> products.empty?
-    def [](expression)
-      evaluate(Expression.parse(expression, @string_scanner))
+    def [](key)
+      resolve(key)
    end

-    def key?(key)
-      self[key] != nil
+    def has_key?(key)
+      resolve(key) != nil
    end

-    def evaluate(object)
-      object.respond_to?(:evaluate) ? object.evaluate(self) : object
-    end
-
-    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key, raise_on_not_found: true)
-      # This was changed from find() to find_index() because this is a very hot
-      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.key?(key) }
-
-      variable = if index
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
-      else
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
-      end
-
-      # update variable's context before invoking #to_liquid
-      variable.context = self if variable.respond_to?(:context=)
-
-      liquid_variable = variable.to_liquid
-
-      liquid_variable.context = self if variable != liquid_variable && liquid_variable.respond_to?(:context=)
-
-      liquid_variable
-    end
-
-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
-      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
-        raise Liquid::UndefinedVariable, "undefined variable #{key}"
-      end
-
-      value = obj[key]
-
-      if value.is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.arity == 0 ? value.call : value.call(self)
-      else
-        value
-      end
-    end
-
-    def with_disabled_tags(tag_names)
-      tag_names.each do |name|
-        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
-      end
-      yield
-    ensure
-      tag_names.each do |name|
-        @disabled_tags[name] -= 1
-      end
-    end
-
-    def tag_disabled?(tag_name)
-      @disabled_tags.fetch(tag_name, 0) > 0
-    end
-
-    protected
-
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
-
    private
+      LITERALS = {
+        nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+        'true'.freeze  => true,
+        'false'.freeze => false,
+        'blank'.freeze => :blank?,
+        'empty'.freeze => :empty?
+      }

-    attr_reader :base_scope_depth
-
-    def try_variable_find_in_environments(key, raise_on_not_found:)
-      @environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      @static_environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      nil
-    end
-
-    def check_overflow
-      raise StackLevelError, "Nesting too deep" if overflow?
-    end
-
-    def overflow?
-      base_scope_depth + @scopes.length > Block::MAX_DEPTH
-    end
-
-    def internal_error
-      # raise and catch to set backtrace and cause on exception
-      raise Liquid::InternalError, 'internal'
-    rescue Liquid::InternalError => exc
-      exc
-    end
-
-    def squash_instance_assigns_with_environments
-      @scopes.last.each_key do |k|
-        @environments.each do |env|
-          if env.key?(k)
-            scopes.last[k] = lookup_and_evaluate(env, k)
-            break
+      # Look up variable, either resolve directly after considering the name. We can directly handle
+      # Strings, digits, floats and booleans (true,false).
+      # If no match is made we lookup the variable in the current scope and
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+      #
+      # Example:
+      #   products == empty #=> products.empty?
+      def resolve(key)
+        if LITERALS.key?(key)
+          LITERALS[key]
+        else
+          case key
+          when /\A'(.*)'\z/m # Single quoted strings
+            $1
+          when /\A"(.*)"\z/m # Double quoted strings
+            $1
+          when /\A(-?\d+)\z/ # Integer and floats
+            $1.to_i
+          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+            (resolve($1).to_i..resolve($2).to_i)
+          when /\A(-?\d[\d\.]+)\z/ # Floats
+            $1.to_f
+          else
+            variable(key)
          end
        end
      end
-    end # squash_instance_assigns_with_environments
+
+      # Fetches an object starting at the local scope and then moving up the hierachy
+      def find_variable(key)
+
+        # This was changed from find() to find_index() because this is a very hot
+        # path and find_index() is optimized in MRI to reduce object allocation
+        index = @scopes.find_index { |s| s.has_key?(key) }
+        scope = @scopes[index] if index
+
+        variable = nil
+
+        if scope.nil?
+          @environments.each do |e|
+            variable = lookup_and_evaluate(e, key)
+            unless variable.nil?
+              scope = e
+              break
+            end
+          end
+        end
+
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
+
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
+
+        return variable
+      end
+
+      def variable_parse(markup)
+        parts = markup.scan(VariableParser)
+        needs_resolution = false
+        if parts.first =~ SQUARE_BRACKETED 
+          needs_resolution = true
+          parts[0] = $1
+        end
+        {:first => parts.shift, :needs_resolution => needs_resolution, :rest => parts} 
+      end
+
+      # Resolves namespaced queries gracefully.
+      #
+      # Example
+      #  @context['hash'] = {"name" => 'tobi'}
+      #  assert_equal 'tobi', @context['hash.name']
+      #  assert_equal 'tobi', @context['hash["name"]']
+      def variable(markup)
+        parts = @parsed_variables[markup]
+
+        first_part = parts[:first] 
+        if parts[:needs_resolution]
+          first_part = resolve(parts[:first])
+        end
+
+        if object = find_variable(first_part)
+
+          parts[:rest].each do |part|
+            part = resolve($1) if part_resolved = (part =~ SQUARE_BRACKETED)
+
+            # If object is a hash- or array-like object we look for the
+            # presence of the key and if its available we return it
+            if object.respond_to?(:[]) and
+              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
+               (object.respond_to?(:fetch) and part.is_a?(Integer)))
+
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
+
+              # Some special cases. If the part wasn't in square brackets and
+              # no key with the same name was found we interpret following calls
+              # as commands and call them on the current object
+            elsif !part_resolved and object.respond_to?(part) and ['size'.freeze, 'first'.freeze, 'last'.freeze].include?(part)
+
+              object = object.send(part.intern).to_liquid
+
+              # No key was present with the desired value and it wasn't one of the directly supported
+              # keywords either. The only thing we got left is to return nil
+            else
+              return nil
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
+        end
+
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
+      def squash_instance_assigns_with_environments
+        @scopes.last.each_key do |k|
+          @environments.each do |env|
+            if env.has_key?(k)
+              scopes.last[k] = lookup_and_evaluate(env, k)
+              break
+            end
+          end
+        end
+      end # squash_instance_assigns_with_environments
  end # Context
 end # Liquid
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-
-module Liquid
-  class Deprecations
-    class << self
-      attr_accessor :warned
-
-      Deprecations.warned = Set.new
-
-      def warn(name, alternative)
-        return if warned.include?(name)
-
-        warned << name
-
-        caller_location = caller_locations(2, 1).first
-        Warning.warn("[DEPRECATION] #{name} is deprecated. Use #{alternative} instead. Called from #{caller_location}\n")
-      end
-    end
-  end
-end
@@ -1,65 +1,17 @@
-# frozen_string_literal: true
-
 module Liquid
-  class Document
-    def self.parse(tokens, parse_context)
-      doc = new(parse_context)
-      doc.parse(tokens, parse_context)
-      doc
+  class Document < Block
+    def self.parse(tokens, options={})
+      # we don't need markup to open this block
+      super(nil, nil, tokens, options)
    end

-    attr_reader :parse_context, :body
-
-    def initialize(parse_context)
-      @parse_context = parse_context
-      @body = new_body
+    # There isn't a real delimiter
+    def block_delimiter
+      []
    end

-    def nodelist
-      @body.nodelist
-    end
-
-    def parse(tokenizer, parse_context)
-      while parse_body(tokenizer)
-      end
-      @body.freeze
-    rescue SyntaxError => e
-      e.line_number ||= parse_context.line_number
-      raise
-    end
-
-    def unknown_tag(tag, _markup, _tokenizer)
-      case tag
-      when 'else', 'end'
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
-      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
-      end
-    end
-
-    def render_to_output_buffer(context, output)
-      @body.render_to_output_buffer(context, output)
-    end
-
-    def render(context)
-      render_to_output_buffer(context, +'')
-    end
-
-    private
-
-    def new_body
-      parse_context.new_block_body
-    end
-
-    def parse_body(tokenizer)
-      @body.parse(tokenizer, parse_context) do |unknown_tag_name, unknown_tag_markup|
-        if unknown_tag_name
-          unknown_tag(unknown_tag_name, unknown_tag_markup, tokenizer)
-          true
-        else
-          false
-        end
-      end
+    # Document blocks don't need to be terminated since they are not actually opened
+    def assert_missing_delimitation!
    end
  end
 end
@@ -1,8 +1,7 @@
-# frozen_string_literal: true
-
 require 'set'

 module Liquid
+
  # A drop in liquid is a class which allows you to export DOM like things to liquid.
  # Methods of drops are callable.
  # The main use for liquid drops is to implement lazy loaded objects.
@@ -20,31 +19,28 @@ module Liquid
  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
  #
-  # Your drop can either implement the methods sans any parameters
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
+  # catch all.
  class Drop
    attr_writer :context

-    def initialize
-      @context = nil
-    end
+    EMPTY_STRING = ''.freeze

    # Catch all for the method
-    def liquid_method_missing(method)
-      return nil unless @context&.strict_variables
-      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
+    def before_method(method)
+      nil
    end

    # called by liquid to invoke a drop
    def invoke_drop(method_or_key)
-      if self.class.invokable?(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
        send(method_or_key)
      else
-        liquid_method_missing(method_or_key)
+        before_method(method_or_key)
      end
    end

-    def key?(_name)
+    def has_key?(name)
      true
    end

@@ -60,25 +56,22 @@ module Liquid
      self.class.name
    end

-    alias_method :[], :invoke_drop
+    alias :[] :invoke_drop
+
+    private

    # Check for method existence without invoking respond_to?, which creates symbols
    def self.invokable?(method_name)
-      invokable_methods.include?(method_name.to_s)
-    end
-
-    def self.invokable_methods
-      @invokable_methods ||= begin
+      unless @invokable_methods
        blacklist = Liquid::Drop.public_instance_methods + [:each]
-
        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max]
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
        end
-
        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        Set.new(whitelist.map(&:to_s))
+        @invokable_methods = Set.new(whitelist.map(&:to_s))
      end
+      @invokable_methods.include?(method_name.to_s)
    end
  end
 end
@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # The Environment is the container for all configuration options of Liquid, such as
-  # the registered tags, filters, and the default error mode.
-  class Environment
-    # The default error mode for all templates. This can be overridden on a
-    # per-template basis.
-    attr_accessor :error_mode
-
-    # The tags that are available to use in the template.
-    attr_accessor :tags
-
-    # The strainer template which is used to store filters that are available to
-    # use in templates.
-    attr_accessor :strainer_template
-
-    # The exception renderer that is used to render exceptions that are raised
-    # when rendering a template
-    attr_accessor :exception_renderer
-
-    # The default file system that is used to load templates from.
-    attr_accessor :file_system
-
-    # The default resource limits that are used to limit the resources that a
-    # template can consume.
-    attr_accessor :default_resource_limits
-
-    class << self
-      # Creates a new environment instance.
-      #
-      # @param tags [Hash] The tags that are available to use in
-      #  the template.
-      # @param file_system The default file system that is used
-      #  to load templates from.
-      # @param error_mode [Symbol] The default error mode for all templates
-      #  (either :strict, :warn, or :lax).
-      # @param exception_renderer [Proc] The exception renderer that is used to
-      #   render exceptions.
-      # @yieldparam environment [Environment] The environment instance that is being built.
-      # @return [Environment] The new environment instance.
-      def build(tags: nil, file_system: nil, error_mode: nil, exception_renderer: nil)
-        ret = new
-        ret.tags = tags if tags
-        ret.file_system = file_system if file_system
-        ret.error_mode = error_mode if error_mode
-        ret.exception_renderer = exception_renderer if exception_renderer
-        yield ret if block_given?
-        ret.freeze
-      end
-
-      # Returns the default environment instance.
-      #
-      # @return [Environment] The default environment instance.
-      def default
-        @default ||= new
-      end
-
-      # Sets the default environment instance for the duration of the block
-      #
-      # @param environment [Environment] The environment instance to use as the default for the
-      #   duration of the block.
-      # @yield
-      # @return [Object] The return value of the block.
-      def dangerously_override(environment)
-        original_default = @default
-        @default = environment
-        yield
-      ensure
-        @default = original_default
-      end
-    end
-
-    # Initializes a new environment instance.
-    # @api private
-    def initialize
-      @tags = Tags::STANDARD_TAGS.dup
-      @error_mode = :lax
-      @strainer_template = Class.new(StrainerTemplate).tap do |klass|
-        klass.add_filter(StandardFilters)
-      end
-      @exception_renderer = ->(exception) { exception }
-      @file_system = BlankFileSystem.new
-      @default_resource_limits = Const::EMPTY_HASH
-      @strainer_template_class_cache = {}
-    end
-
-    # Registers a new tag with the environment.
-    #
-    # @param name [String] The name of the tag.
-    # @param klass [Liquid::Tag] The class that implements the tag.
-    # @return [void]
-    def register_tag(name, klass)
-      @tags[name] = klass
-    end
-
-    # Registers a new filter with the environment.
-    #
-    # @param filter [Module] The module that contains the filter methods.
-    # @return [void]
-    def register_filter(filter)
-      @strainer_template_class_cache.clear
-      @strainer_template.add_filter(filter)
-    end
-
-    # Registers multiple filters with this environment.
-    #
-    # @param filters [Array<Module>] The modules that contain the filter methods.
-    # @return [self]
-    def register_filters(filters)
-      @strainer_template_class_cache.clear
-      filters.each { |f| @strainer_template.add_filter(f) }
-      self
-    end
-
-    # Creates a new strainer instance with the given filters, caching the result
-    # for faster lookup.
-    #
-    # @param context [Liquid::Context] The context that the strainer will be
-    #   used in.
-    # @param filters [Array<Module>] The filters that the strainer will have
-    #   access to.
-    # @return [Liquid::Strainer] The new strainer instance.
-    def create_strainer(context, filters = Const::EMPTY_ARRAY)
-      return @strainer_template.new(context) if filters.empty?
-
-      strainer_template = @strainer_template_class_cache[filters] ||= begin
-        klass = Class.new(@strainer_template)
-        filters.each { |f| klass.add_filter(f) }
-        klass
-      end
-
-      strainer_template.new(context)
-    end
-
-    # Returns the names of all the filter methods that are available to use in
-    # the strainer template.
-    #
-    # @return [Array<String>] The names of all the filter methods.
-    def filter_method_names
-      @strainer_template.filter_method_names
-    end
-
-    # Returns the tag class for the given tag name.
-    #
-    # @param name [String] The name of the tag.
-    # @return [Liquid::Tag] The tag class.
-    def tag_for_name(name)
-      @tags[name]
-    end
-
-    def freeze
-      @tags.freeze
-      # TODO: freeze the tags, currently this is not possible because of liquid-c
-      # @strainer_template.freeze
-      super
-    end
-  end
-end
@@ -1,59 +1,12 @@
-# frozen_string_literal: true
-
 module Liquid
-  class Error < ::StandardError
-    attr_accessor :line_number
-    attr_accessor :template_name
-    attr_accessor :markup_context
+  class Error < ::StandardError; end

-    def to_s(with_prefix = true)
-      str = +""
-      str << message_prefix if with_prefix
-      str << super()
-
-      if markup_context
-        str << " "
-        str << markup_context
-      end
-
-      str
-    end
-
-    private
-
-    def message_prefix
-      str = +""
-      str << if is_a?(SyntaxError)
-        "Liquid syntax error"
-      else
-        "Liquid error"
-      end
-
-      if line_number
-        str << " ("
-        str << template_name << " " if template_name
-        str << "line " << line_number.to_s << ")"
-      end
-
-      str << ": "
-      str
-    end
-  end
-
-  ArgumentError         = Class.new(Error)
-  ContextError          = Class.new(Error)
-  FileSystemError       = Class.new(Error)
-  StandardError         = Class.new(Error)
-  SyntaxError           = Class.new(Error)
-  StackLevelError       = Class.new(Error)
-  MemoryError           = Class.new(Error)
-  ZeroDivisionError     = Class.new(Error)
-  FloatDomainError      = Class.new(Error)
-  UndefinedVariable     = Class.new(Error)
-  UndefinedDropMethod   = Class.new(Error)
-  UndefinedFilter       = Class.new(Error)
-  MethodOverrideError   = Class.new(Error)
-  DisabledError         = Class.new(Error)
-  InternalError         = Class.new(Error)
-  TemplateEncodingError = Class.new(Error)
+  class ArgumentError < Error; end
+  class ContextError < Error; end
+  class FilterNotFound < Error; end
+  class FileSystemError < Error; end
+  class StandardError < Error; end
+  class SyntaxError < Error; end
+  class StackLevelError < Error; end
+  class MemoryError < Error; end
 end
@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Expression
-    LITERALS = {
-      nil => nil,
-      'nil' => nil,
-      'null' => nil,
-      '' => nil,
-      'true' => true,
-      'false' => false,
-      'blank' => '',
-      'empty' => '',
-      # in lax mode, minus sign can be a VariableLookup
-      # For simplicity and performace, we treat it like a literal
-      '-' => VariableLookup.parse("-", nil).freeze,
-    }.freeze
-
-    DOT = ".".ord
-    ZERO = "0".ord
-    NINE = "9".ord
-    DASH = "-".ord
-
-    # Use an atomic group (?>...) to avoid pathological backtracing from
-    # malicious input as described in https://github.com/Shopify/liquid/issues/1357
-    RANGES_REGEX = /\A\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\z/
-    INTEGER_REGEX = /\A(-?\d+)\z/
-    FLOAT_REGEX = /\A(-?\d+)\.\d+\z/
-
-    class << self
-      def parse(markup, ss = StringScanner.new(""), cache = nil)
-        return unless markup
-
-        markup = markup.strip # markup can be a frozen string
-
-        if (markup.start_with?('"') && markup.end_with?('"')) ||
-          (markup.start_with?("'") && markup.end_with?("'"))
-          return markup[1..-2]
-        elsif LITERALS.key?(markup)
-          return LITERALS[markup]
-        end
-
-        # Cache only exists during parsing
-        if cache
-          return cache[markup] if cache.key?(markup)
-
-          cache[markup] = inner_parse(markup, ss, cache).freeze
-        else
-          inner_parse(markup, ss, nil).freeze
-        end
-      end
-
-      def inner_parse(markup, ss, cache)
-        if (markup.start_with?("(") && markup.end_with?(")")) && markup =~ RANGES_REGEX
-          return RangeLookup.parse(
-            Regexp.last_match(1),
-            Regexp.last_match(2),
-            ss,
-            cache,
-          )
-        end
-
-        if (num = parse_number(markup, ss))
-          num
-        else
-          VariableLookup.parse(markup, ss, cache)
-        end
-      end
-
-      def parse_number(markup, ss)
-        # check if the markup is simple integer or float
-        case markup
-        when INTEGER_REGEX
-          return Integer(markup, 10)
-        when FLOAT_REGEX
-          return markup.to_f
-        end
-
-        ss.string = markup
-        # the first byte must be a digit or  a dash
-        byte = ss.scan_byte
-
-        return false if byte != DASH && (byte < ZERO || byte > NINE)
-
-        if byte == DASH
-          peek_byte = ss.peek_byte
-
-          # if it starts with a dash, the next byte must be a digit
-          return false if peek_byte.nil? || !(peek_byte >= ZERO && peek_byte <= NINE)
-        end
-
-        # The markup could be a float with multiple dots
-        first_dot_pos = nil
-        num_end_pos = nil
-
-        while (byte = ss.scan_byte)
-          return false if byte != DOT && (byte < ZERO || byte > NINE)
-
-          # we found our number and now we are just scanning the rest of the string
-          next if num_end_pos
-
-          if byte == DOT
-            if first_dot_pos.nil?
-              first_dot_pos = ss.pos
-            else
-              # we found another dot, so we know that the number ends here
-              num_end_pos = ss.pos - 1
-            end
-          end
-        end
-
-        num_end_pos = markup.length if ss.eos?
-
-        if num_end_pos
-          # number ends with a number "123.123"
-          markup.byteslice(0, num_end_pos).to_f
-        else
-          # number ends with a dot "123."
-          markup.byteslice(0, first_dot_pos).to_f
-        end
-      end
-    end
-  end
-end
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'time'
 require 'date'

@@ -9,56 +7,44 @@ class String # :nodoc:
  end
 end

-class Symbol # :nodoc:
-  def to_liquid
-    to_s
-  end
-end
-
-class Array # :nodoc:
+class Array  # :nodoc:
  def to_liquid
    self
  end
 end

-class Hash # :nodoc:
+class Hash  # :nodoc:
  def to_liquid
    self
  end
 end

-class Numeric # :nodoc:
+class Numeric  # :nodoc:
  def to_liquid
    self
  end
 end

-class Range # :nodoc:
+class Time  # :nodoc:
  def to_liquid
    self
  end
 end

-class Time # :nodoc:
+class DateTime < Date  # :nodoc:
  def to_liquid
    self
  end
 end

-class DateTime < Date # :nodoc:
-  def to_liquid
-    self
-  end
-end
-
-class Date # :nodoc:
+class Date  # :nodoc:
  def to_liquid
    self
  end
 end

 class TrueClass
-  def to_liquid # :nodoc:
+  def to_liquid  # :nodoc:
    self
  end
 end
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
  #
@@ -10,13 +8,13 @@ module Liquid
  #
  # Example:
  #
-  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  #   liquid = Liquid::Template.parse(template)
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # liquid = Liquid::Template.parse(template)
  #
  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
  class BlankFileSystem
    # Called by Liquid to retrieve a template file
-    def read_template_file(_template_path)
+    def read_template_file(template_path, context)
      raise FileSystemError, "This liquid context does not allow includes."
    end
  end
@@ -28,10 +26,10 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path")
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
  #
-  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
-  #   file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
  #
  # Optionally in the second argument you can specify a custom pattern for template filenames.
  # The Kernel::sprintf format specification is used.
@@ -39,35 +37,35 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
  #
-  #   file_system.full_path("index") # => "/some/path/index.html"
+  # file_system.full_path("index") # => "/some/path/index.html"
  #
  class LocalFileSystem
    attr_accessor :root

-    def initialize(root, pattern = "_%s.liquid")
-      @root    = root
+    def initialize(root, pattern = "_%s.liquid".freeze)
+      @root = root
      @pattern = pattern
    end

-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
      full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)

      File.read(full_path)
    end

    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless %r{\A[^./][a-zA-Z0-9_/]+\z}.match?(template_path)
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/

-      full_path = if template_path.include?('/')
+      full_path = if template_path.include?('/'.freeze)
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
      else
        File.join(root, @pattern % template_path)
      end

-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/

      full_path
    end
@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # @liquid_public_docs
-  # @liquid_type object
-  # @liquid_name forloop
-  # @liquid_summary
-  #   Information about a parent [`for` loop](/docs/api/liquid/tags/for).
-  class ForloopDrop < Drop
-    def initialize(name, length, parentloop)
-      @name       = name
-      @length     = length
-      @parentloop = parentloop
-      @index      = 0
-    end
-
-    # @liquid_public_docs
-    # @liquid_name length
-    # @liquid_summary
-    #   The total number of iterations in the loop.
-    # @liquid_return [number]
-    attr_reader :length
-
-    # @liquid_public_docs
-    # @liquid_name parentloop
-    # @liquid_summary
-    #   The parent `forloop` object.
-    # @liquid_description
-    #   If the current `for` loop isn't nested inside another `for` loop, then `nil` is returned.
-    # @liquid_return [forloop]
-    attr_reader :parentloop
-
-    attr_reader :name
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 1-based index of the current iteration.
-    # @liquid_return [number]
-    def index
-      @index + 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 0-based index of the current iteration.
-    # @liquid_return [number]
-    def index0
-      @index
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 1-based index of the current iteration, in reverse order.
-    # @liquid_return [number]
-    def rindex
-      @length - @index
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 0-based index of the current iteration, in reverse order.
-    # @liquid_return [number]
-    def rindex0
-      @length - @index - 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   Returns `true` if the current iteration is the first. Returns `false` if not.
-    # @liquid_return [boolean]
-    def first
-      @index == 0
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   Returns `true` if the current iteration is the last. Returns `false` if not.
-    # @liquid_return [boolean]
-    def last
-      @index == @length - 1
-    end
-
-    protected
-
-    def increment!
-      @index += 1
-    end
-  end
-end
@@ -1,12 +1,11 @@
-# frozen_string_literal: true
-
 require 'yaml'

 module Liquid
  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")

-    TranslationError = Class.new(StandardError)
+    class TranslationError < StandardError
+    end

    attr_reader :path

@@ -24,17 +23,16 @@ module Liquid
    end

    private
-
    def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) do
+      name.gsub(/%\{(\w+)\}/) {
        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        (vars[Regexp.last_match(1).to_sym]).to_s
-      end
+        "#{vars[$1.to_sym]}"
+      }
    end

    def deep_fetch_translation(name)
-      name.split('.').reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+      name.split('.'.freeze).reduce(locale) do |level, cur|
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
@@ -1,12 +1,11 @@
-# frozen_string_literal: true
-
 module Liquid
+
  # An interrupt is any command that breaks processing of a block (ex: a for loop).
  class Interrupt
    attr_reader :message

-    def initialize(message = nil)
-      @message = message || "interrupt"
+    def initialize(message=nil)
+      @message = message || "interrupt".freeze
    end
  end

@@ -1,179 +1,51 @@
-# frozen_string_literal: true
-
+require "strscan"
 module Liquid
  class Lexer
-    CLOSE_ROUND = [:close_round, ")"].freeze
-    CLOSE_SQUARE = [:close_square, "]"].freeze
-    COLON = [:colon, ":"].freeze
-    COMMA = [:comma, ","].freeze
-    COMPARISION_NOT_EQUAL = [:comparison, "!="].freeze
-    COMPARISON_CONTAINS = [:comparison, "contains"].freeze
-    COMPARISON_EQUAL = [:comparison, "=="].freeze
-    COMPARISON_GREATER_THAN = [:comparison, ">"].freeze
-    COMPARISON_GREATER_THAN_OR_EQUAL = [:comparison, ">="].freeze
-    COMPARISON_LESS_THAN = [:comparison, "<"].freeze
-    COMPARISON_LESS_THAN_OR_EQUAL = [:comparison, "<="].freeze
-    COMPARISON_NOT_EQUAL_ALT = [:comparison, "<>"].freeze
-    DASH = [:dash, "-"].freeze
-    DOT = [:dot, "."].freeze
-    DOTDOT = [:dotdot, ".."].freeze
-    DOT_ORD = ".".ord
-    DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    EOS = [:end_of_string].freeze
-    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
-    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
-    OPEN_ROUND = [:open_round, "("].freeze
-    OPEN_SQUARE = [:open_square, "["].freeze
-    PIPE = [:pipe, "|"].freeze
-    QUESTION = [:question, "?"].freeze
-    RUBY_WHITESPACE = [" ", "\t", "\r", "\n", "\f"].freeze
+    SPECIALS = {
+      '|'.freeze => :pipe,
+      '.'.freeze => :dot,
+      ':'.freeze => :colon,
+      ','.freeze => :comma,
+      '['.freeze => :open_square,
+      ']'.freeze => :close_square,
+      '('.freeze => :open_round,
+      ')'.freeze => :close_round
+    }
+    IDENTIFIER = /[\w\-?!]+/
    SINGLE_STRING_LITERAL = /'[^\']*'/
-    WHITESPACE_OR_NOTHING = /\s*/
+    DOUBLE_STRING_LITERAL = /"[^\"]*"/
+    NUMBER_LITERAL = /-?\d+(\.\d+)?/
+    DOTDOT = /\.\./
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/

-    SINGLE_COMPARISON_TOKENS = [].tap do |table|
-      table["<".ord] = COMPARISON_LESS_THAN
-      table[">".ord] = COMPARISON_GREATER_THAN
-      table.freeze
+    def initialize(input)
+      @ss = StringScanner.new(input.rstrip)
    end

-    TWO_CHARS_COMPARISON_JUMP_TABLE = [].tap do |table|
-      table["=".ord] = [].tap do |sub_table|
-        sub_table["=".ord] = COMPARISON_EQUAL
-        sub_table.freeze
-      end
-      table["!".ord] = [].tap do |sub_table|
-        sub_table["=".ord] = COMPARISION_NOT_EQUAL
-        sub_table.freeze
-      end
-      table.freeze
-    end
+    def tokenize
+      @output = []

-    COMPARISON_JUMP_TABLE = [].tap do |table|
-      table["<".ord] = [].tap do |sub_table|
-        sub_table["=".ord] = COMPARISON_LESS_THAN_OR_EQUAL
-        sub_table[">".ord] = COMPARISON_NOT_EQUAL_ALT
-        sub_table.freeze
-      end
-      table[">".ord] = [].tap do |sub_table|
-        sub_table["=".ord] = COMPARISON_GREATER_THAN_OR_EQUAL
-        sub_table.freeze
-      end
-      table.freeze
-    end
-
-    NEXT_MATCHER_JUMP_TABLE = [].tap do |table|
-      "a".upto("z") do |c|
-        table[c.ord] = [:id, IDENTIFIER].freeze
-        table[c.upcase.ord] = [:id, IDENTIFIER].freeze
-      end
-      table["_".ord] = [:id, IDENTIFIER].freeze
-
-      "0".upto("9") do |c|
-        table[c.ord] = [:number, NUMBER_LITERAL].freeze
-      end
-      table["-".ord] = [:number, NUMBER_LITERAL].freeze
-
-      table["'".ord] = [:string, SINGLE_STRING_LITERAL].freeze
-      table["\"".ord] = [:string, DOUBLE_STRING_LITERAL].freeze
-      table.freeze
-    end
-
-    SPECIAL_TABLE = [].tap do |table|
-      table["|".ord] = PIPE
-      table[".".ord] = DOT
-      table[":".ord] = COLON
-      table[",".ord] = COMMA
-      table["[".ord] = OPEN_SQUARE
-      table["]".ord] = CLOSE_SQUARE
-      table["(".ord] = OPEN_ROUND
-      table[")".ord] = CLOSE_ROUND
-      table["?".ord] = QUESTION
-      table["-".ord] = DASH
-    end
-
-    NUMBER_TABLE = [].tap do |table|
-      "0".upto("9") do |c|
-        table[c.ord] = true
-      end
-      table.freeze
-    end
-
-    # rubocop:disable Metrics/BlockNesting
-    class << self
-      def tokenize(ss)
-        output = []
-
-        until ss.eos?
-          ss.skip(WHITESPACE_OR_NOTHING)
-
-          break if ss.eos?
-
-          start_pos = ss.pos
-          peeked = ss.peek_byte
-
-          if (special = SPECIAL_TABLE[peeked])
-            ss.scan_byte
-            # Special case for ".."
-            if special == DOT && ss.peek_byte == DOT_ORD
-              ss.scan_byte
-              output << DOTDOT
-            elsif special == DASH
-              # Special case for negative numbers
-              if (peeked_byte = ss.peek_byte) && NUMBER_TABLE[peeked_byte]
-                ss.pos -= 1
-                output << [:number, ss.scan(NUMBER_LITERAL)]
-              else
-                output << special
-              end
-            else
-              output << special
-            end
-          elsif (sub_table = TWO_CHARS_COMPARISON_JUMP_TABLE[peeked])
-            ss.scan_byte
-            if (peeked_byte = ss.peek_byte) && (found = sub_table[peeked_byte])
-              output << found
-              ss.scan_byte
-            else
-              raise_syntax_error(start_pos, ss)
-            end
-          elsif (sub_table = COMPARISON_JUMP_TABLE[peeked])
-            ss.scan_byte
-            if (peeked_byte = ss.peek_byte) && (found = sub_table[peeked_byte])
-              output << found
-              ss.scan_byte
-            else
-              output << SINGLE_COMPARISON_TOKENS[peeked]
-            end
+      while !@ss.eos?
+        @ss.skip(/\s*/)
+        tok = case
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
+        else
+          c = @ss.getch
+          if s = SPECIALS[c]
+            [s,c]
          else
-            type, pattern = NEXT_MATCHER_JUMP_TABLE[peeked]
-
-            if type && (t = ss.scan(pattern))
-              # Special case for "contains"
-              output << if type == :id && t == "contains" && output.last&.first != :dot
-                COMPARISON_CONTAINS
-              else
-                [type, t]
-              end
-            else
-              raise_syntax_error(start_pos, ss)
-            end
+            raise SyntaxError, "Unexpected character #{c}"
          end
        end
-        # rubocop:enable Metrics/BlockNesting
-        output << EOS
-      rescue ::ArgumentError => e
-        if e.message == "invalid byte sequence in #{ss.string.encoding}"
-          raise SyntaxError, "Invalid byte sequence in #{ss.string.encoding}"
-        else
-          raise
-        end
+        @output << tok
      end

-      def raise_syntax_error(start_pos, ss)
-        ss.pos = start_pos
-        # the character could be a UTF-8 character, use getch to get all the bytes
-        raise SyntaxError, "Unexpected character #{ss.getch}"
-      end
+      @output << [:end_of_string]
    end
  end
 end
@@ -1,32 +1,22 @@
 ---
  errors:
    syntax:
-      tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
-      block_tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: {% %{tag} %}{% end%{tag} %}"
      assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
      capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
      case: "Syntax Error in 'case' - Valid syntax: case [condition]"
      case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"
      case_invalid_else: "Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) "
      cycle: "Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]"
-      doc_invalid_nested: "Syntax Error in 'doc' - Nested doc tags are not allowed"
      for: "Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]"
      for_invalid_in: "For loops require an 'in' clause"
      for_invalid_attribute: "Invalid attribute in for loop. Valid attributes are limit and offset"
      if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
      include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
-      inline_comment_invalid: "Syntax error in tag '#' - Each line of comments must be prefixed by the '#' character"
-      invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
-      invalid_template_encoding: "Invalid template encoding"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
-      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      tag_never_closed: "'%{block_name}' tag was never closed"
-      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
-      unexpected_else: "%{block_name} tag does not expect 'else' tag"
-      unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
      unknown_tag: "Unknown tag '%{tag}'"
+      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      unexpected_else: "%{block_name} tag does not expect else tag"
+      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
      variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"
-    disabled:
-      tag: "usage is not allowed in this context"
+      tag_never_closed: "'%{block_name}' tag was never closed"
+      meta_syntax_error: "Liquid syntax error: #{e.message}"
+      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
@@ -0,0 +1,62 @@
+# Copyright 2007 by Domizio Demichelis
+# This library is free software. It may be used, redistributed and/or modified
+# under the same terms as Ruby itself
+#
+# This extension is used in order to expose the object of the implementing class
+# to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
+# to the allowed method passed with the liquid_methods call
+# Example:
+#
+# class SomeClass
+#   liquid_methods :an_allowed_method
+#
+#   def an_allowed_method
+#     'this comes from an allowed method'
+#   end
+#   def unallowed_method
+#     'this will never be an output'
+#   end
+# end
+#
+# if you want to extend the drop to other methods you can defines more methods
+# in the class <YourClass>::LiquidDropClass
+#
+#   class SomeClass::LiquidDropClass
+#     def another_allowed_method
+#       'and this from another allowed method'
+#     end
+#   end
+# end
+#
+# usage:
+# @something = SomeClass.new
+#
+# template:
+# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
+#
+# output:
+# 'this comes from an allowed method and this from another allowed method'
+#
+# You can also chain associations, by adding the liquid_method call in the
+# association models.
+#
+class Module
+
+  def liquid_methods(*allowed_methods)
+    drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
+    define_method :to_liquid do
+      drop_class.new(self)
+    end
+    drop_class.class_eval do
+      def initialize(object)
+        @object = object
+      end
+      allowed_methods.each do |sym|
+        define_method sym do
+          @object.send sym
+        end
+      end
+    end
+  end
+
+end
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :warnings, :error_mode, :environment
-
-    def initialize(options = Const::EMPTY_HASH)
-      @environment = options.fetch(:environment, Environment.default)
-      @template_options = options ? options.dup : {}
-
-      @locale   = @template_options[:locale] ||= I18n.new
-      @warnings = []
-
-      # constructing new StringScanner in Lexer, Tokenizer, etc is expensive
-      # This StringScanner will be shared by all of them
-      @string_scanner = StringScanner.new("")
-
-      @expression_cache = if options[:expression_cache].nil?
-        {}
-      elsif options[:expression_cache].respond_to?(:[]) && options[:expression_cache].respond_to?(:[]=)
-        options[:expression_cache]
-      elsif options[:expression_cache]
-        {}
-      end
-
-      self.depth   = 0
-      self.partial = false
-    end
-
-    def [](option_key)
-      @options[option_key]
-    end
-
-    def new_block_body
-      Liquid::BlockBody.new
-    end
-
-    def new_parser(input)
-      @string_scanner.string = input
-      Parser.new(@string_scanner)
-    end
-
-    def new_tokenizer(source, start_line_number: nil, for_liquid_tag: false)
-      Tokenizer.new(
-        source: source,
-        string_scanner: @string_scanner,
-        line_number: start_line_number,
-        for_liquid_tag: for_liquid_tag,
-      )
-    end
-
-    def parse_expression(markup)
-      Expression.parse(markup, @string_scanner, @expression_cache)
-    end
-
-    def partial=(value)
-      @partial = value
-      @options = value ? partial_options : @template_options
-
-      @error_mode = @options[:error_mode] || @environment.error_mode
-    end
-
-    def partial_options
-      @partial_options ||= begin
-        dont_pass = @template_options[:include_options_blacklist]
-        if dont_pass == true
-          { locale: locale }
-        elsif dont_pass.is_a?(Array)
-          @template_options.reject { |k, _v| dont_pass.include?(k) }
-        else
-          @template_options
-        end
-      end
-    end
-  end
-end
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class ParseTreeVisitor
-    def self.for(node, callbacks = Hash.new(proc {}))
-      if defined?(node.class::ParseTreeVisitor)
-        node.class::ParseTreeVisitor
-      else
-        self
-      end.new(node, callbacks)
-    end
-
-    def initialize(node, callbacks)
-      @node      = node
-      @callbacks = callbacks
-    end
-
-    def add_callback_for(*classes, &block)
-      callback = block
-      callback = ->(node, _) { yield node } if block.arity.abs == 1
-      callback = ->(_, _) { yield } if block.arity.zero?
-      classes.each { |klass| @callbacks[klass] = callback }
-      self
-    end
-
-    def visit(context = nil)
-      children.map do |node|
-        item, new_context = @callbacks[node.class].call(node, context)
-        [
-          item,
-          ParseTreeVisitor.for(node, @callbacks).visit(new_context || context),
-        ]
-      end
-    end
-
-    protected
-
-    def children
-      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : Const::EMPTY_ARRAY
-    end
-  end
-end
@@ -1,11 +1,9 @@
-# frozen_string_literal: true
-
 module Liquid
  class Parser
    def initialize(input)
-      ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
-      @tokens = Lexer.tokenize(ss)
-      @p      = 0 # pointer to current location
+      l = Lexer.new(input)
+      @tokens = l.tokenize
+      @p = 0 # pointer to current location
    end

    def jump(point)
@@ -48,18 +46,11 @@ module Liquid

    def expression
      token = @tokens[@p]
-      case token[0]
-      when :id
-        str = consume
-        str << variable_lookups
-      when :open_square
-        str = consume.dup
-        str << expression
-        str << consume(:close_square)
-        str << variable_lookups
-      when :string, :number
+      if token[0] == :id
+        variable_signature
+      elsif [:string, :number].include? token[0]
        consume
-      when :open_round
+      elsif token.first == :open_round
        consume
        first = expression
        consume(:dotdot)
@@ -72,29 +63,26 @@ module Liquid
    end

    def argument
-      str = +""
+      str = ""
      # might be a keyword argument (identifier: expression)
      if look(:id) && look(:colon, 1)
-        str << consume << consume << ' '
+        str << consume << consume << ' '.freeze
      end

      str << expression
      str
    end

-    def variable_lookups
-      str = +""
-      loop do
-        if look(:open_square)
-          str << consume
-          str << expression
-          str << consume(:close_square)
-        elsif look(:dot)
-          str << consume
-          str << consume(:id)
-        else
-          break
-        end
+    def variable_signature
+      str = consume(:id)
+      if look(:open_square)
+        str << consume
+        str << expression
+        str << consume(:close_square)
+      end
+      if look(:dot)
+        str << consume
+        str << variable_signature
      end
      str
    end
@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module ParserSwitching
-    def strict_parse_with_error_mode_fallback(markup)
-      strict_parse_with_error_context(markup)
-    rescue SyntaxError => e
-      case parse_context.error_mode
-      when :strict
-        raise
-      when :warn
-        parse_context.warnings << e
-      end
-      lax_parse(markup)
-    end
-
-    def parse_with_selected_parser(markup)
-      case parse_context.error_mode
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
-      when :warn
-        begin
-          strict_parse_with_error_context(markup)
-        rescue SyntaxError => e
-          parse_context.warnings << e
-          lax_parse(markup)
-        end
-      end
-    end
-
-    private
-
-    def strict_parse_with_error_context(markup)
-      strict_parse(markup)
-    rescue SyntaxError => e
-      e.line_number    = line_number
-      e.markup_context = markup_context(markup)
-      raise e
-    end
-
-    def markup_context(markup)
-      "in \"#{markup.strip}\""
-    end
-  end
-end
@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class PartialCache
-    def self.load(template_name, context:, parse_context:)
-      cached_partials = context.registers[:cached_partials]
-      cache_key = "#{template_name}:#{parse_context.error_mode}"
-      cached = cached_partials[cache_key]
-      return cached if cached
-
-      file_system = context.registers[:file_system]
-      source      = file_system.read_template_file(template_name)
-
-      parse_context.partial = true
-
-      template_factory = context.registers[:template_factory]
-      template = template_factory.for(template_name)
-
-      begin
-        partial = template.parse(source, parse_context)
-      rescue Liquid::Error => e
-        e.template_name = template&.name || template_name
-        raise e
-      end
-
-      partial.name ||= template_name
-
-      cached_partials[cache_key] = partial
-    ensure
-      parse_context.partial = false
-    end
-  end
-end
@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require 'liquid/profiler/hooks'
-
-module Liquid
-  # Profiler enables support for profiling template rendering to help track down performance issues.
-  #
-  # To enable profiling, first require 'liquid/profiler'.
-  # Then, to profile a parse/render cycle, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>.
-  # After <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
-  # class via the <tt>Liquid::Template#profiler</tt> method.
-  #
-  #   template = Liquid::Template.parse(template_content, profile: true)
-  #   output  = template.render
-  #   profile = template.profiler
-  #
-  # This object contains all profiling information, containing information on what tags were rendered,
-  # where in the templates these tags live, and how long each tag took to render.
-  #
-  # This is a tree structure that is Enumerable all the way down, and keeps track of tags and rendering times
-  # inside of <tt>{% include %}</tt> tags.
-  #
-  #   profile.each do |node|
-  #     # Access to the node itself
-  #     node.code
-  #
-  #     # Which template and line number of this node.
-  #     # The top-level template name is `nil` by default, but can be set in the Liquid::Context before rendering.
-  #     node.partial
-  #     node.line_number
-  #
-  #     # Render time in seconds of this node
-  #     node.render_time
-  #
-  #     # If the template used {% include %}, this node will also have children.
-  #     node.children.each do |child2|
-  #       # ...
-  #     end
-  #   end
-  #
-  # Profiler also exposes the total time of the template's render in <tt>Liquid::Profiler#total_render_time</tt>.
-  #
-  # All render times are in seconds. There is a small performance hit when profiling is enabled.
-  #
-  class Profiler
-    include Enumerable
-
-    class Timing
-      attr_reader :code, :template_name, :line_number, :children
-      attr_accessor :total_time
-      alias_method :render_time, :total_time
-      alias_method :partial, :template_name
-
-      def initialize(code: nil, template_name: nil, line_number: nil)
-        @code = code
-        @template_name = template_name
-        @line_number = line_number
-        @children = []
-      end
-
-      def self_time
-        @self_time ||= begin
-          total_children_time = 0.0
-          @children.each do |child|
-            total_children_time += child.total_time
-          end
-          @total_time - total_children_time
-        end
-      end
-    end
-
-    attr_reader :total_time
-    alias_method :total_render_time, :total_time
-
-    def initialize
-      @root_children = []
-      @current_children = nil
-      @total_time = 0.0
-    end
-
-    def profile(template_name, &block)
-      # nested renders are done from a tag that already has a timing node
-      return yield if @current_children
-
-      root_children = @root_children
-      render_idx = root_children.length
-      begin
-        @current_children = root_children
-        profile_node(template_name, &block)
-      ensure
-        @current_children = nil
-        if (timing = root_children[render_idx])
-          @total_time += timing.total_time
-        end
-      end
-    end
-
-    def children
-      children = @root_children
-      if children.length == 1
-        children.first.children
-      else
-        children
-      end
-    end
-
-    def each(&block)
-      children.each(&block)
-    end
-
-    def [](idx)
-      children[idx]
-    end
-
-    def length
-      children.length
-    end
-
-    def profile_node(template_name, code: nil, line_number: nil)
-      timing = Timing.new(code: code, template_name: template_name, line_number: line_number)
-      parent_children = @current_children
-      start_time = monotonic_time
-      begin
-        @current_children = timing.children
-        yield
-      ensure
-        @current_children = parent_children
-        timing.total_time = monotonic_time - start_time
-        parent_children << timing
-      end
-    end
-
-    private
-
-    def monotonic_time
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
-    end
-  end
-end
@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module BlockBodyProfilingHook
-    def render_node(context, output, node)
-      if (profiler = context.profiler)
-        profiler.profile_node(context.template_name, code: node.raw, line_number: node.line_number) do
-          super
-        end
-      else
-        super
-      end
-    end
-  end
-  BlockBody.prepend(BlockBodyProfilingHook)
-
-  module DocumentProfilingHook
-    def render_to_output_buffer(context, output)
-      return super unless context.profiler
-      context.profiler.profile(context.template_name) { super }
-    end
-  end
-  Document.prepend(DocumentProfilingHook)
-
-  module ContextProfilingHook
-    attr_accessor :profiler
-
-    def new_isolated_subcontext
-      new_context = super
-      new_context.profiler = profiler
-      new_context
-    end
-  end
-  Context.prepend(ContextProfilingHook)
-end
@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class RangeLookup
-    def self.parse(start_markup, end_markup, string_scanner, cache = nil)
-      start_obj = Expression.parse(start_markup, string_scanner, cache)
-      end_obj   = Expression.parse(end_markup, string_scanner, cache)
-      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
-        new(start_obj, end_obj)
-      else
-        begin
-          start_obj.to_i..end_obj.to_i
-        rescue NoMethodError
-          invalid_expr = start_markup unless start_obj.respond_to?(:to_i)
-          invalid_expr ||= end_markup unless end_obj.respond_to?(:to_i)
-          if invalid_expr
-            raise Liquid::SyntaxError, "Invalid expression type '#{invalid_expr}' in range expression"
-          end
-
-          raise
-        end
-      end
-    end
-
-    attr_reader :start_obj, :end_obj
-
-    def initialize(start_obj, end_obj)
-      @start_obj = start_obj
-      @end_obj   = end_obj
-    end
-
-    def evaluate(context)
-      start_int = to_integer(context.evaluate(@start_obj))
-      end_int   = to_integer(context.evaluate(@end_obj))
-      start_int..end_int
-    end
-
-    private
-
-    def to_integer(input)
-      case input
-      when Integer
-        input
-      when NilClass, String
-        input.to_i
-      else
-        Utils.to_integer(input)
-      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.start_obj, @node.end_obj]
-      end
-    end
-  end
-end
@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Registers
-    attr_reader :static
-
-    def initialize(registers = {})
-      @static = registers.is_a?(Registers) ? registers.static : registers
-      @changes = {}
-    end
-
-    def []=(key, value)
-      @changes[key] = value
-    end
-
-    def [](key)
-      if @changes.key?(key)
-        @changes[key]
-      else
-        @static[key]
-      end
-    end
-
-    def delete(key)
-      @changes.delete(key)
-    end
-
-    UNDEFINED = Object.new
-
-    def fetch(key, default = UNDEFINED, &block)
-      if @changes.key?(key)
-        @changes.fetch(key)
-      elsif default != UNDEFINED
-        if block_given?
-          @static.fetch(key, &block)
-        else
-          @static.fetch(key, default)
-        end
-      else
-        @static.fetch(key, &block)
-      end
-    end
-
-    def key?(key)
-      @changes.key?(key) || @static.key?(key)
-    end
-  end
-
-  # Alias for backwards compatibility
-  StaticRegisters = Registers
-end
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
-    attr_reader :render_score, :assign_score
-
-    def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit  = limits[:render_score_limit]
-      @assign_score_limit  = limits[:assign_score_limit]
-      reset
-    end
-
-    def increment_render_score(amount)
-      @render_score += amount
-      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
-    end
-
-    def increment_assign_score(amount)
-      @assign_score += amount
-      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
-    end
-
-    # update either render_length or assign_score based on whether or not the writes are captured
-    def increment_write_score(output)
-      if (last_captured = @last_capture_length)
-        captured = output.bytesize
-        increment = captured - last_captured
-        @last_capture_length = captured
-        increment_assign_score(increment)
-      elsif @render_length_limit && output.bytesize > @render_length_limit
-        raise_limits_reached
-      end
-    end
-
-    def raise_limits_reached
-      @reached_limit = true
-      raise MemoryError, "Memory limits exceeded"
-    end
-
-    def reached?
-      @reached_limit
-    end
-
-    def reset
-      @reached_limit = false
-      @last_capture_length = nil
-      @render_score = @assign_score = 0
-    end
-
-    def with_capture
-      old_capture_length = @last_capture_length
-      begin
-        @last_capture_length = 0
-        yield
-      ensure
-        @last_capture_length = old_capture_length
-      end
-    end
-  end
-end
@@ -0,0 +1,63 @@
+require 'set'
+
+module Liquid
+
+  # Strainer is the parent class for the filters system.
+  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
+  #
+  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
+  # Context#add_filters or Template.register_filter
+  class Strainer #:nodoc:
+    @@filters = []
+    @@known_filters = Set.new
+    @@known_methods = Set.new
+    @@strainer_class_cache = Hash.new do |hash, filters|
+      hash[filters] = Class.new(Strainer) do
+        filters.each { |f| include f }
+      end
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    def self.global_filter(filter)
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      add_known_filter(filter)
+      @@filters << filter unless @@filters.include?(filter)
+    end
+
+    def self.add_known_filter(filter)
+      unless @@known_filters.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+        new_methods = filter.instance_methods.map(&:to_s)
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @@known_methods.merge(new_methods)
+        @@known_filters.add(filter)
+      end
+    end
+
+    def self.strainer_class_cache
+      @@strainer_class_cache
+    end
+
+    def self.create(context, filters = [])
+      filters = @@filters + filters
+      strainer_class_cache[filters].new(context)
+    end
+
+    def invoke(method, *args)
+      if invokable?(method)
+        send(method, *args)
+      else
+        args.first
+      end
+    rescue ::ArgumentError => e
+      raise Liquid::ArgumentError.new(e.message)
+    end
+
+    def invokable?(method)
+      @@known_methods.include?(method.to_s) && respond_to?(method)
+    end
+  end
+end
@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module Liquid
-  # StrainerTemplate is the computed class for the filters system.
-  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
-  #
-  # The Strainer only allows method calls defined in filters given to it via StrainerFactory.add_global_filter,
-  # Context#add_filters or Template.register_filter
-  class StrainerTemplate
-    def initialize(context)
-      @context = context
-    end
-
-    class << self
-      def add_filter(filter)
-        return if include?(filter)
-
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
-        if invokable_non_public_methods.any?
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
-        end
-
-        include(filter)
-
-        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-      end
-
-      def invokable?(method)
-        filter_methods.include?(method.to_s)
-      end
-
-      def inherited(subclass)
-        super
-        subclass.instance_variable_set(:@filter_methods, @filter_methods.dup)
-      end
-
-      def filter_method_names
-        filter_methods.map(&:to_s).to_a
-      end
-
-      private
-
-      def filter_methods
-        @filter_methods ||= Set.new
-      end
-    end
-
-    def invoke(method, *args)
-      if self.class.invokable?(method)
-        send(method, *args)
-      elsif @context.strict_filters
-        raise Liquid::UndefinedFilter, "undefined filter #{method}"
-      else
-        args.first
-      end
-    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError, e.message, e.backtrace
-    end
-  end
-end
@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # @liquid_public_docs
-  # @liquid_type object
-  # @liquid_name tablerowloop
-  # @liquid_summary
-  #   Information about a parent [`tablerow` loop](/docs/api/liquid/tags/tablerow).
-  class TablerowloopDrop < Drop
-    def initialize(length, cols)
-      @length = length
-      @row    = 1
-      @col    = 1
-      @cols   = cols
-      @index  = 0
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The total number of iterations in the loop.
-    # @liquid_return [number]
-    attr_reader :length
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 1-based index of the current column.
-    # @liquid_return [number]
-    attr_reader :col
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 1-based index of current row.
-    # @liquid_return [number]
-    attr_reader :row
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 1-based index of the current iteration.
-    # @liquid_return [number]
-    def index
-      @index + 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 0-based index of the current iteration.
-    # @liquid_return [number]
-    def index0
-      @index
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 0-based index of the current column.
-    # @liquid_return [number]
-    def col0
-      @col - 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 1-based index of the current iteration, in reverse order.
-    # @liquid_return [number]
-    def rindex
-      @length - @index
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   The 0-based index of the current iteration, in reverse order.
-    # @liquid_return [number]
-    def rindex0
-      @length - @index - 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   Returns `true` if the current iteration is the first. Returns `false` if not.
-    # @liquid_return [boolean]
-    def first
-      @index == 0
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   Returns `true` if the current iteration is the last. Returns `false` if not.
-    # @liquid_return [boolean]
-    def last
-      @index == @length - 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   Returns `true` if the current column is the first in the row. Returns `false` if not.
-    # @liquid_return [boolean]
-    def col_first
-      @col == 1
-    end
-
-    # @liquid_public_docs
-    # @liquid_summary
-    #   Returns `true` if the current column is the last in the row. Returns `false` if not.
-    # @liquid_return [boolean]
-    def col_last
-      @col == @cols
-    end
-
-    protected
-
-    def increment!
-      @index += 1
-
-      if @col == @cols
-        @col = 1
-        @row += 1
-      else
-        @col += 1
-      end
-    end
-  end
-end
@@ -1,75 +1,61 @@
-# frozen_string_literal: true
-
-require 'liquid/tag/disabler'
-require 'liquid/tag/disableable'
-
 module Liquid
  class Tag
-    attr_reader :nodelist, :tag_name, :line_number, :parse_context
-    alias_method :options, :parse_context
-    include ParserSwitching
+    attr_accessor :options
+    attr_reader :nodelist, :warnings

    class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
-        tag = new(tag_name, markup, parse_context)
-        tag.parse(tokenizer)
+      def parse(tag_name, markup, tokens, options)
+        tag = new(tag_name, markup, options)
+        tag.parse(tokens)
        tag
      end

-      def disable_tags(*tag_names)
-        tag_names += disabled_tags
-        define_singleton_method(:disabled_tags) { tag_names }
-        prepend(Disabler)
-      end
-
      private :new
-
-      protected
-
-      def disabled_tags
-        []
-      end
    end

-    def initialize(tag_name, markup, parse_context)
-      @tag_name      = tag_name
-      @markup        = markup
-      @parse_context = parse_context
-      @line_number   = parse_context.line_number
+    def initialize(tag_name, markup, options)
+      @tag_name   = tag_name
+      @markup     = markup
+      @options    = options
    end

-    def parse(_tokens)
-    end
-
-    def raw
-      "#{@tag_name} #{@markup}"
+    def parse(tokens)
    end

    def name
      self.class.name.downcase
    end

-    def render(_context)
-      ''
-    end
-
-    # For backwards compatibility with custom tags. In a future release, the semantics
-    # of the `render_to_output_buffer` method will become the default and the `render`
-    # method will be removed.
-    def render_to_output_buffer(context, output)
-      render_result = render(context)
-      output << render_result if render_result
-      output
+    def render(context)
+      ''.freeze
    end

    def blank?
      false
    end

+    def parse_with_selected_parser(markup)
+      case @options[:error_mode] || Template.error_mode
+      when :strict then strict_parse_with_error_context(markup)
+      when :lax    then lax_parse(markup)
+      when :warn
+        begin
+          return strict_parse_with_error_context(markup)
+        rescue SyntaxError => e
+          @warnings ||= []
+          @warnings << e
+          return lax_parse(markup)
+        end
+      end
+    end
+
    private

-    def parse_expression(markup)
-      parse_context.parse_expression(markup)
+    def strict_parse_with_error_context(markup)
+      strict_parse(markup)
+    rescue SyntaxError => e
+      e.message << " in \"#{markup.strip}\"" 
+      raise e
    end
  end
 end
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disableable
-      def render_to_output_buffer(context, output)
-        if context.tag_disabled?(tag_name)
-          output << disabled_error(context)
-          return
-        end
-        super
-      end
-
-      def disabled_error(context)
-        # raise then rescue the exception so that the Context#exception_renderer can re-raise it
-        raise DisabledError, "#{tag_name} #{parse_context[:locale].t('errors.disabled.tag')}"
-      rescue DisabledError => exc
-        context.handle_error(exc, line_number)
-      end
-    end
-  end
-end
@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disabler
-      def render_to_output_buffer(context, output)
-        context.with_disabled_tags(self.class.disabled_tags) do
-          super
-        end
-      end
-    end
-  end
-end
@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "tags/table_row"
-require_relative "tags/echo"
-require_relative "tags/if"
-require_relative "tags/break"
-require_relative "tags/inline_comment"
-require_relative "tags/for"
-require_relative "tags/assign"
-require_relative "tags/ifchanged"
-require_relative "tags/case"
-require_relative "tags/include"
-require_relative "tags/continue"
-require_relative "tags/capture"
-require_relative "tags/decrement"
-require_relative "tags/unless"
-require_relative "tags/increment"
-require_relative "tags/comment"
-require_relative "tags/raw"
-require_relative "tags/render"
-require_relative "tags/cycle"
-require_relative "tags/doc"
-
-module Liquid
-  module Tags
-    STANDARD_TAGS = {
-      'cycle' => Cycle,
-      'render' => Render,
-      'raw' => Raw,
-      'comment' => Comment,
-      'increment' => Increment,
-      'unless' => Unless,
-      'decrement' => Decrement,
-      'capture' => Capture,
-      'continue' => Continue,
-      'include' => Include,
-      'case' => Case,
-      'ifchanged' => Ifchanged,
-      'assign' => Assign,
-      'for' => For,
-      '#' => InlineComment,
-      'break' => Break,
-      'if' => If,
-      'echo' => Echo,
-      'tablerow' => TableRow,
-      'doc' => Doc,
-    }.freeze
-  end
-end
@@ -1,75 +1,37 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category variable
-  # @liquid_name assign
-  # @liquid_summary
-  #   Creates a new variable.
-  # @liquid_description
-  #   You can create variables of any [basic type](/docs/api/liquid/basics#types), [object](/docs/api/liquid/objects), or object property.
-  # @liquid_syntax
-  #   {% assign variable_name = value %}
-  # @liquid_syntax_keyword variable_name The name of the variable being created.
-  # @liquid_syntax_keyword value The value you want to assign to the variable.
+
+  # Assign sets a variable in your template.
+  #
+  #   {% assign foo = 'monkey' %}
+  #
+  # You can then use the variable later in the page.
+  #
+  #  {{ foo }}
+  #
  class Assign < Tag
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

-    # @api private
-    def self.raise_syntax_error(parse_context)
-      raise Liquid::SyntaxError, parse_context.locale.t('errors.syntax.assign')
-    end
-
-    attr_reader :to, :from
-
-    def initialize(tag_name, markup, parse_context)
+    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to   = Regexp.last_match(1)
-        @from = Variable.new(Regexp.last_match(2), parse_context)
+        @to = $1
+        @from = Variable.new($2)
      else
-        self.class.raise_syntax_error(parse_context)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
      end
    end

-    def render_to_output_buffer(context, output)
+    def render(context)
      val = @from.render(context)
      context.scopes.last[@to] = val
-      context.resource_limits.increment_assign_score(assign_score_of(val))
-      output
+      context.increment_used_resources(:assign_score_current, val)
+      ''.freeze
    end

    def blank?
      true
    end
-
-    private
-
-    def assign_score_of(val)
-      if val.instance_of?(String)
-        val.bytesize
-      elsif val.instance_of?(Array)
-        sum = 1
-        # Uses #each to avoid extra allocations.
-        val.each { |child| sum += assign_score_of(child) }
-        sum
-      elsif val.instance_of?(Hash)
-        sum = 1
-        val.each do |key, entry_value|
-          sum += assign_score_of(key)
-          sum += assign_score_of(entry_value)
-        end
-        sum
-      else
-        1
-      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.from]
-      end
-    end
  end
+
+  Template.register_tag('assign'.freeze, Assign)
 end
@@ -1,6 +1,5 @@
-# frozen_string_literal: true
-
 module Liquid
+
  # Break tag to be used to break out of a for loop.
  #
  # == Basic Usage:
@@ -10,20 +9,13 @@ module Liquid
  #      {% endif %}
  #    {% endfor %}
  #
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category iteration
-  # @liquid_name break
-  # @liquid_summary
-  #   Stops a [`for` loop](/docs/api/liquid/tags/for) from iterating.
-  # @liquid_syntax
-  #   {% break %}
  class Break < Tag
-    INTERRUPT = BreakInterrupt.new.freeze

-    def render_to_output_buffer(context, output)
-      context.push_interrupt(INTERRUPT)
-      output
+    def interrupt
+      BreakInterrupt.new
    end
+
  end
+
+  Template.register_tag('break'.freeze, Break)
 end
@@ -1,42 +1,38 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category variable
-  # @liquid_name capture
-  # @liquid_summary
-  #   Creates a new variable with a string value.
-  # @liquid_description
-  #   You can create complex strings with Liquid logic and variables.
-  # @liquid_syntax
-  #   {% capture variable %}
-  #     value
+  # Capture stores the result of a block into a variable without rendering it inplace.
+  #
+  #   {% capture heading %}
+  #     Monkeys!
  #   {% endcapture %}
-  # @liquid_syntax_keyword variable The name of the variable being created.
-  # @liquid_syntax_keyword value The value you want to assign to the variable.
+  #   ...
+  #   <h1>{{ heading }}</h1>
+  #
+  # Capture is useful for saving content for use later in your template, such as
+  # in a sidebar or footer.
+  #
  class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    Syntax = /(\w+)/

    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
      end
    end

-    def render_to_output_buffer(context, output)
-      context.resource_limits.with_capture do
-        capture_output = render(context)
-        context.scopes.last[@to] = capture_output
-      end
-      output
+    def render(context)
+      output = super
+      context.scopes.last[@to] = output
+      context.increment_used_resources(:assign_score_current, output)
+      ''.freeze
    end

    def blank?
      true
    end
  end
+
+  Template.register_tag('capture'.freeze, Capture)
 end
@@ -1,126 +1,79 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category conditional
-  # @liquid_name case
-  # @liquid_summary
-  #   Renders a specific expression depending on the value of a specific variable.
-  # @liquid_syntax
-  #   {% case variable %}
-  #     {% when first_value %}
-  #       first_expression
-  #     {% when second_value %}
-  #       second_expression
-  #     {% else %}
-  #       third_expression
-  #   {% endcase %}
-  # @liquid_syntax_keyword variable The name of the variable you want to base your case statement on.
-  # @liquid_syntax_keyword first_value A specific value to check for.
-  # @liquid_syntax_keyword second_value A specific value to check for.
-  # @liquid_syntax_keyword first_expression An expression to be rendered when the variable's value matches `first_value`.
-  # @liquid_syntax_keyword second_expression An expression to be rendered when the variable's value matches `second_value`.
-  # @liquid_syntax_keyword third_expression An expression to be rendered when the variable's value has no match.
  class Case < Block
    Syntax     = /(#{QuotedFragment})/o
    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om

-    attr_reader :blocks, :left
-
    def initialize(tag_name, markup, options)
      super
      @blocks = []

      if markup =~ Syntax
-        @left = parse_expression(Regexp.last_match(1))
+        @left = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
      end
    end

-    def parse(tokens)
-      body = case_body = new_body
-      body = @blocks.last.attachment while parse_body(body, tokens)
-      @blocks.reverse_each do |condition|
-        body = condition.attachment
-        unless body.frozen?
-          body.remove_blank_strings if blank?
-          body.freeze
-        end
-      end
-      case_body.freeze
-    end
-
    def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
    end

    def unknown_tag(tag, markup, tokens)
+      @nodelist = []
      case tag
-      when 'when'
+      when 'when'.freeze
        record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
        record_else_condition(markup)
      else
        super
      end
    end

-    def render_to_output_buffer(context, output)
-      execute_else_block = true
+    def render(context)
+      context.stack do
+        execute_else_block = true

-      @blocks.each do |block|
-        if block.else?
-          block.attachment.render_to_output_buffer(context, output) if execute_else_block
-          next
-        end
-
-        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
-        )
-
-        if result
-          execute_else_block = false
-          block.attachment.render_to_output_buffer(context, output)
+        output = ''
+        @blocks.each do |block|
+          if block.else?
+            return render_all(block.attachment, context) if execute_else_block
+          elsif block.evaluate(context)
+            execute_else_block = false
+            output << render_all(block.attachment, context)
+          end
        end
+        output
      end
-
-      output
    end

    private

    def record_when_condition(markup)
-      body = new_body
-
      while markup
-        unless markup =~ WhenSyntax
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
+        # Create a new nodelist and assign it to the new block
+        if not markup =~ WhenSyntax
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
        end

-        markup = Regexp.last_match(2)
+        markup = $2

-        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
-        block.attach(body)
-        @blocks << block
+        block = Condition.new(@left, '=='.freeze, $1)
+        block.attach(@nodelist)
+        @blocks.push(block)
      end
    end

    def record_else_condition(markup)
-      unless markup.strip.empty?
-        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")
+      if not markup.strip.empty?
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
      end

      block = ElseCondition.new
-      block.attach(new_body)
+      block.attach(@nodelist)
      @blocks << block
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.left] + @node.blocks
-      end
-    end
  end
+
+  Template.register_tag('case'.freeze, Case)
 end
@@ -1,88 +1,16 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category syntax
-  # @liquid_name comment
-  # @liquid_summary
-  #   Prevents an expression from being rendered or output.
-  # @liquid_description
-  #   Any text inside `comment` tags won't be output, and any Liquid code will be parsed, but not executed.
-  # @liquid_syntax
-  #   {% comment %}
-  #     content
-  #   {% endcomment %}
-  # @liquid_syntax_keyword content The content of the comment.
  class Comment < Block
-    def render_to_output_buffer(_context, output)
-      output
+    def render(context)
+      ''.freeze
    end

-    def unknown_tag(_tag, _markup, _tokens)
+    def unknown_tag(tag, markup, tokens)
    end

    def blank?
      true
    end
-
-    private
-
-    def parse_body(body, tokenizer)
-      if parse_context.depth >= MAX_DEPTH
-        raise StackLevelError, "Nesting too deep"
-      end
-
-      parse_context.depth += 1
-      comment_tag_depth = 1
-
-      begin
-        # Consume tokens without creating child nodes.
-        # The children tag doesn't require to be a valid Liquid except the comment and raw tag.
-        # The child comment and raw tag must be closed.
-        while (token = tokenizer.send(:shift))
-          tag_name = if tokenizer.for_liquid_tag
-            next if token.empty? || token.match?(BlockBody::WhitespaceOrNothing)
-
-            tag_name_match = BlockBody::LiquidTagToken.match(token)
-
-            next if tag_name_match.nil?
-
-            tag_name_match[1]
-          else
-            token =~ BlockBody::FullToken
-            Regexp.last_match(2)
-          end
-
-          case tag_name
-          when "raw"
-            parse_raw_tag_body(tokenizer)
-          when "comment"
-            comment_tag_depth += 1
-          when "endcomment"
-            comment_tag_depth -= 1
-          end
-
-          if comment_tag_depth.zero?
-            parse_context.trim_whitespace = (token[-3] == WhitespaceControl) unless tokenizer.for_liquid_tag
-            return false
-          end
-        end
-
-        raise_tag_never_closed(block_name)
-      ensure
-        parse_context.depth -= 1
-      end
-
-      false
-    end
-
-    def parse_raw_tag_body(tokenizer)
-      while (token = tokenizer.send(:shift))
-        return if token =~ BlockBody::FullTokenPossiblyInvalid && "endraw" == Regexp.last_match(2)
-      end
-
-      raise_tag_never_closed("raw")
-    end
  end
+
+  Template.register_tag('comment'.freeze, Comment)
 end
@@ -1,20 +1,18 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category iteration
-  # @liquid_name continue
-  # @liquid_summary
-  #   Causes a [`for` loop](/docs/api/liquid/tags/for) to skip to the next iteration.
-  # @liquid_syntax
-  #   {% continue %}
+  # Continue tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% continue %}
+  #      {% endif %}
+  #    {% endfor %}
+  #
  class Continue < Tag
-    INTERRUPT = ContinueInterrupt.new.freeze
-
-    def render_to_output_buffer(context, output)
-      context.push_interrupt(INTERRUPT)
-      output
+    def interrupt
+      ContinueInterrupt.new
    end
  end
+
+  Template.register_tag('continue'.freeze, Continue)
 end
@@ -1,66 +1,46 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category iteration
-  # @liquid_name cycle
-  # @liquid_summary
-  #   Loops through a group of strings and outputs them one at a time for each iteration of a [`for` loop](/docs/api/liquid/tags/for).
-  # @liquid_description
-  #   The `cycle` tag must be used inside a `for` loop.
+  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
+  #
+  #   {% for item in items %}
+  #     <div class="{% cycle 'red', 'green', 'blue' %}"> {{ item }} </div>
+  #   {% end %}
+  #
+  #    <div class="red"> Item one </div>
+  #    <div class="green"> Item two </div>
+  #    <div class="blue"> Item three </div>
+  #    <div class="red"> Item four </div>
+  #    <div class="green"> Item five</div>
  #
-  #   > Tip:
-  #   > Use the `cycle` tag to output text in a predictable pattern. For example, to apply odd/even classes to rows in a table.
-  # @liquid_syntax
-  #   {% cycle string, string, ... %}
  class Cycle < Tag
    SimpleSyntax = /\A#{QuotedFragment}+/o
    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om

-    attr_reader :variables
-
    def initialize(tag_name, markup, options)
      super
      case markup
      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name      = parse_expression(Regexp.last_match(1))
-        @is_named = true
+        @variables = variables_from_string($2)
+        @name = $1
      when SimpleSyntax
        @variables = variables_from_string(markup)
-        @name      = @variables.to_s
-        @is_named = !@name.match?(/\w+:0x\h{8}/)
+        @name = "'#{@variables.to_s}'"
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
      end
    end

-    def named?
-      @is_named
-    end
+    def render(context)
+      context.registers[:cycle] ||= Hash.new(0)

-    def render_to_output_buffer(context, output)
-      context.registers[:cycle] ||= {}
-
-      key       = context.evaluate(@name)
-      iteration = context.registers[:cycle][key].to_i
-
-      val = context.evaluate(@variables[iteration])
-
-      if val.is_a?(Array)
-        val = val.join
-      elsif !val.is_a?(String)
-        val = val.to_s
+      context.stack do
+        key = context[@name]
+        iteration = context.registers[:cycle][key]
+        result = context[@variables[iteration]]
+        iteration += 1
+        iteration  = 0  if iteration >= @variables.size
+        context.registers[:cycle][key] = iteration
+        result
      end
-
-      output << val
-
-      iteration += 1
-      iteration = 0 if iteration >= @variables.size
-
-      context.registers[:cycle][key] = iteration
-      output
    end

    private
@@ -68,20 +48,10 @@ module Liquid
    def variables_from_string(markup)
      markup.split(',').collect do |var|
        var =~ /\s*(#{QuotedFragment})\s*/o
-        next unless Regexp.last_match(1)
-
-        # Expression Parser returns cached objects, and we need to dup them to
-        # start the cycle over for each new cycle call.
-        # Liquid-C does not have a cache, so we don't need to dup the object.
-        var = parse_expression(Regexp.last_match(1))
-        var.is_a?(VariableLookup) ? var.dup : var
+        $1 ? $1 : nil
      end.compact
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        Array(@node.variables)
-      end
-    end
  end
+
+  Template.register_tag('cycle', Cycle)
 end
@@ -1,38 +1,38 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category variable
-  # @liquid_name decrement
-  # @liquid_summary
-  #   Creates a new variable, with a default value of -1, that's decreased by 1 with each subsequent call.
-  # @liquid_description
-  #   Variables that are declared with `decrement` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
-  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
-  #   [snippets](/themes/architecture/snippets) included in the file.
-  #
-  #   Similarly, variables that are created with `decrement` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
-  #   and [`capture`](/docs/api/liquid/tags/capture). However, `decrement` and [`increment`](/docs/api/liquid/tags/increment) share
-  #   variables.
-  # @liquid_syntax
-  #   {% decrement variable_name %}
-  # @liquid_syntax_keyword variable_name The name of the variable being decremented.
-  class Decrement < Tag
-    attr_reader :variable_name

+  # decrement is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     NOTE: decrement is a pre-decrement, --i,
+  #           while increment is post:      i++.
+  #
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+
+  #   Hello: {% decrement variable %}
+  #
+  # gives you:
+  #
+  #    Hello: -1
+  #    Hello: -2
+  #    Hello: -3
+  #
+  class Decrement < Tag
    def initialize(tag_name, markup, options)
      super
-      @variable_name = markup.strip
+      @variable = markup.strip
    end

-    def render_to_output_buffer(context, output)
-      counter_environment = context.environments.first
-      value = counter_environment[@variable_name] || 0
-      value -= 1
-      counter_environment[@variable_name] = value
-      output << value.to_s
-      output
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      value = value - 1
+      context.environments.first[@variable] = value
+      value.to_s
    end
+
+    private
  end
+
+  Template.register_tag('decrement'.freeze, Decrement)
 end
@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category syntax
-  # @liquid_name doc
-  # @liquid_summary
-  #   Documents template elements with annotations.
-  # @liquid_description
-  #   The `doc` tag allows developers to include documentation within Liquid
-  #   templates. Any content inside `doc` tags is not rendered or outputted.
-  #   Liquid code inside will be parsed but not executed. This facilitates
-  #   tooling support for features like code completion, linting, and inline
-  #   documentation.
-  #
-  #   For detailed documentation syntax and examples, see the
-  #   [`LiquidDoc` reference](/docs/storefronts/themes/tools/liquid-doc).
-  #
-  # @liquid_syntax
-  #   {% doc %}
-  #     Renders a message.
-  #
-  #     @param {string} foo - A string value.
-  #     @param {string} [bar] - An optional string value.
-  #
-  #     @example
-  #     {% render 'message', foo: 'Hello', bar: 'World' %}
-  #   {% enddoc %}
-  class Doc < Block
-    NO_UNEXPECTED_ARGS = /\A\s*\z/
-
-    def initialize(tag_name, markup, parse_context)
-      super
-      ensure_valid_markup(tag_name, markup, parse_context)
-    end
-
-    def parse(tokens)
-      while (token = tokens.shift)
-        tag_name = token =~ BlockBody::FullTokenPossiblyInvalid && Regexp.last_match(2)
-
-        raise_nested_doc_error if tag_name == @tag_name
-
-        if tag_name == block_delimiter
-          parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-          return
-        end
-      end
-
-      raise_tag_never_closed(block_name)
-    end
-
-    def render_to_output_buffer(_context, output)
-      output
-    end
-
-    def blank?
-      true
-    end
-
-    def nodelist
-      []
-    end
-
-    private
-
-    def ensure_valid_markup(tag_name, markup, parse_context)
-      unless NO_UNEXPECTED_ARGS.match?(markup)
-        raise SyntaxError, parse_context.locale.t("errors.syntax.block_tag_unexpected_args", tag: tag_name)
-      end
-    end
-
-    def raise_nested_doc_error
-      raise SyntaxError, parse_context.locale.t("errors.syntax.doc_invalid_nested")
-    end
-  end
-end
@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category syntax
-  # @liquid_name echo
-  # @liquid_summary
-  #   Outputs an expression.
-  # @liquid_description
-  #   Using the `echo` tag is the same as wrapping an expression in curly brackets (`{{` and `}}`). However, unlike the curly
-  #   bracket method, you can use the `echo` tag inside [`liquid` tags](/docs/api/liquid/tags/liquid).
-  #
-  #   > Tip:
-  #   > You can use [filters](/docs/api/liquid/filters) on expressions inside `echo` tags.
-  # @liquid_syntax
-  #   {% liquid
-  #     echo expression
-  #   %}
-  # @liquid_syntax_keyword expression The expression to be output.
-  class Echo < Tag
-    attr_reader :variable
-
-    def initialize(tag_name, markup, parse_context)
-      super
-      @variable = Variable.new(markup, parse_context)
-    end
-
-    def render(context)
-      @variable.render_to_output_buffer(context, +'')
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.variable]
-      end
-    end
-  end
-end
@@ -1,204 +1,175 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category iteration
-  # @liquid_name for
-  # @liquid_summary
-  #   Renders an expression for every item in an array.
-  # @liquid_description
-  #   You can do a maximum of 50 iterations with a `for` loop. If you need to iterate over more than 50 items, then use the
-  #   [`paginate` tag](/docs/api/liquid/tags/paginate) to split the items over multiple pages.
+
+  # "For" iterates over an array or collection.
+  # Several useful variables are available to you within the loop.
+  #
+  # == Basic usage:
+  #    {% for item in collection %}
+  #      {{ forloop.index }}: {{ item.name }}
+  #    {% endfor %}
+  #
+  # == Advanced usage:
+  #    {% for item in collection %}
+  #      <div {% if forloop.first %}class="first"{% endif %}>
+  #        Item {{ forloop.index }}: {{ item.name }}
+  #      </div>
+  #    {% else %}
+  #      There is nothing in the collection.
+  #    {% endfor %}
+  #
+  # You can also define a limit and offset much like SQL.  Remember
+  # that offset starts at 0 for the first item.
+  #
+  #    {% for item in collection limit:5 offset:10 %}
+  #      {{ item.name }}
+  #    {% end %}
+  #
+  #  To reverse the for loop simply use {% for item in collection reversed %}
+  #
+  # == Available variables:
+  #
+  # forloop.name:: 'item-collection'
+  # forloop.length:: Length of the loop
+  # forloop.index:: The current item's position in the collection;
+  #                 forloop.index starts at 1.
+  #                 This is helpful for non-programmers who start believe
+  #                 the first item in an array is 1, not 0.
+  # forloop.index0:: The current item's position in the collection
+  #                  where the first item is 0
+  # forloop.rindex:: Number of items remaining in the loop
+  #                  (length - index) where 1 is the last item.
+  # forloop.rindex0:: Number of items remaining in the loop
+  #                   where 0 is the last item.
+  # forloop.first:: Returns true if the item is the first item.
+  # forloop.last:: Returns true if the item is the last item.
  #
-  #   > Tip:
-  #   > Every `for` loop has an associated [`forloop` object](/docs/api/liquid/objects/forloop) with information about the loop.
-  # @liquid_syntax
-  #   {% for variable in array %}
-  #     expression
-  #   {% endfor %}
-  # @liquid_syntax_keyword variable The current item in the array.
-  # @liquid_syntax_keyword array The array to iterate over.
-  # @liquid_syntax_keyword expression The expression to render for each iteration.
-  # @liquid_optional_param limit [number] The number of iterations to perform.
-  # @liquid_optional_param offset [number] The 1-based index to start iterating at.
-  # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
-  # @liquid_optional_param reversed [untyped] Iterate in reverse order.
  class For < Block
    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o

-    attr_reader :collection_name, :variable_name, :limit, :from
-
    def initialize(tag_name, markup, options)
      super
-      @from = @limit = nil
      parse_with_selected_parser(markup)
-      @for_block = new_body
-      @else_block = nil
-    end
-
-    def parse(tokens)
-      if parse_body(@for_block, tokens)
-        parse_body(@else_block, tokens)
-      end
-      if blank?
-        @else_block&.remove_blank_strings
-        @for_block.remove_blank_strings
-      end
-      @else_block&.freeze
-      @for_block.freeze
+      @nodelist = @for_block = []
    end

    def nodelist
-      @else_block ? [@for_block, @else_block] : [@for_block]
+      if @else_block
+        @for_block + @else_block
+      else
+        @for_block
+      end
    end

    def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
-      @else_block = new_body
+      return super unless tag == 'else'.freeze
+      @nodelist = @else_block = []
    end

-    def render_to_output_buffer(context, output)
-      segment = collection_segment(context)
+    def render(context)
+      context.registers[:for] ||= Hash.new(0)

-      if segment.empty?
-        render_else(context, output)
+      collection = context[@collection_name]
+      collection = collection.to_a if collection.is_a?(Range)
+
+      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
+      return render_else(context) unless iterable?(collection)
+
+      from = if @attributes['offset'.freeze] == 'continue'.freeze
+        context.registers[:for][@name].to_i
      else
-        render_segment(context, output, segment)
+        context[@attributes['offset'.freeze]].to_i
      end

-      output
+      limit = context[@attributes['limit'.freeze]]
+      to    = limit ? limit.to_i + from : nil
+
+      segment = Utils.slice_collection(collection, from, to)
+
+      return render_else(context) if segment.empty?
+
+      segment.reverse! if @reversed
+
+      result = ''
+
+      length = segment.length
+
+      # Store our progress through the collection for the continue flag
+      context.registers[:for][@name] = from + segment.length
+
+      context.stack do
+        segment.each_with_index do |item, index|
+          context[@variable_name] = item
+          context['forloop'.freeze] = {
+            'name'.freeze    => @name,
+            'length'.freeze  => length,
+            'index'.freeze   => index + 1,
+            'index0'.freeze  => index,
+            'rindex'.freeze  => length - index,
+            'rindex0'.freeze => length - index - 1,
+            'first'.freeze   => (index == 0),
+            'last'.freeze    => (index == length - 1)
+          }
+
+          result << render_all(@for_block, context)
+
+          # Handle any interrupts if they exist.
+          if context.has_interrupt?
+            interrupt = context.pop_interrupt
+            break if interrupt.is_a? BreakInterrupt
+            next if interrupt.is_a? ContinueInterrupt
+          end
+        end
+      end
+      result
    end

    protected

    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
-        collection_name  = Regexp.last_match(2)
-        @reversed        = !!Regexp.last_match(3)
-        @name            = "#{@variable_name}-#{collection_name}"
-        @collection_name = parse_expression(collection_name)
+        @variable_name = $1
+        @collection_name = $2
+        @name = "#{$1}-#{$2}"
+        @reversed = $3
+        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
-          set_attribute(key, value)
+          @attributes[key] = value
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
      end
    end

    def strict_parse(markup)
-      p = @parse_context.new_parser(markup)
+      p = Parser.new(markup)
      @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
+      @collection_name = p.expression
+      @name = "#{@variable_name}-#{@collection_name}"
+      @reversed = p.id?('reversed'.freeze)

-      collection_name  = p.expression
-      @collection_name = parse_expression(collection_name)
-
-      @name     = "#{@variable_name}-#{collection_name}"
-      @reversed = p.id?('reversed')
-
-      while p.look(:comma) || p.look(:id)
-        p.consume?(:comma)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
+      @attributes = {}
+      while p.look(:id) && p.look(:colon, 1)
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
        end
-        p.consume(:colon)
-        set_attribute(attribute, p.expression)
+        p.consume
+        val = p.expression
+        @attributes[attribute] = val
      end
      p.consume(:end_of_string)
    end

    private

-    def collection_segment(context)
-      offsets = context.registers[:for] ||= {}
-
-      from = if @from == :continue
-        offsets[@name].to_i
-      else
-        from_value = context.evaluate(@from)
-        if from_value.nil?
-          0
-        else
-          Utils.to_integer(from_value)
-        end
-      end
-
-      collection = context.evaluate(@collection_name)
-      collection = collection.to_a if collection.is_a?(Range)
-
-      limit_value = context.evaluate(@limit)
-      to = if limit_value.nil?
-        nil
-      else
-        Utils.to_integer(limit_value) + from
-      end
-
-      segment = Utils.slice_collection(collection, from, to)
-      segment.reverse! if @reversed
-
-      offsets[@name] = from + segment.length
-
-      segment
+    def render_else(context)
+      return @else_block ? [render_all(@else_block, context)] : ''.freeze
    end

-    def render_segment(context, output, segment)
-      for_stack = context.registers[:for_stack] ||= []
-      length    = segment.length
-
-      context.stack do
-        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
-
-        for_stack.push(loop_vars)
-
-        begin
-          context['forloop'] = loop_vars
-
-          segment.each do |item|
-            context[@variable_name] = item
-            @for_block.render_to_output_buffer(context, output)
-            loop_vars.send(:increment!)
-
-            # Handle any interrupts if they exist.
-            next unless context.interrupt?
-            interrupt = context.pop_interrupt
-            break if interrupt.is_a?(BreakInterrupt)
-            next if interrupt.is_a?(ContinueInterrupt)
-          end
-        ensure
-          for_stack.pop
-        end
-      end
-
-      output
-    end
-
-    def set_attribute(key, expr)
-      case key
-      when 'offset'
-        @from = if expr == 'continue'
-          :continue
-        else
-          parse_expression(expr)
-        end
-      when 'limit'
-        @limit = parse_expression(expr)
-      end
-    end
-
-    def render_else(context, output)
-      if @else_block
-        @else_block.render_to_output_buffer(context, output)
-      else
-        output
-      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        (super + [@node.limit, @node.from, @node.collection_name]).compact
-      end
+    def iterable?(collection)
+      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
    end
  end
+
+  Template.register_tag('for'.freeze, For)
 end
@@ -1,138 +1,106 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category conditional
-  # @liquid_name if
-  # @liquid_summary
-  #   Renders an expression if a specific condition is `true`.
-  # @liquid_syntax
-  #   {% if condition %}
-  #     expression
+  # If is the conditional block
+  #
+  #   {% if user.admin %}
+  #     Admin user!
+  #   {% else %}
+  #     Not admin user
  #   {% endif %}
-  # @liquid_syntax_keyword condition The condition to evaluate.
-  # @liquid_syntax_keyword expression The expression to render if the condition is met.
+  #
+  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
+  #
  class If < Block
-    Syntax                  = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS       = %w(and or).freeze
-
-    attr_reader :blocks
+    BOOLEAN_OPERATORS = %w(and or)

    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      push_block('if', markup)
+      push_block('if'.freeze, markup)
    end

    def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
    end

-    def parse(tokens)
-      while parse_body(@blocks.last.attachment, tokens)
-      end
-      @blocks.reverse_each do |block|
-        block.attachment.remove_blank_strings if blank?
-        block.attachment.freeze
-      end
-    end
-
-    ELSE_TAG_NAMES = ['elsif', 'else'].freeze
-    private_constant :ELSE_TAG_NAMES
-
    def unknown_tag(tag, markup, tokens)
-      if ELSE_TAG_NAMES.include?(tag)
+      if ['elsif'.freeze, 'else'.freeze].include?(tag)
        push_block(tag, markup)
      else
        super
      end
    end

-    def render_to_output_buffer(context, output)
-      @blocks.each do |block|
-        result = Liquid::Utils.to_liquid_value(
-          block.evaluate(context),
-        )
-
-        if result
-          return block.attachment.render_to_output_buffer(context, output)
+    def render(context)
+      context.stack do
+        @blocks.each do |block|
+          if block.evaluate(context)
+            return render_all(block.attachment, context)
+          end
        end
+        ''.freeze
      end
-
-      output
    end

    private

-    def push_block(tag, markup)
-      block = if tag == 'else'
-        ElseCondition.new
-      else
-        parse_with_selected_parser(markup)
+      def push_block(tag, markup)
+        block = if tag == 'else'.freeze
+          ElseCondition.new
+        else
+          parse_with_selected_parser(markup)
+        end
+
+        @blocks.push(block)
+        @nodelist = block.attach(Array.new)
      end

-      @blocks.push(block)
-      block.attach(new_body)
-    end
+      def lax_parse(markup)
+        expressions = markup.scan(ExpressionsAndOperators).reverse
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax

-    def parse_expression(markup)
-      Condition.parse_expression(parse_context, markup)
-    end
+        condition = Condition.new($1, $2, $3)

-    def lax_parse(markup)
-      expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
+        while not expressions.empty?
+          operator = (expressions.shift).to_s.strip

-      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax

-      until expressions.empty?
-        operator = expressions.pop.to_s.strip
+          new_condition = Condition.new($1, $2, $3)
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+          new_condition.send(operator, condition)
+          condition = new_condition
+        end

-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
-
-        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
-        new_condition.send(operator, condition)
-        condition = new_condition
+        condition
      end

-      condition
-    end
+      def strict_parse(markup)
+        p = Parser.new(markup)

-    def strict_parse(markup)
-      p = @parse_context.new_parser(markup)
-      condition = parse_binary_comparisons(p)
-      p.consume(:end_of_string)
-      condition
-    end
+        condition = parse_comparison(p)

-    def parse_binary_comparisons(p)
-      condition = parse_comparison(p)
-      first_condition = condition
-      while (op = p.id?('and') || p.id?('or'))
-        child_condition = parse_comparison(p)
-        condition.send(op, child_condition)
-        condition = child_condition
+        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+          new_cond = parse_comparison(p)
+          new_cond.send(op, condition)
+          condition = new_cond
+        end
+        p.consume(:end_of_string)
+
+        condition
      end
-      first_condition
-    end

-    def parse_comparison(p)
-      a = parse_expression(p.expression)
-      if (op = p.consume?(:comparison))
-        b = parse_expression(p.expression)
-        Condition.new(a, op, b)
-      else
-        Condition.new(a)
+      def parse_comparison(p)
+        a = p.expression
+        if op = p.consume?(:comparison)
+          b = p.expression
+          Condition.new(a, op, b)
+        else
+          Condition.new(a)
+        end
      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.blocks
-      end
-    end
  end
+
+  Template.register_tag('if'.freeze, If)
 end
@@ -1,17 +1,20 @@
-# frozen_string_literal: true
-
 module Liquid
  class Ifchanged < Block
-    def render_to_output_buffer(context, output)
-      block_output = +''
-      super(context, block_output)

-      if block_output != context.registers[:ifchanged]
-        context.registers[:ifchanged] = block_output
-        output << block_output
+    def render(context)
+      context.stack do
+
+        output = render_all(@nodelist, context)
+
+        if output != context.registers[:ifchanged]
+          context.registers[:ifchanged] = output
+          output
+        else
+          ''.freeze
+        end
      end
-
-      output
    end
  end
+
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end
@@ -1,113 +1,94 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category theme
-  # @liquid_name include
-  # @liquid_summary
-  #   Renders a [snippet](/themes/architecture/snippets).
-  # @liquid_description
-  #   Inside the snippet, you can access and alter variables that are [created](/docs/api/liquid/tags/variable-tags) outside of the
-  #   snippet.
-  # @liquid_syntax
-  #   {% include 'filename' %}
-  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
-  # @liquid_deprecated
-  #   Deprecated because the way that variables are handled reduces performance and makes code harder to both read and maintain.
+
+  # Include allows templates to relate with other templates
+  #
+  # Simply include another template:
+  #
+  #   {% include 'product' %}
+  #
+  # Include a template with a local variable:
+  #
+  #   {% include 'product' with products[0] %}
+  #
+  # Include a template for a collection:
+  #
+  #   {% include 'product' for products %}
  #
-  #   The `include` tag has been replaced by [`render`](/docs/api/liquid/tags/render).
  class Include < Tag
-    prepend Tag::Disableable
-
-    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
-    Syntax = SYNTAX
-
-    attr_reader :template_name_expr, :variable_name_expr, :attributes
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o

    def initialize(tag_name, markup, options)
      super

-      if markup =~ SYNTAX
+      if markup =~ Syntax

-        template_name = Regexp.last_match(1)
-        variable_name = Regexp.last_match(3)
-
-        @alias_name         = Regexp.last_match(5)
-        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
-        @template_name_expr = parse_expression(template_name)
-        @attributes         = {}
+        @template_name = $1
+        @variable_name = $3
+        @attributes    = {}

        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = parse_expression(value)
+          @attributes[key] = value
        end

      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
      end
    end

-    def parse(_tokens)
+    def parse(tokens)
    end

-    def render_to_output_buffer(context, output)
-      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name.is_a?(String)
+    def render(context)
+      partial = load_cached_partial(context)
+      variable = context[@variable_name || @template_name[1..-2]]

-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context,
-      )
-
-      context_variable_name = @alias_name || template_name.split('/').last
-
-      variable = if @variable_name_expr
-        context.evaluate(@variable_name_expr)
-      else
-        context.find_variable(template_name, raise_on_not_found: false)
-      end
-
-      old_template_name = context.template_name
-      old_partial       = context.partial
-
-      begin
-        context.template_name = partial.name
-        context.partial = true
-
-        context.stack do
-          @attributes.each do |key, value|
-            context[key] = context.evaluate(value)
-          end
-
-          if variable.is_a?(Array)
-            variable.each do |var|
-              context[context_variable_name] = var
-              partial.render_to_output_buffer(context, output)
-            end
-          else
-            context[context_variable_name] = variable
-            partial.render_to_output_buffer(context, output)
-          end
+      context.stack do
+        @attributes.each do |key, value|
+          context[key] = context[value]
        end
-      ensure
-        context.template_name = old_template_name
-        context.partial       = old_partial
-      end

-      output
-    end
-
-    alias_method :parse_context, :options
-    private :parse_context
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-          @node.variable_name_expr,
-        ] + @node.attributes.values
+        context_variable_name = @template_name[1..-2].split('/'.freeze).last
+        if variable.is_a?(Array)
+          variable.collect do |var|
+            context[context_variable_name] = var
+            partial.render(context)
+          end
+        else
+          context[context_variable_name] = variable
+          partial.render(context)
+        end
      end
    end
+
+    private
+      def load_cached_partial(context)
+        cached_partials = context.registers[:cached_partials] || {}
+        template_name = context[@template_name]
+
+        if cached = cached_partials[template_name]
+          return cached
+        end
+        source = read_template_from_file_system(context)
+        partial = Liquid::Template.parse(source)
+        cached_partials[template_name] = partial
+        context.registers[:cached_partials] = cached_partials
+        partial
+      end
+
+      def read_template_from_file_system(context)
+        file_system = context.registers[:file_system] || Liquid::Template.file_system
+
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context[@template_name])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
+      end
  end
+
+  Template.register_tag('include'.freeze, Include)
 end
@@ -1,38 +1,31 @@
-# frozen_string_literal: true
-
 module Liquid
-  # @liquid_public_docs
-  # @liquid_type tag
-  # @liquid_category variable
-  # @liquid_name increment
-  # @liquid_summary
-  #   Creates a new variable, with a default value of 0, that's increased by 1 with each subsequent call.
-  # @liquid_description
-  #   Variables that are declared with `increment` are unique to the [layout](/themes/architecture/layouts), [template](/themes/architecture/templates),
-  #   or [section](/themes/architecture/sections) file that they're created in. However, the variable is shared across
-  #   [snippets](/themes/architecture/snippets) included in the file.
+  # increment is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+  #
+  #   Hello: {% increment variable %}
+  #
+  # gives you:
+  #
+  #    Hello: 0
+  #    Hello: 1
+  #    Hello: 2
  #
-  #   Similarly, variables that are created with `increment` are independent from those created with [`assign`](/docs/api/liquid/tags/assign)
-  #   and [`capture`](/docs/api/liquid/tags/capture). However, `increment` and [`decrement`](/docs/api/liquid/tags/decrement) share
-  #   variables.
-  # @liquid_syntax
-  #   {% increment variable_name %}
-  # @liquid_syntax_keyword variable_name The name of the variable being incremented.
  class Increment < Tag
-    attr_reader :variable_name
-
    def initialize(tag_name, markup, options)
      super
-      @variable_name = markup.strip
+      @variable = markup.strip
    end

-    def render_to_output_buffer(context, output)
-      counter_environment = context.environments.first
-      value = counter_environment[@variable_name] || 0
-      counter_environment[@variable_name] = value + 1
-
-      output << value.to_s
-      output
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      context.environments.first[@variable] = value + 1
+      value.to_s
    end
  end
+
+  Template.register_tag('increment'.freeze, Increment)
 end
--- a/Show More
+++ b/Show More