feat!: remove --template CLI option

Template is positional-only; bare stdin template and --template/-t are both removed. Keep @- for template and --context. Co-authored-by: Cursor <[email protected]>
feat: accept CLI template as positional or --template
2026-09-14 11:50:40 -07:00 · 2026-07-28 00:01:15 +08:00 · 2026-07-27 21:38:17 +08:00 · 2026-07-27 20:13:23 +08:00 · 2026-07-26 14:16:00 +08:00 · 2026-07-24 02:08:59 +08:00
96 changed files with 683 additions and 1324 deletions
@@ -847,24 +847,6 @@
      "contributions": [
        "code"
      ]
-    },
-    {
-      "login": "YacovGold",
-      "name": "YacovGold",
-      "avatar_url": "https://avatars.githubusercontent.com/u/8984042?v=4",
-      "profile": "https://github.com/YacovGold",
-      "contributions": [
-        "code"
-      ]
-    },
-    {
-      "login": "sarathfrancis90",
-      "name": "Sarath Francis",
-      "avatar_url": "https://avatars.githubusercontent.com/u/9289498?v=4",
-      "profile": "https://github.com/sarathfrancis90",
-      "contributions": [
-        "code"
-      ]
    }
  ],
  "contributorsPerLine": 7,
@@ -22,7 +22,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
-          node-version: '20'
+          node-version: 'latest'
      - name: Install dependencies
        run: npm ci
      - name: Build
@@ -12,7 +12,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
-          node-version: '22'
+          node-version: 'latest'
      - name: Install dependencies
        run: npm ci
      - name: Test
@@ -12,7 +12,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
-          node-version: '20'
+          node-version: 'latest'
      - name: Build
        run: |
          npm ci
@@ -12,7 +12,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
-          node-version: '20'
+          node-version: 'latest'
      - name: Install dependencies
        run: npm ci
      - name: Lint
@@ -17,7 +17,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
-          node-version: '20'
+          node-version: 'latest'
      - name: Download artifacts
        uses: actions/download-artifact@v4
        with:
@@ -24,12 +24,7 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: |
-          if [ ${{ github.ref == 'refs/heads/master' }} ]; then
-            npx semantic-release
-          else
-            npx semantic-release --dry-run
-          fi
+        run: npx semantic-release
      - name: Archive npm failure logs
        uses: actions/upload-artifact@v4
        if: failure()
@@ -7,20 +7,10 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        timezone: [Etc/GMT, Asia/Shanghai, America/New_York]
-        node-version: [22]
+        node-version: [latest]
        include:
-          - os: macos-latest
-            timezone: America/New_York
-            node-versoin: 22
          - os: ubuntu-latest
-            timezone: Etc/GMT
-            node-version: 20
-          - os: ubuntu-latest
-            timezone: Asia/Shanghai
-            node-version: 18
-          - os: ubuntu-latest
-            timezone: Asia/Shanghai
-            node-version: 16
+            node-version: lts/*
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout
@@ -39,7 +29,7 @@ jobs:
          name: dist-${{ matrix.os }}
          path: dist
      - name: Run Test
-        run: TZ=${{ matrix.timezone }} npm test
+        run: TZ=${{ matrix.timezone || 'Etc/GMT' }} npm test
      - name: Archive npm failure logs
        uses: actions/upload-artifact@v4
        if: failure()
@@ -57,7 +47,7 @@ jobs:
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
-          node-version: 22
+          node-version: latest
      - name: Download artifacts
        uses: actions/download-artifact@v4
        with:
@@ -0,0 +1,50 @@
+const gitPlugin = [
+  '@semantic-release/git',
+  {
+    assets: ['package.json', 'package-lock.json', 'CHANGELOG.md'],
+    message: 'chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}'
+  }
+]
+
+const githubPlugin = [
+  '@semantic-release/github',
+  {
+    assets: [
+      { path: 'dist/*.umd.js', label: 'liquid.js' },
+      { path: 'dist/*.min.js', label: 'liquid.min.js' },
+      { path: 'dist/*.min.js.map', label: 'liquid.min.js.map' }
+    ]
+  }
+]
+
+// next is branch-protected (PR-only); skip @semantic-release/git there and publish to npm only.
+const onMaster = process.env.GITHUB_REF === 'refs/heads/master'
+const onNext = process.env.GITHUB_REF === 'refs/heads/next'
+
+// On next, breaking changes are v11 WIP — bump alpha prerelease only, not major.
+const commitAnalyzer = onNext
+  ? ['@semantic-release/commit-analyzer', {
+      releaseRules: [
+        { breaking: true, release: 'patch' }
+      ]
+    }]
+  : '@semantic-release/commit-analyzer'
+
+const basePlugins = [
+  commitAnalyzer,
+  '@semantic-release/release-notes-generator',
+  '@semantic-release/changelog',
+  '@semantic-release/npm'
+]
+
+module.exports = {
+  branches: [
+    'master',
+    { name: 'next', prerelease: 'alpha' }
+  ],
+  plugins: [
+    ...basePlugins,
+    ...(onMaster ? [gitPlugin] : []),
+    githubPlugin
+  ]
+}
@@ -1,34 +1,3 @@
-# [10.29.0](https://github.com/harttle/liquidjs/compare/v10.28.0...v10.29.0) (2026-08-11)
-
-
-### Features
-
-* add unregisterFilter method ([#946](https://github.com/harttle/liquidjs/issues/946)) ([69b2c58](https://github.com/harttle/liquidjs/commit/69b2c589f9b69a34427cb8533ddb938bd997914f))
-* **filters:** add squish filter ([#943](https://github.com/harttle/liquidjs/issues/943)) ([875513f](https://github.com/harttle/liquidjs/commit/875513f4c5136bed0c64562cccabb21a7db8d36c))
-
-# [10.28.0](https://github.com/harttle/liquidjs/compare/v10.27.2...v10.28.0) (2026-08-01)
-
-
-### Bug Fixes
-
-* **date:** %s returns Unix epoch unaffected by display timezone ([#932](https://github.com/harttle/liquidjs/issues/932)) ([39c8743](https://github.com/harttle/liquidjs/commit/39c87437c5ef38ede9a208c9d55cd13231c6c023)), closes [#931](https://github.com/harttle/liquidjs/issues/931)
-
-
-### Features
-
-* Add support of inner expressions enclosed by parentheses ([#863](https://github.com/harttle/liquidjs/issues/863)) ([afa5f54](https://github.com/harttle/liquidjs/commit/afa5f5400428fc1ec935aca0282e579224660c95))
-
-## [10.27.2](https://github.com/harttle/liquidjs/compare/v10.27.1...v10.27.2) (2026-07-09)
-
-
-### Bug Fixes
-
-* charge join/json/inspect filters by produced output size ([#925](https://github.com/harttle/liquidjs/issues/925)) ([7ab49f9](https://github.com/harttle/liquidjs/commit/7ab49f999ac045ec1e87f3a7a9fd68dd9e8602b3))
-* **date:** zero-pad milliseconds when formatting %N fractional seconds ([#929](https://github.com/harttle/liquidjs/issues/929)) ([2634f9d](https://github.com/harttle/liquidjs/commit/2634f9de7b1228cd887b7cab880af8a795c77053))
-* enforce ownPropertyOnly for inherited array indices ([#924](https://github.com/harttle/liquidjs/issues/924)) ([552819a](https://github.com/harttle/liquidjs/commit/552819a84b80c62306fe61072628a756272dc749))
-* **filters:** modulo should follow divisor sign for negative operands ([#922](https://github.com/harttle/liquidjs/issues/922)) ([568bd5f](https://github.com/harttle/liquidjs/commit/568bd5f9cb99f596292c09fd70b00284b8216f0c))
-* **filters:** return empty for out-of-range slice begin or negative length ([#928](https://github.com/harttle/liquidjs/issues/928)) ([f9a1316](https://github.com/harttle/liquidjs/commit/f9a1316d161f4f20018c833160f42dfcf0cde507))
-
 ## [10.27.1](https://github.com/harttle/liquidjs/compare/v10.27.0...v10.27.1) (2026-06-23)


@@ -46,7 +46,7 @@ npm install liquidjs
 **CLI**

 ```bash
-npx liquidjs --template 'Hello, {{ name }}!' --context '{"name": "Liquid"}'
+npx liquidjs 'Hello, {{ name }}!' --context '{"name": "Liquid"}'
 ```

 See the [setup guide][setup] for partials, layouts, caching, and other options.
@@ -242,8 +242,6 @@ Want to contribute? see [Contribution Guidelines][contribution]. Thanks goes to
    </tr>
    <tr>
      <td align="center" valign="top" width="14.28%"><a href="https://github.com/spokodev"><img src="https://avatars.githubusercontent.com/u/239690017?v=4?s=100" width="100px;" alt="spokodev"/><br /><sub><b>spokodev</b></sub></a><br /><a href="https://github.com/harttle/liquidjs/commits?author=spokodev" title="Code">💻</a></td>
-      <td align="center" valign="top" width="14.28%"><a href="https://github.com/YacovGold"><img src="https://avatars.githubusercontent.com/u/8984042?v=4?s=100" width="100px;" alt="YacovGold"/><br /><sub><b>YacovGold</b></sub></a><br /><a href="https://github.com/harttle/liquidjs/commits?author=YacovGold" title="Code">💻</a></td>
-      <td align="center" valign="top" width="14.28%"><a href="https://github.com/sarathfrancis90"><img src="https://avatars.githubusercontent.com/u/9289498?v=4?s=100" width="100px;" alt="Sarath Francis"/><br /><sub><b>Sarath Francis</b></sub></a><br /><a href="https://github.com/harttle/liquidjs/commits?author=sarathfrancis90" title="Code">💻</a></td>
    </tr>
  </tbody>
 </table>
@@ -3,19 +3,7 @@
 const fs = require('fs/promises')
 const Liquid = require('..').Liquid

-// Preserve compatibility by falling back to legacy CLI behavior if:
-// - stdin is redirected (i.e. not connected to a terminal) AND
-// - there are either no arguments, or only a single argument which does not start with a dash
-// TODO: Remove this fallback for 11.0
-
-let renderPromise = null
-if (!process.stdin.isTTY && (process.argv.length === 2 || (process.argv.length === 3 && !process.argv[2].startsWith('-')))) {
-  renderPromise = renderLegacy()
-} else {
-  renderPromise = render()
-}
-
-renderPromise.catch(err => {
+render().catch(err => {
  process.stderr.write(`${err.message}\n`)
  process.exitCode = 1
 })
@@ -26,8 +14,8 @@ async function render () {
  program
    .name('liquidjs')
    .description('Render a Liquid template')
-    .requiredOption('-t, --template <liquid | @path>', 'liquid template to render (@- to read from stdin)') // TODO: Change to argument in 11.0
-    .option('-c, --context <json | @path>', 'input context in JSON format (@- to read from stdin)')
+    .argument('<template>', 'liquid template to render (inline, @path, or @- for stdin)')
+    .option('-c, --context <json | @path>', 'input context in JSON format (inline, @path, or @- for stdin)')
    .option('-o, --output <path>', 'write rendered output to file (omit to write to stdout)')
    .option('--cache [size]', 'cache previously parsed template structures (default cache size: 1024)')
    .option('--extname <string>', 'use a default filename extension when resolving partials and layouts')
@@ -57,12 +45,13 @@ async function render () {
    .parse()

  const options = program.opts()
+  const templateOption = program.args[0]

-  if (Object.values(options).filter((value) => value === '@-').length > 1) {
+  if (Object.values({ template: templateOption, context: options.context }).filter((value) => value === '@-').length > 1) {
    throw new Error(`The stdin input specifier '@-' must only be used once.`)
  }

-  const template = await resolveInputOption(options.template)
+  const template = await resolveInputOption(templateOption)
  const context = await resolveContext(options.context)
  const liquid = new Liquid(options)
  const output = liquid.parseAndRenderSync(template, context)
@@ -108,32 +97,3 @@ async function readStream (stream) {
  }
  return Buffer.concat(chunks).toString('utf8')
 }
-
-// TODO: Remove for 11.0
-async function renderLegacy () {
-  process.stderr.write('Reading template from stdin. This mode will be removed in next major version, use --template option instead.\n')
-  const contextArg = process.argv.slice(2)[0]
-  let context = {}
-  if (contextArg) {
-    const contextJson = await resolveInputOptionLegacy(contextArg)
-    context = JSON.parse(contextJson)
-  }
-  const template = await readStream(process.stdin)
-  const liquid = new Liquid()
-  const output = liquid.parseAndRenderSync(template, context)
-  process.stdout.write(output)
-}
-
-// TODO: Remove for 11.0
-async function resolveInputOptionLegacy (option) {
-  let content = null
-  if (option) {
-    const stat = await fs.stat(option).catch(e => null)
-    if (stat && stat.isFile) {
-      content = await fs.readFile(option, 'utf8')
-    } else {
-      content = option
-    }
-  }
-  return content
-}
@@ -7,13 +7,13 @@ while ! grep -q "Express running" "$LOG_FILE"; do
  if ! kill -0 $SERVER_PID; then
    echo "Server exited unexpectedly."
    cat $LOG_FILE
-    return 1
+    exit 1
  fi
  sleep 1
 done
 curl http://127.0.0.1:3000 | grep -q 'Welcome to LiquidJS'
 RESULT=$?
-killall node
+killall node || true
 rm $LOG_FILE
 if [ $RESULT != 0 ]; then
  exit 1
@@ -94,7 +94,6 @@ filters:
  sort: sort.html
  sort_natural: sort_natural.html
  split: split.html
-  squish: squish.html
  strip: strip.html
  strip_html: strip_html.html
  strip_newlines: strip_newlines.html
@@ -34,7 +34,6 @@ The `date` filter is used to convert a timestamp into the specified format.
            * minutes: `-360` means `'+06:00'` and `360` means `'-06:00'`
            * timeZone ID: `Asia/Colombo` or `America/New_York`
    * See [here](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) for TZ database values
-* `%s` (seconds since the Unix epoch) identifies an instant rather than a wall-clock time, so it's not affected by the display timezone.

 ### Examples
 ```liquid
@@ -1,18 +0,0 @@
---
-title: squish
---
-
-{% since %}v10.28.0{% endsince %}
-
-Removes leading and trailing whitespace from a string, and replaces every run of whitespace inside it with a single space.
-
-Input
-```liquid
-{{ "  Hello   there,
-    Major Tom.  " | squish }}
-```
-
-Output
-```text
-Hello there, Major Tom.
-```
@@ -138,7 +138,7 @@ It defaults to `false`. For example, when set to `true`, a blank string would ev

 **lenientIf** modifies the behavior of `strictVariables` to allow handling optional variables. If set to `true`, an undefined variable will *not* cause an exception in the following two situations: a) it is the condition to an `if`, `elsif`, or `unless` tag; b) it occurs right before a `default` filter. Irrelevant if `strictVariables` is not set. Defaults to `false`.

-**ownPropertyOnly** hides scope variables from prototypes, useful when you're passing a not sanitized object into LiquidJS or need to hide prototypes from templates. Defaults to `true`.
+**ownPropertyOnly** limits template property reads on plain scope objects to own properties. Defaults to `true`. See [Security Model](./security-model.html).

 {% note info Nonexistent Tags %}
 Nonexistent tags always throw errors during parsing and this behavior cannot be customized.
@@ -62,23 +62,7 @@ See existing filter implementations here: <https://github.com/harttle/liquidjs/t

 ## Unregister Tags/Filters

-Filters can be unregistered by name:
-
-```javascript
-engine.unregisterFilter('plus')
-```
-
-With [`strictFilters`][strict-filters] enabled, using an unregistered filter will throw an error. Otherwise, the filter will be skipped.
-
-Built-in filters can be registered again using the exported `filters` object:
-
-```javascript
-import { filters } from 'liquidjs'
-
-engine.registerFilter('plus', filters.plus)
-```
-
-To disable a tag, or to make a disabled filter throw regardless of `strictFilters`, register a dummy implementation that throws a corresponding error (see [#324](https://github.com/harttle/liquidjs/issues/324)):
+In some cases it's desirable to disable some tags/filters (see [#324](https://github.com/harttle/liquidjs/issues/324)). You'll need to register a dummy tag/filter that throws a corresponding Error.

 ```javascript
 // disable a tag
@@ -97,5 +81,3 @@ function disabledFilter(name) {
 }
 engine.registerFilter('plus', disabledFilter('plus'));
 ```
-
-[strict-filters]: /tutorials/options.html#strict
@@ -22,7 +22,7 @@ Expected output:
 </div>
 ```

-Firstly, [register][register-tags] a tag named `wrap` and parse the content into `this.tpls`. Here in `parse(tagToken, remainTokens)`:
+Firstly, [register][register-tags] a tag named `wrap` and parse the content into `this.tpls`. In the tag `constructor(tagToken, remainTokens, liquid)`:

 - `tagToken` is current token `{%raw%}{% wrap %}{%endraw%}`, and
 - `remainTokens` is an array of all tokens following `{%raw%}{% wrap %}{%endraw%}` until the end of this template file.
@@ -30,11 +30,14 @@ Firstly, [register][register-tags] a tag named `wrap` and parse the content into
 Basically, what we need to do is take/`.shift()` enough tags from `remainTokens` until we get an `endwrap` token (the name can be arbitrary, but by convention it should be `endwrap`). And if there's no `endwrap` until the end of the template file, we need to throw a tag-not-closed `Error`.

 ```javascript
-engine.registerTag('wrap', {
-  parse(tagToken, remainTokens) {
-    this.tpls = []
+const { Tag } = require('liquidjs')
+
+engine.registerTag('wrap', class WrapTag extends Tag {
+  tpls = []
+  constructor(tagToken, remainTokens, liquid) {
+    super(tagToken, remainTokens, liquid)
    let closed = false
-    while(remainTokens.length) {
+    while (remainTokens.length) {
      let token = remainTokens.shift()
      // we got the end tag! stop taking tokens
      if (token.name === 'endwrap') {
@@ -44,11 +47,11 @@ engine.registerTag('wrap', {
      // parse token into template
      // parseToken() may consume more than 1 tokens
      // e.g. {% if %}...{% endif %}
-      let tpl = this.liquid.parser.parseToken(token, remainTokens)
+      let tpl = liquid.parser.parseToken(token, remainTokens)
      this.tpls.push(tpl)
    }
    if (!closed) throw new Error(`tag ${tagToken.getText()} not closed`)
-  },
+  }
  * render(context, emitter) {
    emitter.write("<div class='wrapper'>")
    yield this.liquid.renderer.renderTemplates(this.tpls, context, emitter)
@@ -57,16 +60,17 @@ engine.registerTag('wrap', {
 })
 ```

-`.renderTemplates()` can be async; we need `yield` to wait for it to complete. For more details on async in LiquidJS, see [Sync and Async][async]. Other parts of the `render()` method are quite straightforward. Here's a JSFiddle version: <https://jsfiddle.net/por0zcn1/3/>
+`.renderTemplates()` can be async; we need `yield` to wait for it to complete. For more details on async in LiquidJS, see [Sync and Async][async]. Here's a JSFiddle version: <https://jsfiddle.net/por0zcn1/3/>

 ## Using ParseStream

-When it comes to complex tags like [for][for] and [if][if], the `parse()` can be very complicated. There's a [ParseStream][ParseStream] utility to organize the `parse()` in event-based style. Following is a re-written `parse()` using `ParseStream` that does exactly the same as the example above.
+For more complex tags such as [for][for] and [if][if], constructor parsing can get unwieldy. [ParseStream][ParseStream] offers an event-based API for this. The constructor below is equivalent to the example above:

 ```javascript
-parse(tagToken, remainTokens) {
-  this.tpls = []
-  this.liquid.parser.parseStream(remainTokens)
+tpls = []
+constructor(tagToken, remainTokens, liquid) {
+  super(tagToken, remainTokens, liquid)
+  liquid.parser.parseStream(remainTokens)
    .on('template', tpl => this.tpls.push(tpl))
    // note that we cannot use arrow function because we need `this`
    .on('tag:endwrap', function () { this.stop() })
@@ -103,15 +107,18 @@ As you've noticed, there's an additional `repeat.i` in the context of `repeat`.
 Each time we enter a new *Context*, we need to push a new *Scope*. And when we finish rendering and exit the *Context*, we pop the *Scope* from the *Context*. As you can see in the following implementation:

 ```javascript
-engine.registerTag('repeat', {
-  parse(tagToken, remainTokens) {
-    this.tpls = []
-    this.liquid.parser.parseStream(remainTokens)
+const { Tag } = require('liquidjs')
+
+engine.registerTag('repeat', class RepeatTag extends Tag {
+  tpls = []
+  constructor(tagToken, remainTokens, liquid) {
+    super(tagToken, remainTokens, liquid)
+    liquid.parser.parseStream(remainTokens)
      .on('template', tpl => this.tpls.push(tpl))
      .on('tag:endrepeat', function () { this.stop() })
      .on('end', () => { throw new Error(`tag ${tagToken.getText()} not closed`) })
      .start()
-  },
+  }
  * render(context, emitter) {
    const repeat = { i: 1 }
    context.push({ repeat })
@@ -123,7 +130,7 @@ engine.registerTag('repeat', {
 })
 ```

-The `parse()` is exactly the same as `wrap` tag, we repeat the content simply by calling `.renderTemplates(this.tpls)` twice during `render()`. Here's the JSFiddle: <https://jsfiddle.net/por0zcn1/2/>
+The constructor is the same as in the `wrap` tag; we repeat the content by calling `.renderTemplates(this.tpls)` twice during `render()`. Here's the JSFiddle: <https://jsfiddle.net/por0zcn1/2/>

 {% note warn Use Push & Pop in Pairs %}
 `context.push()` and `context.pop()` have to be used in pairs. Failing to `pop()` the *Scope* you pushed will leak the *Scope* to latter templates and may corrupt the *Context* stack.
@@ -2,21 +2,19 @@
 title: Security Model
 ---

-LiquidJS provides DoS-oriented limits (`parseLimit`, `renderLimit`, `memoryLimit`) to reduce risk. This page summarizes those limits, [`ownPropertyOnly`][ownPropertyOnly], custom [`Drop`][drop] usage, and the security boundary to assume in production.
+LiquidJS provides DoS-oriented limits (`parseLimit`, `templateLimit`, `outputLengthLimit`, `maxDepth`) to reduce risk. This page summarizes those limits, [`ownPropertyOnly`][ownPropertyOnly], custom [`Drop`][drop] usage, and the security boundary to assume in production.

-## Security boundary
+## At a glance

-The built-in limits are cooperative safeguards, not strict runtime isolation.
-
- They do **not** equal process RSS/heap usage.
- They do **not** sandbox JavaScript execution.
- They should be combined with process/container limits and request timeouts for defense in depth.
-
-## Limits at a glance
+LiquidJS ships a thin cooperative DoS layer:

 - [parseLimit][parseLimit]: limit total template size per `parse()` call.
- [renderLimit][renderLimit]: limit total render time per `render()` call.
- [memoryLimit][memoryLimit]: cooperatively limit memory-sensitive allocations counted by LiquidJS.
+- [templateLimit][templateLimit]: limit total tag/HTML/output nodes rendered per `render()` call.
+- [outputLengthLimit][outputLengthLimit]: limit total output length per `render()` call.
+- [maxDepth][maxDepth]: limit nesting depth of `{% render %}`, `{% include %}`, and `{% layout %}`.
+- Strftime numeric pad widths in the `date` filter are capped at `1_000_000` (1M) per conversion.
+
+These are cooperative safeguards, not runtime isolation—see [Production guidance](#production-guidance) below for host-level limits and online-service hardening.

 ## Limit details

@@ -26,9 +24,9 @@ The built-in limits are cooperative safeguards, not strict runtime isolation.

 A typical PC handles `1e8` (100M) characters without issues.

-### renderLimit
+### templateLimit

-Restricting template size alone is insufficient because dynamic loops with large counts can occur during rendering. [renderLimit][renderLimit] mitigates this by limiting the time consumed by each `render()` call.
+Restricting template size alone is insufficient because dynamic loops with large counts can occur during rendering. [templateLimit][templateLimit] mitigates this by limiting the number of tag, HTML literal, and output nodes rendered in each `render()` call.

 ```liquid
 {%- for i in (1..10000000) -%}
@@ -36,52 +34,47 @@ Restricting template size alone is insufficient because dynamic loops with large
 {%- endfor -%}
 ```

-Render time is checked on a per-template basis (before rendering each template). In the above example, there are 2 templates in the loop: `order: ` and `{{i}}`, render time will be checked 10000000x2 times.
+Each template node (the `for` tag, literal `order: `, output `{{i}}`, and so on) counts toward the limit. In the above example, a limit of `30000000` would be exceeded before the loop finishes.

-`renderLimit` is not a hard CPU limiter. It is checked between template renders, so compute-intensive filters/tags/user-defined functions or deeply nested template execution between checks can still cause DoS.
+`templateLimit` is checked before each node render, so compute-intensive filters/tags/user-defined functions between checks can still cause DoS.

-### memoryLimit
+### outputLengthLimit

-`memoryLimit` only limits operations that LiquidJS explicitly counts.
+[outputLengthLimit][outputLengthLimit] caps the cumulative length of output written during a `render()` call, including output from partials rendered via `{% render %}`.

- Counted: memory-sensitive LiquidJS operations that call internal memory accounting.
- Not guaranteed counted: arbitrary user object behavior such as custom `toValue()`/`toString()` chains, or other host-side code that allocates outside LiquidJS accounting points.
+### maxDepth

-In other words, `memoryLimit` limits what LiquidJS counts, not every byte your process may allocate.
+[maxDepth][maxDepth] limits how deeply `{% render %}`, `{% include %}`, and `{% layout %}` can nest. Defaults to `128`. In sync rendering (`renderSync`), nested tags are driven by `toValueSync`, which recursively resumes each yielded generator on the call stack—deep nesting can overflow it, and `maxDepth` caps that depth. Async `render()` resumes the same tag generators via `toPromise`/`yield` without a deep synchronous call chain, so stack overflow is not a concern there (the limit still applies as a DoS guard).

-Even with a small number of templates and iterations, memory usage can grow exponentially. In the following example, memory doubles with each iteration:
-
-```liquid
-{% assign array = "1,2,3" | split: "," %}
-{% for i in (1..32) %}
-    {% assign array = array | concat: array %}
-{% endfor %}
-```
-
-As [JavaScript uses GC to manage memory](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_management), `memoryLimit` may not reflect the actual memory footprint.
+The `memoryLimit` option was removed in v11; enforce memory limits at the host or process level instead.

 ## `ownPropertyOnly` and scope data

-With [`ownPropertyOnly`][ownPropertyOnly] `true`, plain scope objects only expose **own** properties (no inherited / `Object.prototype` keys). Default `false` follows normal JS property access. Use `true` for untrusted or polluted objects; add [`strictVariables`][strictVariables] if missing paths should error. Override per render via [`RenderOptions`][renderOwnPropertyOnly]. This is a read policy for scope data—not a sandbox for filters, tags, or your code.
+With [`ownPropertyOnly`][ownPropertyOnly] `true` (default), plain scope objects only expose **own** properties (no inherited / `Object.prototype` keys), and reads of `__proto__`, `constructor`, and `prototype` are blocked (own and inherited) as a prototype-pollution defense. With `false`, inherited properties and those keys are allowed—sanitize untrusted scope data (e.g. with [bourne](https://www.npmjs.com/package/bourne)) before passing it as scope. LiquidJS also uses null-prototype objects for managed scope frames (e.g. `{% capture %}`, `{% assign %}`) so internal frames do not inherit from `Object.prototype`.
+
+Not restricted: [`Drop`][drop] values, iteration via `Symbol.iterator`, `.size`/`.first`/`.last`, filters, and custom tags.
+
+Use `true` for untrusted objects; add [`strictVariables`][strictVariables] if missing paths should error. Override per render via [`RenderOptions`][renderOwnPropertyOnly]. This is a read policy for scope data—not a sandbox for filters, tags, or your code.

 ## Custom `Drop` classes

 [`Drop`][drop] values are not restricted the same way: LiquidJS still reads the prototype chain and may call [`liquidMethodMissing`][liquidMethodMissing]. **You** control what a drop exposes; narrow APIs and never feed unsafe data into drops unless the class is built for template access. `ownPropertyOnly` alone does not harden custom drops—audit them like any privileged code.

-## Online service guidance
+## Production guidance

-If you run an online service, avoid rendering fully user-defined templates whenever possible.
+LiquidJS does not sandbox template code—custom filters, tags, and scope helpers run as ordinary JavaScript with your process privileges. Built-in DoS limits are one layer; production deployments, especially online services that accept template input, need additional hardening:

- Prefer curated templates or a restricted template subset.
- If user-defined templates are required, isolate rendering (worker/process/container), enforce OS/container memory and CPU limits, and apply request rate limits.
- Treat `parseLimit`/`renderLimit`/`memoryLimit` as one layer in a broader DoS defense strategy.
-
-For heavy single-template operations, process-level isolation is still recommended (for example with [paralleljs][paralleljs]).
+- **Prefer curated templates** over fully user-defined Liquid when possible; if users need customization, offer a restricted subset rather than open template editing.
+- Run each render in a **worker thread or child process** with a wall-clock timeout; **kill** the worker on expiry. Libraries such as [paralleljs][paralleljs] can help for heavy single-template work.
+- Enforce **container/Kubernetes cgroup limits**, `ulimit`, or equivalent on the renderer process for memory and CPU.
+- Apply **request rate limits** at the API or gateway layer.
+- **`node:vm`, `isolated-vm`, and Jinja/Twig-style sandbox modes are not a security boundary**—template logic runs in the same JS runtime as your app, with your privileges.

 [paralleljs]: https://www.npmjs.com/package/paralleljs
 [parseLimit]: /api/interfaces/LiquidOptions.html#parseLimit
-[renderLimit]: /api/interfaces/LiquidOptions.html#renderLimit
-[memoryLimit]: /api/interfaces/LiquidOptions.html#memoryLimit
+[templateLimit]: /api/interfaces/LiquidOptions.html#templateLimit
+[outputLengthLimit]: /api/interfaces/LiquidOptions.html#outputLengthLimit
+[maxDepth]: /api/interfaces/LiquidOptions.html#maxDepth
 [ownPropertyOnly]: /api/interfaces/LiquidOptions.html#ownPropertyOnly
 [renderOwnPropertyOnly]: /api/interfaces/RenderOptions.html#ownPropertyOnly
 [strictVariables]: /api/interfaces/LiquidOptions.html#strictVariables
@@ -53,44 +53,39 @@ Pre-built UMD bundles are also available:

 ## LiquidJS in CLI

-LiquidJS can also be used to render a template directly from CLI using `npx`:
+LiquidJS can also be used to render a template directly from CLI using `npx`. Pass the template as a positional argument:

 ```bash
-npx liquidjs --template '{{"hello" | capitalize}}'
+npx liquidjs '{{"hello" | capitalize}}'
 ```

-You can either pass the template inline (as shown above) or you can read it from a file by using the `@` character followed by a path, like so:
+You can either pass the template inline (as shown above), read it from a file with `@` followed by a path, or from `stdin` with `@-`:

 ```bash
-npx liquidjs --template @./some-template.liquid
+npx liquidjs @./some-template.liquid
+echo '{{"hello" | capitalize}}' | npx liquidjs @-
 ```

-You can also use the `@-` syntax to read the template from `stdin`:
+A context can be passed the same ways (inline, from a path, or via `@-` for `stdin`). The following three are equivalent:

 ```bash
-echo '{{"hello" | capitalize}}' | npx liquidjs --template @-
+npx liquidjs 'Hello, {{ name }}!' --context '{"name": "Snake"}'
+npx liquidjs 'Hello, {{ name }}!' --context @./some-context.json
+echo '{"name": "Snake"}' | npx liquidjs 'Hello, {{ name }}!' --context @-
 ```

-A context can be passed in the same ways (i.e. inline, from a path or piped through `stdin`). The following three are equivalent:
-
-```bash
-npx liquidjs --template 'Hello, {{ name }}!' --context '{"name": "Snake"}'
-npx liquidjs --template 'Hello, {{ name }}!' --context @./some-context.json
-echo '{"name": "Snake"}' | npx liquidjs --template 'Hello, {{ name }}!' --context @-
-```
-
-Note that you can only use the `stdin` specifier `@-` for a single argument. If you try to use it for both `--template` and `--context` you will get an error.
+Note that you can only use the `stdin` specifier `@-` for a single argument. If you try to use it for both the template and `--context` you will get an error.

 The rendered output is written to `stdout` by default, but you can also specify an output file (if the file exists, it will be overwritten):

 ```bash
-npx liquidjs --template '{{"hello" | capitalize}}' --output ./hello.txt
+npx liquidjs '{{"hello" | capitalize}}' --output ./hello.txt
 ```

 You can also pass a number of options to customize template rendering behavior. For example, the `--js-truthy` option can be used to enable JavaScript truthiness:

 ```bash
-npx liquidjs --template @./some-template.liquid --js-truthy
+npx liquidjs @./some-template.liquid --js-truthy
 ```

 Most of the [options available through the JavaScript API][options] are also available from the CLI. For help on available options, use `npx liquidjs --help`.
@@ -42,8 +42,7 @@
  if (!/\/playground(?:\.html)?$/.test(location.pathname)) return;
  updateVersion(liquidjs.version);
  const engine = new liquidjs.Liquid({
-    memoryLimit: 1e5,
-    renderLimit: 1e5
+    templateLimit: 1e5
  });
  const colorScheme = window.matchMedia('(prefers-color-scheme: dark)');
  const editor = createEditor('editorEl', 'liquid');
@@ -1,12 +1,12 @@
 {
  "name": "liquidjs",
-  "version": "10.29.0",
+  "version": "10.27.1",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "liquidjs",
-      "version": "10.29.0",
+      "version": "10.27.1",
      "license": "MIT",
      "dependencies": {
        "commander": "^10.0.0"
@@ -64,7 +64,7 @@
        "typescript": "^4.5.3"
      },
      "engines": {
-        "node": ">=16"
+        "node": ">=20"
      },
      "funding": {
        "type": "opencollective",
@@ -1,6 +1,6 @@
 {
  "name": "liquidjs",
-  "version": "10.29.0",
+  "version": "10.27.1",
  "sideEffects": false,
  "description": "A simple, expressive, extensible Liquid template engine for JavaScript — Shopify, Jekyll and GitHub Pages compatible, for Node.js, browsers, and the CLI, with TypeScript support.",
  "main": "dist/liquid.node.js",
@@ -12,7 +12,7 @@
  },
  "types": "dist/index.d.ts",
  "engines": {
-    "node": ">=16"
+    "node": ">=20"
  },
  "scripts": {
    "lint": "eslint \"**/*.mjs\" \"**/*.ts\" .",
