Bump ruby/setup-ruby from 1.295.0 to 1.314.0

Bumps [ruby/setup-ruby](https://github.com/ruby/setup-ruby) from 1.295.0 to 1.314.0. - [Release notes](https://github.com/ruby/setup-ruby/releases) - [Changelog](https://github.com/ruby/setup-ruby/blob/master/release.rb) - [Commits](https://github.com/ruby/setup-ruby/compare/319994f95fa847cf3fb3cd3dbe89f6dcde9f178f...9eb537ca036ebaed86729dcb9309076e4c5c3b74) --- updated-dependencies: - dependency-name: ruby/setup-ruby dependency-version: 1.314.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <[email protected]>
Use liquid-spec branch for self specs
2026-09-12 23:40:45 -07:00 · 2026-06-22 21:33:30 +00:00 · 2026-06-11 23:20:43 -04:00 · 2026-06-11 23:20:43 -04:00 · 2026-06-05 10:47:37 +02:00 · 2026-05-20 09:34:37 +02:00
174 changed files with 15083 additions and 3926 deletions
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
@@ -0,0 +1,22 @@
+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 }}
@@ -0,0 +1,73 @@
+name: Liquid
+on: [push]
+
+env:
+  BUNDLE_JOBS: 4
+  BUNDLE_RETRY: 3
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        entry:
+          - { ruby: 3.3, allowed-failure: false } # minimum supported
+          - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: 4.0, allowed-failure: false } # latest stable
+          - {
+              ruby: 4.0,
+              allowed-failure: false,
+              rubyopt: "--enable-frozen-string-literal",
+            }
+          - { ruby: 4.0, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: 4.0, allowed-failure: false, rubyopt: "--zjit" }
+          - { ruby: truffleruby, allowed-failure: false }
+
+          # Head can have failures due to being in development
+          - { ruby: head, allowed-failure: true }
+          - {
+              ruby: head,
+              allowed-failure: true,
+              rubyopt: "--enable-frozen-string-literal",
+            }
+          - { ruby: head, allowed-failure: true, rubyopt: "--yjit" }
+          - { ruby: head, allowed-failure: true, rubyopt: "--zjit" }
+    name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
+        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 }}
+
+  spec:
+    runs-on: ubuntu-latest
+    env:
+      BUNDLE_WITH: spec
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
+        with:
+          bundler-cache: true
+          bundler: latest
+      - name: Run liquid-spec for all adapters
+        run: |
+          for adapter in spec/*.rb; do
+            echo "=== Running $adapter ==="
+            bundle exec liquid-spec run "$adapter" --no-max-failures
+          done
+
+  memory_profile:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+      - uses: ruby/setup-ruby@9eb537ca036ebaed86729dcb9309076e4c5c3b74 # v1.314.0
+        with:
+          bundler-cache: true
+      - run: bundle exec rake memory_profile:run
@@ -4,6 +4,6 @@
 pkg
 *.rbc
 .rvmrc
-.ruby-version
-Gemfile.lock
 .bundle
+.byebug_history
+Gemfile.lock
@@ -1,125 +1,28 @@
-inherit_from: ./.rubocop_todo.yml
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+inherit_from:
+  - .rubocop_todo.yml
+
+require: rubocop-performance
+
+Performance:
+  Enabled: true

 AllCops:
+  NewCops: disable
+  SuggestExtensions: false
  Exclude:
-    - 'performance/shopify/*'
-    - 'pkg/**'
+    - 'vendor/bundle/**/*'

-Metrics/BlockNesting:
-  Max: 3
+Naming/MethodName:
  Exclude:
-    - 'lib/liquid/block_body.rb'
+    - 'example/server/liquid_servlet.rb'

-Metrics/ModuleLength:
+Style/ClassMethodsDefinitions:
  Enabled: false

-Metrics/ClassLength:
-  Enabled: false
-
-Lint/AssignmentInCondition:
-  Enabled: false
-
-Lint/AmbiguousOperator:
-  Enabled: false
-
-Lint/AmbiguousRegexpLiteral:
-  Enabled: false
-
-Lint/ParenthesesAsGroupedExpression:
-  Enabled: false
-
-Lint/UnusedBlockArgument:
-  Enabled: false
-
-Lint/EndAlignment:
-  AlignWith: variable
-
-Lint/UnusedMethodArgument:
-  Enabled: false
-
-Style/SingleLineBlockParams:
-  Enabled: false
-
-Style/DoubleNegation:
-  Enabled: false
-
-Style/StringLiteralsInInterpolation:
-  Enabled: false
-
-Style/AndOr:
-  Enabled: false
-
-Style/SignalException:
-  Enabled: false
-
-Style/StringLiterals:
-  Enabled: false
-
-Style/BracesAroundHashParameters:
-  Enabled: false
-
-Style/NumericLiterals:
-  Enabled: false
-
-Style/SpaceInsideBrackets:
-  Enabled: false
-
-Style/SpaceBeforeBlockBraces:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Style/ClassAndModuleChildren:
-  Enabled: false
-
-Style/TrailingComma:
-  Enabled: false
-
-Style/IndentHash:
-  EnforcedStyle: consistent
-
-Style/FormatString:
-  Enabled: false
-
-Style/AlignParameters:
-  EnforcedStyle: with_fixed_indentation
-
-Style/MultilineOperationIndentation:
-  EnforcedStyle: indented
-
-Style/IfUnlessModifier:
-  Enabled: false
-
-Style/RaiseArgs:
-  Enabled: false
-
-Style/DeprecatedHashMethods:
-  Enabled: false
-
-Style/RegexpLiteral:
-  Enabled: false
-
-Style/SymbolLiteral:
-  Enabled: false
-
-Performance/Count:
-  Enabled: false
-
-Style/ConstantName:
-  Enabled: false
-
-Style/CaseIndentation:
-  Enabled: false
-
-Style/ClassVars:
-  Enabled: false
-
-Style/PerlBackrefs:
-  Enabled: false
-
-Style/TrivialAccessors:
-  AllowPredicates: true
-
-Style/WordArray:
-  Enabled: false
+# liquid filter calls were being mistaken to be calls on arrays
+Style/ConcatArrayLiterals:
+  Exclude:
+    - 'test/integration/standard_filter_test.rb'
@@ -1,72 +1,189 @@
-# This configuration was generated by `rubocop --auto-gen-config`
-# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.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: 5
-Lint/NestedMethodDefinition:
-  Enabled: false
-
-# Offense count: 53
-Metrics/AbcSize:
-  Max: 58
-
-# Offense count: 12
-Metrics/CyclomaticComplexity:
-  Max: 15
-
-# Offense count: 553
-# Configuration parameters: AllowURI, URISchemes.
-Metrics/LineLength:
-  Max: 294
-
-# Offense count: 77
-# Configuration parameters: CountComments.
-Metrics/MethodLength:
-  Max: 46
+# 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
-Metrics/PerceivedComplexity:
-  Max: 13
+# 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
-Style/AccessorMethodName:
-  Enabled: false
+# This cop supports safe auto-correction (--auto-correct).
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: aligned, indented
+Layout/MultilineOperationIndentation:
+  Exclude:
+    - 'lib/liquid/expression.rb'

-# Offense count: 1
-# Cop supports --auto-correct.
-Style/ClosingParenthesisIndentation:
-  Enabled: false
+# 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: 3
-# Configuration parameters: MinBodyLength.
-Style/GuardClause:
-  Enabled: false
+# 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: 4
-# Configuration parameters: EnforcedStyle, SupportedStyles.
-Style/MethodName:
-  Enabled: false
-
-# Offense count: 1
-Style/MultilineBlockChain:
-  Enabled: false
+# 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
-# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
-Style/Next:
+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: 7
-# Cop supports --auto-correct.
-# Configuration parameters: AllowAsExpressionSeparator.
-Style/Semicolon:
+# 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, AllowCopDirectives, AllowedPatterns.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 260
+
+Naming/PredicatePrefix:
  Enabled: false

 # Offense count: 1
-# Cop supports --auto-correct.
-# Configuration parameters: MaxLineLength.
-Style/WhileUntilModifier:
-  Enabled: false
+# This is intentional - early return from begin/rescue in assignment context
+Lint/NoReturnInBeginEndBlocks:
+  Exclude:
+    - 'lib/liquid/standardfilters.rb'
@@ -0,0 +1 @@
+4.0.2
@@ -1,25 +0,0 @@
-language: ruby
-
-rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - ruby-head
-  - jruby-head
-#  - rbx-2
-
-sudo: false
-
-addons:
-  apt:
-    packages:
-    - libgmp3-dev
-
-matrix:
-  allow_failures:
-    - rvm: jruby-head
-
-script: "bundle exec rake"
-
-notifications:
-  disable: true
@@ -5,6 +5,7 @@
 * 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

 ## Things we won't merge

@@ -14,12 +15,22 @@
 * 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)

 ## 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`)
 * 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)
+
@@ -1,14 +1,38 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
+git_source(:github) do |repo_name|
+  "https://github.com/#{repo_name}.git"
+end

 gemspec
-gem 'stackprof', platforms: :mri_21

-group :test do
-  gem 'spy', '0.4.1'
+gem "base64"
+
+group :benchmark, :test do
  gem 'benchmark-ips'
-  gem 'rubocop', '0.34.2'
+  gem 'memory_profiler'
+  gem 'terminal-table'
+  gem "lru_redux"

-  platform :mri do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '2570693d8d03faa0df9160ec74348a7149436df3'
+  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
+    gem 'stackprof'
  end
 end
+
+group :development do
+  gem "webrick"
+end
+
+group :test do
+  gem 'benchmark'
+  gem 'rubocop', '~> 1.82.0'
+  gem 'rubocop-shopify', '~> 2.18.0', require: false
+  gem 'rubocop-performance', require: false
+end
+
+group :spec do
+  # Using feature branch until https://github.com/Shopify/liquid-spec/pull/144 is merged
+  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'self-drop-env-lookup-specs'
+  gem 'activesupport', require: false
+end
@@ -1,8 +1,238 @@
 # Liquid Change Log

-## 4.0.0 / not yet released / branch "master"
+## 5.11.0
+* Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
+* Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]
+
+## 5.10.0
+* Introduce support for Inline Snippets [Julia Boutin]
+
+## 5.9.0
+* Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]
+
+## 5.8.7
+* Expose body content in the `Doc` tag [James Meng]
+
+## 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]
@@ -18,10 +248,13 @@
 * 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 support for `liquid_methods`
+* 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]
@@ -1,11 +1,11 @@
-[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![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)

 # Liquid template engine

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

@@ -42,6 +42,8 @@ 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.

@@ -50,24 +52,66 @@ 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
+Liquid also comes with different parsers 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::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.
+Liquid::Environment.default.error_mode = :strict2 # Raises a SyntaxError when invalid syntax is used in all tags
+Liquid::Environment.default.error_mode = :strict  # Raises a SyntaxError when invalid syntax is used in some tags
+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.
 ```

 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.

@@ -104,3 +148,9 @@ 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,29 +1,39 @@
+# 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: [:rubocop, :test]
+task(default: [:test, :rubocop])

-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

-desc 'run test suite with warn error mode'
+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')
 task :warn_test do
  ENV['LIQUID_PARSER_MODE'] = 'warn'
  Rake::Task['base_test'].invoke
 end

 task :rubocop do
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
+  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 lax, strict, and strict2 parsers')
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
@@ -32,20 +42,26 @@ task :test do
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke

-  if RUBY_ENGINE == 'ruby'
-    ENV['LIQUID-C'] = '1'
+  ENV['LIQUID_PARSER_MODE'] = 'strict2'
+  Rake::Task['base_test'].reenable
+  Rake::Task['base_test'].invoke

+  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
    ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['base_test'].reenable
-    Rake::Task['base_test'].invoke
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke

    ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['base_test'].reenable
-    Rake::Task['base_test'].invoke
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke
+
+    ENV['LIQUID_PARSER_MODE'] = 'strict2'
+    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
@@ -63,7 +79,7 @@ end

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

@@ -71,6 +87,38 @@ namespace :benchmark do
  task :strict do
    ruby "./performance/benchmark.rb strict"
  end
+
+  desc "Run the liquid benchmark with strict2 parsing"
+  task :strict2 do
+    ruby "./performance/benchmark.rb strict2"
+  end
+
+  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
+  task run: [:lax, :strict, :strict2]
+
+  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
@@ -85,7 +133,14 @@ namespace :profile do
  end
 end

-desc "Run example"
+namespace :memory_profile do
+  desc "Run memory profiler"
+  task :run do
+    ruby "./performance/memory_profile.rb"
+  end
+end
+
+desc("Run example")
 task :example do
  ruby "-w -d -Ilib example/server/server.rb"
 end
@@ -93,3 +148,11 @@ end
 task :console do
  exec 'irb -I lib -r liquid'
 end
+
+desc('run liquid-spec suite across all adapters')
+task :spec do
+  Dir['./spec/*.rb'].sort.each do |adapter|
+    puts "=== Running #{adapter} ==="
+    sh 'bundle', 'exec', 'liquid-spec', 'run', adapter, '--no-max-failures'
+  end
+end
@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'liquid'
+
+class VirtualFileSystem
+  def initialize
+    snippet_1 = <<~LIQUID
+      <h1>
+        {{- greating | default: 'Hello' }}, {{ name | default: 'world' -}}!
+      </h1>
+    LIQUID
+    snippet_2 = <<~LIQUID
+      {%- for i in (1..5) -%}
+        > {{ i }}
+      {%- endfor -%}
+    LIQUID
+
+    @templates = {
+      'snippet-1' => snippet_1,
+      'snippet-2' => snippet_2,
+    }
+  end
+
+  def read_template_file(key)
+    @templates[key] || raise(Liquid::FileSystemError, "No such template '#{key}'")
+  end
+end
+
+def source
+  File.read(ARGV[0])
+rescue StandardError
+  'Usage: bin/render example/server/templates/index.liquid'
+end
+
+def assigns
+  {
+    'date' => Time.now,
+  }
+end
+
+puts Liquid::Template
+  .parse(source, error_mode: :strict2)
+  .tap { |t| t.registers[:file_system] = VirtualFileSystem.new }
+  .render(assigns)
@@ -1,3 +0,0 @@
-machine:
-  ruby:
-    version: ruby-2.0
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module ProductsFilter
  def price(integer)
-    sprintf("$%.2d USD", integer / 100.0)
+    format("$%.2d USD", integer / 100.0)
  end

  def prettyprint(text)
@@ -28,14 +30,18 @@ class Servlet < LiquidServlet
  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' }]
+    [
+      { '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 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' }
+    ]
  end

  def description
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_GET(req, res)
    handle(:get, req, res)
@@ -9,17 +11,17 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet

  private

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

    @request.path_info =~ /(\w+)\z/
-    @action = $1 || 'index'
+    @action  = Regexp.last_match(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)
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'webrick'
 require 'rexml/document'

@@ -8,5 +10,5 @@ require_relative 'example_servlet'
 # Setup webrick
 server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
 server.mount('/', Servlet)
-trap("INT"){ server.shutdown }
+trap("INT") { server.shutdown }
 server.start
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -19,13 +21,17 @@
 # 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           = ','.freeze
-  FilterArgumentSeparator     = ':'.freeze
-  VariableAttributeSeparator  = '.'.freeze
+  ArgumentSeparator           = ','
+  FilterArgumentSeparator     = ':'
+  VariableAttributeSeparator  = '.'
+  WhitespaceControl           = '-'
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
+  TagName                     = /#|\w+/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
  VariableSegment             = /[\w\-]/
  VariableStart               = /\{\{/
@@ -33,46 +39,54 @@ module Liquid
  VariableIncompleteEnd       = /\}\}?/
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /\{\{|\{\%/
+  TagAttributes               = /(\w[\w-]*)\s*\:\s*(#{QuotedFragment})/o
+  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
+  VariableParser              = /\[(?>[^\[\]]+|\g<0>)*\]|#{VariableSegment}+\??/o

-  singleton_class.send(:attr_accessor, :cache_classes)
-  self.cache_classes = true
+  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
+  HAS_STRING_SCANNER_SCAN_BYTE = StringScanner.instance_methods.include?(:scan_byte)
 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/self_drop'
 require 'liquid/tablerowloop_drop'
 require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer'
-require 'liquid/expression'
+require 'liquid/strainer_template'
 require 'liquid/context'
-require 'liquid/parser_switching'
 require 'liquid/tag'
-require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
 require 'liquid/variable'
 require 'liquid/variable_lookup'
 require 'liquid/range_lookup'
-require 'liquid/file_system'
 require 'liquid/resource_limits'
+require 'liquid/expression'
 require 'liquid/template'
-require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
-
-# Load all the tags of the standard library
-#
-Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+require 'liquid/partial_cache'
+require 'liquid/usage'
+require 'liquid/registers'
+require 'liquid/template_factory'
@@ -1,16 +1,22 @@
+# 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 = BlockBody.new
+      @body = new_body
      while parse_body(@body, tokens)
      end
+      @body.freeze
    end

+    # For backwards compatibility
    def render(context)
      @body.render(context)
    end
@@ -23,20 +29,33 @@ module Liquid
      @body.nodelist
    end

-    def unknown_tag(tag, _params, _tokens)
-      case tag
-      when 'else'.freeze
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
-          block_name: block_name))
-      when 'end'.freeze
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+    def unknown_tag(tag_name, _markup, _tokenizer)
+      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
+    end
+
+    # @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,
-          block_delimiter: block_delimiter))
+        )
+      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.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
      end
    end

+    def raise_tag_never_closed(block_name)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+    end
+
    def block_name
      @tag_name
    end
@@ -45,20 +64,32 @@ module Liquid
      @block_delimiter ||= "end#{block_name}"
    end

-    protected
+    private

+    # @api public
+    def new_body
+      parse_context.new_block_body
+    end
+
+    # @api public
    def parse_body(body, tokens)
-      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
-        @blank &&= body.blank?
+      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?

-        return false if end_tag_name == block_delimiter
-        unless end_tag_name
-          raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+          return false if end_tag_name == block_delimiter
+          raise_tag_never_closed(block_name) unless end_tag_name
+
+          # 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)
        end
-
-        # 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)
+      ensure
+        parse_context.depth -= 1
      end

      true
@@ -1,46 +1,65 @@
+# frozen_string_literal: true
+
+require 'English'
+
 module Liquid
  class BlockBody
-    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
+    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
+      @blank    = true
    end

-    def parse(tokenizer, parse_context)
+    def parse(tokenizer, parse_context, &block)
+      raise FrozenError, "can't modify frozen Liquid::BlockBody" if frozen?
+
      parse_context.line_number = tokenizer.line_number
-      while token = tokenizer.shift
-        unless token.empty?
-          case
-          when token.start_with?(TAGSTART)
-            if token =~ FullToken
-              tag_name = $1
-              markup = $2
-              # fetch the tag from registered blocks
-              if tag = registered_tags[tag_name]
-                new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-                @blank &&= new_tag.blank?
-                @nodelist << new_tag
-              else
-                # end parsing if we reach an unknown tag and let the caller decide
-                # determine how to proceed
-                return yield tag_name, markup
-              end
-            else
-              raise_missing_tag_terminator(token, parse_context)
-            end
-          when token.start_with?(VARSTART)
-            @nodelist << create_variable(token, parse_context)
-            @blank = false
-          else
-            @nodelist << token
-            @blank &&= !!(token =~ /\A\s*\z/)
+
+      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
@@ -48,76 +67,207 @@ module Liquid
      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)
-      output = []
-      context.resource_limits.render_score += @nodelist.length
+      render_to_output_buffer(context, +'')
+    end

-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.interrupt?
+    def render_to_output_buffer(context, output)
+      freeze unless frozen?

-        begin
+      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 %}
-          if token.is_a?(Continue) || token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          node_output = render_node(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            output << node_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-          context.handle_error(e, token.line_number)
-          output << nil
-        rescue ::StandardError => e
-          output << context.handle_error(e, token.line_number)
+          # 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.join
+      output
    end

    private

-    def render_node(node, context)
-      node_output = (node.respond_to?(:render) ? node.render(context) : node)
-      node_output = node_output.is_a?(Array) ? node_output.join : node_output.to_s
-
-      context.resource_limits.render_length += node_output.length
-      if context.resource_limits.reached?
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      node_output
+    def render_node(context, output, node)
+      BlockBody.render_node(context, output, node)
    end

    def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
+      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
-      raise_missing_variable_terminator(token, parse_context)
+
+      BlockBody.raise_missing_variable_terminator(token, parse_context)
    end

+    # @deprecated Use {.raise_missing_tag_terminator} instead
    def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect))
+      BlockBody.raise_missing_tag_terminator(token, parse_context)
    end

+    # @deprecated Use {.raise_missing_variable_terminator} instead
    def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
-    end
-
-    def registered_tags
-      Template.tags
+      BlockBody.raise_missing_variable_terminator(token, parse_context)
    end
  end
 end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
  # Container for liquid nodes which conveniently wraps decision making logic
  #
@@ -6,60 +8,88 @@ module Liquid
  #   c = Condition.new(1, '==', 1)
  #   c.evaluate #=> true
  #
-  class Condition #:nodoc:
+  class Condition # :nodoc:
    @@operators = {
-      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<'.freeze  => :<,
-      '>'.freeze  => :>,
-      '>='.freeze => :>=,
-      '<='.freeze => :<=,
-      'contains'.freeze => lambda do |cond, left, right|
+      '==' => ->(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,
    }

    def self.operators
      @@operators
    end

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

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

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

-      case @child_relation
-      when :or
-        result || @child_condition.evaluate(context)
-      when :and
-        result && @child_condition.evaluate(context)
-      else
-        result
+        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
      end
+      result
    end

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

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

@@ -72,52 +102,116 @@ module Liquid
    end

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

+    protected
+
+    attr_reader :child_relation
+
    private

    def equal_variables(left, right)
-      if left.is_a?(Liquid::Expression::MethodLiteral)
-        if right.respond_to?(left.method_name)
-          return right.send(left.method_name)
-        else
-          return nil
-        end
+      if left.is_a?(MethodLiteral)
+        return call_method_literal(left, right)
      end

-      if right.is_a?(Liquid::Expression::MethodLiteral)
-        if left.respond_to?(right.method_name)
-          return left.send(right.method_name)
-        else
-          return nil
-        end
+      if right.is_a?(MethodLiteral)
+        return call_method_literal(right, left)
      end

      left == right
    end

+    def call_method_literal(literal, value)
+      method_name = literal.method_name
+
+      # If the object responds to the method (e.g., ActiveSupport is loaded), use it
+      if value.respond_to?(method_name)
+        value.send(method_name)
+      else
+        # Emulate ActiveSupport's blank?/empty? to make Liquid invariant
+        # to whether ActiveSupport is loaded or not
+        case method_name
+        when :blank?
+          liquid_blank?(value)
+        when :empty?
+          liquid_empty?(value)
+        else
+          false
+        end
+      end
+    end
+
+    # Implement blank? semantics matching ActiveSupport
+    # blank? returns true for nil, false, empty strings, whitespace-only strings,
+    # empty arrays, and empty hashes
+    def liquid_blank?(value)
+      case value
+      when NilClass, FalseClass
+        true
+      when TrueClass, Numeric
+        false
+      when String
+        # Blank if empty or whitespace only (matches ActiveSupport)
+        value.empty? || value.match?(/\A\s*\z/)
+      when Array, Hash
+        value.empty?
+      else
+        # Fall back to empty? if available, otherwise false
+        value.respond_to?(:empty?) ? value.empty? : false
+      end
+    end
+
+    # Implement empty? semantics
+    # Note: nil is NOT empty. empty? checks if a collection has zero elements.
+    def liquid_empty?(value)
+      case value
+      when String, Array, Hash
+        value.empty?
+      else
+        value.respond_to?(:empty?) ? value.empty? : false
+      end
+    end
+
    def interpret_condition(left, right, op, context)
      # 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?

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

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

      if operation.respond_to?(:call)
        operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation)
+      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
        begin
          left.send(operation, right)
        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError.new(e.message)
+          raise Liquid::ArgumentError, 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
+      end
+    end
  end

  class ElseCondition < Condition
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Const
+    EMPTY_HASH = {}.freeze
+    EMPTY_ARRAY = [].freeze
+  end
+end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
@@ -12,36 +14,58 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
-    attr_accessor :exception_handler, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+    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

-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-      @environments     = [environments].flatten
-      @scopes           = [(outer_scope || {})]
-      @registers        = registers
-      @errors           = []
-      @partial          = false
-      @strict_variables = false
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
-      squash_instance_assigns_with_environments
+    # 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

-      @this_stack_used = false
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {}, environment = Environment.default)
+      @environment = environment
+      @environments = [environments]
+      @environments.flatten!

+      @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_handler = ->(e) { raise }
+        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
      end

-      @interrupts = []
-      @filters = []
-      @global_filter = nil
+      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
    end
+    # rubocop:enable Metrics/ParameterLists

    def warnings
      @warnings ||= []
    end

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

    # Adds filters to this context.
@@ -74,30 +98,11 @@ module Liquid
    end

    def handle_error(e, line_number = nil)
-      if e.is_a?(Liquid::Error)
-        e.template_name ||= template_name
-        e.line_number ||= line_number
-      end
-
-      output = nil
-
-      if exception_handler
-        result = exception_handler.call(e)
-        case result
-        when Exception
-          e = result
-          if e.is_a?(Liquid::Error)
-            e.template_name ||= template_name
-            e.line_number ||= line_number
-          end
-        when String
-          output = result
-        else
-          raise if result
-        end
-      end
+      e = internal_error unless e.is_a?(Liquid::Error)
+      e.template_name ||= template_name
+      e.line_number   ||= line_number
      errors.push(e)
-      output || Liquid::Error.render(e)
+      exception_renderer.call(e).to_s
    end

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

    # Merge a hash of variables in the current local scope
@@ -128,20 +133,33 @@ module Liquid
    #      context['var'] = 'hi'
    #   end
    #
-    #   context['var]  #=> nil
-    def stack(new_scope = nil)
-      old_stack_used = @this_stack_used
-      if new_scope
-        push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
+    #   context['var']  #=> nil
+    def stack(new_scope = {})
+      push(new_scope)
      yield
    ensure
-      pop if @this_stack_used
-      @this_stack_used = old_stack_used
+      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
@@ -150,10 +168,6 @@ module Liquid

    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
    def []=(key, value)
-      unless @this_stack_used
-        @this_stack_used = true
-        push({})
-      end
      @scopes[0][key] = value
    end

@@ -166,11 +180,20 @@ module Liquid
    # Example:
    #   products == empty #=> products.empty?
    def [](expression)
-      evaluate(Expression.parse(expression))
+      evaluate(Expression.parse(expression, @string_scanner))
    end

    def key?(key)
-      self[key] != nil
+      find_variable(key, raise_on_not_found: false) != nil
+    end
+
+    # Checks whether a variable is defined in any scope, including nil-valued keys.
+    # Unlike #key?, this uses Hash#key? so that variables explicitly set to nil
+    # are still considered defined.
+    def variable_defined?(key)
+      @scopes.any? { |s| s.key?(key) } ||
+        @environments.any? { |e| e.key?(key) } ||
+        @static_environments.any? { |e| e.key?(key) }
    end

    def evaluate(object)
@@ -178,49 +201,104 @@ module Liquid
    end

    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key)
+    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) }
-      scope = @scopes[index] if index

-      variable = nil
+      fallback_to_self_drop = key == Expression::SELF && index.nil?

-      if scope.nil?
-        @environments.each do |e|
-          variable = lookup_and_evaluate(e, key)
-          unless variable.nil?
-            scope = e
-            break
-          end
-        end
+      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 && !fallback_to_self_drop,
+        )
      end

-      scope ||= @environments.last || @scopes.last
-      variable ||= lookup_and_evaluate(scope, key)
+      # `self` resolves to a SelfDrop (enabling `self['var']` lookups),
+      # but only after the normal environment lookup doesn't find a value.
+      return @self_drop ||= SelfDrop.new(self) if fallback_to_self_drop && variable.nil?

-      variable = variable.to_liquid
+      # update variable's context before invoking #to_liquid
      variable.context = self if variable.respond_to?(:context=)

-      variable
+      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)
-      if @strict_variables && obj.respond_to?(:key?) && !obj.key?(key)
+    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)
+        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

+    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|
@@ -0,0 +1,22 @@
+# 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,26 +1,64 @@
+# frozen_string_literal: true
+
 module Liquid
-  class Document < BlockBody
+  class Document
    def self.parse(tokens, parse_context)
-      doc = new
+      doc = new(parse_context)
      doc.parse(tokens, parse_context)
      doc
    end

-    def parse(tokens, parse_context)
-      super do |end_tag_name, end_tag_params|
-        unknown_tag(end_tag_name, parse_context) if end_tag_name
+    attr_reader :parse_context, :body
+
+    def initialize(parse_context)
+      @parse_context = parse_context
+      @body = new_body
+    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, parse_context)
+    def unknown_tag(tag, _markup, _tokenizer)
      case tag
-      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
+      when 'else', 'end'
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
      else
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
+        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
    end
  end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'

 module Liquid
@@ -23,9 +25,13 @@ module Liquid
  class Drop
    attr_writer :context

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

@@ -67,7 +73,7 @@ module Liquid

        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max, :include?]
+          blacklist -= [:sort, :count, :first, :min, :max]
        end

        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
@@ -0,0 +1,159 @@
+# 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 :strict2, :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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
  class Error < ::StandardError
    attr_accessor :line_number
@@ -5,7 +7,7 @@ module Liquid
    attr_accessor :markup_context

    def to_s(with_prefix = true)
-      str = ""
+      str = +""
      str << message_prefix if with_prefix
      str << super()

@@ -17,22 +19,14 @@ module Liquid
      str
    end

-    def self.render(e)
-      if e.is_a?(Liquid::Error)
-        e.to_s
-      else
-        "Liquid error: #{e}"
-      end
-    end
-
    private

    def message_prefix
-      str = ""
-      if is_a?(SyntaxError)
-        str << "Liquid syntax error"
+      str = +""
+      str << if is_a?(SyntaxError)
+        "Liquid syntax error"
      else
-        str << "Liquid error"
+        "Liquid error"
      end

      if line_number
@@ -46,18 +40,20 @@ module Liquid
    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)
-  TaintedError = 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)
+  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)
 end
@@ -1,43 +1,128 @@
+# frozen_string_literal: true
+
 module Liquid
  class Expression
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-
-      def to_liquid
-        to_s
-      end
-    end
+    SELF = 'self'

    LITERALS = {
-      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze  => true,
-      'false'.freeze => false,
-      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
-      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
-    }
+      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

-    def self.parse(markup)
-      if LITERALS.key?(markup)
-        LITERALS[markup]
-      else
-        case markup
-        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
-          RangeLookup.parse($1, $2)
-        when /\A(-?\d[\d\.]+)\z/ # Floats
-          $1.to_f
+    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 safe_parse(parser, ss = StringScanner.new(""), cache = nil)
+        parse(parser.expression, ss, cache)
+      end
+
+      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
-          VariableLookup.parse(markup)
+          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
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'time'
 require 'date'

@@ -7,6 +9,12 @@ class String # :nodoc:
  end
 end

+class Symbol # :nodoc:
+  def to_liquid
+    to_s
+  end
+end
+
 class Array # :nodoc:
  def to_liquid
    self
@@ -25,6 +33,12 @@ class Numeric # :nodoc:
  end
 end

+class Range # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
 class Time # :nodoc:
  def to_liquid
    self
@@ -1,3 +1,5 @@
+# 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.
  #
@@ -8,8 +10,8 @@ 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
@@ -26,10 +28,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.
@@ -37,15 +39,15 @@ 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".freeze)
-      @root = root
+    def initialize(root, pattern = "_%s.liquid")
+      @root    = root
      @pattern = pattern
    end

@@ -57,9 +59,9 @@ module Liquid
    end

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

-      full_path = if template_path.include?('/'.freeze)
+      full_path = if template_path.include?('/')
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
      else
        File.join(root, @pattern % template_path)
@@ -1,34 +1,81 @@
+# 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
+      @name       = name
+      @length     = length
      @parentloop = parentloop
-      @index = 0
+      @index      = 0
    end

-    attr_reader :name, :length, :parentloop
+    # @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
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'

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

    def deep_fetch_translation(name)
-      name.split('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
+      name.split('.').reduce(locale) do |level, cur|
+        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
      end
    end
  end
@@ -1,10 +1,12 @@
+# 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".freeze
+      @message = message || "interrupt"
    end
  end

@@ -1,53 +1,179 @@
-require "strscan"
+# frozen_string_literal: true
+
 module Liquid
  class Lexer
-    SPECIALS = {
-      '|'.freeze => :pipe,
-      '.'.freeze => :dot,
-      ':'.freeze => :colon,
-      ','.freeze => :comma,
-      '['.freeze => :open_square,
-      ']'.freeze => :close_square,
-      '('.freeze => :open_round,
-      ')'.freeze => :close_round,
-      '?'.freeze => :question,
-      '-'.freeze => :dash
-    }
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
-    SINGLE_STRING_LITERAL = /'[^\']*'/
+    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 = /"[^\"]*"/
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/
-    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
+    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
+    SINGLE_STRING_LITERAL = /'[^\']*'/
+    WHITESPACE_OR_NOTHING = /\s*/

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

-    def tokenize
-      @output = []
+    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

-      until @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]
+    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
          else
-            raise SyntaxError, "Unexpected character #{c}"
+            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
          end
        end
-        @output << tok
+        # 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
      end

-      @output << [:end_of_string]
+      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
    end
  end
 end
@@ -2,23 +2,32 @@
  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]"
-      unknown_tag: "Unknown tag '%{tag}'"
-      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      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"
+      table_row_invalid_attribute: "Invalid attribute '%{attribute}' in tablerow loop. Valid attributes are cols, limit, offset, and range"
+      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"
-      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
+      unknown_tag: "Unknown tag '%{tag}'"
      variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
-      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"
+    argument:
+      include: "Argument error in tag 'include' - Illegal template name"
+    disabled:
+      tag: "usage is not allowed in this context"
@@ -1,12 +1,30 @@
+# frozen_string_literal: true
+
 module Liquid
  class ParseContext
-    attr_accessor :locale, :line_number
-    attr_reader :partial, :warnings, :error_mode
+    attr_accessor :locale, :line_number, :trim_whitespace, :depth
+    attr_reader :partial, :warnings, :error_mode, :environment

-    def initialize(options = {})
+    def initialize(options = Const::EMPTY_HASH)
+      @environment = options.fetch(:environment, Environment.default)
      @template_options = options ? options.dup : {}
-      @locale = @template_options[:locale] ||= I18n.new
+
+      @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

@@ -14,11 +32,48 @@ module Liquid
      @options[option_key]
    end

+    def new_block_body
+      Liquid::BlockBody.new
+    end
+
+    def new_parser(input)
+      @string_scanner.string = input
+      Parser.new(@string_scanner, reject_bare_brackets: @error_mode == :strict2 || @error_mode == :rigid)
+    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 safe_parse_expression(parser)
+      Expression.safe_parse(parser, @string_scanner, @expression_cache)
+    end
+
+    def parse_expression(markup, safe: false)
+      if !safe && @error_mode == :strict2
+        # parse_expression is a widely used API. To maintain backward
+        # compatibility while raising awareness about strict2 parser standards,
+        # the safe flag supports API users make a deliberate decision.
+        #
+        # In strict2 mode, markup MUST come from a string returned by the parser
+        # (e.g., parser.expression). We're not calling the parser here to
+        # prevent redundant parser overhead.
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
+      end
+
+      Expression.parse(markup, @string_scanner, @expression_cache)
+    end
+
    def partial=(value)
      @partial = value
      @options = value ? partial_options : @template_options
-      @error_mode = @options[:error_mode] || Template.error_mode
-      value
+
+      @error_mode = @options[:error_mode] || @environment.error_mode
    end

    def partial_options
@@ -27,7 +82,7 @@ module Liquid
        if dont_pass == true
          { locale: locale }
        elsif dont_pass.is_a?(Array)
-          @template_options.reject { |k, v| dont_pass.include?(k) }
+          @template_options.reject { |k, _v| dont_pass.include?(k) }
        else
          @template_options
        end
@@ -0,0 +1,42 @@
+# 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,9 +1,12 @@
+# frozen_string_literal: true
+
 module Liquid
  class Parser
-    def initialize(input)
-      l = Lexer.new(input)
-      @tokens = l.tokenize
-      @p = 0 # pointer to current location
+    def initialize(input, reject_bare_brackets: false)
+      ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
+      @tokens = Lexer.tokenize(ss)
+      @p      = 0 # pointer to current location
+      @reject_bare_brackets = reject_bare_brackets
    end

    def jump(point)
@@ -46,11 +49,21 @@ module Liquid

    def expression
      token = @tokens[@p]
-      if token[0] == :id
-        variable_signature
-      elsif [:string, :number].include? token[0]
+      case token[0]
+      when :id
+        str = consume
+        str << variable_lookups
+      when :open_square
+        if @reject_bare_brackets
+          raise SyntaxError, "Bare bracket access is not allowed. Use #{Expression::SELF}['...'] instead"
+        end
+        str = consume.dup
+        str << expression
+        str << consume(:close_square)
+        str << variable_lookups
+      when :string, :number
        consume
-      elsif token.first == :open_round
+      when :open_round
        consume
        first = expression
        consume(:dotdot)
@@ -63,26 +76,29 @@ module Liquid
    end

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

      str << expression
      str
    end

-    def variable_signature
-      str = consume(:id)
-      while look(:open_square)
-        str << consume
-        str << expression
-        str << consume(:close_square)
-      end
-      if look(:dot)
-        str << consume
-        str << variable_signature
+    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
      end
      str
    end
@@ -1,25 +1,72 @@
+# frozen_string_literal: true
+
 module Liquid
  module ParserSwitching
+    # Do not use this.
+    #
+    # It's basically doing the same thing the {#parse_with_selected_parser},
+    # except this will try the strict parser regardless of the error mode,
+    # and fall back to the lax parser if the error mode is lax or warn,
+    # except when in strict2 mode where it uses the strict2 parser.
+    #
+    # @deprecated Use {#parse_with_selected_parser} instead.
+    def strict_parse_with_error_mode_fallback(markup)
+      return strict2_parse_with_error_context(markup) if strict2_mode?
+
+      strict_parse_with_error_context(markup)
+    rescue SyntaxError => e
+      case parse_context.error_mode
+      when :rigid
+        rigid_warn
+        raise
+      when :strict2
+        raise
+      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 :rigid   then rigid_warn && strict2_parse_with_error_context(markup)
+      when :strict2 then strict2_parse_with_error_context(markup)
+      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)
+          strict2_parse_with_error_context(markup)
        rescue SyntaxError => e
          parse_context.warnings << e
-          return lax_parse(markup)
+          lax_parse(markup)
        end
      end
    end

+    def strict2_mode?
+      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
+    end
+
    private

+    def rigid_warn
+      Deprecations.warn(':rigid', ':strict2')
+    end
+
+    def strict2_parse_with_error_context(markup)
+      strict2_parse(markup)
+    rescue SyntaxError => e
+      e.line_number    = line_number
+      e.markup_context = markup_context(markup)
+      raise e
+    end
+
    def strict_parse_with_error_context(markup)
      strict_parse(markup)
    rescue SyntaxError => e
-      e.line_number = line_number
+      e.line_number    = line_number
      e.markup_context = markup_context(markup)
      raise e
    end
@@ -0,0 +1,33 @@
+# 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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'liquid/profiler/hooks'

 module Liquid
@@ -23,7 +25,7 @@ module Liquid
  #     node.code
  #
  #     # Which template and line number of this node.
-  #     # If top level, this will be "<root>".
+  #     # The top-level template name is `nil` by default, but can be set in the Liquid::Context before rendering.
  #     node.partial
  #     node.line_number
  #
@@ -44,115 +46,94 @@ module Liquid
    include Enumerable

    class Timing
-      attr_reader :code, :partial, :line_number, :children
+      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(node, partial)
-        @code        = node.respond_to?(:raw) ? node.raw : node
-        @partial     = partial
-        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
-        @children    = []
+      def initialize(code: nil, template_name: nil, line_number: nil)
+        @code = code
+        @template_name = template_name
+        @line_number = line_number
+        @children = []
      end

-      def self.start(node, partial)
-        new(node, partial).tap(&:start)
-      end
-
-      def start
-        @start_time = Time.now
-      end
-
-      def finish
-        @end_time = Time.now
-      end
-
-      def render_time
-        @end_time - @start_time
+      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

-    def self.profile_node_render(node)
-      if Profiler.current_profile && node.respond_to?(:render)
-        Profiler.current_profile.start_node(node)
-        output = yield
-        Profiler.current_profile.end_node(node)
-        output
-      else
-        yield
-      end
-    end
-
-    def self.profile_children(template_name)
-      if Profiler.current_profile
-        Profiler.current_profile.push_partial(template_name)
-        output = yield
-        Profiler.current_profile.pop_partial
-        output
-      else
-        yield
-      end
-    end
-
-    def self.current_profile
-      Thread.current[:liquid_profiler]
-    end
+    attr_reader :total_time
+    alias_method :total_render_time, :total_time

    def initialize
-      @partial_stack = ["<root>"]
-
-      @root_timing = Timing.new("", current_partial)
-      @timing_stack = [@root_timing]
-
-      @render_start_at = Time.now
-      @render_end_at = @render_start_at
+      @root_children = []
+      @current_children = nil
+      @total_time = 0.0
    end

-    def start
-      Thread.current[:liquid_profiler] = self
-      @render_start_at = Time.now
+    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 stop
-      Thread.current[:liquid_profiler] = nil
-      @render_end_at = Time.now
-    end
-
-    def total_render_time
-      @render_end_at - @render_start_at
+    def children
+      children = @root_children
+      if children.length == 1
+        children.first.children
+      else
+        children
+      end
    end

    def each(&block)
-      @root_timing.children.each(&block)
+      children.each(&block)
    end

    def [](idx)
-      @root_timing.children[idx]
+      children[idx]
    end

    def length
-      @root_timing.children.length
+      children.length
    end

-    def start_node(node)
-      @timing_stack.push(Timing.start(node, current_partial))
+    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

-    def end_node(_node)
-      timing = @timing_stack.pop
-      timing.finish
+    private

-      @timing_stack.last.children << timing
-    end
-
-    def current_partial
-      @partial_stack.last
-    end
-
-    def push_partial(partial_name)
-      @partial_stack.push(partial_name)
-    end
-
-    def pop_partial
-      @partial_stack.pop
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
    end
  end
 end
@@ -1,23 +1,35 @@
+# frozen_string_literal: true
+
 module Liquid
-  class BlockBody
-    def render_node_with_profiling(node, context)
-      Profiler.profile_node_render(node) do
-        render_node_without_profiling(node, context)
+  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
-
-    alias_method :render_node_without_profiling, :render_node
-    alias_method :render_node, :render_node_with_profiling
  end
+  BlockBody.prepend(BlockBodyProfilingHook)

-  class Include < Tag
-    def render_with_profiling(context)
-      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_without_profiling(context)
-      end
+  module DocumentProfilingHook
+    def render_to_output_buffer(context, output)
+      return super unless context.profiler
+      context.profiler.profile(context.template_name) { super }
    end
-
-    alias_method :render_without_profiling, :render
-    alias_method :render, :render_with_profiling
  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,23 +1,37 @@
+# frozen_string_literal: true
+
 module Liquid
  class RangeLookup
-    def self.parse(start_markup, end_markup)
-      start_obj = Expression.parse(start_markup)
-      end_obj = Expression.parse(end_markup)
+    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
-        start_obj.to_i..end_obj.to_i
+        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_obj   = end_obj
    end

    def evaluate(context)
      start_int = to_integer(context.evaluate(@start_obj))
-      end_int = to_integer(context.evaluate(@end_obj))
+      end_int   = to_integer(context.evaluate(@end_obj))
      start_int..end_int
    end

@@ -33,5 +47,11 @@ module Liquid
        Utils.to_integer(input)
      end
    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.start_obj, @node.end_obj]
+      end
+    end
  end
 end
@@ -0,0 +1,51 @@
+# 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,23 +1,79 @@
+# frozen_string_literal: true
+
 module Liquid
  class ResourceLimits
-    attr_accessor :render_length, :render_score, :assign_score,
-      :render_length_limit, :render_score_limit, :assign_score_limit
+    attr_accessor :render_length_limit,
+      :render_score_limit,
+      :assign_score_limit,
+      :cumulative_render_score_limit,
+      :cumulative_assign_score_limit
+    attr_reader :render_score,
+      :assign_score,
+      :cumulative_render_score,
+      :cumulative_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]
+      @render_length_limit           = limits[:render_length_limit]
+      @render_score_limit            = limits[:render_score_limit]
+      @assign_score_limit            = limits[:assign_score_limit]
+      @cumulative_render_score_limit = limits[:cumulative_render_score_limit]
+      @cumulative_assign_score_limit = limits[:cumulative_assign_score_limit]
+      @cumulative_render_score = 0
+      @cumulative_assign_score = 0
      reset
    end

+    def increment_render_score(amount)
+      @render_score += amount
+      @cumulative_render_score += amount
+      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
+      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
+    end
+
+    def increment_assign_score(amount)
+      @assign_score += amount
+      @cumulative_assign_score += amount
+      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
+      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_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?
-      (@render_length_limit && @render_length > @render_length_limit) ||
-        (@render_score_limit && @render_score > @render_score_limit) ||
-        (@assign_score_limit && @assign_score > @assign_score_limit)
+      @reached_limit
    end

    def reset
-      @render_length = @render_score = @assign_score = 0
+      @reached_limit = false
+      @last_capture_length = nil
+      @render_score = @assign_score = 0
+      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
+      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
+    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,54 @@
+# frozen_string_literal: true
+
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type object
+  # @liquid_name self
+  # @liquid_summary
+  #   Provides access to variables through the current scope chain.
+  # @liquid_description
+  #   The `self` object resolves variables through the normal lookup hierarchy
+  #   (local > file > global) without exposing filters, interrupts, errors,
+  #   or other context internals. It's used when bare bracket notation
+  #   (`['variable']`) needs to be replaced with an explicit variable lookup.
+  #
+  #   If `self` is explicitly assigned as a local variable (e.g. `{% assign self = 'value' %}`),
+  #   then the local value takes precedence over the `self` object.
+  # @liquid_access global
+  class SelfDrop < Drop
+    def initialize(self_context)
+      super()
+      @self_context = self_context
+    end
+
+    def [](key)
+      @self_context.find_variable(key)
+    rescue UndefinedVariable
+      nil
+    end
+
+    def key?(key)
+      @self_context.variable_defined?(key)
+    end
+
+    def to_liquid
+      self
+    end
+
+    def ==(other)
+      other.is_a?(SelfDrop) && other.self_context.equal?(@self_context)
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      @self_context.object_id.hash
+    end
+
+    protected
+
+    attr_reader :self_context
+
+    undef context=
+  end
+end
@@ -1,65 +0,0 @@
-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:
-    @@global_strainer = Class.new(Strainer) do
-      @filter_methods = Set.new
-    end
-    @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@@global_strainer) do
-        @filter_methods = @@global_strainer.filter_methods.dup
-        filters.each { |f| add_filter(f) }
-      end
-    end
-
-    def initialize(context)
-      @context = context
-    end
-
-    class << self
-      attr_reader :filter_methods
-    end
-
-    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-      unless self.class.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(', ')}"
-        else
-          send(:include, filter)
-          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        end
-      end
-    end
-
-    def self.global_filter(filter)
-      @@global_strainer.add_filter(filter)
-    end
-
-    def self.invokable?(method)
-      @filter_methods.include?(method.to_s)
-    end
-
-    def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
-    end
-
-    def invoke(method, *args)
-      if self.class.invokable?(method)
-        send(method, *args)
-      elsif @context && @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
@@ -0,0 +1,62 @@
+# 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,47 +1,106 @@
+# 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
+      @row    = 1
+      @col    = 1
+      @cols   = cols
+      @index  = 0
    end

-    attr_reader :length, :col, :row
+    # @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
@@ -1,3 +1,8 @@
+# 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
@@ -5,20 +10,32 @@ module Liquid
    include ParserSwitching

    class << self
-      def parse(tag_name, markup, tokenizer, options)
-        tag = new(tag_name, markup, options)
+      def parse(tag_name, markup, tokenizer, parse_context)
+        tag = new(tag_name, markup, parse_context)
        tag.parse(tokenizer)
        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
+      @tag_name      = tag_name
+      @markup        = markup
      @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @line_number   = parse_context.line_number
    end

    def parse(_tokens)
@@ -33,11 +50,30 @@ module Liquid
    end

    def render(_context)
-      ''.freeze
+      ''
+    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
    end

    def blank?
      false
    end
+
+    private
+
+    def safe_parse_expression(parser)
+      parse_context.safe_parse_expression(parser)
+    end
+
+    def parse_expression(markup, safe: false)
+      parse_context.parse_expression(markup, safe: safe)
+    end
  end
 end
@@ -0,0 +1,22 @@
+# 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
@@ -0,0 +1,13 @@
+# 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
@@ -0,0 +1,49 @@
+# 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,30 +1,72 @@
+# frozen_string_literal: true
+
 module Liquid
-  # Assign sets a variable in your template.
-  #
-  #   {% assign foo = 'monkey' %}
-  #
-  # You can then use the variable later in the page.
-  #
-  #  {{ foo }}
+  # @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.
  #
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @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.
  class Assign < Tag
+    include ParserSwitching
+
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

-    def initialize(tag_name, markup, options)
+    # @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)
      super
+      parse_with_selected_parser(markup)
+    end
+
+    def lax_parse(markup)
      if markup =~ Syntax
-        @to = $1
-        @from = Variable.new($2, options)
+        @to   = Regexp.last_match(1)
+        @from = Variable.new(Regexp.last_match(2), parse_context)
      else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        self.class.raise_syntax_error(parse_context)
      end
    end

-    def render(context)
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def strict2_parse(markup)
+      unless markup =~ Syntax
+        self.class.raise_syntax_error(parse_context)
+      end
+
+      lhs = Regexp.last_match(1).strip
+      rhs = Regexp.last_match(2)
+
+      p = @parse_context.new_parser(lhs)
+      @to = p.consume(:id)
+      p.consume(:end_of_string)
+
+      @from = Variable.new(rhs, parse_context)
+    end
+
+    def render_to_output_buffer(context, output)
      val = @from.render(context)
      context.scopes.last[@to] = val
-      context.resource_limits.assign_score += assign_score_of(val)
-      ''.freeze
+      context.resource_limits.increment_assign_score(assign_score_of(val))
+      output
    end

    def blank?
@@ -35,17 +77,28 @@ module Liquid

    def assign_score_of(val)
      if val.instance_of?(String)
-        val.length
-      elsif val.instance_of?(Array) || val.instance_of?(Hash)
+        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
-  end

-  Template.register_tag('assign'.freeze, Assign)
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.from]
+      end
+    end
+  end
 end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
  # Break tag to be used to break out of a for loop.
  #
@@ -8,11 +10,20 @@ 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
-    def interrupt
-      BreakInterrupt.new
+    INTERRUPT = BreakInterrupt.new.freeze
+
+    def render_to_output_buffer(context, output)
+      context.push_interrupt(INTERRUPT)
+      output
    end
  end
-
-  Template.register_tag('break'.freeze, Break)
 end
@@ -1,38 +1,64 @@
+# frozen_string_literal: true
+
 module Liquid
-  # Capture stores the result of a block into a variable without rendering it inplace.
+  # @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.
  #
-  #   {% capture heading %}
-  #     Monkeys!
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @liquid_syntax
+  #   {% capture variable %}
+  #     value
  #   {% endcapture %}
-  #   ...
-  #   <h1>{{ heading }}</h1>
-  #
-  # Capture is useful for saving content for use later in your template, such as
-  # in a sidebar or footer.
-  #
+  # @liquid_syntax_keyword variable The name of the variable being created.
+  # @liquid_syntax_keyword value The value you want to assign to the variable.
  class Capture < Block
+    include ParserSwitching
+
    Syntax = /(#{VariableSignature}+)/o

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

-    def render(context)
-      output = super
-      context.scopes.last[@to] = output
-      context.resource_limits.assign_score += output.length
-      ''.freeze
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup.strip)
+      @to = p.consume(:id)
+      p.consume(:end_of_string)
+    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
    end

    def blank?
      true
    end
  end
-
-  Template.register_tag('capture'.freeze, Capture)
 end
@@ -1,24 +1,50 @@
+# 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 = Expression.parse($1)
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
-      end
+      parse_with_selected_parser(markup)
    end

    def parse(tokens)
-      body = BlockBody.new
-      while parse_body(body, tokens)
-        body = @blocks.last.attachment
+      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
@@ -27,45 +53,91 @@ module Liquid

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

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

-        output = ''
-        @blocks.each do |block|
-          if block.else?
-            return block.attachment.render(context) if execute_else_block
-          elsif block.evaluate(context)
-            execute_else_block = false
-            output << block.attachment.render(context)
-          end
+      @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)
        end
-        output
      end
+
+      output
    end

    private

-    def record_when_condition(markup)
-      body = BlockBody.new
+    def strict2_parse(markup)
+      parser = @parse_context.new_parser(markup)
+      @left = safe_parse_expression(parser)
+      parser.consume(:end_of_string)
+    end

+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @left = parse_expression(Regexp.last_match(1))
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.case")
+      end
+    end
+
+    def record_when_condition(markup)
+      body = new_body
+
+      if strict2_mode?
+        parse_strict2_when(markup, body)
+      else
+        parse_lax_when(markup, body)
+      end
+    end
+
+    def parse_strict2_when(markup, body)
+      parser = @parse_context.new_parser(markup)
+
+      loop do
+        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
+        block = Condition.new(@left, '==', expr)
+        block.attach(body)
+        @blocks << block
+
+        break unless parser.id?('or') || parser.consume?(:comma)
+      end
+
+      parser.consume(:end_of_string)
+    end
+
+    def parse_lax_when(markup, body)
      while markup
        unless markup =~ WhenSyntax
-          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
+          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
        end

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

-        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
+        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
        block.attach(body)
        @blocks << block
      end
@@ -73,14 +145,18 @@ module Liquid

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

      block = ElseCondition.new
-      block.attach(BlockBody.new)
+      block.attach(new_body)
      @blocks << block
    end
-  end

-  Template.register_tag('case'.freeze, Case)
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.left] + @node.blocks
+      end
+    end
+  end
 end
@@ -1,7 +1,22 @@
+# 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(_context)
-      ''.freeze
+    def render_to_output_buffer(_context, output)
+      output
    end

    def unknown_tag(_tag, _markup, _tokens)
@@ -10,7 +25,64 @@ module Liquid
    def blank?
      true
    end
-  end

-  Template.register_tag('comment'.freeze, Comment)
+    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
 end
@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 module Liquid
-  # Continue tag to be used to break out of a for loop.
-  #
-  # == Basic Usage:
-  #    {% for item in collection %}
-  #      {% if item.condition %}
-  #        {% continue %}
-  #      {% endif %}
-  #    {% endfor %}
-  #
+  # @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 %}
  class Continue < Tag
-    def interrupt
-      ContinueInterrupt.new
+    INTERRUPT = ContinueInterrupt.new.freeze
+
+    def render_to_output_buffer(context, output)
+      context.push_interrupt(INTERRUPT)
+      output
    end
  end
-
-  Template.register_tag('continue'.freeze, Continue)
 end
@@ -1,57 +1,140 @@
+# frozen_string_literal: true
+
 module Liquid
-  # 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>
+  # @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.
  #
+  #   > 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
+    UNNAMED_CYCLE_PATTERN = /\w+:0x\h{8}/
+
+    attr_reader :variables

    def initialize(tag_name, markup, options)
      super
-      case markup
-      when NamedSyntax
-        @variables = variables_from_string($2)
-        @name = Expression.parse($1)
-      when SimpleSyntax
-        @variables = variables_from_string(markup)
-        @name = @variables.to_s
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
-      end
+      parse_with_selected_parser(markup)
    end

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

-      context.stack do
-        key = context.evaluate(@name)
-        iteration = context.registers[:cycle][key]
-        result = context.evaluate(@variables[iteration])
-        iteration += 1
-        iteration  = 0 if iteration >= @variables.size
-        context.registers[:cycle][key] = iteration
-        result
+    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
      end
+
+      output << val
+
+      iteration += 1
+      iteration = 0 if iteration >= @variables.size
+
+      context.registers[:cycle][key] = iteration
+      output
    end

    private

+    # cycle [name:] expression(, expression)*
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @variables = []
+
+      raise SyntaxError, options[:locale].t("errors.syntax.cycle") if p.look(:end_of_string)
+
+      first_expression = safe_parse_expression(p)
+      if p.look(:colon)
+        # cycle name: expr1, expr2, ...
+        @name = first_expression
+        @is_named = true
+        p.consume(:colon)
+        # After the colon, parse the first variable (required for named cycles)
+        @variables << maybe_dup_lookup(safe_parse_expression(p))
+      else
+        # cycle expr1, expr2, ...
+        @variables << maybe_dup_lookup(first_expression)
+      end
+
+      # Parse remaining comma-separated expressions
+      while p.consume?(:comma)
+        break if p.look(:end_of_string)
+
+        @variables << maybe_dup_lookup(safe_parse_expression(p))
+      end
+
+      p.consume(:end_of_string)
+
+      unless @is_named
+        @name = @variables.to_s
+        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
+      end
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      case markup
+      when NamedSyntax
+        @variables = variables_from_string(Regexp.last_match(2))
+        @name      = parse_expression(Regexp.last_match(1))
+        @is_named = true
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+        @name      = @variables.to_s
+        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+      end
+    end
+
    def variables_from_string(markup)
      markup.split(',').collect do |var|
        var =~ /\s*(#{QuotedFragment})\s*/o
-        $1 ? Expression.parse($1) : nil
+        next unless Regexp.last_match(1)
+
+        var = parse_expression(Regexp.last_match(1))
+        maybe_dup_lookup(var)
      end.compact
    end
-  end

-  Template.register_tag('cycle', Cycle)
+    # For backwards compatibility, whenever a lookup is used in an unnamed cycle,
+    # we make it so that the @variables.to_s produces different strings for cycles
+    # called with the same arguments (since @variables.to_s is used as the cycle counter key)
+    # This makes it so {% cycle a, b %} and {% cycle a, b %} have independent counters even if a and b share value.
+    # This is not true for literal values, {% cycle "a", "b" %} and {% cycle "a", "b" %} share the same counter.
+    # I was really scratching my head about this one, but migrating away from this would be more headache
+    # than it's worth. So we're keeping this quirk for now.
+    def maybe_dup_lookup(var)
+      var.is_a?(VariableLookup) ? var.dup : var
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        Array(@node.variables)
+      end
+    end
+  end
 end
@@ -1,35 +1,58 @@
-module Liquid
-  # 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.
+# frozen_string_literal: true

-  #   Hello: {% decrement variable %}
+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.
  #
-  # gives you:
-  #
-  #    Hello: -1
-  #    Hello: -2
-  #    Hello: -3
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @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
+    include ParserSwitching
+
+    attr_reader :variable_name
+
    def initialize(tag_name, markup, options)
      super
-      @variable = markup.strip
+      parse_with_selected_parser(markup)
    end

-    def render(context)
-      value = context.environments.first[@variable] ||= 0
+    def lax_parse(markup)
+      @variable_name = markup.strip
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup.strip)
+      @variable_name = p.consume(:id)
+      p.consume(:end_of_string)
+    end
+
+    def render_to_output_buffer(context, output)
+      counter_environment = context.environments.first
+      value = counter_environment[@variable_name] || 0
      value -= 1
-      context.environments.first[@variable] = value
-      value.to_s
+      counter_environment[@variable_name] = value
+      output << value.to_s
+      output
    end
  end
-
-  Template.register_tag('decrement'.freeze, Decrement)
 end
@@ -0,0 +1,81 @@
+# 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)
+      @body = +""
+
+      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)
+          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          return
+        end
+        @body << token unless token.empty?
+      end
+
+      raise_tag_never_closed(block_name)
+    end
+
+    def render_to_output_buffer(_context, output)
+      output
+    end
+
+    def blank?
+      @body.empty?
+    end
+
+    def nodelist
+      [@body]
+    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
@@ -0,0 +1,39 @@
+# 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,62 +1,52 @@
+# frozen_string_literal: true
+
 module Liquid
-  # "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.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
+  # @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.
  #
+  #   > 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 = BlockBody.new
+      @for_block = new_body
      @else_block = nil
    end

    def parse(tokens)
-      return unless parse_body(@for_block, tokens)
-      parse_body(@else_block, 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
    end

    def nodelist
@@ -64,72 +54,90 @@ module Liquid
    end

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

-    def render(context)
+    def render_to_output_buffer(context, output)
      segment = collection_segment(context)

      if segment.empty?
-        render_else(context)
+        render_else(context, output)
      else
-        render_segment(context, segment)
+        render_segment(context, output, segment)
      end
+
+      output
    end

    protected

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

    def strict_parse(markup)
-      p = Parser.new(markup)
+      p = @parse_context.new_parser(markup)
      @variable_name = p.consume(:id)
-      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}"
-      @collection_name = Expression.parse(collection_name)
-      @reversed = p.id?('reversed'.freeze)
+      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')

-      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))
+      collection_name  = p.expression
+      @collection_name = parse_expression(collection_name, safe: true)
+
+      @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")
        end
-        p.consume
-        set_attribute(attribute, p.expression)
+        p.consume(:colon)
+        set_attribute(attribute, p.expression, safe: true)
      end
      p.consume(:end_of_string)
    end

    private

+    def strict2_parse(markup)
+      strict_parse(markup)
+    end
+
    def collection_segment(context)
-      offsets = context.registers[:for] ||= Hash.new(0)
+      offsets = context.registers[:for] ||= {}

      from = if @from == :continue
        offsets[@name].to_i
      else
-        context.evaluate(@from).to_i
+        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 = context.evaluate(@limit)
-      to = limit ? limit.to_i + from : nil
+      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
@@ -139,11 +147,9 @@ module Liquid
      segment
    end

-    def render_segment(context, segment)
+    def render_segment(context, output, segment)
      for_stack = context.registers[:for_stack] ||= []
-      length = segment.length
-
-      result = ''
+      length    = segment.length

      context.stack do
        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
@@ -151,45 +157,52 @@ module Liquid
        for_stack.push(loop_vars)

        begin
-          context['forloop'.freeze] = loop_vars
+          context['forloop'] = loop_vars

-          segment.each_with_index do |item, index|
+          segment.each do |item|
            context[@variable_name] = item
-            result << @for_block.render(context)
+            @for_block.render_to_output_buffer(context, output)
            loop_vars.send(:increment!)

            # Handle any interrupts if they exist.
-            if context.interrupt?
-              interrupt = context.pop_interrupt
-              break if interrupt.is_a? BreakInterrupt
-              next if interrupt.is_a? ContinueInterrupt
-            end
+            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

-      result
+      output
    end

-    def set_attribute(key, expr)
+    def set_attribute(key, expr, safe: false)
      case key
-      when 'offset'.freeze
-        @from = if expr == 'continue'.freeze
+      when 'offset'
+        @from = if expr == 'continue'
          :continue
        else
-          Expression.parse(expr)
+          parse_expression(expr, safe: safe)
        end
-      when 'limit'.freeze
-        @limit = Expression.parse(expr)
+      when 'limit'
+        @limit = parse_expression(expr, safe: safe)
      end
    end

-    def render_else(context)
-      @else_block ? @else_block.render(context) : ''.freeze
+    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
    end
  end
-
-  Template.register_tag('for'.freeze, For)
 end
@@ -1,79 +1,103 @@
+# frozen_string_literal: true
+
 module Liquid
-  # If is the conditional block
-  #
-  #   {% if user.admin %}
-  #     Admin user!
-  #   {% else %}
-  #     Not admin user
+  # @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
  #   {% endif %}
-  #
-  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
-  #
+  # @liquid_syntax_keyword condition The condition to evaluate.
+  # @liquid_syntax_keyword expression The expression to render if the condition is met.
  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)
+    BOOLEAN_OPERATORS       = %w(and or).freeze
+
+    attr_reader :blocks

    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      push_block('if'.freeze, markup)
-    end
-
-    def parse(tokens)
-      while parse_body(@blocks.last.attachment, tokens)
-      end
+      push_block('if', markup)
    end

    def nodelist
      @blocks.map(&:attachment)
    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 ['elsif'.freeze, 'else'.freeze].include?(tag)
+      if ELSE_TAG_NAMES.include?(tag)
        push_block(tag, markup)
      else
        super
      end
    end

-    def render(context)
-      context.stack do
-        @blocks.each do |block|
-          if block.evaluate(context)
-            return block.attachment.render(context)
-          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)
        end
-        ''.freeze
      end
+
+      output
    end

    private

+    def strict2_parse(markup)
+      strict_parse(markup)
+    end
+
    def push_block(tag, markup)
-      block = if tag == 'else'.freeze
+      block = if tag == 'else'
        ElseCondition.new
      else
        parse_with_selected_parser(markup)
      end

      @blocks.push(block)
-      block.attach(BlockBody.new)
+      block.attach(new_body)
+    end
+
+    def parse_expression(markup, safe: false)
+      Condition.parse_expression(parse_context, markup, safe: safe)
    end

    def lax_parse(markup)
      expressions = markup.scan(ExpressionsAndOperators)
-      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
+      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax

-      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))

      until expressions.empty?
        operator = expressions.pop.to_s.strip

-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax

-        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+        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
      end
@@ -82,30 +106,37 @@ module Liquid
    end

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

-    def parse_binary_comparison(p)
+    def parse_binary_comparisons(p)
      condition = parse_comparison(p)
-      if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-        condition.send(op, parse_binary_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
      end
-      condition
+      first_condition
    end

    def parse_comparison(p)
-      a = Expression.parse(p.expression)
-      if op = p.consume?(:comparison)
-        b = Expression.parse(p.expression)
+      a = parse_expression(p.expression, safe: true)
+      if (op = p.consume?(:comparison))
+        b = parse_expression(p.expression, safe: true)
        Condition.new(a, op, b)
      else
        Condition.new(a)
      end
    end
-  end

-  Template.register_tag('if'.freeze, If)
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.blocks
+      end
+    end
+  end
 end
@@ -1,18 +1,17 @@
+# frozen_string_literal: true
+
 module Liquid
  class Ifchanged < Block
-    def render(context)
-      context.stack do
-        output = super
+    def render_to_output_buffer(context, output)
+      block_output = +''
+      super(context, block_output)

-        if output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = output
-          output
-        else
-          ''.freeze
-        end
+      if block_output != context.registers[:ifchanged]
+        context.registers[:ifchanged] = block_output
+        output << block_output
      end
+
+      output
    end
  end
-
-  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end
@@ -1,112 +1,148 @@
+# frozen_string_literal: true
+
 module Liquid
-  # 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 %}
+  # @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.
  #
+  #   The `include` tag has been replaced by [`render`](/docs/api/liquid/tags/render).
  class Include < Tag
-    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
+    prepend Tag::Disableable
+
+    FOR = 'for'
+    SYNTAX = /(#{QuotedFragment}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    Syntax = SYNTAX
+
+    attr_reader :template_name_expr, :variable_name_expr, :attributes

    def initialize(tag_name, markup, options)
      super
-
-      if markup =~ Syntax
-
-        template_name = $1
-        variable_name = $3
-
-        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-        @template_name_expr = Expression.parse(template_name)
-        @attributes = {}
-
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
-        end
-
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
-      end
+      parse_with_selected_parser(markup)
    end

    def parse(_tokens)
    end

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

-      context_variable_name = template_name.split('/'.freeze).last
+      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)
+        context.find_variable(template_name, raise_on_not_found: false)
      end

      old_template_name = context.template_name
-      old_partial = context.partial
+      old_partial       = context.partial
+
      begin
-        context.template_name = template_name
+        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.collect do |var|
+            variable.each do |var|
              context[context_variable_name] = var
-              partial.render(context)
+              partial.render_to_output_buffer(context, output)
            end
          else
            context[context_variable_name] = variable
-            partial.render(context)
+            partial.render_to_output_buffer(context, output)
          end
        end
      ensure
        context.template_name = old_template_name
-        context.partial = old_partial
+        context.partial       = old_partial
      end
-    end

-    private
+      output
+    end

    alias_method :parse_context, :options
    private :parse_context

-    def load_cached_partial(template_name, context)
-      cached_partials = context.registers[:cached_partials] || {}
-
-      if cached = cached_partials[template_name]
-        return cached
-      end
-      source = read_template_from_file_system(context)
-      begin
-        parse_context.partial = true
-        partial = Liquid::Template.parse(source, parse_context)
-      ensure
-        parse_context.partial = false
-      end
-      cached_partials[template_name] = partial
-      context.registers[:cached_partials] = cached_partials
-      partial
+    def for_loop?
+      @is_for_loop
    end

-    def read_template_from_file_system(context)
-      file_system = context.registers[:file_system] || Liquid::Template.file_system
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)

-      file_system.read_template_file(context.evaluate(@template_name_expr))
+      @template_name_expr = safe_parse_expression(p)
+      with_or_for         = p.id?("for") || p.id?("with")
+      @variable_name_expr = safe_parse_expression(p) if with_or_for
+      @alias_name         = p.consume(:id) if p.id?("as")
+      @is_for_loop        = (with_or_for == FOR)
+
+      p.consume?(:comma)
+
+      @attributes = {}
+      while p.look(:id)
+        key = p.consume
+        p.consume(:colon)
+        @attributes[key] = safe_parse_expression(p)
+        p.consume?(:comma)
+      end
+
+      p.consume(:end_of_string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ SYNTAX
+        template_name = Regexp.last_match(1)
+        with_or_for   = Regexp.last_match(3)
+        variable_name = Regexp.last_match(4)
+
+        @alias_name         = Regexp.last_match(6)
+        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = parse_expression(template_name)
+        @is_for_loop        = (with_or_for == FOR)
+        @attributes         = {}
+
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
+        end
+
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+          @node.variable_name_expr,
+        ] + @node.attributes.values
+      end
    end
  end
-
-  Template.register_tag('include'.freeze, Include)
 end
@@ -1,31 +1,58 @@
+# frozen_string_literal: true
+
 module Liquid
-  # 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)
+  # @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.
  #
-  #     if the variable does not exist, it is created with value 0.
-  #
-  #   Hello: {% increment variable %}
-  #
-  # gives you:
-  #
-  #    Hello: 0
-  #    Hello: 1
-  #    Hello: 2
+  #   > Caution:
+  #   > Predefined Liquid objects can be overridden by variables with the same name.
+  #   > To make sure that you can access all Liquid objects, make sure that your variable name doesn't match a predefined object's name.
+  # @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.
  #
+  #   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
+    include ParserSwitching
+
+    attr_reader :variable_name
+
    def initialize(tag_name, markup, options)
      super
-      @variable = markup.strip
+      parse_with_selected_parser(markup)
    end

-    def render(context)
-      value = context.environments.first[@variable] ||= 0
-      context.environments.first[@variable] = value + 1
-      value.to_s
+    def lax_parse(markup)
+      @variable_name = markup.strip
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup.strip)
+      @variable_name = p.consume(:id)
+      p.consume(:end_of_string)
+    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
    end
  end
-
-  Template.register_tag('increment'.freeze, Increment)
 end
@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Liquid
+  class InlineComment < Tag
+    def initialize(tag_name, markup, options)
+      super
+
+      # Semantically, a comment should only ignore everything after it on the line.
+      # Currently, this implementation doesn't support mixing a comment with another tag
+      # but we need to reserve future support for this and prevent the introduction
+      # of inline comments from being backward incompatible change.
+      #
+      # As such, we're forcing users to put a # symbol on every line otherwise this
+      # tag will throw an error.
+      if markup.match?(/\n\s*[^#\s]/)
+        raise SyntaxError, options[:locale].t("errors.syntax.inline_comment_invalid")
+      end
+    end
+
+    def render_to_output_buffer(_context, output)
+      output
+    end
+
+    def blank?
+      true
+    end
+  end
+end
@@ -1,31 +1,43 @@
+# frozen_string_literal: true
+
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category syntax
+  # @liquid_name raw
+  # @liquid_summary
+  #   Outputs any Liquid code as text instead of rendering it.
+  # @liquid_syntax
+  #   {% raw %}
+  #     expression
+  #   {% endraw %}
+  # @liquid_syntax_keyword expression The expression to be output without being rendered.
  class Raw < Block
    Syntax = /\A\s*\z/
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om

    def initialize(tag_name, markup, parse_context)
      super

-      unless markup =~ Syntax
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
-      end
+      ensure_valid_markup(tag_name, markup, parse_context)
    end

    def parse(tokens)
-      @body = ''
-      while token = tokens.shift
-        if token =~ FullTokenPossiblyInvalid
-          @body << $1 if $1 != "".freeze
-          return if block_delimiter == $2
+      @body = +''
+      while (token = tokens.shift)
+        if token =~ BlockBody::FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
+          parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          return
        end
        @body << token unless token.empty?
      end

-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+      raise_tag_never_closed(block_name)
    end

-    def render(_context)
-      @body
+    def render_to_output_buffer(_context, output)
+      output << @body
+      output
    end

    def nodelist
@@ -35,7 +47,13 @@ module Liquid
    def blank?
      @body.empty?
    end
-  end

-  Template.register_tag('raw'.freeze, Raw)
+    protected
+
+    def ensure_valid_markup(tag_name, markup, parse_context)
+      unless Syntax.match?(markup)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
+      end
+    end
+  end
 end
@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category theme
+  # @liquid_name render
+  # @liquid_summary
+  #   Renders a [snippet](/themes/architecture/snippets) or [app block](/themes/architecture/sections/section-schema#render-app-blocks).
+  # @liquid_description
+  #   Inside snippets and app blocks, you can't directly access variables that are [created](/docs/api/liquid/tags/variable-tags) outside
+  #   of the snippet or app block. However, you can [specify variables as parameters](/docs/api/liquid/tags/render#render-passing-variables-to-a-snippet)
+  #   to pass outside variables to snippets.
+  #
+  #   While you can't directly access created variables, you can access global objects, as well as any objects that are
+  #   directly accessible outside the snippet or app block. For example, a snippet or app block inside the [product template](/themes/architecture/templates/product)
+  #   can access the [`product` object](/docs/api/liquid/objects/product), and a snippet or app block inside a [section](/themes/architecture/sections)
+  #   can access the [`section` object](/docs/api/liquid/objects/section).
+  #
+  #   Outside a snippet or app block, you can't access variables created inside the snippet or app block.
+  #
+  #   > Note:
+  #   > When you render a snippet using the `render` tag, you can't use the [`include` tag](/docs/api/liquid/tags/include)
+  #   > inside the snippet.
+  # @liquid_syntax
+  #   {% render 'filename' %}
+  # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
+  class Render < Tag
+    FOR = 'for'
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+
+    disable_tags "include"
+
+    attr_reader :template_name_expr, :variable_name_expr, :attributes, :alias_name
+
+    def initialize(tag_name, markup, options)
+      super
+      parse_with_selected_parser(markup)
+    end
+
+    def for_loop?
+      @is_for_loop
+    end
+
+    def render_to_output_buffer(context, output)
+      render_tag(context, output)
+    end
+
+    def render_tag(context, output)
+      # The expression should be a String literal, which parses to a String object
+      template_name = @template_name_expr
+      raise ::ArgumentError unless template_name.is_a?(String)
+
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context,
+      )
+
+      context_variable_name = @alias_name || template_name.split('/').last
+
+      render_partial_func = ->(var, forloop) {
+        inner_context               = context.new_isolated_subcontext
+        inner_context.template_name = partial.name
+        inner_context.partial       = true
+        inner_context['forloop']    = forloop if forloop
+
+        @attributes.each do |key, value|
+          inner_context[key] = context.evaluate(value)
+        end
+        inner_context[context_variable_name] = var unless var.nil?
+        partial.render_to_output_buffer(inner_context, output)
+        forloop&.send(:increment!)
+      }
+
+      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
+      if @is_for_loop && variable.respond_to?(:each) && variable.respond_to?(:count)
+        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
+        variable.each { |var| render_partial_func.call(var, forloop) }
+      else
+        render_partial_func.call(variable, nil)
+      end
+
+      output
+    end
+
+    # render (string) (with|for expression)? (as id)? (key: value)*
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
+      with_or_for         = p.id?("for") || p.id?("with")
+      @variable_name_expr = safe_parse_expression(p) if with_or_for
+      @alias_name         = p.consume(:id) if p.id?("as")
+      @is_for_loop        = (with_or_for == FOR)
+
+      p.consume?(:comma)
+
+      @attributes = {}
+      while p.look(:id)
+        key = p.consume
+        p.consume(:colon)
+        @attributes[key] = safe_parse_expression(p)
+        p.consume?(:comma)
+      end
+
+      p.consume(:end_of_string)
+    end
+
+    def strict2_template_name(p)
+      p.consume(:string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
+
+      template_name = Regexp.last_match(1)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
+
+      @alias_name = Regexp.last_match(6)
+      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+      @template_name_expr = parse_expression(template_name)
+      @is_for_loop = (with_or_for == FOR)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = parse_expression(value)
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+          @node.variable_name_expr,
+        ] + @node.attributes.values
+      end
+    end
+  end
+end
@@ -1,54 +1,137 @@
+# frozen_string_literal: true
+
 module Liquid
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category iteration
+  # @liquid_name tablerow
+  # @liquid_summary
+  #   Generates HTML table rows for every item in an array.
+  # @liquid_description
+  #   The `tablerow` tag must be wrapped in HTML `<table>` and `</table>` tags.
+  #
+  #   > Tip:
+  #   > Every `tablerow` loop has an associated [`tablerowloop` object](/docs/api/liquid/objects/tablerowloop) with information about the loop.
+  # @liquid_syntax
+  #   {% tablerow variable in array %}
+  #     expression
+  #   {% endtablerow %}
+  # @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.
+  # @liquid_optional_param cols: [number] The number of columns that the table should have.
+  # @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.
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
+    ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
+
+    attr_reader :variable_name, :collection_name, :attributes

    def initialize(tag_name, markup, options)
      super
+      parse_with_selected_parser(markup)
+    end
+
+    def strict2_parse(markup)
+      p = @parse_context.new_parser(markup)
+
+      @variable_name = p.consume(:id)
+
+      unless p.id?("in")
+        raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in")
+      end
+
+      @collection_name = safe_parse_expression(p)
+
+      p.consume?(:comma)
+
+      @attributes = {}
+      while p.look(:id)
+        key = p.consume
+        unless ALLOWED_ATTRIBUTES.include?(key)
+          raise SyntaxError, options[:locale].t("errors.syntax.table_row_invalid_attribute", attribute: key)
+        end
+
+        p.consume(:colon)
+        @attributes[key] = safe_parse_expression(p)
+        p.consume?(:comma)
+      end
+
+      p.consume(:end_of_string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = Expression.parse($2)
-        @attributes = {}
+        @variable_name   = Regexp.last_match(1)
+        @collection_name = parse_expression(Regexp.last_match(2))
+        @attributes      = {}
        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = parse_expression(value)
        end
      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
      end
    end

-    def render(context)
-      collection = context.evaluate(@collection_name) or return ''.freeze
+    def render_to_output_buffer(context, output)
+      (collection = context.evaluate(@collection_name)) || (return '')

-      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
-      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
+      from = @attributes.key?('offset') ? to_integer(context.evaluate(@attributes['offset'])) : 0
+      to = @attributes.key?('limit') ? from + to_integer(context.evaluate(@attributes['limit'])) : nil

      collection = Utils.slice_collection(collection, from, to)
+      length     = collection.length

-      length = collection.length
+      cols = @attributes.key?('cols') ? to_integer(context.evaluate(@attributes['cols'])) : length

-      cols = context.evaluate(@attributes['cols'.freeze]).to_i
-
-      result = "<tr class=\"row1\">\n"
+      output << "<tr class=\"row1\">\n"
      context.stack do
        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
-        context['tablerowloop'.freeze] = tablerowloop
+        context['tablerowloop'] = tablerowloop

-        collection.each_with_index do |item, index|
+        collection.each do |item|
          context[@variable_name] = item

-          result << "<td class=\"col#{tablerowloop.col}\">" << super << '</td>'
+          output << "<td class=\"col#{tablerowloop.col}\">"
+          super
+          output << '</td>'
+
+          # Handle any interrupts if they exist.
+          if context.interrupt?
+            interrupt = context.pop_interrupt
+            break if interrupt.is_a?(BreakInterrupt)
+          end

          if tablerowloop.col_last && !tablerowloop.last
-            result << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
          end

          tablerowloop.send(:increment!)
        end
      end
-      result << "</tr>\n"
-      result
+
+      output << "</tr>\n"
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        super + @node.attributes.values + [@node.collection_name]
+      end
+    end
+
+    private
+
+    def to_integer(value)
+      value.to_i
+    rescue NoMethodError
+      raise Liquid::ArgumentError, "invalid integer"
    end
  end
-
-  Template.register_tag('tablerow'.freeze, TableRow)
 end
@@ -1,30 +1,47 @@
+# frozen_string_literal: true
+
 require_relative 'if'

 module Liquid
-  # Unless is a conditional just like 'if' but works on the inverse logic.
-  #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
-  #
+  # @liquid_public_docs
+  # @liquid_type tag
+  # @liquid_category conditional
+  # @liquid_name unless
+  # @liquid_summary
+  #   Renders an expression unless a specific condition is `true`.
+  # @liquid_description
+  #   > Tip:
+  #   > Similar to the [`if` tag](/docs/api/liquid/tags/if), you can use `elsif` to add more conditions to an `unless` tag.
+  # @liquid_syntax
+  #   {% unless condition %}
+  #     expression
+  #   {% endunless %}
+  # @liquid_syntax_keyword condition The condition to evaluate.
+  # @liquid_syntax_keyword expression The expression to render unless the condition is met.
  class Unless < If
-    def render(context)
-      context.stack do
-        # First condition is interpreted backwards ( if not )
-        first_block = @blocks.first
-        unless first_block.evaluate(context)
-          return first_block.attachment.render(context)
-        end
+    def render_to_output_buffer(context, output)
+      # First condition is interpreted backwards ( if not )
+      first_block = @blocks.first
+      result = Liquid::Utils.to_liquid_value(
+        first_block.evaluate(context),
+      )

-        # After the first condition unless works just like if
-        @blocks[1..-1].each do |block|
-          if block.evaluate(context)
-            return block.attachment.render(context)
-          end
-        end
-
-        ''.freeze
+      unless result
+        return first_block.attachment.render_to_output_buffer(context, output)
      end
+
+      # After the first condition unless works just like if
+      @blocks[1..-1].each do |block|
+        result = Liquid::Utils.to_liquid_value(
+          block.evaluate(context),
+        )
+
+        if result
+          return block.attachment.render_to_output_buffer(context, output)
+        end
+      end
+
+      output
    end
  end
-
-  Template.register_tag('unless'.freeze, Unless)
 end
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Liquid
  # Templates are central to liquid.
-  # Interpretating templates is a two step process. First you compile the
+  # Interpreting templates is a two step process. First you compile the
  # source code you got. During compile time some extensive error checking is performed.
  # your code should expect to get some SyntaxErrors.
  #
@@ -13,113 +15,96 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
-    attr_accessor :root
+    attr_accessor :root, :name
    attr_reader :resource_limits, :warnings

-    @@file_system = BlankFileSystem.new
-
-    class TagRegistry
-      def initialize
-        @tags = {}
-        @cache = {}
-      end
-
-      def [](tag_name)
-        return nil unless @tags.key?(tag_name)
-        return @cache[tag_name] if Liquid.cache_classes
-
-        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
-      end
-
-      def []=(tag_name, klass)
-        @tags[tag_name]  = klass.name
-        @cache[tag_name] = klass
-      end
-
-      def delete(tag_name)
-        @tags.delete(tag_name)
-        @cache.delete(tag_name)
-      end
-
-      private
-
-      def lookup_class(name)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
-      end
-    end
-
    attr_reader :profiler

    class << self
      # Sets how strict the parser should be.
      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
      # :warn is the default and will give deprecation warnings when invalid syntax is used.
-      # :strict will enforce correct syntax.
-      attr_writer :error_mode
-
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
-
-      def file_system
-        @@file_system
-      end
-
-      def file_system=(obj)
-        @@file_system = obj
-      end
-
-      def register_tag(name, klass)
-        tags[name.to_s] = klass
-      end
-
-      def tags
-        @tags ||= TagRegistry.new
+      # :strict enforces correct syntax for most tags
+      # :strict2 enforces correct syntax for all tags
+      def error_mode=(mode)
+        Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
+        Environment.default.error_mode = mode
      end

      def error_mode
-        @error_mode ||= :lax
+        Environment.default.error_mode
      end

-      def taint_mode
-        @taint_mode ||= :lax
+      def default_exception_renderer=(renderer)
+        Deprecations.warn("Template.default_exception_renderer=", "Environment#exception_renderer=")
+        Environment.default.exception_renderer = renderer
+      end
+
+      def default_exception_renderer
+        Environment.default.exception_renderer
+      end
+
+      def file_system=(file_system)
+        Deprecations.warn("Template.file_system=", "Environment#file_system=")
+        Environment.default.file_system = file_system
+      end
+
+      def file_system
+        Environment.default.file_system
+      end
+
+      def tags
+        Environment.default.tags
+      end
+
+      def register_tag(name, klass)
+        Deprecations.warn("Template.register_tag", "Environment#register_tag")
+        Environment.default.register_tag(name, klass)
      end

      # Pass a module with filter methods which should be available
      # to all liquid views. Good for registering the standard library
      def register_filter(mod)
-        Strainer.global_filter(mod)
+        Deprecations.warn("Template.register_filter", "Environment#register_filter")
+        Environment.default.register_filter(mod)
+      end
+
+      private def default_resource_limits=(limits)
+        Deprecations.warn("Template.default_resource_limits=", "Environment#default_resource_limits=")
+        Environment.default.default_resource_limits = limits
      end

      def default_resource_limits
-        @default_resource_limits ||= {}
+        Environment.default.default_resource_limits
      end

      # creates a new <tt>Template</tt> object from liquid source code
      # To enable profiling, pass in <tt>profile: true</tt> as an option.
      # See Liquid::Profiler for more information
      def parse(source, options = {})
-        template = Template.new
-        template.parse(source, options)
+        environment = options[:environment] || Environment.default
+        new(environment: environment).parse(source, options)
      end
    end

-    def initialize
-      @rethrow_errors = false
-      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
+    def initialize(environment: Environment.default)
+      @environment = environment
+      @rethrow_errors  = false
+      @resource_limits = ResourceLimits.new(environment.default_resource_limits)
    end

    # Parse source code.
    # Returns self for easy chaining
    def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
-      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @root = Document.parse(tokenize(source), parse_context)
-      @warnings = parse_context.warnings
+      parse_context = configure_options(options)
+      source = source.to_s.to_str
+
+      unless source.valid_encoding?
+        raise TemplateEncodingError, parse_context.locale.t("errors.syntax.invalid_template_encoding")
+      end
+
+      tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
+      @root         = Document.parse(tokenizer, parse_context)
      self
    end

@@ -154,33 +139,41 @@ module Liquid
    #    filters and tags and might be useful to integrate liquid more with its host application
    #
    def render(*args)
-      return ''.freeze if @root.nil?
+      return '' if @root.nil?

      context = case args.first
      when Liquid::Context
        c = args.shift

        if @rethrow_errors
-          c.exception_handler = ->(e) { raise }
+          c.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
        end

        c
      when Liquid::Drop
        drop = args.shift
-        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
+        c    = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
+        drop.context = c if drop.respond_to?(:context=)
+        c
      when Hash
-        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
      when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits, {}, @environment)
      else
        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
      end

+      output = nil
+
      case args.last
      when Hash
        options = args.pop
+        output  = options[:output] if options[:output]
+        static_registers = context.registers.static

-        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
+        options[:registers]&.each do |key, register|
+          static_registers[key] = register
+        end

        apply_options_to_context(context, options)
      when Module, Array
@@ -190,13 +183,15 @@ module Liquid
      # Retrying a render resets resource usage
      context.resource_limits.reset

+      if @profiling && context.profiler.nil?
+        @profiler = context.profiler = Liquid::Profiler.new
+      end
+
+      context.template_name ||= name
+
      begin
        # render the nodelist.
-        # for performance reasons we get an array back here. join will make a string out of it.
-        result = with_profiling(context) do
-          @root.render(context)
-        end
-        result.respond_to?(:join) ? result.join : result
+        @root.render_to_output_buffer(context, output || +'')
      rescue Liquid::MemoryError => e
        context.handle_error(e)
      ensure
@@ -209,35 +204,37 @@ module Liquid
      render(*args)
    end

-    private
-
-    def tokenize(source)
-      Tokenizer.new(source, @line_numbers)
+    def render_to_output_buffer(context, output)
+      render(context, output: output)
    end

-    def with_profiling(context)
-      if @profiling && !context.partial
+    private
+
+    def configure_options(options)
+      if (profiling = options[:profile])
        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-
-        @profiler = Profiler.new
-        @profiler.start
-
-        begin
-          yield
-        ensure
-          @profiler.stop
-        end
-      else
-        yield
      end
+
+      @options      = options
+      @profiling    = profiling
+      @line_numbers = options[:line_numbers] || @profiling
+      parse_context = if options.is_a?(ParseContext)
+        options
+      else
+        opts = options.key?(:environment) ? options : options.merge(environment: @environment)
+        ParseContext.new(opts)
+      end
+
+      @warnings = parse_context.warnings
+      parse_context
    end

    def apply_options_to_context(context, options)
      context.add_filters(options[:filters]) if options[:filters]
-      context.global_filter = options[:global_filter] if options[:global_filter]
-      context.exception_handler = options[:exception_handler] if options[:exception_handler]
-      context.strict_variables = options[:strict_variables] if options[:strict_variables]
-      context.strict_filters = options[:strict_filters] if options[:strict_filters]
+      context.global_filter      = options[:global_filter] if options[:global_filter]
+      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
+      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
    end
  end
 end
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Liquid
+  class TemplateFactory
+    def for(_template_name)
+      Liquid::Template.new
+    end
+  end
+end
@@ -1,31 +1,161 @@
+# frozen_string_literal: true
+
+require "strscan"
+
 module Liquid
  class Tokenizer
-    attr_reader :line_number
+    attr_reader :line_number, :for_liquid_tag

-    def initialize(source, line_numbers = false)
-      @source = source
-      @line_number = line_numbers ? 1 : nil
-      @tokens = tokenize
+    TAG_END = /%\}/
+    TAG_OR_VARIABLE_START = /\{[\{\%]/
+    NEWLINE = /\n/
+
+    OPEN_CURLEY = "{".ord
+    CLOSE_CURLEY = "}".ord
+    PERCENTAGE = "%".ord
+
+    def initialize(
+      source:,
+      string_scanner:,
+      line_numbers: false,
+      line_number: nil,
+      for_liquid_tag: false
+    )
+      @line_number = line_number || (line_numbers ? 1 : nil)
+      @for_liquid_tag = for_liquid_tag
+      @source = source.to_s.to_str
+      @offset = 0
+      @tokens = []
+
+      if @source
+        @ss = string_scanner
+        @ss.string = @source
+        tokenize
+      end
    end

    def shift
-      token = @tokens.shift
-      @line_number += token.count("\n") if @line_number && token
+      token = @tokens[@offset]
+
+      return unless token
+
+      @offset += 1
+
+      if @line_number
+        @line_number += @for_liquid_tag ? 1 : token.count("\n")
+      end
+
      token
    end

    private

    def tokenize
-      @source = @source.source if @source.respond_to?(:source)
-      return [] if @source.to_s.empty?
+      if @for_liquid_tag
+        @tokens = @source.split("\n")
+      else
+        @tokens << shift_normal until @ss.eos?
+      end

-      tokens = @source.split(TemplateParser)
+      @source = nil
+      @ss = nil
+    end

-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0] && tokens[0].empty?
+    def shift_normal
+      token = next_token

-      tokens
+      return unless token
+
+      token
+    end
+
+    def next_token
+      # possible states: :text, :tag, :variable
+      byte_a = @ss.peek_byte
+
+      if byte_a == OPEN_CURLEY
+        @ss.scan_byte
+
+        byte_b = @ss.peek_byte
+
+        if byte_b == PERCENTAGE
+          @ss.scan_byte
+          return next_tag_token
+        elsif byte_b == OPEN_CURLEY
+          @ss.scan_byte
+          return next_variable_token
+        end
+
+        @ss.pos -= 1
+      end
+
+      next_text_token
+    end
+
+    def next_text_token
+      start = @ss.pos
+
+      unless @ss.skip_until(TAG_OR_VARIABLE_START)
+        token = @ss.rest
+        @ss.terminate
+        return token
+      end
+
+      pos = @ss.pos -= 2
+      @source.byteslice(start, pos - start)
+    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
+    end
+
+    def next_variable_token
+      start = @ss.pos - 2
+
+      byte_a = byte_b = @ss.scan_byte
+
+      while byte_b
+        byte_a = @ss.scan_byte while byte_a && byte_a != CLOSE_CURLEY && byte_a != OPEN_CURLEY
+
+        break unless byte_a
+
+        if @ss.eos?
+          return byte_a == CLOSE_CURLEY ? @source.byteslice(start, @ss.pos - start) : "{{"
+        end
+
+        byte_b = @ss.scan_byte
+
+        if byte_a == CLOSE_CURLEY
+          if byte_b == CLOSE_CURLEY
+            return @source.byteslice(start, @ss.pos - start)
+          elsif byte_b != CLOSE_CURLEY
+            @ss.pos -= 1
+            return @source.byteslice(start, @ss.pos - start)
+          end
+        elsif byte_a == OPEN_CURLEY && byte_b == PERCENTAGE
+          return next_tag_token_with_start(start)
+        end
+
+        byte_a = byte_b
+      end
+
+      "{{"
+    end
+
+    def next_tag_token
+      start = @ss.pos - 2
+      if (len = @ss.skip_until(TAG_END))
+        @source.byteslice(start, len + 2)
+      else
+        "{%"
+      end
+    end
+
+    def next_tag_token_with_start(start)
+      @ss.skip_until(TAG_END)
+      @source.byteslice(start, @ss.pos - start)
    end
  end
 end
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Usage
+    def self.increment(name)
+    end
+  end
+end
@@ -1,5 +1,10 @@
+# frozen_string_literal: true
+
 module Liquid
  module Utils
+    DECIMAL_REGEX = /\A-?\d+\.\d+\z/
+    UNIX_TIMESTAMP_REGEX = /\A\d+\z/
+
    def self.slice_collection(collection, from, to)
      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
        collection.load_slice(from, to)
@@ -10,7 +15,7 @@ module Liquid

    def self.slice_collection_using_each(collection, from, to)
      segments = []
-      index = 0
+      index    = 0

      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
      if collection.is_a?(String)
@@ -46,11 +51,11 @@ module Liquid
    def self.to_number(obj)
      case obj
      when Float
-        BigDecimal.new(obj.to_s)
+        BigDecimal(obj.to_s)
      when Numeric
        obj
      when String
-        (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
+        DECIMAL_REGEX.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
      else
        if obj.respond_to?(:to_number)
          obj.to_number
@@ -64,14 +69,14 @@ module Liquid
      return obj if obj.respond_to?(:strftime)

      if obj.is_a?(String)
-        return nil if obj.empty?
+        return if obj.empty?
        obj = obj.downcase
      end

      case obj
-      when 'now'.freeze, 'today'.freeze
+      when 'now', 'today'
        Time.now
-      when /\A\d+\z/, Integer
+      when UNIX_TIMESTAMP_REGEX, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
@@ -79,5 +84,111 @@ module Liquid
    rescue ::ArgumentError
      nil
    end
+
+    def self.to_liquid_value(obj)
+      # Enable "obj" to represent itself as a primitive value like integer, string, or boolean
+      return obj.to_liquid_value if obj.respond_to?(:to_liquid_value)
+
+      # Otherwise return the object itself
+      obj
+    end
+
+    def self.to_s(obj, seen = {})
+      case obj
+      when BigDecimal
+        obj.to_s("F")
+      when Hash
+        # If the custom hash implementation overrides `#to_s`, use their
+        # custom implementation. Otherwise we use Liquid's default
+        # implementation.
+        if obj.class.instance_method(:to_s) == HASH_TO_S_METHOD
+          hash_inspect(obj, seen)
+        else
+          obj.to_s
+        end
+      when Array
+        array_inspect(obj, seen)
+      else
+        obj.to_s
+      end
+    end
+
+    def self.inspect(obj, seen = {})
+      case obj
+      when Hash
+        # If the custom hash implementation overrides `#inspect`, use their
+        # custom implementation. Otherwise we use Liquid's default
+        # implementation.
+        if obj.class.instance_method(:inspect) == HASH_INSPECT_METHOD
+          hash_inspect(obj, seen)
+        else
+          obj.inspect
+        end
+      when Array
+        array_inspect(obj, seen)
+      else
+        obj.inspect
+      end
+    end
+
+    def self.array_inspect(arr, seen = {})
+      if seen[arr.object_id]
+        return "[...]"
+      end
+
+      seen[arr.object_id] = true
+      str = +"["
+      cursor = 0
+      len = arr.length
+
+      while cursor < len
+        if cursor > 0
+          str << ", "
+        end
+
+        item_str = inspect(arr[cursor], seen)
+        str << item_str
+        cursor += 1
+      end
+
+      str << "]"
+      str
+    ensure
+      seen.delete(arr.object_id)
+    end
+
+    def self.hash_inspect(hash, seen = {})
+      if seen[hash.object_id]
+        return "{...}"
+      end
+      seen[hash.object_id] = true
+
+      str = +"{"
+      first = true
+      hash.each do |key, value|
+        if first
+          first = false
+        else
+          str << ", "
+        end
+
+        key_str = inspect(key, seen)
+        str << key_str
+        str << "=>"
+
+        value_str = inspect(value, seen)
+        str << value_str
+      end
+      str << "}"
+      str
+    ensure
+      seen.delete(hash.object_id)
+    end
+
+    HASH_TO_S_METHOD = Hash.instance_method(:to_s)
+    private_constant :HASH_TO_S_METHOD
+
+    HASH_INSPECT_METHOD = Hash.instance_method(:inspect)
+    private_constant :HASH_INSPECT_METHOD
  end
 end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
  # Holds variables. Variables are only loaded "just in time"
  # and are not evaluated as part of the render stage
@@ -10,60 +12,83 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
+    FilterParser             = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    JustTagAttributes        = /\A#{TagAttributes}\z/o
+    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
+
    attr_accessor :filters, :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context
+
    include ParserSwitching

    def initialize(markup, parse_context)
-      @markup  = markup
-      @name    = nil
+      @markup        = markup
+      @name          = nil
      @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @line_number   = parse_context.line_number

-      parse_with_selected_parser(markup)
+      strict_parse_with_error_mode_fallback(markup)
    end

    def raw
      @markup
    end

+    def ==(other)
+      self.class == other.class && name == other.name && filters == other.filters
+    end
+
    def markup_context(markup)
      "in \"{{#{markup}}}\""
    end

    def lax_parse(markup)
      @filters = []
-      return unless markup =~ /(#{QuotedFragment})(.*)/om
+      return unless markup =~ MarkupWithQuotedFragment

-      name_markup = $1
-      filter_markup = $2
-      @name = Expression.parse(name_markup)
-      if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-        filters = $1.scan(FilterParser)
+      name_markup   = Regexp.last_match(1)
+      filter_markup = Regexp.last_match(2)
+      @name         = parse_context.parse_expression(name_markup)
+      if filter_markup =~ FilterMarkupRegex
+        filters = Regexp.last_match(1).scan(FilterParser)
        filters.each do |f|
          next unless f =~ /\w+/
          filtername = Regexp.last_match(0)
-          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-          @filters << parse_filter_expressions(filtername, filterargs)
+          filterargs = f.scan(FilterArgsRegex).flatten
+          @filters << lax_parse_filter_expressions(filtername, filterargs)
        end
      end
    end

    def strict_parse(markup)
      @filters = []
-      p = Parser.new(markup)
+      p = @parse_context.new_parser(markup)

-      @name = Expression.parse(p.expression)
+      return if p.look(:end_of_string)
+
+      @name = parse_context.safe_parse_expression(p)
      while p.consume?(:pipe)
        filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << parse_filter_expressions(filtername, filterargs)
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
+        @filters << lax_parse_filter_expressions(filtername, filterargs)
      end
      p.consume(:end_of_string)
    end

+    def strict2_parse(markup)
+      @filters = []
+      p = @parse_context.new_parser(markup)
+
+      return if p.look(:end_of_string)
+
+      @name = parse_context.safe_parse_expression(p)
+      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
+      p.consume(:end_of_string)
+    end
+
    def parse_filterargs(p)
      # first argument
      filterargs = [p.argument]
@@ -73,37 +98,103 @@ module Liquid
    end

    def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
+      obj = context.evaluate(@name)
+
+      @filters.each do |filter_name, filter_args, filter_kwargs|
        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        context.invoke(filter_name, output, *filter_args)
+        obj = context.invoke(filter_name, obj, *filter_args)
      end

-      obj = context.apply_global_filter(obj)
+      context.apply_global_filter(obj)
+    end

-      taint_check(context, obj)
+    def render_to_output_buffer(context, output)
+      obj = render(context)
+      render_obj_to_output(obj, output)
+      output
+    end

-      obj
+    def render_obj_to_output(obj, output)
+      case obj
+      when NilClass
+        # Do nothing
+      when Array
+        obj.each do |o|
+          render_obj_to_output(o, output)
+        end
+      else
+        output << Liquid::Utils.to_s(obj)
+      end
+    end
+
+    def disabled?(_context)
+      false
+    end
+
+    def disabled_tags
+      []
    end

    private

-    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
-      keyword_args = {}
+    def lax_parse_filter_expressions(filter_name, unparsed_args)
+      filter_args  = []
+      keyword_args = nil
      unparsed_args.each do |a|
-        if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args[matches[1]] = Expression.parse(matches[2])
+        if (matches = a.match(JustTagAttributes))
+          keyword_args           ||= {}
+          keyword_args[matches[1]] = parse_context.parse_expression(matches[2])
        else
-          filter_args << Expression.parse(a)
+          filter_args << parse_context.parse_expression(a)
        end
      end
      result = [filter_name, filter_args]
+      result << keyword_args if keyword_args
+      result
+    end
+
+    # Surprisingly, positional and keyword arguments can be mixed.
+    #
+    # filter = filtername [":" filterargs?]
+    # filterargs = argument ("," argument)*
+    # argument = (positional_argument | keyword_argument)
+    # positional_argument = expression
+    # keyword_argument = id ":" expression
+    def strict2_parse_filter_expressions(p)
+      filtername = p.consume(:id)
+      filter_args = []
+      keyword_args = {}
+
+      if p.consume?(:colon)
+        # Parse first argument (no leading comma)
+        argument(p, filter_args, keyword_args) unless end_of_arguments?(p)
+
+        # Parse remaining arguments (with leading commas) and optional trailing comma
+        argument(p, filter_args, keyword_args) while p.consume?(:comma) && !end_of_arguments?(p)
+      end
+
+      result = [filtername, filter_args]
      result << keyword_args unless keyword_args.empty?
      result
    end

+    def argument(p, positional_arguments, keyword_arguments)
+      if p.look(:id) && p.look(:colon, 1)
+        key = p.consume(:id)
+        p.consume(:colon)
+        value = parse_context.safe_parse_expression(p)
+        keyword_arguments[key] = value
+      else
+        positional_arguments << parse_context.safe_parse_expression(p)
+      end
+    end
+
+    def end_of_arguments?(p)
+      p.look(:pipe) || p.look(:end_of_string)
+    end
+
    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
+      parsed_args = filter_args.map { |expr| context.evaluate(expr) }
      if filter_kwargs
        parsed_kwargs = {}
        filter_kwargs.each do |key, expr|
@@ -114,22 +205,9 @@ module Liquid
      parsed_args
    end

-    def taint_check(context, obj)
-      return unless obj.tainted?
-      return if Template.taint_mode == :lax
-
-      @markup =~ QuotedFragment
-      name = Regexp.last_match(0)
-
-      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
-      error.line_number = line_number
-      error.template_name = context.template_name
-
-      case Template.taint_mode
-      when :warn
-        context.warnings << error
-      when :error
-        raise error
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.name] + @node.filters.flatten
      end
    end
  end
@@ -1,43 +1,59 @@
+# frozen_string_literal: true
+
 module Liquid
  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
+    COMMAND_METHODS = ['size', 'first', 'last'].freeze

    attr_reader :name, :lookups

-    def self.parse(markup)
-      new(markup)
+    def self.parse(markup, string_scanner = StringScanner.new(""), cache = nil)
+      new(markup, string_scanner, cache)
    end

-    def initialize(markup)
+    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil)
      lookups = markup.scan(VariableParser)

      name = lookups.shift