@@ -35,7 +35,7 @@
    "build:contributors": "node bin/build-contributors.js",
    "build:apidoc": "shx rm -rf docs/source/api && typedoc --plugin typedoc-plugin-missing-exports ./src --gitRevision master --out docs/source/api",
    "build:changelog": "node bin/build-changelog.js",
-    "build:docs-hexo": "cd docs && npm ci && npm run build && shx cp CNAME .nojekyll public/",
+    "build:docs-hexo": "cd docs && npm ci && npm run build && shx cp CNAME public/",
    "serve:docs": "cd docs && npm run start",
    "dev:docs": "run-s prepare:docs serve:docs"
  },
@@ -121,45 +121,6 @@
  "dependencies": {
    "commander": "^10.0.0"
  },
-  "release": {
-    "branch": "master",
-    "plugins": [
-      "@semantic-release/commit-analyzer",
-      "@semantic-release/release-notes-generator",
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      [
-        "@semantic-release/git",
-        {
-          "assets": [
-            "package.json",
-            "package-lock.json",
-            "CHANGELOG.md"
-          ],
-          "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-        }
-      ],
-      [
-        "@semantic-release/github",
-        {
-          "assets": [
-            {
-              "path": "dist/*.umd.js",
-              "label": "liquid.js"
-            },
-            {
-              "path": "dist/*.min.js",
-              "label": "liquid.min.js"
-            },
-            {
-              "path": "dist/*.min.js.map",
-              "label": "liquid.min.js.map"
-            }
-          ]
-        }
-      ]
-    ]
-  },
  "publishConfig": {
    "provenance": true
  },
@@ -23,8 +23,7 @@ const tsconfig = (target) => ({
    compilerOptions: {
      target,
      module: 'ES2015',
-      rootDir: 'src',
-      downlevelIteration: true
+      rootDir: 'src'
    }
  }
 })