-      if name =~ SQUARE_BRACKETED
-        name = Expression.parse($1)
+      if name&.start_with?('[') && name&.end_with?(']')
+        name = Expression.parse(
+          name[1..-2],
+          string_scanner,
+          cache,
+        )
      end
      @name = name

-      @lookups = lookups
+      @lookups       = lookups
      @command_flags = 0

      @lookups.each_index do |i|
        lookup = lookups[i]
-        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse($1)
+        if lookup&.start_with?('[') && lookup&.end_with?(']')
+          lookups[i] = Expression.parse(
+            lookup[1..-2],
+            string_scanner,
+            cache,
+          )
        elsif COMMAND_METHODS.include?(lookup)
          @command_flags |= 1 << i
        end
      end
    end

+    def lookup_command?(lookup_index)
+      @command_flags & (1 << lookup_index) != 0
+    end
+
    def evaluate(context)
-      name = context.evaluate(@name)
+      name   = context.evaluate(@name)
      object = context.find_variable(name)

      @lookups.each_index do |i|
        key = context.evaluate(@lookups[i])

+        # Cast "key" to its liquid value to enable it to act as a primitive value
+        key = Liquid::Utils.to_liquid_value(key)
+
        # 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?(:[]) &&
@@ -45,15 +61,20 @@ module Liquid
             (object.respond_to?(:fetch) && key.is_a?(Integer)))

          # if its a proc we will replace the entry with the proc
-          res = context.lookup_and_evaluate(object, key)
+          res    = context.lookup_and_evaluate(object, key)
          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 @command_flags & (1 << i) != 0 && object.respond_to?(key)
+        elsif lookup_command?(i) && object.respond_to?(key)
          object = object.send(key).to_liquid

+        # Handle string first/last like ActiveSupport does (returns first/last character)
+        # ActiveSupport returns "" for empty strings, not nil
+        elsif lookup_command?(i) && object.is_a?(String) && (key == "first" || key == "last")
+          object = key == "first" ? (object[0] || "") : (object[-1] || "")
+
          # 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 or
          # raise an exception if `strict_variables` option is set to true
@@ -78,5 +99,11 @@ module Liquid
    def state
      [@name, @lookups, @command_flags]
    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.lookups
+      end
+    end
  end
 end
@@ -1,4 +1,6 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 module Liquid
-  VERSION = "4.0.0.rc2"
+  VERSION = "5.12.0"
 end
@@ -1,6 +1,8 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)

 require "liquid/version"

@@ -11,19 +13,24 @@ Gem::Specification.new do |s|
  s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
  s.authors     = ["Tobias Lütke"]
  s.email       = ["[email protected]"]
-  s.homepage    = "http://www.liquidmarkup.org"
+  s.homepage    = "https://shopify.github.io/liquid/"
  s.license     = "MIT"
  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."