@@ -89,7 +88,7 @@ const nodeEsm = {
  plugins: [
    versionInjection,
    replace(esmRequire),
-    typescript(tsconfig('es6'))
+    typescript(tsconfig('ES2020'))
  ],
  treeshake,
  input
@@ -108,7 +107,7 @@ const browserEsm = {
    replace(browserBase64),
    replace(browserCrypto),
    replace(browserStream),
-    typescript(tsconfig('es6'))
+    typescript(tsconfig('ES2020'))
  ],
  treeshake,
  input
@@ -128,7 +127,7 @@ const browserUmd = {
    replace(browserBase64),
    replace(browserCrypto),
    replace(browserStream),
-    typescript(tsconfig('es5'))
+    typescript(tsconfig('ES2020'))
  ],
  treeshake,
  input
@@ -148,7 +147,7 @@ const browserMin = {
    replace(browserBase64),
    replace(browserCrypto),
    replace(browserStream),
-    typescript(tsconfig('es5')),
+    typescript(tsconfig('ES2020')),
    uglify()
  ],
  treeshake,
@@ -2,11 +2,6 @@ import * as base64 from './base64-impl-browser'
 import { JSDOM } from 'jsdom'

 describe('base64-impl/browser', function () {
-  if (+(process.version.match(/^v(\d+)/) as RegExpMatchArray)[1] < 8) {
-    console.info('jsdom not supported, skipping base64-impl-browser...')
-    return
-  }
-
  beforeEach(function () {
    const dom = new JSDOM(``, {
      url: 'https://example.com/',
@@ -3,10 +3,6 @@ import * as sinon from 'sinon'
 import { JSDOM } from 'jsdom'

 describe('fs/browser', function () {
-  if (+(process.version.match(/^v(\d+)/) as RegExpMatchArray)[1] < 8) {
-    console.info('jsdom not supported, skipping template-browser...')
-    return
-  }
  beforeEach(function () {
    const dom = new JSDOM(``, {
      url: 'https://example.com/foo/bar/',
@@ -58,6 +58,9 @@ describe('Context', function () {
    it('should return map size as size', async function () {
      expect(ctx.get(['map', 'size'])).toEqual(1)
    })
+    it('should return own size property', async function () {
+      expect(ctx.get(['zoo', 'size'])).toEqual(4)
+    })
    it('should return undefined if not have a size', async function () {
      expect(ctx.get(['one', 'size'])).toBeUndefined()
      expect(ctx.get(['non-exist', 'size'])).toBeUndefined()
@@ -130,6 +133,10 @@ describe('Context', function () {
      ctx = new Context({ foo: Object.create({ bar: 'BAR' }) }, { ownPropertyOnly: false } as any)
      return expect(ctx.getSync(['foo', 'bar'])).toEqual('BAR')
    })
+    it('should read inherited size when ownPropertyOnly=false', function () {
+      ctx = new Context({ foo: Object.create({ size: 99 }) }, { ownPropertyOnly: false } as any)
+      return expect(ctx.getSync(['foo', 'size'])).toEqual(99)
+    })
    it('renderOptions.ownPropertyOnly should override options.ownPropertyOnly', function () {
      ctx = new Context({ foo: Object.create({ bar: 'BAR' }) }, { ownPropertyOnly: false } as any, { ownPropertyOnly: true })
      return expect(ctx.getSync(['foo', 'bar'])).toEqual(undefined)
@@ -198,6 +205,36 @@ describe('Context', function () {
        delete (Array.prototype as any)[0]
      }
    })
+    it('should allow own blocked keys when ownPropertyOnly=false', function () {
+      ctx = new Context({
+        foo: {
+          ...JSON.parse('{"__proto__": {"bar": "BAR"}}'),
+          constructor: { name: 'Custom' },
+          prototype: { x: 1 }
+        }
+      }, { ownPropertyOnly: false } as any)
+      expect(ctx.getSync(['foo', '__proto__', 'bar'])).toEqual('BAR')
+      expect(ctx.getSync(['foo', 'constructor', 'name'])).toEqual('Custom')
+      expect(ctx.getSync(['foo', 'prototype', 'x'])).toEqual(1)
+    })
+    it('should allow inherited properties when ownPropertyOnly=false', function () {
+      ctx = new Context({ foo: Object.create({ __proto__: { bar: 'BAR' }, constructor: { name: 'Evil' } }) }, { ownPropertyOnly: false } as any)
+      expect(ctx.getSync(['foo', '__proto__', '__proto__', 'bar'])).toEqual('BAR')
+      expect(ctx.getSync(['foo', 'constructor', 'name'])).toEqual('Evil')
+    })
+    it('should block own constructor when ownPropertyOnly=true', function () {
+      ctx.push({ foo: { constructor: { name: 'Evil' } } })
+      expect(ctx.getSync(['foo', 'constructor'])).toEqual(undefined)
+    })
+    it('should block own prototype when ownPropertyOnly=true', function () {
+      ctx.push({ foo: { prototype: { bar: 'BAR' } } })
+      expect(ctx.getSync(['foo', 'prototype'])).toEqual(undefined)
+    })
+    it('should block own top-level __proto__ variable when ownPropertyOnly=true', function () {
+      ctx = new Context(JSON.parse('{"__proto__": {"bar": "BAR"}, "bar": "BAR"}'))
+      expect(ctx.getSync(['__proto__'])).toEqual(undefined)
+      expect(ctx.getSync(['bar'])).toEqual('BAR')
+    })
  })

  describe('.getAll()', function () {
@@ -221,6 +258,11 @@ describe('Context', function () {
      expect(ctx.getSync(['bar', 'foo'])).toEqual('foo')
      expect(ctx.getSync(['bar', 'bar'])).toEqual(undefined)
    })
+    it('should return pushed scope for in-place mutation', function () {
+      const scope = ctx.push({})
+      scope.item = 'ITEM'
+      expect(ctx.getSync(['item'])).toEqual('ITEM')
+    })
  })
  describe('.pop()', function () {
    it('should pop scope', async function () {
@@ -1,4 +1,3 @@
-import { getPerformance } from '../util/performance'
 import { Drop } from '../drop/drop'
 import { __assign } from 'tslib'
 import { NormalizedFullOptions, defaultOptions, RenderOptions } from '../liquid-options'
@@ -7,6 +6,8 @@ import { hasOwnProperty, isArray, isNil, isUndefined, isString, isFunction, isNu

 type PropertyKey = string | number;

+const BLOCKED_SCOPE_KEYS: ReadonlySet<PropertyKey> = new Set(['__proto__', 'constructor', 'prototype'])
+
 export class Context {
  /**
   * insert a Context-level empty scope,
@@ -31,27 +32,24 @@ export class Context {
   * The normalized liquid options object
   */
  public opts: NormalizedFullOptions
-  /**
-   * Reference to the Liquid instance for filter resolution
-   */
-  public liquid?: any
  /**
   * Throw when accessing undefined variable?
   */
  public strictVariables: boolean;
  public ownPropertyOnly: boolean;
-  public memoryLimit: Limiter;
-  public renderLimit: Limiter;
-  public constructor (env: object = {}, opts: NormalizedFullOptions = defaultOptions, renderOptions: RenderOptions = {}, { memoryLimit, renderLimit, liquid }: { memoryLimit?: Limiter, renderLimit?: Limiter, liquid?: any } = {}) {
+  public templateLimit: Limiter;
+  public outputLengthLimit: Limiter;
+  public depthLimit: Limiter;
+  public constructor (env: object = {}, opts: NormalizedFullOptions = defaultOptions, renderOptions: RenderOptions = {}, { templateLimit, outputLengthLimit, depthLimit }: { templateLimit?: Limiter, outputLengthLimit?: Limiter, depthLimit?: Limiter } = {}) {
    this.sync = !!renderOptions.sync
    this.opts = opts
    this.globals = renderOptions.globals ?? opts.globals
    this.environments = isObject(env) ? env : Object(env)
    this.strictVariables = renderOptions.strictVariables ?? this.opts.strictVariables
    this.ownPropertyOnly = renderOptions.ownPropertyOnly ?? opts.ownPropertyOnly
-    this.memoryLimit = memoryLimit ?? new Limiter('memory alloc', renderOptions.memoryLimit ?? opts.memoryLimit)
-    this.renderLimit = renderLimit ?? new Limiter('template render', getPerformance().now() + (renderOptions.renderLimit ?? opts.renderLimit))
-    this.liquid = liquid
+    this.templateLimit = templateLimit ?? new Limiter('template', renderOptions.templateLimit ?? opts.templateLimit)
+    this.outputLengthLimit = outputLengthLimit ?? new Limiter('output length', renderOptions.outputLengthLimit ?? opts.outputLengthLimit)
+    this.depthLimit = depthLimit ?? new Limiter('template depth', opts.maxDepth)
  }
  public getRegister<T> (key: string, defaultValue: T = undefined as T): T {
    return (this.registers[key] = this.registers[key] || defaultValue)
@@ -98,8 +96,10 @@ export class Context {
    }
    return scope
  }
-  public push (ctx: object) {
-    return this.scopes.push(ctx)
+  public push (ctx: Scope): Scope {
+    const scope = createScope(ctx)
+    this.scopes.push(scope)
+    return scope
  }
  public pop () {
    return this.scopes.pop()
@@ -114,17 +114,17 @@ export class Context {
      strictVariables: this.strictVariables,
      ownPropertyOnly: this.ownPropertyOnly
    }, {
-      renderLimit: this.renderLimit,
-      memoryLimit: this.memoryLimit,
-      liquid: this.liquid
+      templateLimit: this.templateLimit,
+      outputLengthLimit: this.outputLengthLimit,
+      depthLimit: this.depthLimit
    })
  }
  private findScope (key: string | number) {
    for (let i = this.scopes.length - 1; i >= 0; i--) {
      const candidate = this.scopes[i]
-      if (key in candidate) return candidate
+      if (this.ownPropertyOnly ? hasOwnProperty.call(candidate, key) : key in candidate) return candidate
    }
-    if (key in this.environments) return this.environments
+    if (this.ownPropertyOnly ? hasOwnProperty.call(this.environments, key) : key in this.environments) return this.environments
    return this.globals
  }
  readProperty (obj: Scope, key: (PropertyKey | Drop)) {
@@ -135,30 +135,30 @@ export class Context {
    const value = readJSProperty(obj, key, this.ownPropertyOnly)
    if (value === undefined && obj instanceof Drop) return obj.liquidMethodMissing(key, this)
    if (isFunction(value)) return value.call(obj)
-    if (key === 'size') return readSize(obj)
-    else if (key === 'first') return readFirst(obj, this.ownPropertyOnly)
-    else if (key === 'last') return readLast(obj, this.ownPropertyOnly)
+    if (key === 'size') return this.readSize(obj)
+    else if (key === 'first') return this.readFirst(obj)
+    else if (key === 'last') return this.readLast(obj)
    return value
  }
+  private readFirst (obj: Scope) {
+    if (isArray(obj)) return readArrayElement(obj, 0, this.ownPropertyOnly)
+    return readJSProperty(obj, 'first', this.ownPropertyOnly)
+  }
+  private readLast (obj: Scope) {
+    if (isArray(obj)) return readArrayElement(obj, -1, this.ownPropertyOnly)
+    return readJSProperty(obj, 'last', this.ownPropertyOnly)
+  }
+  private readSize (obj: Scope) {
+    if (hasOwnProperty.call(obj, 'size')) return obj['size']
+    if (!this.ownPropertyOnly && obj['size'] !== undefined) return obj['size']
+    if (isArray(obj) || isString(obj)) return obj.length
+    if (obj instanceof Map || obj instanceof Set) return obj.size
+    if (typeof obj === 'object') return Object.keys(obj).length
+  }
 }

 export function readJSProperty (obj: Scope, key: PropertyKey, ownPropertyOnly: boolean) {
+  if (BLOCKED_SCOPE_KEYS.has(key) && ownPropertyOnly) return undefined
  if (ownPropertyOnly && !hasOwnProperty.call(obj, key) && !(obj instanceof Drop)) return undefined
  return obj[key]
 }
-
-function readFirst (obj: Scope, ownPropertyOnly: boolean) {
-  if (isArray(obj)) return readArrayElement(obj, 0, ownPropertyOnly)
-  return readJSProperty(obj, 'first', ownPropertyOnly)
-}
-
-function readLast (obj: Scope, ownPropertyOnly: boolean) {
-  if (isArray(obj)) return readArrayElement(obj, -1, ownPropertyOnly)
-  return readJSProperty(obj, 'last', ownPropertyOnly)
-}
-
-function readSize (obj: Scope) {
-  if (hasOwnProperty.call(obj, 'size') || obj['size'] !== undefined) return obj['size']
-  if (isArray(obj) || isString(obj)) return obj.length
-  if (typeof obj === 'object') return Object.keys(obj).length
-}
@@ -6,8 +6,7 @@ export interface ScopeObject extends Record<string | number | symbol, any> {

 export type Scope = ScopeObject | Drop

-export function createScope (from?: ScopeObject): ScopeObject {
-  const scope = Object.create(null)
-  if (from) Object.assign(scope, from)
-  return scope
+export function createScope (from?: Scope): Scope {
+  if (from instanceof Drop) return from
+  return Object.assign(Object.create(null), from)
 }
@@ -1,4 +1,3 @@
 export * from './emitter'
 export * from './simple-emitter'
 export * from './streamed-emitter'
-export * from './keeping-type-emitter'
@@ -1,19 +0,0 @@
-import { stringify, toValue } from '../util'
-import { Emitter } from './emitter'
-
-export class KeepingTypeEmitter implements Emitter {
-  public buffer: any = '';
-
-  public write (html: any) {
-    html = toValue(html)
-    // This will only preserve the type if the value is isolated.
-    // I.E:
-    // {{ my-port }} -> 42
-    // {{ my-host }}:{{ my-port }} -> 'host:42'
-    if (typeof html !== 'string' && this.buffer === '') {
-      this.buffer = html
-    } else {
-      this.buffer = stringify(this.buffer) + stringify(html)
-    }
-  }
-}
@@ -1,10 +1,17 @@
-import { stringify } from '../util'
+import { stringify, Limiter } from '../util'
 import { Emitter } from './emitter'

 export class SimpleEmitter implements Emitter {
  public buffer = '';
+  private outputLengthLimit?: Limiter
+
+  constructor (outputLengthLimit?: Limiter) {
+    this.outputLengthLimit = outputLengthLimit
+  }

  public write (html: any) {
-    this.buffer += stringify(html)
+    const str = stringify(html)
+    this.outputLengthLimit?.use(str.length)
+    this.buffer += str
  }
 }
@@ -1,12 +1,20 @@
-import { stringify } from '../util'
+import { stringify, Limiter } from '../util'
 import { Emitter } from './emitter'
 import { PassThrough } from 'stream'

 export class StreamedEmitter implements Emitter {
  public buffer = '';
  public stream: NodeJS.ReadWriteStream = new PassThrough()
+  private outputLengthLimit?: Limiter
+
+  constructor (outputLengthLimit?: Limiter) {
+    this.outputLengthLimit = outputLengthLimit
+  }
+
  public write (html: any) {
-    this.stream.write(stringify(html))
+    const str = stringify(html)
+    this.outputLengthLimit?.use(str.length)
+    this.stream.write(str)
  }
  public error (err: Error) {
    this.stream.emit('error', err)
@@ -8,9 +8,6 @@ import { EmptyDrop } from '../drop'
 export const join = argumentsToValue(function (this: FilterImpl, v: any[], arg: string) {
  const array = toArray(v)
  const sep = isNil(arg) ? ' ' : stringify(arg)
-  let outputSize = sep.length * Math.max(array.length - 1, 0)
-  for (let i = 0; i < array.length; i++) outputSize += String(array[i]).length
-  this.context.memoryLimit.use(outputSize)
  return Array.prototype.join.call(array, sep)
 })
 export const last = argumentsToValue(function (this: FilterImpl, v: any) {
@@ -21,14 +18,12 @@ export const first = argumentsToValue(function (this: FilterImpl, v: any) {
 })
 export const reverse = argumentsToValue(function (this: FilterImpl, v: any[]) {
  const array = toArray(v)
-  this.context.memoryLimit.use(array.length)
  return [...array].reverse()
 })

 function * sortBy<T> (this: FilterImpl, arr: T[], property: string | undefined, comparator: (a: unknown, b: unknown) => number): IterableIterator<unknown> {
  const values: [T, unknown][] = []
  const array = toArray(arr)
-  this.context.memoryLimit.use(array.length)
  for (const item of array) {
    values.push([
      item,
@@ -46,12 +41,11 @@ export function * sort_natural<T> (this: FilterImpl, arr: T[], property?: string
  return yield * sortBy.call(this, arr, property, caseInsensitiveCompare)
 }

-export const size = (v: string | any[]) => (v && v.length) || 0
+export const size = (v: string | any[]) => v?.length || 0

 export function * map (this: FilterImpl, arr: Scope[], property: string): IterableIterator<unknown> {
  const results = []
  const array = toArray(arr)
-  this.context.memoryLimit.use(array.length)
  for (const item of array) {
    results.push(yield this.context._getFromScope(item, stringify(property), false))
  }
@@ -70,14 +64,12 @@ export function * sum (this: FilterImpl, arr: Scope[], property?: string): Itera

 export function compact<T> (this: FilterImpl, arr: T[]) {
  const array = toArray(arr)
-  this.context.memoryLimit.use(array.length)
  return Array.prototype.filter.call(array, x => !isNil(toValue(x)))
 }

 export function concat<T1, T2> (this: FilterImpl, v: T1[], arg: T2[] = []): (T1 | T2)[] {
  const lhs = toArray(v)
  const rhs = toArray(arg)
-  this.context.memoryLimit.use(lhs.length + rhs.length)
  return Array.prototype.concat.call(lhs, rhs)
 }

@@ -87,7 +79,6 @@ export function push<T> (this: FilterImpl, v: T[], arg: T): T[] {

 export function unshift<T> (this: FilterImpl, v: T[], arg: T): T[] {
  const array = toArray(v)
-  this.context.memoryLimit.use(array.length)
  const clone = [...array]
  clone.unshift(arg)
  return clone
@@ -95,7 +86,6 @@ export function unshift<T> (this: FilterImpl, v: T[], arg: T): T[] {

 export function pop<T> (this: FilterImpl, v: T[]): T[] {
  const array = toArray(v)
-  this.context.memoryLimit.use(array.length)
  const clone = [...array]
  clone.pop()
  return clone
@@ -103,7 +93,6 @@ export function pop<T> (this: FilterImpl, v: T[]): T[] {

 export function shift<T> (this: FilterImpl, v: T[]): T[] {
  const array = toArray(v)
-  this.context.memoryLimit.use(array.length)
  const clone = [...array]
  clone.shift()
  return clone
@@ -114,8 +103,6 @@ export function slice<T> (this: FilterImpl, v: T[] | string, begin: number, leng
  if (isNil(v)) return []
  if (!isArray(v)) v = stringify(v)
  begin = begin < 0 ? v.length + begin : begin
-  if (begin < 0 || length < 0) return isArray(v) ? [] : ''
-  this.context.memoryLimit.use(length)
  return isArray(v)
    ? Array.prototype.slice.call(v, begin, begin + length)
    : String.prototype.slice.call(v, begin, begin + length)
@@ -134,7 +121,6 @@ function expectedMatcher (this: FilterImpl, expected: any): (v: any) => boolean
 function * filter<T extends object> (this: FilterImpl, include: boolean, arr: T[], property: string, expected: any): IterableIterator<unknown> {
  const values: unknown[] = []
  arr = toArray(arr)
-  this.context.memoryLimit.use(arr.length)
  const token = new Tokenizer(stringify(property)).readScopeValue()
  for (const item of arr) {
    values.push(yield evalToken(token, this.context.spawn(item)))
@@ -147,7 +133,6 @@ function * filter_exp<T extends object> (this: FilterImpl, include: boolean, arr
  const filtered: unknown[] = []
  const keyTemplate = new Value(stringify(exp), this.liquid)
  const array = toArray(arr)
-  this.context.memoryLimit.use(array.length)
  for (const item of array) {
    this.context.push({ [itemName]: item })
    const value = yield keyTemplate.value(this.context)
@@ -177,7 +162,6 @@ export function * group_by<T extends object> (this: FilterImpl, arr: T[], proper
  const map = new Map()
  arr = toEnumerable(arr)
  const token = new Tokenizer(stringify(property)).readScopeValue()
-  this.context.memoryLimit.use(arr.length)
  for (const item of arr) {
    const key = yield evalToken(token, this.context.spawn(item))
    if (!map.has(key)) map.set(key, [])
@@ -190,7 +174,6 @@ export function * group_by_exp<T extends object> (this: FilterImpl, arr: T[], it
  const map = new Map()
  const keyTemplate = new Value(stringify(exp), this.liquid)
  arr = toEnumerable(arr)
-  this.context.memoryLimit.use(arr.length)
  for (const item of arr) {
    this.context.push({ [itemName]: item })
    const key = yield keyTemplate.value(this.context)
@@ -254,7 +237,6 @@ export function * find_exp<T extends object> (this: FilterImpl, arr: T[], itemNa

 export function uniq<T> (this: FilterImpl, arr: T[]): T[] {
  arr = toArray(arr)
-  this.context.memoryLimit.use(arr.length)
  return [...new Set(arr)]
 }

@@ -262,7 +244,6 @@ export function sample<T> (this: FilterImpl, v: T[] | string, count = 1): T | st
  v = toValue(v)
  if (isNil(v)) return []
  if (!isArray(v)) v = stringify(v)
-  this.context.memoryLimit.use(v.length)
  const shuffled = [...v].sort(() => Math.random() - 0.5)
  if (count === 1) return shuffled[0]
  return shuffled.slice(0, count)
@@ -10,16 +10,13 @@ import { base64Encode, base64Decode } from './base64-impl'

 export function base64_encode (this: FilterImpl, value: string | Buffer): string {
  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
-    this.context.memoryLimit.use(value.byteLength)
    return value.toString('base64')
  }
  const str = stringify(value)
-  this.context.memoryLimit.use(str.length)
  return base64Encode(str)
 }

 export function base64_decode (this: FilterImpl, value: string): string {
  const str = stringify(value)
-  this.context.memoryLimit.use(str.length)
  return base64Decode(str)
 }
@@ -10,13 +10,11 @@ import { sha256 as sha256Impl, hmacSha256 as hmacSha256Impl } from './crypto-imp

 export function sha256 (this: FilterImpl, value: unknown): string | Promise<string> {
  const str = stringify(value)
-  this.context.memoryLimit.use(str.length)
  return sha256Impl(str)
 }

 export function hmac_sha256 (this: FilterImpl, value: unknown, key: unknown): string | Promise<string> {
  const str = stringify(value)
  const keyStr = stringify(key)
-  this.context.memoryLimit.use(str.length + keyStr.length)
  return hmacSha256Impl(str, keyStr)
 }
@@ -3,14 +3,11 @@ import { FilterImpl } from '../template'
 import { NormalizedFullOptions } from '../liquid-options'

 export function date (this: FilterImpl, v: string | Date, format?: string, timezoneOffset?: number | string) {
-  const size = ((v as string)?.length ?? 0) + ((timezoneOffset as string)?.length ?? 0)
-  this.context.memoryLimit.use(size)
  const date = parseDate(v, this.context.opts, timezoneOffset)
  if (!date) return v
  format = toValue(format)
  format = isNil(format) ? this.context.opts.dateFormat : stringify(format)
-  this.context.memoryLimit.use(format.length)
-  return strftime(date, format, this.context.memoryLimit)
+  return strftime(date, format)
 }

 export function date_to_xmlschema (this: FilterImpl, v: string | Date) {
@@ -32,14 +29,13 @@ export function date_to_long_string (this: FilterImpl, v: string | Date, type?:
 function stringify_date (this: FilterImpl, v: string | Date, month_type: string, type?: string, style?: string) {
  const date = parseDate(v, this.context.opts)
  if (!date) return v
-  const ml = this.context.memoryLimit
  if (type === 'ordinal') {
    const d = date.getDate()
    return style === 'US'
-      ? strftime(date, `${month_type} ${d}%q, %Y`, ml)
-      : strftime(date, `${d}%q ${month_type} %Y`, ml)
+      ? strftime(date, `${month_type} ${d}%q, %Y`)
+      : strftime(date, `${d}%q ${month_type} %Y`)
  }
-  return strftime(date, `%d ${month_type} %Y`, ml)
+  return strftime(date, `%d ${month_type} %Y`)
 }

 function parseDate (v: string | Date, opts: NormalizedFullOptions, timezoneOffset?: number | string): LiquidDate | undefined {
@@ -18,7 +18,6 @@ const unescapeMap: Record<string, string> = {

 export function escape (this: FilterImpl, str: string) {
  str = stringify(str)
-  this.context.memoryLimit.use(str.length)
  return str.replace(/&|<|>|"|'/g, m => escapeMap[m])
 }

@@ -28,7 +27,6 @@ export function xml_escape (this: FilterImpl, str: string) {

 function unescape (this: FilterImpl, str: string) {
  str = stringify(str)
-  this.context.memoryLimit.use(str.length)
  return str.replace(/&(amp|lt|gt|#34|#39);/g, m => unescapeMap[m])
 }

@@ -38,7 +36,6 @@ export function escape_once (this: FilterImpl, str: string) {

 export function newline_to_br (this: FilterImpl, v: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  return str.replace(/\r?\n/gm, '<br />\n')
 }

@@ -46,7 +43,6 @@ export function newline_to_br (this: FilterImpl, v: string) {
 // equivalent is O(n^2) in V8 on unclosed openers.
 export function strip_html (this: FilterImpl, v: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  const blocks = new Map([['<script', '</script>'], ['<style', '</style>'], ['<!--', '-->'], ['<', '>']])
  let out = ''
  let i = 0
@@ -2,18 +2,6 @@ import { isFalsy } from '../render/boolean'
 import { identify, isArray, isString, toValue } from '../util/underscore'
 import { FilterImpl } from '../template'

-function chargeJsonReplacerValue (memoryLimit: { use(count: number): void }, val: unknown) {
-  if (typeof val === 'string') {
-    memoryLimit.use(val.length)
-  } else if (val === null || typeof val === 'number' || typeof val === 'boolean') {
-    memoryLimit.use(JSON.stringify(val).length)
-  } else if (Array.isArray(val)) {
-    memoryLimit.use(val.length + 1)
-  } else if (typeof val === 'object') {
-    memoryLimit.use(2)
-  }
-}
-
 function defaultFilter<T1 extends boolean, T2> (this: FilterImpl, value: T1, defaultValue: T2, ...args: Array<[string, any]>): T1 | T2 {
  value = toValue(value)
  if (isArray(value) || isString(value)) return value.length ? value : defaultValue
@@ -22,29 +10,21 @@ function defaultFilter<T1 extends boolean, T2> (this: FilterImpl, value: T1, def
 }

 function json (this: FilterImpl, value: any, space = 0) {
-  const memoryLimit = this.context.memoryLimit
-  return JSON.stringify(value, (_key, val) => {
-    chargeJsonReplacerValue(memoryLimit, val)
-    return val
-  }, space)
+  return JSON.stringify(value, undefined, space)
 }

 function inspect (this: FilterImpl, value: any, space = 0) {
-  const memoryLimit = this.context.memoryLimit
  const ancestors: object[] = []
  return JSON.stringify(value, function (this: unknown, _key: unknown, value: any) {
    if (typeof value !== 'object' || value === null) {
-      chargeJsonReplacerValue(memoryLimit, value)
      return value
    }
    // `this` is the object that value is contained in, i.e., its direct parent.
    while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) ancestors.pop()
    if (ancestors.includes(value)) {
-      memoryLimit.use('[Circular]'.length)
      return '[Circular]'
    }
    ancestors.push(value)
-    chargeJsonReplacerValue(memoryLimit, value)
    return value
  }, space)
 }
@@ -22,7 +22,6 @@ export function append (this: FilterImpl, v: string, arg: string) {
  assert(arguments.length === 2, 'append expect 2 arguments')
  const lhs = stringify(v)
  const rhs = stringify(arg)
-  this.context.memoryLimit.use(lhs.length + rhs.length)
  return lhs + rhs
 }

@@ -30,16 +29,13 @@ export function prepend (this: FilterImpl, v: string, arg: string) {
  assert(arguments.length === 2, 'prepend expect 2 arguments')
  const lhs = stringify(v)
  const rhs = stringify(arg)
-  this.context.memoryLimit.use(lhs.length + rhs.length)
  return rhs + lhs
 }

 export function lstrip (this: FilterImpl, v: string, chars?: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  if (chars) {
    chars = stringify(chars)
-    this.context.memoryLimit.use(chars.length)
    for (let i = 0, set = new Set(chars); i < str.length; i++) {
      if (!set.has(str[i])) return str.slice(i)
    }
@@ -50,34 +46,29 @@ export function lstrip (this: FilterImpl, v: string, chars?: string) {

 export function downcase (this: FilterImpl, v: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  return str.toLowerCase()
 }

 export function upcase (this: FilterImpl, v: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  return stringify(str).toUpperCase()
 }

 export function remove (this: FilterImpl, v: string, arg: string) {
  const str = stringify(v)
  arg = stringify(arg)
-  this.context.memoryLimit.use(str.length + arg.length)
  return str.split(arg).join('')
 }

 export function remove_first (this: FilterImpl, v: string, l: string) {
  const str = stringify(v)
  l = stringify(l)
-  this.context.memoryLimit.use(str.length + l.length)
  return str.replace(l, '')
 }

 export function remove_last (this: FilterImpl, v: string, l: string) {
  const str = stringify(v)
  const pattern = stringify(l)
-  this.context.memoryLimit.use(str.length + pattern.length)
  const index = str.lastIndexOf(pattern)
  if (index === -1) return str
  return str.substring(0, index) + str.substring(index + pattern.length)
@@ -85,10 +76,8 @@ export function remove_last (this: FilterImpl, v: string, l: string) {

 export function rstrip (this: FilterImpl, str: string, chars?: string) {
  str = stringify(str)
-  this.context.memoryLimit.use(str.length)
  if (chars) {
    chars = stringify(chars)
-    this.context.memoryLimit.use(chars.length)
    for (let i = str.length - 1, set = new Set(chars); i >= 0; i--) {
      if (!set.has(str[i])) return str.slice(0, i + 1)
    }
@@ -99,7 +88,6 @@ export function rstrip (this: FilterImpl, str: string, chars?: string) {

 export function split (this: FilterImpl, v: string, arg: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  const arr = str.split(stringify(arg))
  // align to ruby split, which is the behavior of shopify/liquid
  // see: https://ruby-doc.org/core-2.4.0/String.html#method-i-split
@@ -109,10 +97,8 @@ export function split (this: FilterImpl, v: string, arg: string) {

 export function strip (this: FilterImpl, v: string, chars?: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  if (chars) {
    const set = new Set(stringify(chars))
-    this.context.memoryLimit.use(set.size)
    let i = 0
    let j = str.length - 1
    while (set.has(str[i])) i++
@@ -124,19 +110,11 @@ export function strip (this: FilterImpl, v: string, chars?: string) {

 export function strip_newlines (this: FilterImpl, v: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  return str.replace(/\r?\n/gm, '')
 }

-export function squish (this: FilterImpl, v: string) {
-  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
-  return str.replace(/\s+/g, ' ').trim()
-}
-
 export function capitalize (this: FilterImpl, str: string) {
  str = stringify(str)
-  this.context.memoryLimit.use(str.length)
  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase()
 }

@@ -145,8 +123,6 @@ export function replace (this: FilterImpl, v: string, pattern: string, replaceme
  pattern = stringify(pattern)
  replacement = stringify(replacement)
  const parts = str.split(pattern)
-  const outputSize = str.length + (parts.length - 1) * (replacement.length - pattern.length)
-  this.context.memoryLimit.use(outputSize)
  return parts.join(replacement)
 }

@@ -154,7 +130,6 @@ export function replace_first (this: FilterImpl, v: string, arg1: string, arg2:
  const str = stringify(v)
  arg1 = stringify(arg1)
  arg2 = stringify(arg2)
-  this.context.memoryLimit.use(str.length + arg1.length + arg2.length)
  return str.replace(arg1, () => arg2)
 }

@@ -162,7 +137,6 @@ export function replace_last (this: FilterImpl, v: string, arg1: string, arg2: s
  const str = stringify(v)
  const pattern = stringify(arg1)
  const replacement = stringify(arg2)
-  this.context.memoryLimit.use(str.length + pattern.length + replacement.length)
  const index = str.lastIndexOf(pattern)
  if (index === -1) return str
  return str.substring(0, index) + replacement + str.substring(index + pattern.length)
@@ -171,7 +145,6 @@ export function replace_last (this: FilterImpl, v: string, arg1: string, arg2: s
 export function truncate (this: FilterImpl, v: string, l = 50, o = '...') {
  const str = stringify(v)
  o = stringify(o)
-  this.context.memoryLimit.use(str.length + o.length)
  if (str.length <= l) return v
  return str.substring(0, l - o.length) + o
 }
@@ -179,7 +152,6 @@ export function truncate (this: FilterImpl, v: string, l = 50, o = '...') {
 export function truncatewords (this: FilterImpl, v: string, words = 15, o = '...') {
  const str = stringify(v)
  o = stringify(o)
-  this.context.memoryLimit.use(str.length + o.length)
  const arr = str.split(/\s+/)
  if (words <= 0) words = 1
  let ret = arr.slice(0, words).join(' ')
@@ -189,13 +161,11 @@ export function truncatewords (this: FilterImpl, v: string, words = 15, o = '...

 export function normalize_whitespace (this: FilterImpl, v: string) {
  const str = stringify(v)
-  this.context.memoryLimit.use(str.length)
  return str.replace(/\s+/g, ' ')
 }

 export function number_of_words (this: FilterImpl, input: string, mode?: 'cjk' | 'auto') {
  const str = stringify(input)
-  this.context.memoryLimit.use(str.length)
  input = str.trim()
  if (!input) return 0
  switch (mode) {
@@ -215,9 +185,6 @@ export function number_of_words (this: FilterImpl, input: string, mode?: 'cjk' |

 export function array_to_sentence_string (this: FilterImpl, array: unknown[], connector = 'and') {
  connector = stringify(connector)
-  let outputSize = connector.length + array.length * 2
-  for (let i = 0; i < array.length; i++) outputSize += stringify(array[i]).length
-  this.context.memoryLimit.use(outputSize)
  switch (array.length) {
    case 0:
      return ''
@@ -1,6 +1,6 @@
 import { stringify } from '../util/underscore'

-export const url_decode = (x: string) => decodeURIComponent(stringify(x).replace(/\+/g, ' '))
+export const url_decode = (x: string) => decodeURIComponent(stringify(x)).replace(/\+/g, ' ')
 export const url_encode = (x: string) => encodeURIComponent(stringify(x)).replace(/%20/g, '+')
 export const cgi_escape = (x: string) => encodeURIComponent(stringify(x))
  .replace(/%20/g, '+')
@@ -11,7 +11,7 @@ export { Context, Scope } from './context'
 export { Value, Hash, Template, FilterImplOptions, Tag, Filter, Output, Variable, VariableLocation, VariableSegments, Variables, StaticAnalysis, StaticAnalysisOptions, analyze, analyzeSync, Arguments, PartialScope } from './template'
 export type { TagRenderReturn } from './template'
 export { Token, TopLevelToken, TagToken, ValueToken } from './tokens'
-export type { RangeToken, LiteralToken, QuotedToken, PropertyAccessToken, NumberToken, FilteredValueToken } from './tokens'
+export type { RangeToken, LiteralToken, QuotedToken, PropertyAccessToken, NumberToken } from './tokens'
 export { TokenKind, Tokenizer, ParseStream, Parser } from './parser'
 export { filters } from './filters'
 export * from './tags'
@@ -38,10 +38,7 @@ export interface LiquidOptions {
  strictVariables?: boolean;
  /** Catch all errors instead of exit upon one. Please note that render errors won't be reached when parse fails. */
  catchAllErrors?: boolean;
-  /**
-   * Hide scope variables from prototypes, useful when you're passing a not sanitized object into LiquidJS or need to hide prototypes from templates.
-   * This only applies to property/index access on scope objects. Filter transforms and iteration operate on the resolved value with standard JavaScript semantics, so prototype-inherited array indices may still be surfaced by them.
-   */
+  /** Limit template property reads on plain scope objects to own properties. Defaults to `true`. See https://liquidjs.com/tutorials/security-model.html */
  ownPropertyOnly?: boolean;
  /** Modifies the behavior of `strictVariables`. If set, a single undefined variable will *not* cause an exception in the context of the `if`/`elsif`/`unless` tag and the `default` filter. Instead, it will evaluate to `false` and `null`, respectively. Irrelevant if `strictVariables` is not set. Defaults to `false`. **/
  lenientIf?: boolean;
@@ -79,22 +76,20 @@ export interface LiquidOptions {
  templates?: {[key: string]: string};
  /** the global scope passed down to all partial and layout templates, i.e. templates included by `include`, `layout` and `render` tags. */
  globals?: object;
-  /** Whether or not to keep value type when writing the Output, not working for streamed rendering. Defaults to `false`. */
-  keepOutputType?: boolean;
  /** Default escape filter applied to output values, when set, you'll have to add `| raw` for values don't need to be escaped. Defaults to `undefined`. */
  outputEscape?: OutputEscapeOption;
  /** An object of operators for conditional statements. Defaults to the regular Liquid operators. */
  operators?: Operators;
  /** Respect parameter order when using filters like "for ... reversed limit", Defaults to `false`. */
  orderedFilterParameters?: boolean;
-  /** Allow parenthesized expressions as operands in conditions and loops, e.g. `{% if (foo | upcase) == "BAR" %}`. This is a non-standard extension to Liquid. Defaults to `false`. */
-  groupedExpressions?: boolean;
  /** For DoS handling, limit total length of templates parsed in one `parse()` call. A typical PC can handle 1e8 (100M) characters without issues. */
  parseLimit?: number;
-  /** For DoS handling, limit total time (in ms) for each `render()` call. */
-  renderLimit?: number;
-  /** For DoS handling, limit new objects creation, including array concat/join/strftime, etc. A typical PC can handle 1e9 (1G) memory without issue. */
-  memoryLimit?: number;
+  /** For DoS handling, limit total renders of tag/HTML/output in one `render()` call. */
+  templateLimit?: number;
+  /** For DoS handling, limit total output length in one `render()` call. */
+  outputLengthLimit?: number;
+  /** For DoS handling, limit nesting depth of `{% render %}`, `{% include %}`, and `{% layout %}` tags. Defaults to `128`. */
+  maxDepth?: number;
 }

 export interface RenderOptions {
@@ -114,12 +109,10 @@ export interface RenderOptions {
   * Same as `ownPropertyOnly` on LiquidOptions, but only for current render() call
   */
  ownPropertyOnly?: boolean;
-  /** For DoS handling, limit total renders of tag/HTML/output in one `render()` call. A typical PC can handle 1e5 renders of typical templates per second. */
+  /** For DoS handling, limit total renders of tag/HTML/output in one `render()` call. */
  templateLimit?: number;
-  /** For DoS handling, limit total time (in ms) for each `render()` call. */
-  renderLimit?: number;
-  /** For DoS handling, limit new objects creation, including array concat/join/strftime, etc. A typical PC can handle 1e9 (1G) memory without issue.. */
-  memoryLimit?: number;
+  /** For DoS handling, limit total output length in one `render()` call. */
+  outputLengthLimit?: number;
 }

 export interface RenderFileOptions extends RenderOptions {
@@ -162,12 +155,11 @@ export interface NormalizedFullOptions extends NormalizedOptions {
  preserveTimezones: boolean;
  greedy: boolean;
  globals: object;
-  keepOutputType: boolean;
  operators: Operators;
-  groupedExpressions: boolean;
  parseLimit: number;
-  renderLimit: number;
-  memoryLimit: number;
+  templateLimit: number;
+  outputLengthLimit: number;
+  maxDepth: number;
 }

 export const defaultOptions: NormalizedFullOptions = {
@@ -199,20 +191,19 @@ export const defaultOptions: NormalizedFullOptions = {
  ownPropertyOnly: true,
  lenientIf: false,
  globals: {},
-  keepOutputType: false,
  operators: defaultOperators,
-  groupedExpressions: false,
-  memoryLimit: Infinity,
  parseLimit: Infinity,
-  renderLimit: Infinity
+  templateLimit: Infinity,
+  outputLengthLimit: Infinity,
+  maxDepth: 128
 }

 export function normalize (options: LiquidOptions): NormalizedFullOptions {
-  if (options.hasOwnProperty('root')) {
-    if (!options.hasOwnProperty('partials')) options.partials = options.root
-    if (!options.hasOwnProperty('layouts')) options.layouts = options.root
+  if ('root' in options) {
+    if (!('partials' in options)) options.partials = options.root
+    if (!('layouts' in options)) options.layouts = options.root
  }
-  if (options.hasOwnProperty('cache')) {
+  if ('cache' in options) {
    let cache: LiquidCache | undefined
    if (typeof options.cache === 'number') cache = options.cache > 0 ? new LRU(options.cache) : undefined
    else if (typeof options.cache === 'object') cache = options.cache
@@ -1,6 +1,6 @@
 import { Context } from './context'
-import { toPromise, toValueSync, isFunction, forOwn, isString, strictUniq } from './util'
-import { TagClass, createTagClass, TagImplOptions, FilterImplOptions, Template, Value, StaticAnalysisOptions, StaticAnalysis, analyze, analyzeSync, SegmentArray } from './template'
+import { toPromise, toValueSync, forOwn, isString, strictUniq } from './util'
+import { TagClass, FilterImplOptions, Template, Value, StaticAnalysisOptions, StaticAnalysis, analyze, analyzeSync, SegmentArray } from './template'
 import { LookupType } from './fs/loader'
 import { Render } from './render'
 import { Parser } from './parser'
@@ -31,7 +31,7 @@ export class Liquid {
  }

  public _render (tpl: Template[], scope: Context | object | undefined, renderOptions: RenderOptions): IterableIterator<any> {
-    const ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions, { liquid: this })
+    const ctx = scope instanceof Context ? scope : new Context(scope, this.options, renderOptions)
    return this.renderer.renderTemplates(tpl, ctx)
  }
  public async render (tpl: Template[], scope?: object, renderOptions?: RenderOptions): Promise<any> {
@@ -41,7 +41,7 @@ export class Liquid {
    return toValueSync(this._render(tpl, scope, { ...renderOptions, sync: true }))
  }
  public renderToNodeStream (tpl: Template[], scope?: object, renderOptions: RenderOptions = {}): NodeJS.ReadableStream {
-    const ctx = new Context(scope, this.options, renderOptions, { liquid: this })
+    const ctx = new Context(scope, this.options, renderOptions)
    return this.renderer.renderTemplatesToNodeStream(tpl, ctx)
  }

@@ -88,7 +88,7 @@ export class Liquid {

  public _evalValue (str: string, scope?: object | Context): IterableIterator<any> {
    const value = new Value(str, this)
-    const ctx = scope instanceof Context ? scope : new Context(scope, this.options, {}, { liquid: this })
+    const ctx = scope instanceof Context ? scope : new Context(scope, this.options)
    return value.value(ctx)
  }
  public async evalValue (str: string, scope?: object | Context): Promise<any> {
@@ -101,11 +101,8 @@ export class Liquid {
  public registerFilter (name: string, filter: FilterImplOptions) {
    this.filters[name] = filter
  }
-  public unregisterFilter (name: string) {
-    delete this.filters[name]
-  }
-  public registerTag (name: string, tag: TagClass | TagImplOptions) {
-    this.tags[name] = isFunction(tag) ? tag : createTagClass(tag)
+  public registerTag (name: string, tag: TagClass) {
+    this.tags[name] = tag
  }
  public plugin (plugin: (this: Liquid, L: typeof Liquid) => void) {
    return plugin.call(this, Liquid)
@@ -33,7 +33,7 @@ export class Parser {
  public parse (html: string, filepath?: string): Template[] {
    html = String(html)
    this.parseLimit.use(html.length)
-    const tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath, undefined, this.liquid.options.groupedExpressions)
+    const tokenizer = new Tokenizer(html, this.liquid.options.operators, filepath)
    const tokens = tokenizer.readTopLevelTokens(this.liquid.options)
    return this.parseTokens(tokens)
  }
@@ -12,6 +12,5 @@ export enum TokenKind {
  Quoted = 1024,
  Operator = 2048,
  FilteredValue = 4096,
-  GroupedExpression = 8192,
  Delimited = Tag | Output
 }
@@ -1,4 +1,4 @@
-import { LiquidTagToken, HTMLToken, QuotedToken, OutputToken, TagToken, OperatorToken, RangeToken, PropertyAccessToken, NumberToken, IdentifierToken, FilteredValueToken } from '../tokens'
+import { LiquidTagToken, HTMLToken, QuotedToken, OutputToken, TagToken, OperatorToken, RangeToken, PropertyAccessToken, NumberToken, IdentifierToken } from '../tokens'
 import { Tokenizer } from './tokenizer'
 import { defaultOperators } from '../render/operator'
 import { createTrie } from '../util/operator-trie'
@@ -229,115 +229,24 @@ describe('Tokenizer', function () {
  })
  describe('#readRange()', () => {
    it('should read `(1..3)`', () => {
-      const range = new Tokenizer('(1..3)').readGroupOrRange()
-      expect(range).toBeDefined()
+      const range = new Tokenizer('(1..3)').readRange()
      expect(range).toBeInstanceOf(RangeToken)
      expect(range!.getText()).toEqual('(1..3)')
-      expect((range as RangeToken).lhs).toBeInstanceOf(NumberToken)
-      expect((range as RangeToken).lhs.getText()).toBe('1')
-      expect((range as RangeToken).rhs).toBeInstanceOf(NumberToken)
-      expect((range as RangeToken).rhs.getText()).toBe('3')
+      const { lhs, rhs } = range!
+      expect(lhs).toBeInstanceOf(NumberToken)
+      expect(lhs.getText()).toBe('1')
+      expect(rhs).toBeInstanceOf(NumberToken)
+      expect(rhs.getText()).toBe('3')
    })
    it('should throw for `(..3)`', () => {
-      expect(() => new Tokenizer('(..3)').readGroupOrRange()).toThrow('unexpected token "..3)", value expected')
+      expect(() => new Tokenizer('(..3)').readRange()).toThrow('unexpected token "..3)", value expected')
    })
    it('should read `(a.b..c["..d"])`', () => {
-      const range = new Tokenizer('(a.b..c["..d"])').readGroupOrRange()
-      expect(range).toBeDefined()
+      const range = new Tokenizer('(a.b..c["..d"])').readRange()
      expect(range).toBeInstanceOf(RangeToken)
      expect(range!.getText()).toEqual('(a.b..c["..d"])')
    })
  })
-  describe('#readGroupedExpression()', () => {
-    function createGrouped (input: string): Tokenizer {
-      const t = new Tokenizer(input, defaultOperators)
-      t.groupedExpressions = true
-      return t
-    }
-    it('should read `(foo | upcase)` as FilteredValueToken', () => {
-      const token = createGrouped('(foo | upcase)').readValue()
-      expect(token).toBeInstanceOf(FilteredValueToken)
-      const grouped = token as FilteredValueToken
-      expect(grouped.getText()).toBe('(foo | upcase)')
-      expect(grouped.initial.postfix).toHaveLength(1)
-      expect(grouped.filters).toHaveLength(1)
-      expect(grouped.filters[0].name).toBe('upcase')
-    })
-    it('should read `(foo | append: "!")` with filter argument', () => {
-      const token = createGrouped('(foo | append: "!")').readValue()
-      expect(token).toBeInstanceOf(FilteredValueToken)
-      const grouped = token as FilteredValueToken
-      expect(grouped.filters).toHaveLength(1)
-      expect(grouped.filters[0].name).toBe('append')
-      expect(grouped.filters[0].args).toHaveLength(1)
-    })
-    it('should read nested `((foo | append: "!") | upcase)`', () => {
-      const token = createGrouped('((foo | append: "!") | upcase)').readValue()
-      expect(token).toBeInstanceOf(FilteredValueToken)
-      const grouped = token as FilteredValueToken
-      expect(grouped.filters).toHaveLength(1)
-      expect(grouped.filters[0].name).toBe('upcase')
-      expect(grouped.initial.postfix).toHaveLength(1)
-      expect(grouped.initial.postfix[0]).toBeInstanceOf(FilteredValueToken)
-    })
-    it('should parse `(a | upcase) == "BAR"` as expression', () => {
-      const exp = [...createGrouped('(a | upcase) == "BAR"').readExpressionTokens()]
-      expect(exp).toHaveLength(3)
-      expect(exp[0]).toBeInstanceOf(FilteredValueToken)
-      expect(exp[1]).toBeInstanceOf(OperatorToken)
-      expect(exp[1].getText()).toBe('==')
-      expect(exp[2]).toBeInstanceOf(QuotedToken)
-    })
-    it('should read `((a | upcase) > 3)` as outer FilteredValueToken with comparison inside parens', () => {
-      const token = createGrouped('((a | upcase) > 3)').readValue()
-      expect(token).toBeInstanceOf(FilteredValueToken)
-      const outer = token as FilteredValueToken
-      expect(outer.filters).toHaveLength(0)
-      expect(outer.getText()).toBe('((a | upcase) > 3)')
-      const [first, second, third] = outer.initial.postfix
-      expect(first).toBeInstanceOf(FilteredValueToken)
-      expect(second).toBeInstanceOf(NumberToken)
-      expect(third).toBeInstanceOf(OperatorToken)
-      expect((first as FilteredValueToken).filters[0].name).toBe('upcase')
-    })
-    it('should read `(1 < 3)` as grouped comparison with no filters', () => {
-      const token = createGrouped('(1 < 3)').readValue() as FilteredValueToken
-      expect(token.filters).toHaveLength(0)
-      expect(token.initial.postfix).toHaveLength(3)
-      expect(token.initial.postfix[0]).toBeInstanceOf(NumberToken)
-      expect(token.initial.postfix[1]).toBeInstanceOf(NumberToken)
-      expect((token.initial.postfix[2] as OperatorToken).operator).toBe('<')
-    })
-    it('should read redundant parens `(x)` as FilteredValueToken', () => {
-      const token = createGrouped('(x)').readValue() as FilteredValueToken
-      expect(token.filters).toHaveLength(0)
-      expect(token.initial.postfix).toHaveLength(1)
-    })
-    it('should read expression plus filters inside parens `(a == b | default: "x")`', () => {
-      const token = createGrouped('(a == b | default: "x")').readValue() as FilteredValueToken
-      expect(token.filters).toHaveLength(1)
-      expect(token.filters[0].name).toBe('default')
-      expect(token.initial.postfix.map((t) => t.getText()).join(' ')).toMatch(/a.*b.*==/)
-    })
-    it('should parse `((a | upcase) > 3) and (1 < 3)` as three expression tokens', () => {
-      const exp = [...createGrouped('((a | upcase) > 3) and (1 < 3)').readExpressionTokens()]
-      expect(exp).toHaveLength(3)
-      expect(exp[0]).toBeInstanceOf(FilteredValueToken)
-      expect(exp[1]).toBeInstanceOf(OperatorToken)
-      expect(exp[1].getText()).toBe('and')
-      expect(exp[2]).toBeInstanceOf(FilteredValueToken)
-    })
-    it('should still parse `(1..3)` as RangeToken', () => {
-      const token = createGrouped('(1..3)').readValue()
-      expect(token).toBeInstanceOf(RangeToken)
-    })
-    it('should throw for unclosed parens', () => {
-      expect(() => createGrouped('(foo | upcase').readValue()).toThrow('unbalanced parentheses')
-    })
-    it('should fall back to readRange when flag is off', () => {
-      expect(() => new Tokenizer('(foo | upcase)', defaultOperators).readValue()).toThrow('invalid range syntax')
-    })
-  })
  describe('#readFilter()', () => {
    it('should read a simple filter', function () {
      const tokenizer = new Tokenizer('| plus')
@@ -9,7 +9,6 @@ import { whiteSpaceCtrl } from './whitespace-ctrl'
 export class Tokenizer {
  p: number
  N: number
-  public groupedExpressions: boolean
  private rawBeginAt = -1
  private opTrie: Trie<OperatorHandler>
  private literalTrie: Trie<LiteralValue>
@@ -18,14 +17,12 @@ export class Tokenizer {
    public input: string,
    operators: Operators = defaultOptions.operators,
    public file?: string,
-    range?: [number, number],
-    groupedExpressions = false
+    range?: [number, number]
  ) {
    this.p = range ? range[0] : 0
    this.N = range ? range[1] : input.length
    this.opTrie = createTrie(operators)
    this.literalTrie = createTrie(literalValues)
-    this.groupedExpressions = groupedExpressions
  }

  readExpression () {
@@ -83,7 +80,6 @@ export class Tokenizer {
  readFilter (): FilterToken | null {
    this.skipBlank()
    if (this.end()) return null
-    if (this.peek() === ')') return null
    this.assert(this.read() === '|', `expected "|" before filter`)
    const name = this.readIdentifier()
    if (!name.size()) {
@@ -98,9 +94,9 @@ export class Tokenizer {
        const arg = this.readFilterArg()
        arg && args.push(arg)
        this.skipBlank()
-        this.assert(this.end() || this.peek() === ',' || this.peek() === '|' || this.peek() === ')', () => `unexpected character ${this.snapshot()}`)
+        this.assert(this.end() || this.peek() === ',' || this.peek() === '|', () => `unexpected character ${this.snapshot()}`)
      } while (this.peek() === ',')
-    } else if (this.peek() === '|' || this.peek() === ')' || this.end()) {
+    } else if (this.peek() === '|' || this.end()) {
      // do nothing
    } else {
      throw this.error('expected ":" after filter name')
@@ -311,13 +307,10 @@ export class Tokenizer {
    return -1
  }

-  readValue (): ValueToken | FilteredValueToken | undefined {
+  readValue (): ValueToken | undefined {
    this.skipBlank()
    const begin = this.p
-    let variable: ValueToken | FilteredValueToken | undefined = this.readLiteral() || this.readQuoted() || this.readNumber()
-    if (!variable && this.peek() === '(') {
-      variable = this.readGroupOrRange()
-    }
+    const variable = this.readLiteral() || this.readQuoted() || this.readRange() || this.readNumber()
    const props = this.readProperties(!variable)
    if (!props.length) return variable
    return new PropertyAccessToken(variable, props, this.input, begin, this.p)
@@ -392,32 +385,18 @@ export class Tokenizer {
    return literal
  }

-  readGroupOrRange (): FilteredValueToken | RangeToken | undefined {
+  readRange (): RangeToken | undefined {
    this.skipBlank()
    const begin = this.p
    if (this.peek() !== '(') return
    ++this.p
    const lhs = this.readValueOrThrow()
    this.skipBlank()
-
-    if (this.peek() === '.' && this.peek(1) === '.') {
-      this.p += 2
-      const rhs = this.readValueOrThrow()
-      this.skipBlank()
-      this.assert(this.read() === ')', 'invalid range syntax')
-      return new RangeToken(this.input, begin, this.p, lhs, rhs, this.file)
-    }
-
-    if (this.groupedExpressions) {
-      const initial = new Expression([lhs, ...this.readExpressionTokens()])
-      this.assert(initial.valid(), () => `invalid value expression: ${this.snapshot()}`)
-      const filters = this.readFilters()
-      this.skipBlank()
-      this.assert(this.read() === ')', 'unbalanced parentheses')
-      return new FilteredValueToken(initial, filters, this.input, begin, this.p, this.file)
-    }
-
-    throw this.error('invalid range syntax')
+    this.assert(this.read() === '.' && this.read() === '.', 'invalid range syntax')
+    const rhs = this.readValueOrThrow()
+    this.skipBlank()
+    this.assert(this.read() === ')', 'invalid range syntax')
+    return new RangeToken(this.input, begin, this.p, lhs, rhs, this.file)
  }

  readValueOrThrow (): ValueToken {
@@ -1,14 +1,13 @@
-import { QuotedToken, RangeToken, OperatorToken, Token, PropertyAccessToken, OperatorType, operatorTypes, FilteredValueToken } from '../tokens'
-import { isRangeToken, isPropertyAccessToken, isFilteredValueToken, UndefinedVariableError, range, isOperatorToken, assert } from '../util'
+import { QuotedToken, RangeToken, OperatorToken, Token, PropertyAccessToken, OperatorType, operatorTypes } from '../tokens'
+import { isRangeToken, isPropertyAccessToken, UndefinedVariableError, range, isOperatorToken, assert } from '../util'
 import type { Context } from '../context'
 import type { UnaryOperatorHandler } from '../render'
 import { Drop } from '../drop'
-import { Filter } from '../template/filter'

 export class Expression {
  readonly postfix: Token[]

-  public constructor (tokens: Iterable<Token>) {
+  public constructor (tokens: IterableIterator<Token>) {
    this.postfix = [...toPostfix(tokens)]
  }
  public * evaluate (ctx: Context, lenient?: boolean): Generator<unknown, unknown, unknown> {
@@ -41,22 +40,6 @@ export function * evalToken (token: Token | undefined, ctx: Context, lenient = f
  if ('content' in token) return token.content
  if (isPropertyAccessToken(token)) return yield evalPropertyAccessToken(token, ctx, lenient)
  if (isRangeToken(token)) return yield evalRangeToken(token, ctx)
-  if (isFilteredValueToken(token)) return yield evalFilteredValueToken(token, ctx, lenient)
-}
-
-function * evalFilteredValueToken (token: FilteredValueToken, ctx: Context, lenient: boolean): IterableIterator<unknown> {
-  assert(ctx.liquid, 'FilteredValueToken evaluation requires liquid instance in context')
-  lenient = lenient || (ctx.opts.lenientIf && token.filters.length > 0 && token.filters[0].name === 'default')
-  let val = yield token.initial.evaluate(ctx, lenient)
-
-  for (const filterToken of token.filters) {
-    const filterImpl = ctx.liquid.filters[filterToken.name]
-    assert(filterImpl || !ctx.liquid.options.strictFilters, () => `undefined filter: ${filterToken.name}`)
-    const filter = new Filter(filterToken, filterImpl, ctx.liquid)
-    val = yield filter.render(val, ctx)
-  }
-
-  return val
 }

 function * evalPropertyAccessToken (token: PropertyAccessToken, ctx: Context, lenient: boolean): IterableIterator<unknown> {
@@ -84,11 +67,10 @@ export function evalQuotedToken (token: QuotedToken) {
 function * evalRangeToken (token: RangeToken, ctx: Context) {
  const low: number = yield evalToken(token.lhs, ctx)
  const high: number = yield evalToken(token.rhs, ctx)
-  ctx.memoryLimit.use(high - low + 1)
  return range(+low, +high + 1)
 }

-function * toPostfix (tokens: Iterable<Token>): IterableIterator<Token> {
+function * toPostfix (tokens: IterableIterator<Token>): IterableIterator<Token> {
  const ops: OperatorToken[] = []
  for (const token of tokens) {
    if (isOperatorToken(token)) {
@@ -1,28 +1,21 @@
-import { getPerformance } from '../util/performance'
 import { toPromise, RenderError, LiquidErrors, LiquidError } from '../util'
 import { Context } from '../context'
 import { Template } from '../template'
-import { Emitter, KeepingTypeEmitter, StreamedEmitter, SimpleEmitter } from '../emitters'
+import { Emitter, StreamedEmitter, SimpleEmitter } from '../emitters'

 export class Render {
  public renderTemplatesToNodeStream (templates: Template[], ctx: Context): NodeJS.ReadableStream {
-    const emitter = new StreamedEmitter()
+    const emitter = new StreamedEmitter(ctx.outputLengthLimit)
    Promise.resolve().then(() => toPromise(this.renderTemplates(templates, ctx, emitter)))
      .then(() => emitter.end(), err => emitter.error(err))
    return emitter.stream
  }
-  public * renderTemplates (templates: Template[], ctx: Context, emitter?: Emitter): IterableIterator<any> {
-    if (!emitter) {
-      emitter = ctx.opts.keepOutputType ? new KeepingTypeEmitter() : new SimpleEmitter()
-    }
-    ctx.renderLimit.check(getPerformance().now())
+  public * renderTemplates (templates: Template[], ctx: Context, emitter: Emitter = new SimpleEmitter(ctx.outputLengthLimit)): IterableIterator<any> {
    const errors = []
    for (const tpl of templates) {
-      ctx.renderLimit.check(getPerformance().now())
+      ctx.templateLimit.use(1)
      try {
-        // if tpl.render supports emitter, it'll return empty `html`
        const html = yield tpl.render(ctx, emitter)
-        // if not, it'll return an `html`, write to the emitter for it
        html && emitter.write(html)
        if (ctx.breakCalled || ctx.continueCalled) break
      } catch (e) {
@@ -1,4 +1,4 @@
-import { BlockMode, createScope } from '../context'
+import { BlockMode } from '../context'
 import { isTagToken } from '../util'
 import { BlockDrop } from '../drop'
 import { Liquid, TagToken, TopLevelToken, Template, Context, Emitter, Tag } from '..'
@@ -38,7 +38,7 @@ export default class extends Tag {
      if (stack.includes(self)) throw new Error('block tag cannot be nested')

      stack.push(self)
-      ctx.push(createScope({ block: superBlock }))
+      ctx.push({ block: superBlock })
      yield liquid.renderer.renderTemplates(templates, ctx, emitter)
      ctx.pop()
      stack.pop()
@@ -1,11 +1,11 @@
-import { ValueToken, Liquid, toValue, evalToken, Value, Emitter, TagToken, TopLevelToken, Context, Template, Tag, ParseStream, FilteredValueToken } from '..'
+import { ValueToken, Liquid, toValue, evalToken, Value, Emitter, TagToken, TopLevelToken, Context, Template, Tag, ParseStream } from '..'
 import { Parser } from '../parser'
 import { equals } from '../render'
 import { Arguments } from '../template'

 export default class extends Tag {
  value: Value
-  branches: { values: (ValueToken | FilteredValueToken)[], templates: Template[] }[] = []
+  branches: { values: ValueToken[], templates: Template[] }[] = []
  elseTemplates: Template[] = []
  constructor (tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser) {
    super(tagToken, remainTokens, liquid)
@@ -22,7 +22,7 @@ export default class extends Tag {

        p = []

-        const values: (ValueToken | FilteredValueToken)[] = []
+        const values: ValueToken[] = []
        while (!token.tokenizer.end()) {
          values.push(token.tokenizer.readValueOrThrow())
          token.tokenizer.skipBlank()
@@ -1,6 +1,5 @@
-import { Hash, ValueToken, Liquid, Tag, evalToken, Emitter, TagToken, TopLevelToken, Context, Template, ParseStream, FilteredValueToken } from '..'
+import { Hash, ValueToken, Liquid, Tag, evalToken, Emitter, TagToken, TopLevelToken, Context, Template, ParseStream } from '..'
 import { assertEmpty, isValueToken, toEnumerable } from '../util'
-import { createScope } from '../context/scope'
 import { ForloopDrop } from '../drop/forloop-drop'
 import { Parser } from '../parser'
 import { Arguments } from '../template'
@@ -11,7 +10,7 @@ type valueOf<T> = T[keyof T]

 export default class extends Tag {
  variable: string
-  collection: ValueToken | FilteredValueToken
+  collection: ValueToken
  hash: Hash
  templates: Template[]
  elseTemplates: Template[]
@@ -43,15 +42,8 @@ export default class extends Tag {
  }
  * render (ctx: Context, emitter: Emitter): Generator<unknown, void | string, Template[]> {
    const r = this.liquid.renderer
-    let collection = toEnumerable(yield evalToken(this.collection, ctx))
-
-    if (!collection.length) {
-      yield r.renderTemplates(this.elseTemplates, ctx, emitter)
-      return
-    }
-
    const continueKey = 'continue-' + this.variable + '-' + this.collection.getText()
-    ctx.push(createScope({ continue: ctx.getRegister(continueKey, {}) }))
+    ctx.push({ continue: ctx.getRegister(continueKey, {}) })
    const hash = (yield this.hash.render(ctx)) as Record<string, any>
    ctx.pop()

@@ -59,6 +51,7 @@ export default class extends Tag {
      ? Object.keys(hash).filter(x => MODIFIERS.includes(x))
      : MODIFIERS.filter(x => hash[x] !== undefined)

+    let collection = toEnumerable(yield evalToken(this.collection, ctx))
    collection = modifiers.reduce((collection, modifier: valueOf<typeof MODIFIERS>) => {
      if (modifier === 'offset') return offset(collection, hash['offset'])
      if (modifier === 'limit') return limit(collection, hash['limit'])
@@ -66,8 +59,15 @@ export default class extends Tag {
    }, collection)

    ctx.setRegister(continueKey, (hash['offset'] || 0) + collection.length)
-    const scope = createScope({ forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) })
-    ctx.push(scope)
+
+    if (!collection.length) {
+      yield r.renderTemplates(this.elseTemplates, ctx, emitter)
+      return
+    }
+
+    if (!this.templates.length) return
+
+    const scope = ctx.push({ forloop: new ForloopDrop(collection.length, this.collection.getText(), this.variable) })
    for (const item of collection) {
      scope[this.variable] = item
      ctx.continueCalled = ctx.breakCalled = false
@@ -1,5 +1,5 @@
 import { Template, ValueToken, TopLevelToken, Liquid, Tag, assert, evalToken, Hash, Emitter, TagToken, Context } from '..'
-import { BlockMode, createScope, Scope } from '../context'
+import { BlockMode, Scope } from '../context'
 import { Parser } from '../parser'
 import { Argument, Arguments, PartialScope } from '../template'
 import { isString, isValueToken } from '../util'
@@ -28,6 +28,7 @@ export default class extends Tag {
    this.hash = new Hash(tokenizer, liquid.options.jekyllInclude || liquid.options.keyValueSeparator)
  }
  * render (ctx: Context, emitter: Emitter): Generator<unknown, void, unknown> {
+    ctx.depthLimit.use(1)
    const { liquid, hash, withVar } = this
    const { renderer } = liquid
    const filepath = (yield renderFilePath(this.file, ctx, liquid)) as string
@@ -36,13 +37,14 @@ export default class extends Tag {
    const saved = ctx.saveRegister('blocks', 'blockMode')
    ctx.setRegister('blocks', {})
    ctx.setRegister('blockMode', BlockMode.OUTPUT)
-    const scope = createScope((yield hash.render(ctx)) as Scope)
+    const scope = (yield hash.render(ctx)) as Scope
    if (withVar) scope[filepath] = yield evalToken(withVar, ctx)
    const templates = (yield liquid._parsePartialFile(filepath, ctx.sync, this.currentFile)) as Template[]
-    ctx.push(ctx.opts.jekyllInclude ? createScope({ include: scope }) : scope)
+    ctx.push(ctx.opts.jekyllInclude ? { include: scope } : scope)
    yield renderer.renderTemplates(templates, ctx, emitter)
    ctx.pop()
    ctx.restoreRegister(saved)
+    ctx.depthLimit.release(1)
  }

  public * children (partials: boolean, sync: boolean): Generator<unknown, Template[]> {
@@ -1,5 +1,5 @@
 import { Scope, Template, Liquid, Tag, assert, Emitter, Hash, TagToken, TopLevelToken, Context } from '..'
-import { BlockMode, createScope } from '../context'
+import { BlockMode } from '../context'
 import { parseFilePath, renderFilePath, ParsedFileName } from './render'
 import { BlankDrop } from '../drop'
 import { Parser } from '../parser'
@@ -26,6 +26,7 @@ export default class extends Tag {
      yield renderer.renderTemplates(this.templates, ctx, emitter)
      return
    }
+    ctx.depthLimit.use(1)
    const filepath = (yield renderFilePath(this.file, ctx, liquid)) as string
    assert(filepath, () => `illegal file path "${filepath}"`)
    const templates = (yield liquid._parseLayoutFile(filepath, ctx.sync, this.currentFile)) as Template[]
@@ -40,9 +41,10 @@ export default class extends Tag {
    ctx.setRegister('blockMode', BlockMode.OUTPUT)

    // render the layout file use stored blocks
-    ctx.push(createScope((yield args.render(ctx)) as Scope))
+    ctx.push((yield args.render(ctx)) as Scope)
    yield renderer.renderTemplates(templates, ctx, emitter)
    ctx.pop()
+    ctx.depthLimit.release(1)
  }

  public * children (partials: boolean): Generator<unknown, Template[]> {
@@ -55,6 +55,7 @@ export default class extends Tag {
    this.hash = new Hash(tokenizer, liquid.options.keyValueSeparator)
  }
  * render (ctx: Context, emitter: Emitter): Generator<unknown, void, unknown> {
+    ctx.depthLimit.use(1)
    const { liquid, hash } = this
    const filepath = (yield renderFilePath(this.file, ctx, liquid)) as string
    assert(filepath, () => `illegal file path "${filepath}"`)
@@ -81,6 +82,7 @@ export default class extends Tag {
      const templates = (yield liquid._parsePartialFile(filepath, childCtx.sync, this.currentFile)) as Template[]
      yield liquid.renderer.renderTemplates(templates, childCtx, emitter)
    }
+    ctx.depthLimit.release(1)
  }

  public * children (partials: boolean, sync: boolean): Generator<unknown, Template[]> {
@@ -1,6 +1,5 @@
 import { isValueToken, toEnumerable } from '../util'
-import { createScope } from '../context/scope'
-import { ValueToken, Liquid, Tag, evalToken, Emitter, Hash, TagToken, TopLevelToken, Context, Template, ParseStream, FilteredValueToken } from '..'
+import { ValueToken, Liquid, Tag, evalToken, Emitter, Hash, TagToken, TopLevelToken, Context, Template, ParseStream } from '..'
 import { TablerowloopDrop } from '../drop/tablerowloop-drop'
 import { Parser } from '../parser'
 import { Arguments } from '../template'
@@ -9,7 +8,7 @@ export default class extends Tag {
  variable: string
  args: Hash
  templates: Template[]
-  collection: ValueToken | FilteredValueToken
+  collection: ValueToken
  constructor (tagToken: TagToken, remainTokens: TopLevelToken[], liquid: Liquid, parser: Parser) {
    super(tagToken, remainTokens, liquid)
    const variable = this.tokenizer.readIdentifier()
@@ -45,12 +44,15 @@ export default class extends Tag {
    const limit = (args.limit === undefined) ? collection.length : args.limit

    collection = collection.slice(offset, offset + limit)
+    if (!collection.length) return
+
+    if (!this.templates.length) return
+
    const cols = args.cols || collection.length

    const r = this.liquid.renderer
    const tablerowloop = new TablerowloopDrop(collection.length, cols, this.collection.getText(), this.variable)
-    const scope = createScope({ tablerowloop })
-    ctx.push(scope)
+    const scope = ctx.push({ tablerowloop })

    for (let idx = 0; idx < collection.length; idx++, tablerowloop.next()) {
      scope[this.variable] = collection[idx]
@@ -2,7 +2,6 @@ import { Argument, Template, Value } from '.'
 import { isKeyValuePair } from '../parser/filter-arg'
 import { PropertyAccessToken, ValueToken } from '../tokens'
 import {
-  isFilteredValueToken,
  isNumberToken,
  isPropertyAccessToken,
  isQuotedToken,
@@ -372,31 +371,11 @@ function * extractValueTokenVariables (token: ValueToken): Generator<Variable> {
  if (isRangeToken(token)) {
    yield * extractValueTokenVariables(token.lhs)
    yield * extractValueTokenVariables(token.rhs)
-  } else if (isFilteredValueToken(token)) {
-    yield * extractGroupedExpressionTokenVariables(token)
  } else if (isPropertyAccessToken(token)) {
    yield extractPropertyAccessVariable(token)
  }
 }

-function * extractGroupedExpressionTokenVariables (token: ValueToken): Generator<Variable> {
-  if (!isFilteredValueToken(token)) return
-
-  for (const t of token.initial.postfix) {
-    if (isValueToken(t)) yield * extractValueTokenVariables(t)
-  }
-
-  for (const filter of token.filters) {
-    for (const arg of filter.args) {
-      if (isKeyValuePair(arg) && arg[1]) {
-        yield * extractValueTokenVariables(arg[1])
-      } else if (isValueToken(arg)) {
-        yield * extractValueTokenVariables(arg)
-      }
-    }
-  }
-}
-
 function extractPropertyAccessVariable (token: PropertyAccessToken): Variable {
  const segments: VariableSegments = []

@@ -1,7 +1,6 @@
 export * from './template'
 export * from './template-impl'
 export * from './tag'
-export * from './tag-options-adapter'
 export * from './filter'
 export * from './filter-impl-options'
 export * from './hash'
@@ -2,7 +2,6 @@ import { toPromise } from '../util'
 import { Context } from '../context'
 import { Output } from '../template'
 import { OutputToken } from '../tokens'
-import { defaultOptions } from '../liquid-options'

 describe('Output', function () {
  const emitter: any = { write: (html: string) => (emitter.html += html), html: '' }
@@ -30,59 +29,4 @@ describe('Output', function () {
    await toPromise(output.render(scope, emitter))
    return expect(emitter.html).toBe('FOO')
  })
-  it('should respect to .toString()', async () => {
-    const scope = new Context({ obj: { toString: () => 'FOO' } })
-    const output = new Output(token, liquid)
-    await toPromise(output.render(scope, emitter))
-    return expect(emitter.html).toBe('FOO')
-  })
-  describe('when keepOutputType is enabled', () => {
-    const emitter: any = {
-      write: (html: any) => {
-        if (emitter.keepOutputType && typeof html !== 'string') {
-          emitter.html = html
-        } else {
-          emitter.html += html as string
-        }
-      },
-      html: '',
-      keepOutputType: true
-    }
-    const token = { content: 'foo', input: 'foo' } as OutputToken
-
-    beforeEach(() => { emitter.html = '' })
-
-    it('should respect output variable number type', async () => {
-      const scope = new Context({
-        foo: 42
-      }, { ...defaultOptions, keepOutputType: true })
-      const output = new Output(token, liquid)
-      await toPromise(output.render(scope, emitter))
-      return expect(emitter.html).toBe(42)
-    })
-    it('should respect output variable boolean type', async () => {
-      const scope = new Context({
-        foo: true
-      }, { ...defaultOptions, keepOutputType: true })
-      const output = new Output(token, liquid)
-      await toPromise(output.render(scope, emitter))
-      return expect(emitter.html).toBe(true)
-    })
-    it('should respect output variable object type', async () => {
-      const scope = new Context({
-        foo: 'test'
-      }, { ...defaultOptions, keepOutputType: true })
-      const output = new Output(token, liquid)
-      await toPromise(output.render(scope, emitter))
-      return expect(emitter.html).toBe('test')
-    })
-    it('should respect output variable string type', async () => {
-      const scope = new Context({
-        foo: { a: { b: 42 } }
-      }, { ...defaultOptions, keepOutputType: true })
-      const output = new Output(token, liquid)
-      await toPromise(output.render(scope, emitter))
-      return expect(emitter.html).toEqual({ a: { b: 42 } })
-    })
-  })
 })
@@ -12,7 +12,7 @@ export class Output extends TemplateImpl<OutputToken> implements Template {
  value: Value
  public constructor (token: OutputToken, liquid: Liquid) {
    super(token)
-    const tokenizer = new Tokenizer(token.input, liquid.options.operators, token.file, token.contentRange, liquid.options.groupedExpressions)
+    const tokenizer = new Tokenizer(token.input, liquid.options.operators, token.file, token.contentRange)
    this.value = new Value(tokenizer.readFilteredValue(), liquid)
    const filters = this.value.filters
    const outputEscape = liquid.options.outputEscape
@@ -1,28 +0,0 @@
-import { isFunction } from '../util'
-import { Hash } from './hash'
-import { Tag, TagClass, TagRenderReturn } from './tag'
-import { TagToken, TopLevelToken } from '../tokens'
-import { Emitter } from '../emitters'
-import { Context } from '../context'
-import type { Liquid } from '../liquid'
-
-export interface TagImplOptions {
-  [key: string]: any
-  parse?: (this: Tag & TagImplOptions, token: TagToken, remainingTokens: TopLevelToken[]) => void;
-  render: (this: Tag & TagImplOptions, ctx: Context, emitter: Emitter, hash: Record<string, any>) => TagRenderReturn;
-}
-
-export function createTagClass (options: TagImplOptions): TagClass {
-  return class extends Tag {
-    constructor (token: TagToken, tokens: TopLevelToken[], liquid: Liquid) {
-      super(token, tokens, liquid)
-      if (isFunction(options.parse)) {
-        options.parse.call(this, token, tokens)
-      }
-    }
-    * render (ctx: Context, emitter: Emitter): TagRenderReturn {
-      const hash = (yield new Hash(this.token.args, ctx.opts.keyValueSeparator).render(ctx)) as Record<string, any>
-      return yield options.render.call(this, ctx, emitter, hash)
-    }
-  }
-}
@@ -15,7 +15,7 @@ export class Value {
   */
  public constructor (input: string | FilteredValueToken, liquid: Liquid) {
    const token: FilteredValueToken = typeof input === 'string'
-      ? new Tokenizer(input, liquid.options.operators, undefined, undefined, liquid.options.groupedExpressions).readFilteredValue()
+      ? new Tokenizer(input, liquid.options.operators).readFilteredValue()
      : input
    this.initial = token.initial
    this.filters = token.filters.map(token => new Filter(token, this.getFilter(liquid, token.name), liquid))
@@ -16,7 +16,7 @@ export class LiquidTagToken extends DelimitedToken {
    file?: string
  ) {
    super(TokenKind.Tag, [begin, end], input, begin, end, false, false, file)
-    this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange, options.groupedExpressions)
+    this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange)
    this.name = this.tokenizer.readTagName()
    this.tokenizer.assert(this.name, 'illegal liquid tag syntax')
    this.tokenizer.skipBlank()
@@ -5,12 +5,11 @@ import { IdentifierToken } from './identifier-token'
 import { NumberToken } from './number-token'
 import { RangeToken } from './range-token'
 import { QuotedToken } from './quoted-token'
-import { FilteredValueToken } from './filtered-value-token'
 import { TokenKind } from '../parser'

 export class PropertyAccessToken extends Token {
  constructor (
-    public variable: QuotedToken | RangeToken | LiteralToken | NumberToken | FilteredValueToken | undefined,
+    public variable: QuotedToken | RangeToken | LiteralToken | NumberToken | undefined,
    public props: (ValueToken | IdentifierToken)[],
    input: string,
    begin: number,
@@ -17,7 +17,7 @@ export class TagToken extends DelimitedToken {
    const [valueBegin, valueEnd] = [begin + tagDelimiterLeft.length, end - tagDelimiterRight.length]
    super(TokenKind.Tag, [valueBegin, valueEnd], input, begin, end, trimTagLeft, trimTagRight, file)

-    this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange, options.groupedExpressions)
+    this.tokenizer = new Tokenizer(input, options.operators, file, this.contentRange)
    this.name = this.tokenizer.readTagName()
    this.tokenizer.assert(this.name, `illegal tag syntax, tag name expected`)
    this.tokenizer.skipBlank()
@@ -3,6 +3,5 @@ import { LiteralToken } from './literal-token'
 import { NumberToken } from './number-token'
 import { QuotedToken } from './quoted-token'
 import { PropertyAccessToken } from './property-access-token'
-import { FilteredValueToken } from './filtered-value-token'

-export type ValueToken = RangeToken | LiteralToken | QuotedToken | PropertyAccessToken | NumberToken | FilteredValueToken
+export type ValueToken = RangeToken | LiteralToken | QuotedToken | PropertyAccessToken | NumberToken
@@ -14,6 +14,11 @@ export class Limiter {
      this.base += +count
    }
  }
+  release (count: number) {
+    if (+count > 0) {
+      this.base -= +count
+    }
+  }
  check (count: number) {
    if (+count > 0) {
      assert(+count <= this.limit, this.message)
@@ -53,15 +53,6 @@ export class LiquidDate {
  getTime () {
    return this.displayDate.getTime()
  }
-  /**
-   * The underlying UTC timestamp in milliseconds, unaffected by the display
-   * timezone. Use this (not `getTime()`) for timezone-invariant values like
-   * `%s`: `getTime()` reads `displayDate`, which is deliberately shifted by
-   * the display timezone offset so wall-clock getters can delegate to Date.
-   */
-  dateValue () {
-    return this.date.getTime()
-  }
  getMilliseconds () {
    return this.displayDate.getMilliseconds()
  }
@@ -87,15 +87,6 @@ describe('util/strftime', function () {
      expect(t(time, '%10N')).toBe('1290000000')
      expect(t(time, '%0N')).toBe('129000000')
    })
-    it('should zero pad %N for sub-100ms fractional seconds', function () {
-      const time = new TestDate('2019-12-15 01:21:00.005')
-      expect(t(time, '%N')).toBe('005000000')
-      expect(t(time, '%3N')).toBe('005')
-      expect(t(time, '%6N')).toBe('005000')
-      const tens = new TestDate('2019-12-15 01:21:00.050')
-      expect(t(tens, '%N')).toBe('050000000')
-      expect(t(tens, '%2N')).toBe('05')
-    })
    it('should format %p as upper cased am/pm', function () {
      expect(t(now, '%p')).toBe('PM')
      expect(t(then, '%p')).toBe('AM')
@@ -197,6 +188,14 @@ describe('util/strftime', function () {
    it('should have higher priority than H', () => {
      expect(t(then, '%0H')).toBe('03')
    })
+    it('should allow pad width up to MAX_STRFTIME_PAD', () => {
+      expect(t(now, '%100000d').length).toBe(100000)
+      expect(t(now, `%${1_000_000}d`).length).toBe(1_000_000)
+    })
+    it('should throw when pad width exceeds MAX_STRFTIME_PAD', () => {
+      expect(() => t(now, `%${1024 * 1024 + 1}d`)).toThrow('strftime pad width limit exceeded')
+      expect(() => t(now, '%5000000d')).toThrow('strftime pad width limit exceeded')
+    })
  })
  describe('modifier field', () => {
    it('should ignore E modifier', () => {
@@ -1,13 +1,15 @@
 import { changeCase, padStart, padEnd } from './underscore'
 import { LiquidDate } from './liquid-date'
-import type { Limiter } from './limiter'
+import { assert } from './assert'
+
+/** Per-conversion numeric width cap for strftime (%N, %15d, …). */
+export const MAX_STRFTIME_PAD = 1024 * 1024

 const rFormat = /%([-_0^#:]+)?(\d+)?([EO])?(.)/
 interface FormatOptions {
  flags: Record<string, boolean>;
  width?: string;
  modifier?: string;
-  memoryLimit?: Pick<Limiter, 'use'>;
 }

 // prototype extensions
@@ -98,14 +100,14 @@ const formatCodes: Record<string, FormatCodeHandler> = {
  M: (d: LiquidDate) => d.getMinutes(),
  N: (d: LiquidDate, opts: FormatOptions) => {
    const width = Number(opts.width) || 9
-    const str = padStart(String(d.getMilliseconds()), 3, '0').slice(0, width)
-    opts.memoryLimit?.use(width - str.length)
+    assertPadWidth(width)
+    const str = String(d.getMilliseconds()).slice(0, width)
    return padEnd(str, width, '0')
  },
  p: (d: LiquidDate) => (d.getHours() < 12 ? 'AM' : 'PM'),
  P: (d: LiquidDate) => (d.getHours() < 12 ? 'am' : 'pm'),
  q: (d: LiquidDate) => ordinal(d),
-  s: (d: LiquidDate) => Math.floor(d.dateValue() / 1000),
+  s: (d: LiquidDate) => Math.round(d.getTime() / 1000),
  S: (d: LiquidDate) => d.getSeconds(),
  u: (d: LiquidDate) => d.getDay() || 7,
  U: (d: LiquidDate) => getWeekOfYear(d, 0),
@@ -123,25 +125,29 @@ const formatCodes: Record<string, FormatCodeHandler> = {
 }
 formatCodes.h = formatCodes.b

-export function strftime (d: LiquidDate, formatStr: string, memoryLimit?: Pick<Limiter, 'use'>) {
+export function strftime (d: LiquidDate, formatStr: string) {
  let output = ''
  let remaining = formatStr
  let match
  while ((match = rFormat.exec(remaining))) {
    output += remaining.slice(0, match.index)
    remaining = remaining.slice(match.index + match[0].length)
-    output += format(d, match, memoryLimit)
+    output += format(d, match)
  }
  return output + remaining
 }

-function format (d: LiquidDate, match: RegExpExecArray, memoryLimit?: Pick<Limiter, 'use'>) {
+function assertPadWidth (width: number) {
+  assert(width <= MAX_STRFTIME_PAD, 'strftime pad width limit exceeded')
+}
+
+function format (d: LiquidDate, match: RegExpExecArray) {
  const [input, flagStr = '', width, modifier, conversion] = match
  const convert = formatCodes[conversion]
  if (!convert) return input
  const flags: Record<string, boolean> = {}
  for (const flag of flagStr) flags[flag] = true
-  let ret = String(convert(d, { flags, width, modifier, memoryLimit }))
+  let ret = String(convert(d, { flags, width, modifier }))
  let padChar = padSpaceChars.has(conversion) ? ' ' : '0'
  let padWidth = Number(width) || padWidths[conversion] || 0
  if (flags['^']) ret = ret.toUpperCase()
@@ -149,6 +155,6 @@ function format (d: LiquidDate, match: RegExpExecArray, memoryLimit?: Pick<Limit
  if (flags['_']) padChar = ' '
  else if (flags['0']) padChar = '0'
  if (flags['-']) padWidth = 0
-  memoryLimit?.use(Number(padWidth) - ret.length)
+  else assertPadWidth(padWidth)
  return padStart(ret, padWidth, padChar)
 }
@@ -1,4 +1,4 @@
-import { RangeToken, NumberToken, QuotedToken, LiteralToken, PropertyAccessToken, OutputToken, HTMLToken, TagToken, IdentifierToken, DelimitedToken, OperatorToken, ValueToken, FilteredValueToken } from '../tokens'
+import { RangeToken, NumberToken, QuotedToken, LiteralToken, PropertyAccessToken, OutputToken, HTMLToken, TagToken, IdentifierToken, DelimitedToken, OperatorToken, ValueToken } from '../tokens'
 import { TokenKind } from '../parser'

 export function isDelimitedToken (val: any): val is DelimitedToken {
@@ -45,13 +45,9 @@ export function isRangeToken (val: any): val is RangeToken {
  return getKind(val) === TokenKind.Range
 }

-export function isFilteredValueToken (val: any): val is FilteredValueToken {
-  return getKind(val) === TokenKind.FilteredValue
-}
-
 export function isValueToken (val: any): val is ValueToken {
-  // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range | TokenKind.FilteredValue
-  return (getKind(val) & 5763) > 0
+  // valueTokenBitMask = TokenKind.Number | TokenKind.Literal | TokenKind.Quoted | TokenKind.PropertyAccess | TokenKind.Range
+  return (getKind(val) & 1667) > 0
 }

 function getKind (val: any) {
@@ -1,10 +1,9 @@
 import { Drop } from '../drop/drop'

 export const toString = Object.prototype.toString
+export const hasOwnProperty = Object.prototype.hasOwnProperty
 const toLowerCase = String.prototype.toLowerCase

-export const hasOwnProperty = Object.hasOwnProperty
-
 export function isString (value: any): value is string {
  return typeof value === 'string'
 }
@@ -90,8 +89,7 @@ export function isUndefined (value: any): boolean {
 }

 export function isArray (value: any): value is any[] {
-  // be compatible with IE 8
-  return toString.call(value) === '[object Array]'
+  return Array.isArray(value)
 }

 export function isArrayLike (value: any): value is any[] {
@@ -14,9 +14,9 @@ for demo in $(ls demo); do
  npm link liquidjs

  if npm test; then
-    echo [success] demo/webpack
+    echo "[success] demo/$demo"
  else
-    echo [fail] demo/webpack
+    echo "[fail] demo/$demo"
    exit 1
  fi
  cd -
@@ -1,4 +1,4 @@
-import { TopLevelToken, TagToken, Tokenizer, Context, Liquid, Drop, toValueSync, LiquidError, IfTag } from '../..'
+import { Tokenizer, Context, Liquid, Drop, toValueSync, LiquidError, IfTag } from '../..'
 import { spawnSync } from 'child_process'
 import { resolve as resolvePath } from 'path'
 const LiquidUMD = require('../../dist/liquid.browser.umd.js').Liquid
@@ -362,33 +362,8 @@ describe('Issues', function () {
    const html = await liquid.parseAndRender(tpl)
    expect(html).toMatch(/^\s*This is a love or luck potion.\s+This is a strength or health or love potion.\s*$/)
  })
-  it('tag registration compatible to v9 #570', async () => {
-    const liquid = new Liquid()
-    liquid.registerTag('metadata_file', {
-      parse (tagToken: TagToken, remainTokens: TopLevelToken[]) {
-        this.str = tagToken.args
-      },
-      async render (ctx: Context) {
-        const content = await Promise.resolve(`{{${this.str}}}`)
-        return this.liquid.parseAndRender(content.toString(), ctx)
-      }
-    })
-    const tpl = '{% metadata_file foo %}'
-    const ctx = { foo: 'FOO' }
-    const html = await liquid.parseAndRender(tpl, ctx)
-    expect(html).toBe('FOO')
-  })
  it('date filter should return parsed input when no format is provided #573', async () => {
    const liquid = new Liquid()
-    liquid.registerTag('metadata_file', {
-      parse (tagToken: TagToken, remainTokens: TopLevelToken[]) {
-        this.str = tagToken.args
-      },
-      async render (ctx: Context) {
-        const content = await Promise.resolve(`{{${this.str}}}`)
-        return this.liquid.parseAndRender(content.toString(), ctx)
-      }
-    })
    const tpl = `{{ 'now' | date }}`
    const html = await liquid.parseAndRender(tpl)
    // sample: Thursday, February 2, 2023 at 6:25 pm +0000
@@ -544,13 +519,6 @@ describe('Issues', function () {
    const result = engine.parseAndRenderSync(`\n{{ "foo" | pos }}`)
    expect(result).toEqual('\n[2,12] foo')
  })
-  it("memoryLimit doesn't work in for tag #776", () => {
-    const engine = new Liquid({
-      memoryLimit: 1e5
-    })
-    const tpl = `{% for i in (1..1000000000) %} {{'a'}} {% endfor %}`
-    expect(() => engine.parseAndRenderSync(tpl)).toThrow('memory alloc limit exceeded, line:1, col:1')
-  })
  it('group_by_exp fails with object as input #785', () => {
    const site = {
      tags: {
@@ -288,9 +288,6 @@ describe('filters/array', function () {
    it('should slice substr by -2,2', () => test('{{ "abc" | slice: -2, 2 }}', 'bc'))
    it('should support array', () => test('{{ "1,2,3,4" | split: "," | slice: 1,2 | join }}', '2 3'))
    it('should return empty array for nil value', () => test('{{ nil | slice: 0 }}', ''))
-    it('should return empty when begin is out of negative range', () => test('{{ "hello" | slice: -10, 2 }}', ''))
-    it('should return empty when length is negative', () => test('{{ "Liquid" | slice: 1, -2 }}', ''))
-    it('should return empty array when begin is out of negative range', () => test('{{ "1,2,3,4,5" | split: "," | slice: -10, 2 | join: "," }}', ''))
  })
  describe('sort', function () {
    it('should support sort', function () {
@@ -140,18 +140,6 @@ describe('filters/date', function () {
    it('should support timezone name argument when DST is active', function () {
      return test('{{ "2021-06-01T23:00:00Z" | date: "%Y-%m-%dT%H:%M:%S", "America/New_York" }}', '2021-06-01T19:00:00')
    })
-    it('should not shift %s by the timezone name argument', function () {
-      return test('{{ "2026-06-30T21:00:00Z" | date: "%s", "America/Toronto" }}', '1782853200')
-    })
-    it('should not shift %s by the timezone offset argument', function () {
-      return test('{{ "2026-06-30T21:00:00Z" | date: "%s", 360 }}', '1782853200')
-    })
-    it('should not shift %s by the timezoneOffset option', function () {
-      return test('{{ "2026-06-30T21:00:00Z" | date: "%s" }}', '1782853200', undefined, opts)
-    })
-    it('should truncate %s toward the epoch like Ruby strftime', function () {
-      return test('{{ "2026-06-30T17:00:00.500Z" | date: "%s" }}', '1782838800')
-    })
    it('should offset date literal with timezone 00:00 specified', function () {
      return test('{{ "1990-12-31T23:00:00+00:00" | date: "%Y-%m-%dT%H:%M:%S"}}', '1990-12-31T17:00:00', undefined, opts)
    })
@@ -216,31 +204,21 @@ describe('filters/date', function () {
      return test('{{ "1990-12-31T23:00:00Z" | date: "%Y-%m-%dT%H:%M:%S" }}', '1991-01-01T04:30:00', undefined, optsWithDateFormat)
    })
  })
-  describe('strftime width / memoryLimit', () => {
-    it('should charge memoryLimit for huge numeric strftime widths', () => {
-      const liquid = new Liquid({ memoryLimit: 500 })
-      expect(() => liquid.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f: '%5000000d' }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should charge memoryLimit for array format PoC', () => {
-      const liquid = new Liquid({ memoryLimit: 50, renderLimit: 1e9 })
-      expect(() => liquid.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f: ['a'.repeat(2000000)] }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should charge memoryLimit for object toString format PoC', () => {
-      const liquid = new Liquid({ memoryLimit: 50, renderLimit: 1e9 })
-      const huge = 'a'.repeat(2000000)
-      const f = { toString: () => huge }
-      expect(() => liquid.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should honor numeric strftime pad width when memoryLimit allows', () => {
-      const liquid = new Liquid({ memoryLimit: 1e7 })
+  describe('strftime width', () => {
+    it('should honor numeric strftime pad width', () => {
+      const liquid = new Liquid()
      const out = liquid.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f: '%5000d' })
      expect(out.length).toBe(5000)
-      const tight = new Liquid({ memoryLimit: 100 })
-      expect(() => tight.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f: '%5000d' }))
-        .toThrow('memory alloc limit exceeded')
+    })
+    it('should honor large numeric strftime pad width up to the cap', () => {
+      const liquid = new Liquid()
+      const out = liquid.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f: '%100000d' })
+      expect(out.length).toBe(100000)
+    })
+    it('should throw when numeric strftime pad width is too large', () => {
+      const liquid = new Liquid()
+      expect(() => liquid.parseAndRenderSync('{{ d | date: f }}', { d: 'now', f: '%5000000d' }))
+        .toThrow('strftime pad width limit exceeded')
    })
  })
 })
@@ -153,26 +153,6 @@ describe('filters/string', function () {
            '{{ string_with_newlines | strip_newlines }}',
    'Hellothere')
  })
-  describe('squish', function () {
-    it('should collapse whitespace between words', function () {
-      return test('{{ "Hello   World!" | squish }}', 'Hello World!')
-    })
-    it('should strip leading and trailing whitespace', function () {
-      return test('{{ "  HelloWorld!  " | squish }}', 'HelloWorld!')
-    })
-    it('should treat newlines and tabs as whitespace', function () {
-      return test('{{ " \n\t\r\nHello  \n\t World!  \n" | squish }}', 'Hello World!')
-    })
-    it('should return empty string for whitespace only', function () {
-      return test('{{ " \n\t " | squish }}', '')
-    })
-    it('should stringify a number', function () {
-      return test('{{ 5 | squish }}', '5')
-    })
-    it('should return empty string for undefined', function () {
-      return test('{{ nosuchthing | squish }}', '')
-    })
-  })
  describe('truncate', function () {
    it('should truncate when string too long', function () {
      return test('{{ "Ground control to Major Tom." | truncate: 20 }}',
@@ -7,14 +7,6 @@ describe('filters/url', () => {
      const html = liquid.parseAndRenderSync('{{ "%27Stop%21%27+said+Fred" | url_decode }}')
      expect(html).toEqual("'Stop!' said Fred")
    })
-    it('should decode %2B to a literal plus', () => {
-      const html = liquid.parseAndRenderSync('{{ "1%2B1" | url_decode }}')
-      expect(html).toEqual('1+1')
-    })
-    it('should keep a literal plus when round-tripped through url_encode', () => {
-      const html = liquid.parseAndRenderSync('{{ "a+b c" | url_encode | url_decode }}')
-      expect(html).toEqual('a+b c')
-    })
  })

  describe('url_encode', () => {
@@ -4,15 +4,18 @@ import { mock, restore } from '../../stub/mockfs'
 describe('DoS related', function () {
  describe('#parseLimit', function () {
    afterEach(restore)
+
    it('should throw when parse limit exceeded', async () => {
      const noLimit = new Liquid()
      const limit10 = new Liquid({ parseLimit: 10 })
      const limit90 = new Liquid({ parseLimit: 90 })
      const template = '{% capture bar %}{{ foo | bar: 3, a[3] }}{% endcapture %}'
+
      await expect(noLimit.parseAndRender(template)).resolves.toBe('')
      await expect(limit10.parseAndRender(template)).rejects.toThrow('parse length limit exceeded')
      await expect(limit90.parseAndRender(template)).resolves.toBe('')
    })
+
    it('should take included template into account', async () => {
      mock({
        '/small': 'Lorem ipsum',
@@ -23,119 +26,151 @@ describe('DoS related', function () {
      await expect(liquid.parseAndRender('{% include "large" %}')).rejects.toThrow('parse length limit exceeded')
    })
  })
-  describe('#renderLimit', () => {
+
+  describe('#templateLimit', () => {
    it('should throw when rendering too many templates', async () => {
      const src = '{% for i in (1..1000) %}{{i}},{% endfor %}'
      const noLimit = new Liquid()
-      const limitSmall = new Liquid({ renderLimit: 0.01 })
-      const limitLarge = new Liquid({ renderLimit: 2e4 })
+      const limitSmall = new Liquid({ templateLimit: 100 })
+      const limitLarge = new Liquid({ templateLimit: 2001 })
      await expect(noLimit.parseAndRender(src)).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
-      await expect(limitSmall.parseAndRender(src)).rejects.toThrow('template render limit exceeded')
+      await expect(limitSmall.parseAndRender(src)).rejects.toThrow('template limit exceeded')
      await expect(limitLarge.parseAndRender(src)).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
    })
+
    it('should support reset when calling render', async () => {
      const src = '{% for i in (1..1000) %}{{i}},{% endfor %}'
-      const liquid = new Liquid({ renderLimit: 0.01 })
-      await expect(liquid.parseAndRender(src)).rejects.toThrow('template render limit exceeded')
-      await expect(liquid.parseAndRender(src, {}, { renderLimit: 1e6 })).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
+      const liquid = new Liquid({ templateLimit: 100 })
+      await expect(liquid.parseAndRender(src)).rejects.toThrow('template limit exceeded')
+      await expect(liquid.parseAndRender(src, {}, { templateLimit: 2001 })).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
    })
+
    it('should take partials into account', async () => {
      mock({
        '/small': '{% for i in (1..5) %}{{i}}{% endfor %}',
        '/large': '{% for i in (1..50000000) %}{{i}}{% endfor %}'
      })
-      const liquid = new Liquid({ root: '/', renderLimit: 1000 })
-      await expect(liquid.parseAndRender('{% render "large" %}')).rejects.toThrow('template render limit exceeded')
+      const liquid = new Liquid({ root: '/', templateLimit: 1000 })
+      await expect(liquid.parseAndRender('{% render "large" %}')).rejects.toThrow('template limit exceeded')
      await expect(liquid.parseAndRender('{% render "small" %}')).resolves.toBe('12345')
    })
-    it('should enforce renderLimit when for body has no template nodes', () => {
-      const liquid = new Liquid({ memoryLimit: 1e9, renderLimit: 1 })
-      expect(() => liquid.parseAndRenderSync('{%- for i in (1..5000000) -%}{%- endfor -%}', {}))
-        .toThrow('template render limit exceeded')
-    })
-    it('should enforce renderLimit when tablerow body has no template nodes', () => {
-      const liquid = new Liquid({ memoryLimit: 1e9, renderLimit: 1 })
-      expect(() => liquid.parseAndRenderSync('{%- tablerow i in (1..1000000) cols:1 -%}{%- endtablerow -%}', {}))
-        .toThrow('template render limit exceeded')
-    })
  })
-  describe('#memoryLimit', () => {
-    it('should throw for too many array creation in filters', async () => {
-      const array = Array(1e3).fill(0)
-      const liquid = new Liquid({ memoryLimit: 100 })
-      await expect(liquid.parseAndRender('{{ array | slice: 0, 3 | join }}', { array })).resolves.toBe('0 0 0')
-      await expect(liquid.parseAndRender('{{ array | slice: 0, 300 | join }}', { array })).rejects.toThrow('memory alloc limit exceeded, line:1, col:1')
+
+  describe('#outputLengthLimit', () => {
+    it('should throw when output length exceeded', async () => {
+      const src = '{% for i in (1..1000) %}{{i}},{% endfor %}'
+      const noLimit = new Liquid()
+      const limitSmall = new Liquid({ outputLengthLimit: 10 })
+      const limitLarge = new Liquid({ outputLengthLimit: 5000 })
+      await expect(noLimit.parseAndRender(src)).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
+      await expect(limitSmall.parseAndRender(src)).rejects.toThrow('output length limit exceeded')
+      await expect(limitLarge.parseAndRender(src)).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
    })
+
    it('should support reset when calling render', async () => {
-      const array = Array(1e3).fill(0)
-      const liquid = new Liquid({ memoryLimit: 100 })
-      await expect(liquid.parseAndRender('{{ array | slice: 0, 300 | join }}', { array })).rejects.toThrow('memory alloc limit exceeded, line:1, col:1')
-      await expect(liquid.parseAndRender('{{ array | slice: 0, 300 | join }}', { array }, { memoryLimit: 1e3 })).resolves.toBe(Array(300).fill(0).join(' '))
+      const src = '{% for i in (1..1000) %}{{i}},{% endfor %}'
+      const liquid = new Liquid({ outputLengthLimit: 10 })
+      await expect(liquid.parseAndRender(src)).rejects.toThrow('output length limit exceeded')
+      await expect(liquid.parseAndRender(src, {}, { outputLengthLimit: 5000 })).resolves.toMatch(/^1,2,3,4,5,.*,999,1000,$/)
    })
-    it('should throw for too many array iteration in tags', async () => {
-      const array = ['a']
-      const liquid = new Liquid({ memoryLimit: 100 })
-      const src = '{% for i in (1..count) %}{% assign array = array | concat: array %}{% endfor %}{{ array | join }}'
-      await expect(liquid.parseAndRender(src, { array, count: 3 })).resolves.toBe('a a a a a a a a')
-      await expect(liquid.parseAndRender(src, { array, count: 100 })).rejects.toThrow('memory alloc limit exceeded, line:1, col:26')
+
+    it('should take partials into account', async () => {
+      mock({
+        '/small': 'abc',
+        '/large': '{% for i in (1..1000) %}{{i}}{% endfor %}'
+      })
+      const liquid = new Liquid({ root: '/', outputLengthLimit: 10 })
+      await expect(liquid.parseAndRender('{% render "small" %}')).resolves.toBe('abc')
+      await expect(liquid.parseAndRender('{% render "large" %}')).rejects.toThrow('output length limit exceeded')
    })
-    it('should charge pop allocation to memoryLimit', async () => {
-      const array = Array(1e3).fill(0)
-      const liquid = new Liquid({ memoryLimit: 100 })
-      await expect(liquid.parseAndRender('{{ array | pop | size }}', { array })).rejects.toThrow('memory alloc limit exceeded')
+
+    it('should enforce outputLengthLimit in sync render', () => {
+      const liquid = new Liquid({ outputLengthLimit: 5 })
+      expect(() => liquid.parseAndRenderSync('{% for i in (1..100) %}{{i}}{% endfor %}'))
+        .toThrow('output length limit exceeded')
    })
-    it('should charge sample allocation to memoryLimit', async () => {
-      const array = Array(1e3).fill(0)
-      const liquid = new Liquid({ memoryLimit: 100 })
-      await expect(liquid.parseAndRender('{{ array | sample: 1 | size }}', { array })).rejects.toThrow('memory alloc limit exceeded')
-    })
-    it('should charge join by produced output size, not element count', () => {
-      const array = ['a'.repeat(100), 'b'.repeat(100)]
-      const liquid = new Liquid({ memoryLimit: 100 })
-      expect(() => liquid.parseAndRenderSync('{{ array | join: "" }}', { array }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should allow join within memoryLimit', () => {
-      const array = ['a'.repeat(20), 'b'.repeat(20)]
-      const liquid = new Liquid({ memoryLimit: 100 })
-      expect(liquid.parseAndRenderSync('{{ array | join: "" }}', { array })).toBe('a'.repeat(20) + 'b'.repeat(20))
-    })
-    it('should prevent concat doubling from bypassing join memoryLimit', () => {
-      const liquid = new Liquid({ memoryLimit: 1e4 })
-      const src = '{%- assign a = s | split: "NOSEP" -%}' +
-        '{%- assign a = a | concat: a -%}{%- assign a = a | concat: a -%}{%- assign a = a | concat: a -%}' +
-        '{{ a | join: "" | size }}'
-      expect(() => liquid.parseAndRenderSync(src, { s: 'a'.repeat(5000) }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should charge array_to_sentence_string by produced output size', () => {
-      const array = ['a'.repeat(100), 'b'.repeat(100), 'c'.repeat(100)]
-      const liquid = new Liquid({ memoryLimit: 100 })
-      expect(() => liquid.parseAndRenderSync('{{ array | array_to_sentence_string }}', { array }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should charge json serialization of concat-doubled arrays', () => {
-      const liquid = new Liquid({ memoryLimit: 1e4 })
-      const src = '{%- assign a = s | split: "NOSEP" -%}' +
-        '{%- assign a = a | concat: a -%}{%- assign a = a | concat: a -%}{%- assign a = a | concat: a -%}' +
-        '{{ a | json | size }}'
-      expect(() => liquid.parseAndRenderSync(src, { s: 'a'.repeat(5000) }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should charge inspect serialization of concat-doubled arrays', () => {
-      const liquid = new Liquid({ memoryLimit: 1e4 })
-      const src = '{%- assign a = s | split: "NOSEP" -%}' +
-        '{%- assign a = a | concat: a -%}{%- assign a = a | concat: a -%}{%- assign a = a | concat: a -%}' +
-        '{{ a | inspect | size }}'
-      expect(() => liquid.parseAndRenderSync(src, { s: 'a'.repeat(5000) }))
-        .toThrow('memory alloc limit exceeded')
-    })
-    it('should charge strip_html input length to memoryLimit', () => {
-      const liquid = new Liquid({ memoryLimit: 100 })
-      expect(() => liquid.parseAndRenderSync('{{ s | strip_html }}', { s: 'a'.repeat(200) }))
-        .toThrow('memory alloc limit exceeded')
+
+    it('should enforce outputLengthLimit in stream render', async () => {
+      const liquid = new Liquid({ outputLengthLimit: 5 })
+      const tpl = liquid.parse('{% for i in (1..100) %}{{i}}{% endfor %}')
+      const stream = liquid.renderToNodeStream(tpl)
+      await expect(new Promise((resolve, reject) => {
+        stream.on('error', reject)
+        stream.on('end', resolve)
+      })).rejects.toThrow('output length limit exceeded')
    })
  })
+
+  describe('#maxDepth', () => {
+    function chain (depth: number, tag: string) {
+      const templates: Record<string, string> = {}
+      for (let i = 0; i < depth; i++) {
+        templates[`t${i}`] = i === depth - 1 ? 'done' : `{% ${tag} "t${i + 1}" %}`
+      }
+      return templates
+    }
+
+    it('should throw when include depth exceeded', async () => {
+      const liquid = new Liquid({ templates: chain(3, 'include'), maxDepth: 2 })
+      await expect(liquid.parseAndRender('{% include "t0" %}')).rejects.toThrow('template depth limit exceeded')
+    })
+
+    it('should allow include within maxDepth', async () => {
+      const liquid = new Liquid({ templates: chain(2, 'include'), maxDepth: 2 })
+      await expect(liquid.parseAndRender('{% include "t0" %}')).resolves.toBe('done')
+    })
+
+    it('should throw when render depth exceeded', async () => {
+      const liquid = new Liquid({ templates: chain(3, 'render'), maxDepth: 2 })
+      await expect(liquid.parseAndRender('{% render "t0" %}')).rejects.toThrow('template depth limit exceeded')
+    })
+
+    it('should allow render within maxDepth', async () => {
+      const liquid = new Liquid({ templates: chain(2, 'render'), maxDepth: 2 })
+      await expect(liquid.parseAndRender('{% render "t0" %}')).resolves.toBe('done')
+    })
+
+    it('should throw when layout depth exceeded', async () => {
+      const liquid = new Liquid({
+        templates: {
+          a: '{% layout "b" %}body-a',
+          b: '{% layout "c" %}body-b',
+          c: 'body-c'
+        },
+        maxDepth: 2
+      })
+      await expect(liquid.parseAndRender('{% layout "a" %}root')).rejects.toThrow('template depth limit exceeded')
+    })
+
+    it('should allow layout within maxDepth', async () => {
+      const liquid = new Liquid({
+        templates: {
+          a: '{% layout "b" %}body-a',
+          b: 'body-b'
+        },
+        maxDepth: 2
+      })
+      await expect(liquid.parseAndRender('{% layout "a" %}root')).resolves.toBe('body-b')
+    })
+
+    it('should not count layout none toward depth', async () => {
+      const liquid = new Liquid({ maxDepth: 0 })
+      await expect(liquid.parseAndRender('{% layout none %}ok')).resolves.toBe('ok')
+    })
+
+    it('should default maxDepth to 128', async () => {
+      const liquid = new Liquid({ templates: chain(128, 'include') })
+      await expect(liquid.parseAndRender('{% include "t0" %}')).resolves.toBe('done')
+      const overflow = new Liquid({ templates: chain(129, 'include') })
+      await expect(overflow.parseAndRender('{% include "t0" %}')).rejects.toThrow('template depth limit exceeded')
+    })
+
+    it('should enforce maxDepth in sync render', () => {
+      const liquid = new Liquid({ templates: chain(3, 'include'), maxDepth: 2 })
+      expect(() => liquid.parseAndRenderSync('{% include "t0" %}')).toThrow('template depth limit exceeded')
+    })
+  })
+
  describe('strip_html ReDoS', () => {
    // Regression for O(n^2) backtracking on unclosed `<script` / `<style` openers.
    // The previous regex stalled the event loop for ~10s on 350KB of `'<script'.repeat`.
@@ -145,11 +180,13 @@ describe('DoS related', function () {
      const payload = '<script'.repeat(50000)
      expect(liquid.parseAndRenderSync('{{ x | strip_html }}', { x: payload })).toBe(payload)
    }, 1000)
+
    it('should handle many unclosed <style openers in linear time', () => {
      const liquid = new Liquid()
      const payload = '<style'.repeat(50000)
      expect(liquid.parseAndRenderSync('{{ x | strip_html }}', { x: payload })).toBe(payload)
    }, 1000)
+
    it('should handle <script openers that have > but no </script> in linear time', () => {
      const liquid = new Liquid()
      const payload = '<script>foo'.repeat(50000)
@@ -1,39 +0,0 @@
-import { Liquid } from '../../../src/liquid'
-
-describe('LiquidOptions#*keepOutputType*', function () {
-  it('should respect keepOutputType', async function () {
-    const engine = new Liquid({
-      keepOutputType: true
-    })
-    const context = {
-      'my-boolean': true,
-      'my-number': 42,
-      'my-string': 'test'
-    }
-    const booleanHtml = await engine.parseAndRender('{{my-boolean}}', context)
-    expect(booleanHtml).toBe(true)
-    const numberHtml = await engine.parseAndRender('{{my-number}}', context)
-    expect(numberHtml).toBe(42)
-    const html = await engine.parseAndRender('{{my-string}}', context)
-    expect(html).toBe('test')
-    const composedHtml = await engine.parseAndRender('{{my-string}}:{{my-number}}', context)
-    expect(composedHtml).toBe('test:42')
-  })
-
-  it('should respect keepOutputType = false as default', async function () {
-    const engine = new Liquid()
-    const context = {
-      'my-boolean': true,
-      'my-number': 42,
-      'my-string': 'test'
-    }
-    const booleanHtml = await engine.parseAndRender('{{my-boolean}}', context)
-    expect(booleanHtml).toBe('true')
-    const numberHtml = await engine.parseAndRender('{{my-number}}', context)
-    expect(numberHtml).toBe('42')
-    const html = await engine.parseAndRender('{{my-string}}', context)
-    expect(html).toBe('test')
-    const composedHtml = await engine.parseAndRender('{{my-string}}:{{my-number}}', context)
-    expect(composedHtml).toBe('test:42')
-  })
-})
@@ -1,6 +1,7 @@
 import { Liquid, Context, isFalsy } from '../../../src'
 import { mock, restore } from '../../stub/mockfs'
 import { drainStream } from '../../stub/stream'
+import { ThrowingTag } from '../../stub/tags'
 import { resolve } from 'path'

 describe('Liquid', function () {
@@ -231,11 +232,7 @@ describe('Liquid', function () {
        '/root/error.html': 'A{%throwingTag%}B'
      })
      engine = new Liquid({ root: ['/root/'] })
-      engine.registerTag('throwingTag', {
-        render: function () {
-          throw new Error('intended render error')
-        }
-      })
+      engine.registerTag('throwingTag', ThrowingTag)
    })
    afterEach(restore)
    it('should render a simple value', async () => {
@@ -244,7 +241,7 @@ describe('Liquid', function () {
    })
    it('should throw RenderError when tag throws', async () => {
      const stream = await engine.renderFileToNodeStream('error.html')
-      expect(drainStream(stream)).rejects.toThrow(/intended render error/)
+      expect(drainStream(stream)).rejects.toThrow(/intended error/)
    })
  })
  describe('#analyze', () => {
@@ -1,4 +1,4 @@
-import { Liquid, filters } from '../../../src'
+import { Liquid } from '../../../src/liquid'

 describe('liquid#registerFilter()', function () {
  let liquid: Liquid
@@ -67,32 +67,3 @@ describe('liquid#registerFilter()', function () {
    await expect(new Liquid({ strictFilters: true }).parseAndRender('{{ 1 | constructor }}')).rejects.toThrow('undefined filter')
  })
 })
-
-describe('liquid#unregisterFilter()', function () {
-  let liquid: Liquid
-  beforeEach(() => { liquid = new Liquid() })
-
-  it('should unregister a custom filter', async () => {
-    liquid.registerFilter('greet', value => `hello ${value}`)
-    liquid.unregisterFilter('greet')
-    const html = await liquid.parseAndRender('{{ "world" | greet }}')
-    return expect(html).toBe('world')
-  })
-
-  it('should unregister a built-in filter', () => {
-    liquid = new Liquid({ strictFilters: true })
-    liquid.unregisterFilter('upcase')
-    return expect(liquid.parseAndRender('{{ "foo" | upcase }}')).rejects.toThrow('undefined filter: upcase')
-  })
-
-  it('should support re-registering a built-in filter', async () => {
-    liquid.unregisterFilter('upcase')
-    liquid.registerFilter('upcase', filters.upcase)
-    const html = await liquid.parseAndRender('{{ "foo" | upcase }}')
-    return expect(html).toBe('FOO')
-  })
-
-  it('should not throw for an unknown filter', () => {
-    expect(() => liquid.unregisterFilter('unknown')).not.toThrow()
-  })
-})
@@ -1,38 +1,57 @@
 import { Liquid } from '../../../src/liquid'
+import { Tag } from '../../../src/template/tag'
+import type { Context } from '../../../src/context'
+import type { TagToken, TopLevelToken } from '../../../src/tokens'

 describe('liquid#registerTag()', function () {
  it('should support render to simple string', async () => {
+    class SimpleStringTag extends Tag {
+      render () {
+        return 'B'
+      }
+    }
    const liquid = new Liquid()
-    liquid.registerTag('simple-string', {
-      render: () => 'B'
-    })
+    liquid.registerTag('simple-string', SimpleStringTag)
    const html = await liquid.parseAndRender(`A{% simple-string %}C`)
    return expect(html).toBe('ABC')
  })
  it('should support async tag render', async () => {
+    class AsyncStringTag extends Tag {
+      async render () {
+        return 'B'
+      }
+    }
    const liquid = new Liquid()
-    liquid.registerTag('async-string', {
-      render: async () => 'B'
-    })
+    liquid.registerTag('async-string', AsyncStringTag)
    const html = await liquid.parseAndRender(`A{% async-string %}C`)
    return expect(html).toBe('ABC')
  })
  it('should have access to ctx in render()', async () => {
+    class DynamicStringTag extends Tag {
+      async render (ctx: Context) {
+        return ctx.get(['c'])
+      }
+    }
    const liquid = new Liquid()
-    liquid.registerTag('dynamic-string', {
-      render: async (ctx) => ctx.get(['c'])
-    })
+    liquid.registerTag('dynamic-string', DynamicStringTag)
    const html = await liquid.parseAndRender(`A{% dynamic-string %}C`, {
      c: 'B'
    })
    return expect(html).toBe('ABC')
  })
  it('should have access to tag arguments', async () => {
+    class ArgumentReflectorTag extends Tag {
+      variable: string
+      constructor (token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid) {
+        super(token, remainTokens, liquid)
+        this.variable = token.args.split('=')[1]
+      }
+      async render (ctx: Context) {
+        return ctx.get([this.variable])
+      }
+    }
    const liquid = new Liquid()
-    liquid.registerTag('argument-reflector', {
-      parse: function (token) { this.variable = token.args.split('=')[1] },
-      render: async function (ctx) { return ctx.get(this.variable) }
-    })
+    liquid.registerTag('argument-reflector', ArgumentReflectorTag)
    const html = await liquid.parseAndRender(`A{% argument-reflector variable=c %}C`, {
      c: 'B'
    })
@@ -0,0 +1,61 @@
+import { Liquid } from '../../../src/liquid'
+import { Drop } from '../../../src/drop/drop'
+
+describe('scope security', function () {
+  let liquid: Liquid
+
+  beforeEach(function () {
+    liquid = new Liquid()
+  })
+
+  it('should iterate plain objects via inherited Symbol.iterator (ownPropertyOnly exception)', async function () {
+    // eslint-disable-next-line no-extend-native
+    (Object.prototype as any)[Symbol.iterator] = function * () { yield 'inherited' }
+    try {
+      await expect(liquid.parseAndRender(
+        '{% for x in obj %}{{ x }}{% endfor %}',
+        { obj: {} }
+      )).resolves.toBe('inherited')
+    } finally {
+      delete (Object.prototype as any)[Symbol.iterator]
+    }
+  })
+
+  it('should not read inherited size on plain objects', async function () {
+    const obj = Object.create({ size: 99 })
+    obj.own = 'yes'
+    await expect(liquid.parseAndRender('{{ obj.size }}', { obj })).resolves.toBe('1')
+  })
+
+  it('should read inherited size when ownPropertyOnly=false', async function () {
+    liquid = new Liquid({ ownPropertyOnly: false })
+    const obj = Object.create({ size: 99 })
+    await expect(liquid.parseAndRender('{{ obj.size }}', { obj })).resolves.toBe('99')
+  })
+
+  it('should still iterate Drop with Symbol.iterator', async function () {
+    class IterableDrop extends Drop {
+      * [Symbol.iterator] () {
+        yield 'a'
+        yield 'b'
+      }
+    }
+    await expect(liquid.parseAndRender(
+      '{% for x in drop %}{{ x }}{% endfor %}',
+      { drop: new IterableDrop() }
+    )).resolves.toBe('ab')
+  })
+
+  it('should block own blocked keys when ownPropertyOnly=true', async function () {
+    const scope = JSON.parse('{"__proto__": {"polluted": true}, "constructor": {"name": "Custom"}, "name": "Alice"}')
+    await expect(liquid.parseAndRender('{{ __proto__.polluted }}', scope)).resolves.toBe('')
+    await expect(liquid.parseAndRender('{{ constructor.name }}', scope)).resolves.toBe('')
+    await expect(liquid.parseAndRender('{{ name }}', scope)).resolves.toBe('Alice')
+  })
+
+  it('should block inherited properties when ownPropertyOnly=true', async function () {
+    const scope = { foo: Object.create({ __proto__: { bar: 'BAR' }, constructor: { name: 'Evil' } }) }
+    await expect(liquid.parseAndRender('{{ foo.__proto__ }}', scope)).resolves.toBe('')
+    await expect(liquid.parseAndRender('{{ foo.constructor }}', scope)).resolves.toBe('')
+  })
+})
@@ -2,7 +2,8 @@ import { RenderError } from '../../../src/util/error'
 import { Liquid } from '../../../src/liquid'
 import { resolve } from 'path'
 import { mock, restore } from '../../stub/mockfs'
-import { throwIntendedError, rejectIntendedError } from '../../stub/util'
+import { throwIntendedError } from '../../stub/util'
+import { ThrowingTag, RejectingTag, ThrowsOnParseTag } from '../../stub/tags'

 const strictEngine = new Liquid({
  strictVariables: true,
@@ -13,9 +14,9 @@ const strictCatchingEngine = new Liquid({
  strictVariables: true,
  strictFilters: true
 })
-strictEngine.registerTag('throwingTag', { render: throwIntendedError })
+strictEngine.registerTag('throwingTag', ThrowingTag)
 strictEngine.registerFilter('throwingFilter', throwIntendedError)
-strictCatchingEngine.registerTag('throwingTag', { render: throwIntendedError })
+strictCatchingEngine.registerTag('throwingTag', ThrowingTag)
 strictCatchingEngine.registerFilter('throwingFilter', throwIntendedError)

 describe('error', function () {
@@ -83,8 +84,8 @@ describe('error', function () {
      engine = new Liquid({
        root: '/'
      })
-      engine.registerTag('throwingTag', { render: throwIntendedError })
-      engine.registerTag('rejectingTag', { render: rejectIntendedError })
+      engine.registerTag('throwingTag', ThrowingTag)
+      engine.registerTag('rejectingTag', RejectingTag)
      engine.registerFilter('throwingFilter', throwIntendedError)
    })
    it('should throw RenderError when tag throws', async function () {
@@ -244,10 +245,7 @@ describe('error', function () {
    let engine: Liquid
    beforeEach(function () {
      engine = new Liquid()
-      engine.registerTag('throwsOnParse', {
-        parse: throwIntendedError,
-        render: () => ''
-      })
+      engine.registerTag('throwsOnParse', ThrowsOnParseTag)
    })
    it('should throw ParseError when filter not defined', async function () {
      await expect(strictEngine.parseAndRender('{{1 | a}}')).rejects.toMatchObject({
@@ -337,11 +335,7 @@ describe('error', function () {
      engine = new Liquid({
        root: '/'
      })
-      engine.registerTag('throwingTag', {
-        render: function () {
-          throw new Error('intended error')
-        }
-      })
+      engine.registerTag('throwingTag', ThrowingTag)
    })
    it('should throw RenderError when tag throws', function () {
      const src = '{%throwingTag%}'
@@ -1085,24 +1085,4 @@ describe('Variable analysis', () => {
      locals: { y: [new Variable(['y'], { row: 1, col: 11, file: 'a' })] }
    })
  })
-
-  describe('grouped expressions', () => {
-    const ge = new Liquid({ groupedExpressions: true })
-
-    it('should report variables inside a grouped output expression', () => {
-      const analysis = analyzeSync(ge.parse('{{ (a | append: b) }}'))
-      expect(Object.keys(analysis.variables).sort()).toStrictEqual(['a', 'b'])
-    })
-
-    it('should report variables inside a grouped condition', () => {
-      const analysis = analyzeSync(ge.parse('{% if (a | append: b) == c %}{% endif %}'))
-      expect(Object.keys(analysis.globals).sort()).toStrictEqual(['a', 'b', 'c'])
-    })
-
-    it('should separate locals from globals for grouped assign', () => {
-      const analysis = analyzeSync(ge.parse('{% assign x = (a | upcase) %}{{ x }}'))
-      expect(Object.keys(analysis.globals)).toStrictEqual(['a'])
-      expect(Object.keys(analysis.locals)).toStrictEqual(['x'])
-    })
-  })
 })
@@ -99,13 +99,4 @@ describe('tags/assign', function () {
    const html = liquid.parseAndRenderSync(src)
    return expect(html).toBe('bar')
  })
-  describe('grouped expressions', function () {
-    const ge = new Liquid({ groupedExpressions: true })
-    it('should assign a grouped expression', async () => {
-      expect(await ge.parseAndRender('{% assign x = (name | upcase) %}{{ x }}', { name: 'bar' })).toBe('BAR')
-    })
-    it('should assign a grouped range', async () => {
-      expect(await ge.parseAndRender('{% assign x = (1..(items | size)) %}{{ x }}', { items: ['a', 'b', 'c'] })).toBe('123')
-    })
-  })
 })
@@ -132,30 +132,4 @@ describe('tags/case', function () {
      TRUE
    `)
  })
-  describe('parenthesized filter chains', function () {
-    describe('when enabled', () => {
-      const ge = new Liquid({ groupedExpressions: true })
-      it('should support grouped expression in case value', () => {
-        const src = '{% case (status | downcase) %}{% when "active" %}active{% when "pending" %}pending{% else %}other{% endcase %}'
-        const html = ge.parseAndRenderSync(src, { status: 'ACTIVE' })
-        expect(html).toBe('active')
-      })
-      it('should support grouped expression in when value', () => {
-        const src = '{% case status %}{% when (expected | downcase) %}match{% else %}no match{% endcase %}'
-        const html = ge.parseAndRenderSync(src, { status: 'active', expected: 'ACTIVE' })
-        expect(html).toBe('match')
-      })
-    })
-    describe('when disabled', () => {
-      const ge = new Liquid({ groupedExpressions: false })
-      it('should throw error for grouped expression in case value', () => {
-        const src = '{% case (status | downcase) %}{% when "active" %}active{% when "pending" %}pending{% else %}other{% endcase %}'
-        expect(() => ge.parseAndRenderSync(src, { status: 'ACTIVE' })).toThrow('invalid range syntax')
-      })
-      it('should throw error for grouped expression in when value', () => {
-        const src = '{% case status %}{% when (expected | downcase) %}match{% else %}no match{% endcase %}'
-        expect(() => ge.parseAndRenderSync(src, { status: 'active', expected: 'ACTIVE' })).toThrow('invalid range syntax')
-      })
-    })
-  })
 })
@@ -36,14 +36,4 @@ describe('tags/echo', function () {
    const html = await liquid.parseAndRender(src, { user: { name: 'Sally' } })
    return expect(html).toBe('Hello, SALLY!')
  })
-
-  describe('grouped expressions', function () {
-    const ge = new Liquid({ groupedExpressions: true })
-    it('should echo a grouped expression', async () => {
-      expect(await ge.parseAndRender('{% echo (name | upcase) %}', { name: 'bar' })).toBe('BAR')
-    })
-    it('should render a grouped expression in an output statement', async () => {
-      expect(await ge.parseAndRender('{{ (name | upcase | append: "!") }}', { name: 'bar' })).toBe('BAR!')
-    })
-  })
 })
@@ -7,9 +7,6 @@ describe('tags/for', function () {
  let liquid: Liquid, scope: Scope
  beforeEach(function () {
    liquid = new Liquid()
-    liquid.registerTag('throwingTag', {
-      render: function () { throw new Error('intended render error') }
-    })
    scope = {
      one: 1,
      // eslint-disable-next-line
@@ -123,6 +120,18 @@ describe('tags/for', function () {
      const html = await liquid.parseAndRender(src, scope)
      return expect(html).toBe('b')
    })
+
+    it('should goto else when limit empties collection', async function () {
+      const src = '{%for c in alpha limit:0%}a{%else%}b{%endfor%}'
+      const html = await liquid.parseAndRender(src, scope)
+      return expect(html).toBe('b')
+    })
+
+    it('should goto else when offset past end', async function () {
+      const src = '{%for c in alpha offset:10%}a{%else%}b{%endfor%}'
+      const html = await liquid.parseAndRender(src, scope)
+      return expect(html).toBe('b')
+    })
  })

  it('should support for with forloop', async function () {
@@ -426,21 +435,4 @@ describe('tags/for', function () {
      return expect(html).toBe('i-someDrop i-someDrop i-someDrop ')
    })
  })
-  describe('parenthesized filter chains', function () {
-    describe('when enabled', function () {
-      const ge = new Liquid({ groupedExpressions: true })
-      it('should support range with filtered RHS', function () {
-        const src = '{% for i in (1..(items | size)) %}{{i}} {% endfor %}'
-        const html = ge.parseAndRenderSync(src, { items: ['a', 'b', 'c'] })
-        expect(html).toBe('1 2 3 ')
-      })
-    })
-    describe('when disabled', function () {
-      const ge = new Liquid({ groupedExpressions: false })
-      it('should throw for range with filtered RHS', function () {
-        const src = '{% for i in (1..(items | size)) %}{{i}} {% endfor %}'
-        expect(() => ge.parseAndRenderSync(src, { items: ['a', 'b', 'c'] })).toThrow('invalid range syntax')
-      })
-    })
-  })
 })
@@ -169,84 +169,4 @@ describe('tags/if', function () {
    expect(() => liquid.parseAndRenderSync('{% if false %}{% else %}{% elsif true %}{% endif %}'))
      .toThrow(`unexpected elsif after else`)
  })
-  describe('parenthesized filter chains', function () {
-    describe('when enabled', function () {
-      const ge = new Liquid({ groupedExpressions: true })
-      it('should support (foo | upcase) == "BAR"', async function () {
-        const src = '{% if (foo | upcase) == "BAR" %}yes{% else %}no{% endif %}'
-        const html = await ge.parseAndRender(src, { foo: 'bar' })
-        return expect(html).toBe('yes')
-      })
-      it('should support both sides parenthesized', async function () {
-        const src = '{% if (a | upcase) == (b | upcase) %}yes{% else %}no{% endif %}'
-        const html = await ge.parseAndRender(src, { a: 'hi', b: 'hi' })
-        return expect(html).toBe('yes')
-      })
-      it('should support with logical operators', async function () {
-        const src = '{% if (a | upcase) == "FOO" and (b | downcase) == "bar" %}yes{% else %}no{% endif %}'
-        const html = await ge.parseAndRender(src, { a: 'foo', b: 'BAR' })
-        return expect(html).toBe('yes')
-      })
-      it('should support standalone parenthesized filter via evalValueSync', function () {
-        const result = ge.evalValueSync('(foo | upcase)', { foo: 'bar' })
-        return expect(result).toBe('BAR')
-      })
-      it('should support comparison via evalValueSync', function () {
-        const result = ge.evalValueSync('(foo | upcase) == "BAR"', { foo: 'bar' })
-        return expect(result).toBe(true)
-      })
-      it('should keep range syntax working', function () {
-        const result = ge.evalValueSync('(1..5)', {})
-        return expect(result).toEqual([1, 2, 3, 4, 5])
-      })
-      it('should support chained filters in condition', async function () {
-        const src = '{% if (name | downcase | size) > 3 %}long{% else %}short{% endif %}'
-        const html = await ge.parseAndRender(src, { name: 'Alice' })
-        return expect(html).toBe('long')
-      })
-      it('should support real parenthesis grouping with comparisons and and', async function () {
-        const src = '{% if (((name | downcase | size) > 3) and (one < three)) %}long{% else %}short{% endif %}'
-        const html = await ge.parseAndRender(src, { name: 'Alice', one: 1, three: 3 })
-        return expect(html).toBe('long')
-      })
-      it('should support nested parenthesized expressions in if condition', async function () {
-        const src = '{% if ((foo | append: "!") | upcase) == "BAR!" %}match{% else %}no match{% endif %}'
-        const html = await ge.parseAndRender(src, { foo: 'bar' })
-        return expect(html).toBe('match')
-      })
-      it('should support or with grouped operands', async function () {
-        const src = '{% if (a | upcase) == "X" or (b | upcase) == "B" %}yes{% else %}no{% endif %}'
-        expect(await ge.parseAndRender(src, { a: 'z', b: 'b' })).toBe('yes')
-      })
-      it('should support not with a grouped operand', async function () {
-        const src = '{% if not (a | upcase) == "B" %}no{% else %}yes{% endif %}'
-        expect(await ge.parseAndRender(src, { a: 'b' })).toBe('yes')
-      })
-      it('should support contains with a grouped operand', async function () {
-        const src = '{% if (csv | split: ",") contains "b" %}yes{% else %}no{% endif %}'
-        expect(await ge.parseAndRender(src, { csv: 'a,b,c' })).toBe('yes')
-      })
-      it('should support property access on a grouped result', function () {
-        expect(ge.evalValueSync('(items | first).name', { items: [{ name: 'Sally' }] })).toBe('Sally')
-      })
-      it('should support a grouped expression inside a bracket index', function () {
-        expect(ge.evalValueSync('arr[(i | plus: 1)]', { arr: [10, 20, 30], i: 1 })).toBe(30)
-      })
-      it('should support an async filter inside a grouped expression', async function () {
-        ge.registerFilter('asyncUpcase', (v: string) => Promise.resolve(String(v).toUpperCase()))
-        const src = '{% if (name | asyncUpcase) == "BAR" %}yes{% else %}no{% endif %}'
-        expect(await ge.parseAndRender(src, { name: 'bar' })).toBe('yes')
-      })
-    })
-    describe('when disabled', function () {
-      const ge = new Liquid({ groupedExpressions: false })
-      it('should throw for parenthesized filter in condition', () => {
-        const src = '{% if (foo | upcase) == "BAR" %}yes{% else %}no{% endif %}'
-        expect(() => ge.parseAndRenderSync(src, { foo: 'bar' })).toThrow('invalid range syntax')
-      })
-      it('should throw for parenthesized filter via evalValueSync', () => {
-        expect(() => ge.evalValueSync('(foo | upcase)', { foo: 'bar' })).toThrow('invalid range syntax')
-      })
-    })
-  })
 })
@@ -83,21 +83,4 @@ describe('tags/unless', function () {
      expect(html).toBe('yes')
    })
  })
-  describe('parenthesized filter chains', function () {
-    describe('when enabled', function () {
-      const ge = new Liquid({ groupedExpressions: true })
-      it('should support grouped expression in unless condition', function () {
-        const src = '{% unless (content | size) == 0 %}has content{% else %}empty{% endunless %}'
-        const html = ge.parseAndRenderSync(src, { content: 'hello' })
-        expect(html).toBe('has content')
-      })
-    })
-    describe('when disabled', function () {
-      const ge = new Liquid({ groupedExpressions: false })
-      it('should throw for grouped expression in unless condition', function () {
-        const src = '{% unless (content | size) == 0 %}has content{% else %}empty{% endunless %}'
-        expect(() => ge.parseAndRenderSync(src, { content: 'hello' })).toThrow('invalid range syntax')
-      })
-    })
-  })
 })
@@ -0,0 +1,26 @@
+import { throwIntendedError, rejectIntendedError } from './util'
+import { Tag } from '../../src/template/tag'
+import type { TagToken, TopLevelToken } from '../../src/tokens'
+import type { Liquid } from '../../src/liquid'
+
+export class ThrowingTag extends Tag {
+  render () {
+    throwIntendedError()
+  }
+}
+
+export class RejectingTag extends Tag {
+  async render () {
+    await rejectIntendedError()
+  }
+}
+
+export class ThrowsOnParseTag extends Tag {
+  constructor (token: TagToken, remainTokens: TopLevelToken[], liquid: Liquid) {
+    super(token, remainTokens, liquid)
+    throwIntendedError()
+  }
+  render () {
+    return ''
+  }
+}
@@ -1,8 +1,9 @@
 {
  "compilerOptions": {
-    "target": "es6",
-    "module":"CommonJS",
-    "lib": ["es2015", "es2016", "es2017", "dom"],
+    "target": "ES2020",
+    "module":"ES2020",
+    "lib": ["ES2020", "dom"],
+    "moduleResolution": "node",
    "sourceMap": true,
    "outDir": "dist",
    "declaration": true,
Author	SHA1	Message	Date
Yang JunandCursor	8b39836357	feat!: remove --template CLI option Template is positional-only; bare stdin template and --template/-t are both removed. Keep @- for template and --context. Co-authored-by: Cursor <[email protected]>	2026-07-28 00:01:15 +08:00
Yang JunandCursor	a87b5db66e	feat: accept CLI template as positional or --template Support positional <template> alongside --template/-t for compatibility; error if both are set and differ. Bare stdin template remains removed; @- still works. Co-authored-by: Cursor <[email protected]>	2026-07-27 21:38:17 +08:00
Yang JunandCursor	75ce063ac9	fix: restore explicit @- stdin for template and context Keep @- for --template and --context; only the legacy bare-stdin-as-template fallback stays removed. Co-authored-by: Cursor <[email protected]>	2026-07-27 20:13:23 +08:00
Yang JunandCursor	ed801e1581	fix: restore --template CLI option Revert the positional-only template change. Keep --template as the primary API; stdin template remains unsupported without a special error. Co-authored-by: Cursor <[email protected]>	2026-07-26 14:16:00 +08:00
Yang JunandCursor	456d7dc6a4	feat!: take CLI template as positional argument Make template a required positional arg (drop --template) for v11 per #586; stdin template remains unsupported without a special error. Co-authored-by: Cursor <[email protected]>	2026-07-24 02:08:59 +08:00
Yang JunandCursor	44712f64fc	feat!: remove CLI support for template via STDIN Fixes #940 Co-authored-by: Cursor <[email protected]>	2026-07-24 01:54:17 +08:00
Yang Jun GitHub Cursor	964a63b362	fix: v11 scope security and ownPropertyOnly hardening (#898 ) (#938 ) * feat: block dangerous scope keys and harden findScope (#898) Co-authored-by: Cursor <[email protected]> * docs: fix ownPropertyOnly default in security model Co-authored-by: Cursor <[email protected]> * feat: harden scope writes, iteration, and readSize (#898) Block writes to dangerous keys in assign/capture/increment/decrement, use own-property Symbol.iterator for plain objects when ownPropertyOnly is true, fix inherited size reads, and sanitize filter iteration scopes. Co-authored-by: Cursor <[email protected]> * fix: tie proto key blocking to ownPropertyOnly policy Block __proto__, constructor, and prototype only when ownPropertyOnly is true or when access would traverse the prototype chain. Allow own properties with those names when ownPropertyOnly is false. Co-authored-by: Cursor <[email protected]> * fix: revert ownPropertyOnly iteration hardening Iteration is documented as an ownPropertyOnly exception; restore isIterable/toEnumerable and document inherited Symbol.iterator behavior. Co-authored-by: Cursor <[email protected]> * docs: fix ownPropertyOnly blocked-keys wording in options Co-authored-by: Cursor <[email protected]> * fix: unify blocked-key checks in findScope Use shouldBlockScopeKeyRead in findScope hasKey so inherited constructor/__proto__/prototype do not falsely match environments. Remove redundant globals hasKey check; globals remains the fallback scope. Co-authored-by: Cursor <[email protected]> * test: trim redundant scope-security integration tests Co-authored-by: Cursor <[email protected]> * refactor: move readSize to Context methods Move readSize, readFirst, and readLast to private Context methods using this.ownPropertyOnly. Remove redundant shouldBlockScopeKeyRead from findScope. Co-authored-by: Cursor <[email protected]> * refactor: wrap plain scopes in Context.push() Centralize null-prototype scope creation in push() so callers pass plain objects; Drop instances and existing null-proto frames are pushed as-is. Remove sanitizeScope in favor of createScope via Object.assign. * refactor: drop redundant tag write-path blocking Write blocking on assign/capture/increment/decrement duplicated read-side protection in readJSProperty; null-proto scopes from push already prevent prototype pollution on managed writes. Co-authored-by: Cursor <[email protected]> * fix: address scope-security review findings Restore null-prototype hardening for Jekyll include bindings, colocate blocked-key checks with readJSProperty, align ownPropertyOnly JSDoc with security docs, and drop integration tests duplicated in context.spec. Co-authored-by: Cursor <[email protected]> * refactor: simplify scope-security MR Drop null-prototype passthrough in push(), inline blocked-key checks, remove redundant createScope at include tag, trim verbose docs, and drop implementation-detail unit tests. Co-authored-by: Cursor <[email protected]> * refactor: trim scope-security helpers and docs Inline findScope and blocked-key checks, shorten ownPropertyOnly docs, and drop implementation-detail push() unit tests. Co-authored-by: Cursor <[email protected]> * refactor: encapsulate Drop passthrough in createScope * refactor: drop redundant typeof in blocked key check Set.has already returns false for non-string PropertyKey values; widen BLOCKED_SCOPE_KEYS type so TypeScript accepts the direct has(key) call. Co-authored-by: Cursor <[email protected]> * docs: shorten ownPropertyOnly proto-key wording Co-authored-by: Cursor <[email protected]> * fix: clarify blocked key checks in readJSProperty Split the OR condition into two explicit checks so inherited proto keys are always blocked and own proto keys are blocked only when ownPropertyOnly is true. Co-authored-by: Cursor <[email protected]> * fix: apply ownPropertyOnly uniformly in readJSProperty Proto keys block inherited access only; ownPropertyOnly is checked once before return for all keys. Own __proto__/constructor/prototype properties are readable—sanitize untrusted scope input. Co-authored-by: Cursor <[email protected]> * fix: remove BLOCKED_SCOPE_KEYS; ownPropertyOnly is the sole read policy Proto keys were incorrectly blocked even when ownPropertyOnly=false. Inherited access is now gated only by ownPropertyOnly; docs updated. Co-authored-by: Cursor <[email protected]> * fix: restore BLOCKED_SCOPE_KEYS gated by ownPropertyOnly Dangerous keys (__proto__, constructor, prototype) are blocked only when ownPropertyOnly is true (default). With false, full prototype access is allowed as an explicit opt-out; use bourne for untrusted input. Co-authored-by: Cursor <[email protected]> * docs: shorten ownPropertyOnly entry in options tutorial Details live in Security Model; keep options.md consistent with strictFilters/strictVariables tone. Co-authored-by: Cursor <[email protected]> * docs: simplify ownPropertyOnly JSDoc in LiquidOptions Co-authored-by: Cursor <[email protected]> * test: cover readSize branches in Context Co-authored-by: Cursor <[email protected]> --------- Co-authored-by: Cursor <[email protected]>	2026-07-24 00:53:21 +08:00
Yang Jun GitHub Cursor	61ed163821	feat: remove memoryLimit; add templateLimit, outputLengthLimit, maxDepth (#937 ) * feat: remove memoryLimit option (#910) Co-authored-by: Cursor <[email protected]> * feat: add templateLimit, outputLengthLimit, and maxDepth DoS limits Enforce v11 resource guards in render and tags, fix for offset/else behavior, and update tutorials for Tag-class registration. Co-authored-by: Cursor <[email protected]> * docs: revert unnecessary tutorial churn from memoryLimit PR Restore the two-example register-filters-tags structure (Value + Hash) and undo unrelated constructor/emitter doc edits not required for DoS limits. Co-authored-by: Cursor <[email protected]> * docs: trim security-model prose and update render-tag-content Remove diary-style engine comparisons from security-model.md. Update render-tag-content tutorial to Tag class examples with tpls class field. Co-authored-by: Cursor <[email protected]> * docs: note maxDepth stack overflow applies to renderSync only Explain why async render does not need maxDepth for stack protection based on generator/toPromise driving. Co-authored-by: Cursor <[email protected]> * refactor: track maxDepth via depthLimit Limiter on Context Replace increaseDepth/decreaseDepth with a shared Limiter that supports paired use/release, matching templateLimit and outputLengthLimit patterns. Co-authored-by: Cursor <[email protected]> * fix: remove spurious diff noise in filter files Restore misc.ts from origin/next with LF line endings and re-apply only memoryLimit removal, avoiding CRLF and blank-line churn in the export block. Co-authored-by: Cursor <[email protected]> * refactor: minimize PR diff noise Co-authored-by: Cursor <[email protected]> * feat: cap strftime pad width at 1M docs: restructure security model with production guidance Co-authored-by: Cursor <[email protected]> * refactor: simplify depthLimit in partial tags and tighten security docs Drop try/finally around depthLimit in include, layout, and render; release at generator end. Consolidate production guidance in security-model.md. Fix padded-blocks lint in dos.spec.ts. Co-authored-by: Cursor <[email protected]> --------- Co-authored-by: Cursor <[email protected]>	2026-07-15 22:58:13 +08:00
Yang Jun GitHub Cursor	f0b6cd375c	feat: remove downlevelIteration from Rollup tsconfig override (#905 ) (#933 ) Browser UMD/min bundles already compile with ES2020 on next; drop the ES5-only downlevelIteration override from rollup.config.mjs. Co-authored-by: Cursor <[email protected]>	2026-07-11 11:26:17 +08:00
Yang Jun GitHub Cursor	9481008f2b	feat: drop keepOutputType option (#838 ) (#930 ) Remove KeepingTypeEmitter and always stringify via SimpleEmitter. On next, map breaking commits to patch so alpha stays on 11.x. Co-authored-by: Cursor <[email protected]>	2026-07-09 23:13:19 +08:00
Yang JunandCursor	cc4a9ce0a7	feat!: drop TagImplOptions in favor of Tag classes (#839 ) (#927 ) * feat!: drop TagImplOptions in favor of Tag classes (#839) Remove tag-options-adapter and the registerTag object-literal overload. Custom tags must extend Tag. Co-authored-by: Cursor <[email protected]> * test: drop TagImplOptions-specific e2e coverage (#839) Remove #570 v9 object-literal registration test and unused metadata_file setup in #573. Co-authored-by: Cursor <[email protected]> * test: use inline Tag classes in register-tags spec Co-authored-by: Cursor <[email protected]> * test: remove dead throwingTag setup and duplicate throw stub for.spec kept throwingTag registration after #713 removed its test. Reuse ThrowingTag in liquid.spec instead of IntendedRenderErrorTag. Co-authored-by: Cursor <[email protected]> * test: remove dead throwingTag setup and duplicate throw stub for.spec kept throwingTag registration after #713 removed its test. Reuse ThrowingTag in liquid.spec instead of IntendedRenderErrorTag. Co-authored-by: Cursor <[email protected]> * fix(demo): ignore killall exit when express server already stopped Co-authored-by: Cursor <[email protected]> * fix(demo): revert unrelated return->exit change in express test Co-authored-by: Cursor <[email protected]> * fix(demo): use exit in express test script (no enclosing function) Co-authored-by: Cursor <[email protected]> --------- Co-authored-by: Cursor <[email protected]>	2026-07-09 00:58:43 +08:00
Yang JunandCursor	5e3928654b	chore(release): setup v11 alpha publishing on next Co-authored-by: Cursor <[email protected]>	2026-07-09 00:58:43 +08:00
Yang Jun	962e5b6433	chore: update to Node.js LTS	2026-07-09 00:58:42 +08:00