+  s.required_ruby_version     = ">= 3.0.0"
  s.required_rubygems_version = ">= 1.3.7"

-  s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  s.files = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)

  s.extra_rdoc_files = ["History.md", "README.md"]

  s.require_path = "lib"

-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
+  s.add_dependency("strscan", ">= 3.1.1")
+  s.add_dependency("bigdecimal")
+
+  s.add_development_dependency('rake', '~> 13.0')
+  s.add_development_dependency('minitest')
 end
@@ -1,17 +1,25 @@
+# frozen_string_literal: true
+
 require 'benchmark/ips'
 require_relative 'theme_runner'

-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
+Liquid::Environment.default.error_mode = ARGV.first.to_sym if ARGV.first
+
 profiler = ThemeRunner.new

 Benchmark.ips do |x|
-  x.time = 60
-  x.warmup = 5
+  x.time   = 20
+  x.warmup = 10

  puts
  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
  puts

-  x.report("parse:") { profiler.compile }
-  x.report("parse & run:") { profiler.run }
+  phase = ENV["PHASE"] || "all"
+
+  x.report("tokenize:") { profiler.tokenize } if phase == "all" || phase == "tokenize"
+  x.report("parse:") { profiler.compile } if phase == "all" || phase == "parse"
+  x.report("render:") { profiler.render } if phase == "all" || phase == "render"
+  x.report("parse & render:") { profiler.run } if phase == "all" || phase == "run"
 end
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'memory_profiler'
+require 'terminal-table'
+require_relative 'theme_runner'
+
+class Profiler
+  LOG_LABEL   = "Profiling: ".rjust(14).freeze
+  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
+
+  def self.run
+    puts
+    yield new
+  end
+
+  def initialize
+    @allocated = []
+    @retained  = []
+    @headings  = []
+  end
+
+  def profile(phase, &block)
+    print(LOG_LABEL)
+    print("#{phase}.. ".ljust(10))
+    report = MemoryProfiler.report(&block)
+    puts 'Done.'
+    @headings  << phase.capitalize
+    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
+    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
+
+    return if ENV['CI']
+
+    require 'fileutils'
+    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
+    FileUtils.mkdir_p(REPORTS_DIR)
+    report.pretty_print(to_file: report_file, scale_bytes: true)
+  end
+
+  def tabulate
+    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
+      t << @allocated.unshift('Total allocated')
+      t << @retained.unshift('Total retained')
+    end
+
+    puts
+    puts table
+    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
+  end
+
+  def sanitize(string)
+    string.downcase.gsub(/[\W]/, '-').squeeze('-')
+  end
+end
+
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+
+runner = ThemeRunner.new
+Profiler.run do |x|
+  x.profile('parse') { runner.compile }
+  x.profile('render') { runner.render }
+  x.tabulate
+end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stackprof'
 require_relative 'theme_runner'

@@ -13,7 +15,7 @@ profiler.run
    end
  end

-  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
+  if profile_type == :cpu && (graph_filename = ENV['GRAPH_FILENAME'])
    File.open(graph_filename, 'w') do |f|
      StackProf::Report.new(results).print_graphviz(nil, f)
    end
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CommentForm < Liquid::Block
  Syntax = /(#{Liquid::VariableSignature}+)/

@@ -5,14 +7,14 @@ class CommentForm < Liquid::Block
    super

    if markup =~ Syntax
-      @variable_name = $1
-      @attributes = {}
+      @variable_name = Regexp.last_match(1)
+      @attributes    = {}
    else
-      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
+      raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
    end
  end

-  def render(context)
+  def render_to_output_buffer(context, output)
    article = context[@variable_name]

    context.stack do
@@ -20,10 +22,12 @@ class CommentForm < Liquid::Block
        'posted_successfully?' => context.registers[:posted_successfully],
        'errors' => context['comment.errors'],
        'author' => context['comment.author'],
-        'email'  => context['comment.email'],
-        'body'   => context['comment.body']
+        'email' => context['comment.email'],
+        'body' => context['comment.body'],
      }
-      wrap_in_form(article, render_all(@nodelist, context))
+
+      output << wrap_in_form(article, render_all(@nodelist, context, output))
+      output
    end
  end

@@ -1,11 +1,21 @@
+# frozen_string_literal: true
+
 require 'yaml'

 module Database
+  DATABASE_FILE_PATH = "#{__dir__}/vision.database.yml"
+
  # Load the standard vision toolkit database and re-arrage it to be simply exportable
  # to liquid as assigns. All this is based on Shopify
  def self.tables
    @tables ||= begin
-      db = YAML.load_file("#{__dir__}/vision.database.yml")
+      db =
+        if YAML.respond_to?(:unsafe_load_file) # Only Psych 4+ can use unsafe_load_file
+          # unsafe_load_file is needed for YAML references
+          YAML.unsafe_load_file(DATABASE_FILE_PATH)
+        else
+          YAML.load_file(DATABASE_FILE_PATH)
+        end

      # From vision source
      db['products'].each do |product|
@@ -16,9 +26,10 @@ module Database
      end

      # key the tables by handles, as this is how liquid expects it.
-      db = db.inject({}) do |assigns, (key, values)|
-        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
-        assigns
+      db = db.each_with_object({}) do |(key, values), assigns|
+        assigns[key] = values.each_with_object({}) do |v, h|
+          h[v['handle']] = v
+        end
      end

      # Some standard direct accessors so that the specialized templates
@@ -29,17 +40,12 @@ module Database
      db['article']    = db['blog']['articles'].first

      db['cart']       = {
-        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
-        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
-        'items'       => db['line_items'].values
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] },
+        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
+        'items' => db['line_items'].values,
      }

      db
    end
  end
 end
-
-if __FILE__ == $PROGRAM_NAME
-  p Database.tables['collections']['frontpage'].keys
-  # p Database.tables['blog']['articles']
-end
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'json'

 module JsonFilter
  def json(object)
-    JSON.dump(object.reject { |k, v| k == "collections" })
+    JSON.dump(object.reject { |k, _v| k == "collections" })
  end
 end
@@ -1,4 +1,6 @@
-$:.unshift __dir__ + '/../../lib'
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(__dir__ + '/../../lib')
 require_relative '../../lib/liquid'

 require_relative 'comment_form'
@@ -9,11 +11,12 @@ require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'

-Liquid::Template.register_tag 'paginate', Paginate
-Liquid::Template.register_tag 'form', CommentForm
+default_environment = Liquid::Environment.default
+default_environment.register_tag('paginate', Paginate)
+default_environment.register_tag('form', CommentForm)

-Liquid::Template.register_filter JsonFilter
-Liquid::Template.register_filter MoneyFilter
-Liquid::Template.register_filter WeightFilter
-Liquid::Template.register_filter ShopFilter
-Liquid::Template.register_filter TagFilter
+default_environment.register_filter(JsonFilter)
+default_environment.register_filter(MoneyFilter)
+default_environment.register_filter(WeightFilter)
+default_environment.register_filter(ShopFilter)
+default_environment.register_filter(TagFilter)
@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module MoneyFilter
  def money_with_currency(money)
    return '' if money.nil?
-    sprintf("$ %.2f USD", money / 100.0)
+    format("$ %.2f USD", money / 100.0)
  end

  def money(money)
    return '' if money.nil?
-    sprintf("$ %.2f", money / 100.0)
+    format("$ %.2f", money / 100.0)
  end

  private
@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 class Paginate < Liquid::Block
-  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/

  def initialize(tag_name, markup, options)
    super

    if markup =~ Syntax
-      @collection_name = $1
-      @page_size = if $2
-        $3.to_i
+      @collection_name = Regexp.last_match(1)
+      @page_size       = if Regexp.last_match(2)
+        Regexp.last_match(3).to_i
      else
        20
      end
@@ -17,34 +19,34 @@ class Paginate < Liquid::Block
        @attributes[key] = value
      end
    else
-      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
+      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
    end
  end

-  def render(context)
+  def render_to_output_buffer(context, output)
    @context = context

    context.stack do
-      current_page  = context['current_page'].to_i
+      current_page = context['current_page'].to_i

      pagination = {
-        'page_size'      => @page_size,
-        'current_page'   => 5,
-        'current_offset' => @page_size * 5
+        'page_size' => @page_size,
+        'current_page' => 5,
+        'current_offset' => @page_size * 5,
      }

      context['paginate'] = pagination

-      collection_size  = context[@collection_name].size
+      collection_size = context[@collection_name].size

-      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?
+      raise ArgumentError, "Cannot paginate array '#{@collection_name}'. Not found." if collection_size.nil?

      page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1

      pagination['items']      = collection_size
      pagination['pages']      = page_count - 1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
-      pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
+      pagination['previous']   = link('&laquo; Previous', current_page - 1)  if 1 < current_page
+      pagination['next']       = link('Next &raquo;', current_page + 1)      if page_count > current_page + 1
      pagination['parts']      = []

      hellip_break = false
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ShopFilter
  def asset_url(input)
    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
@@ -29,7 +31,7 @@ module ShopFilter

  def link_to_vendor(vendor)
    if vendor
-      link_to vendor, url_for_vendor(vendor), vendor
+      link_to(vendor, url_for_vendor(vendor), vendor)
    else
      'Unknown Vendor'
    end
@@ -37,7 +39,7 @@ module ShopFilter

  def link_to_type(type)
    if type
-      link_to type, url_for_type(type), type
+      link_to(type, url_for_type(type), type)
    else
      'Unknown Vendor'
    end
@@ -52,15 +54,15 @@ module ShopFilter
  end

  def product_img_url(url, style = 'small')
-    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
+    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
      raise ArgumentError, 'filter "size" can only be called on product images'
    end

    case style
    when 'original'
-      return '/files/shops/random_number/' + url
+      '/files/shops/random_number/' + url
    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
+      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
    else
      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
    end
@@ -70,16 +72,14 @@ module ShopFilter
    html = []
    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']

-    for part in paginate['parts']
-
-      if part['is_link']
-        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+    paginate['parts'].each do |part|
+      html << if part['is_link']
+        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
      elsif part['title'].to_i == paginate['current_page'].to_i
-        html << %(<span class="page current">#{part['title']}</span>)
+        %(<span class="page current">#{part['title']}</span>)
      else
-        html << %(<span class="deco">#{part['title']}</span>)
+        %(<span class="deco">#{part['title']}</span>)
      end
-
    end

    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TagFilter
  def link_to_tag(label, tag)
    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
@@ -13,11 +15,11 @@ module TagFilter

  def link_to_add_tag(label, tag)
    tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
  end

  def link_to_remove_tag(label, tag)
    tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
  end
 end
@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module WeightFilter
  def weight(grams)
-    sprintf("%.2f", grams / 1000)
+    format("%.2f", grams / 1000)
  end

  def weight_with_unit(grams)
@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 # This profiler run simulates Shopify.
 # We are looking in the tests directory for liquid files and render them within the designated layout file.
 # We will also export a substantial database to liquid which the templates can render values of.
-# All this is to make the benchmark as non syntetic as possible. All templates and tests are lifted from
+# All this is to make the benchmark as non synthetic as possible. All templates and tests are lifted from
 # direct real-world usage and the profiler measures code that looks very similar to the way it looks in
 # Shopify which is likely the biggest user of liquid in the world which something to the tune of several
 # million Template#render calls a day.
@@ -21,53 +23,117 @@ class ThemeRunner
    end
  end

-  # Load all templates into memory, do this now so that
-  # we don't profile IO.
+  # Initialize a new liquid ThemeRunner instance
+  # Will load all templates into memory, do this now so that we don't profile IO.
  def initialize
    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
      next if File.basename(test) == 'theme.liquid'

      theme_path = File.dirname(test) + '/theme.liquid'
-
-      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
+      {
+        liquid: File.read(test),
+        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
+        template_name: test,
+      }
    end.compact
+
+    compile_all_tests
  end

+  # `compile` will test just the compilation portion of liquid without any templates
  def compile
-    # Dup assigns because will make some changes to them
-
-    @tests.each do |liquid, layout, template_name|
-      tmpl = Liquid::Template.new
-      tmpl.parse(liquid)
-      tmpl = Liquid::Template.new
-      tmpl.parse(layout)
+    @tests.each do |test_hash|
+      Liquid::Template.new.parse(test_hash[:liquid])
+      Liquid::Template.new.parse(test_hash[:layout])
    end
  end

-  def run
-    # Dup assigns because will make some changes to them
-    assigns = Database.tables.dup
+  # `tokenize` will just test the tokenizen portion of liquid without any templates
+  def tokenize
+    ss = StringScanner.new("")
+    @tests.each do |test_hash|
+      tokenizer = Liquid::Tokenizer.new(
+        source: test_hash[:liquid],
+        string_scanner: ss,
+        line_numbers: true,
+      )
+      while tokenizer.shift; end
+    end
+  end

-    @tests.each do |liquid, layout, template_name|
-      # Compute page_tempalte outside of profiler run, uninteresting to profiler
-      page_template = File.basename(template_name, File.extname(template_name))
+  # `run` is called to benchmark rendering and compiling at the same time
+  def run
+    each_test do |liquid, layout, assigns, page_template, template_name|
      compile_and_render(liquid, layout, assigns, page_template, template_name)
    end
  end

-  def compile_and_render(template, layout, assigns, page_template, template_file)
-    tmpl = Liquid::Template.new
-    tmpl.assigns['page_title'] = 'Page title'
-    tmpl.assigns['template'] = page_template
-    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
+  # `render` is called to benchmark just the render portion of liquid
+  def render
+    @compiled_tests.each do |test|
+      tmpl    = test[:tmpl]
+      assigns = test[:assigns]
+      layout  = test[:layout]

-    content_for_layout = tmpl.parse(template).render!(assigns)
-
-    if layout
-      assigns['content_for_layout'] = content_for_layout
-      tmpl.parse(layout).render!(assigns)
-    else
-      content_for_layout
+      if layout
+        assigns['content_for_layout'] = tmpl.render!(assigns)
+        layout.render!(assigns)
+      else
+        tmpl.render!(assigns)
+      end
    end
  end
+
+  private
+
+  def render_layout(template, layout, assigns)
+    assigns['content_for_layout'] = template.render!(assigns)
+    layout&.render!(assigns)
+  end
+
+  def compile_and_render(template, layout, assigns, page_template, template_file)
+    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
+    render_layout(compiled_test[:tmpl], compiled_test[:layout], compiled_test[:assigns])
+  end
+
+  def compile_all_tests
+    @compiled_tests = []
+    each_test do |liquid, layout, assigns, page_template, template_name|
+      @compiled_tests << compile_test(liquid, layout, assigns, page_template, template_name)
+    end
+    @compiled_tests
+  end
+
+  def compile_test(template, layout, assigns, page_template, template_file)
+    tmpl            = init_template(page_template, template_file)
+    parsed_template = tmpl.parse(template).dup
+
+    if layout
+      parsed_layout = tmpl.parse(layout)
+      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
+    else
+      { tmpl: parsed_template, assigns: assigns }
+    end
+  end
+
+  # utility method with similar functionality needed in `compile_all_tests` and `run`
+  def each_test
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |test_hash|
+      # Compute page_template outside of profiler run, uninteresting to profiler
+      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
+      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
+    end
+  end
+
+  # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
+  def init_template(page_template, template_file)
+    tmpl                         = Liquid::Template.new
+    tmpl.assigns['page_title']   = 'Page title'
+    tmpl.assigns['template']     = page_template
+    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
+    tmpl
+  end
 end
@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+
+# benchmark liquid lexing
+
+require 'liquid'
+
+RubyVM::YJIT.enable
+
+STRING_MARKUPS = [
+  "\"foo\"",
+  "\"fooooooooooo\"",
+  "\"foooooooooooooooooooooooooooooo\"",
+  "'foo'",
+  "'fooooooooooo'",
+  "'foooooooooooooooooooooooooooooo'",
+]
+
+VARIABLE_MARKUPS = [
+  "article",
+  "article.title",
+  "article.title.size",
+  "very_long_variable_name_2024_11_05",
+  "very_long_variable_name_2024_11_05.size",
+]
+
+NUMBER_MARKUPS = [
+  "0",
+  "35",
+  "1241891024912849",
+  "3.5",
+  "3.51214128409128",
+  "12381902839.123819283910283",
+  "123.456.789",
+  "-123",
+  "-12.33",
+  "-405.231",
+  "-0",
+  "0",
+  "0.0",
+  "0.0000000000000000000000",
+  "0.00000000001",
+]
+
+RANGE_MARKUPS = [
+  "(1..30)",
+  "(1...30)",
+  "(1..30..5)",
+  "(1.0...30.0)",
+  "(1.........30)",
+  "(1..foo)",
+  "(foo..30)",
+  "(foo..bar)",
+  "(foo...bar...100)",
+  "(foo...bar...100.0)",
+]
+
+LITERAL_MARKUPS = [
+  nil,
+  'nil',
+  'null',
+  '',
+  'true',
+  'false',
+  'blank',
+  'empty',
+]
+
+MARKUPS = {
+  "string" => STRING_MARKUPS,
+  "literal" => LITERAL_MARKUPS,
+  "variable" => VARIABLE_MARKUPS,
+  "number" => NUMBER_MARKUPS,
+  "range" => RANGE_MARKUPS,
+}
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 5)
+
+  MARKUPS.each do |type, markups|
+    x.report("Liquid::Expression#parse: #{type}") do
+      markups.each do |markup|
+        Liquid::Expression.parse(markup)
+      end
+    end
+  end
+
+  x.report("Liquid::Expression#parse: all") do
+    MARKUPS.values.flatten.each do |markup|
+      Liquid::Expression.parse(markup)
+    end
+  end
+end
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "benchmark/ips"
+
+# benchmark liquid lexing
+
+require 'liquid'
+
+RubyVM::YJIT.enable
+
+EXPRESSIONS = [
+  "foo[1..2].baz",
+  "12.0",
+  "foo.bar.based",
+  "21 - 62",
+  "foo.bar.baz",
+  "foo > 12",
+  "foo < 12",
+  "foo <= 12",
+  "foo >= 12",
+  "foo <> 12",
+  "foo == 12",
+  "foo != 12",
+  "foo contains 12",
+  "foo contains 'bar'",
+  "foo != 'bar'",
+  "'foo' contains 'bar'",
+  '234089',
+  "foo | default: -1",
+]
+
+Benchmark.ips do |x|
+  x.config(time: 10, warmup: 5)
+
+  x.report("Liquid::Lexer#tokenize") do
+    EXPRESSIONS.each do |expr|
+      l = Liquid::Lexer.new(expr)
+      l.tokenize
+    end
+  end
+
+  x.compare!
+end
--- a/Show More
+++ b/Show More