eleventy-plugin-vento 4.0.1 → 4.1.1-beta.0

package/CHANGELOG.md

@@ -1,10 +1,49 @@
 # eleventy-plugin-vento
 
+## 4.1.1-beta.0
+
+### Patch Changes
+
+- 335f21e: Select type updates (shouldn't affect compilation, however should improve DX)
+
+  Changes are:
+
+  - split types into separate files
+  - namespace `ventojs` type imports
+  - make `PluginOptions` optional by default
+  - make Eleventy types more readable
+  - declare a special (`EleventyVentoEnvironment`) for this plugin to replace Vento's own `Environment`
+
+- 9eaa059: Update `debug` to v4.4.0
+- f387b5e: Update `ventojs` to v1.12.13
+- 070109a: Refactored files and functions internally that shouldn't have any impact on usage or performance:
+
+  - Split `debug` functions into separate exports, renamed `runCompatiblityCheck -> compatibilityCheck` (dd4c379b)
+  - Utilities are now split into separate files (e06a83ab)
+  - Main file renamed from `index.ts` to `plugin.ts` (1b122d2a)
+
+## 4.1.0
+
+### Minor Changes
+
+- eb33d79: Expose Vento's `FilterThis` on Eleventy-declared filters. (fixes #72)
+
+  > [!IMPORTANT]
+  > Using this feature incurs the same performance regression that [`eleventyComputed` template strings](https://www.11ty.dev/docs/data-computed/#using-a-template-string) do. Caching can assist with this, see [README](https://github.com/noelforte/eleventy-plugin-vento/blob/main/readme.md) for more information.
+
+  Vento binds its own `this` object when executing filter functions. The `this` object contains 2 keys, `this.env` and `this.data`, for getting access to both the Vento environment and the template data respectively.
+
+  In addition to Vento's object, `this.page` and `this.eleventy` are also cloned to the top level from `this.data` to maintain feature-parity with Eleventy.
+
+  With this change, you can now create filters that leverage the Vento environment. See [README](https://github.com/noelforte/eleventy-plugin-vento/blob/main/readme.md) for more info.
+
+- eb33d79: Update vento to 1.12.12
+
 ## 4.0.1
 
 ### Patch Changes
 
-- - hotfix - include `types` field in package.json to declare bundled types
+- hotfix - include `types` field in package.json to declare bundled types
 
 ## 4.0.0
 

package/dist/{index.d.ts → plugin.d.ts}

@@ -1,13 +1,13 @@
 import { UserConfig } from '@11ty/eleventy';
-import { Options } from 'ventojs';
+import { LiteralUnion } from 'type-fest';
+import * as ventojs from 'ventojs';
 import { Plugin } from 'ventojs/src/environment.js';
 
-type AutotrimConfig = boolean | ('@11ty' | '@vento' | (string & Record<never, never>))[];
-interface VentoPluginOptions {
+interface PluginOptions {
     /**
      * An array of Vento plugins
      */
-    plugins: Plugin[];
+    plugins?: Plugin[];
     /**
      * Enables Vento's autotrim plugin.
      * ```js
@@ -20,13 +20,13 @@ interface VentoPluginOptions {
      * autotrim: true
      * ```
      */
-    autotrim: AutotrimConfig;
+    autotrim?: LiteralUnion<'@11ty' | '@vento', string>[] | boolean;
     /** Enable use of Eleventy filters */
-    filters: boolean;
+    filters?: boolean;
     /** Enable use of Eleventy shortcodes */
-    shortcodes: boolean;
+    shortcodes?: boolean;
     /** Enable use of Eleventy paired shortcodes */
-    pairedShortcodes: boolean;
+    pairedShortcodes?: boolean;
     /**
      * A Vento configuration object.
      *
@@ -34,13 +34,9 @@ interface VentoPluginOptions {
      * Eleventy's own `dir.includes` location.**
      * @see {@link https://vento.js.org/configuration/}
      */
-    ventoOptions: Options;
+    ventoOptions?: ventojs.Options;
 }
 
-/**
- * @file Main plugin declaration
- */
-
-declare function VentoPlugin(eleventyConfig: UserConfig, userOptions: Partial<VentoPluginOptions>): void;
+declare function VentoPlugin(eleventyConfig: UserConfig, userOptions: PluginOptions): void;
 
 export { VentoPlugin };

package/dist/plugin.js

@@ -0,0 +1,243 @@
+// src/plugin.ts
+import path from "node:path";
+import autotrimPlugin, { defaultTags as autotrimDefaultTags } from "ventojs/plugins/auto_trim.js";
+
+// src/engine.ts
+import createVentoEnv from "ventojs";
+
+// src/utils/create-vento-tag.ts
+function createVentoTag(tagInfo) {
+  const IS_PAIRED = tagInfo.group === "pairedShortcodes";
+  let INT = 0;
+  const tag = (env, code, output, tokens) => {
+    if (!code.startsWith(tagInfo.name)) return;
+    const { dataVarname } = env.options;
+    const thisArg = `{
+			page: ${dataVarname}.page,
+			eleventy: ${dataVarname}.eleventy
+		}`;
+    const fn = `__env.utils.eleventyFunctions.${tagInfo.group}.${tagInfo.name}`;
+    const args = [code.replace(tagInfo.name, "").trim()];
+    const compiled = [];
+    if (IS_PAIRED) {
+      const nestedVarname = `__arg${INT++}`;
+      args.unshift(env.compileFilters(tokens, nestedVarname, env.options.autoescape));
+      compiled.push(
+        "{",
+        `let ${nestedVarname} = "";`,
+        ...env.compileTokens(tokens, nestedVarname, [`/${tagInfo.name}`])
+      );
+      if (tokens.length > 0 && (tokens[0][0] !== "tag" || tokens[0][1] !== `/${tagInfo.name}`)) {
+        throw new Error(`Vento: Missing closing tag for ${tagInfo.name} tag: ${code}`);
+      }
+      tokens.shift();
+    }
+    args.unshift(thisArg);
+    compiled.push(
+      "{",
+      `const __result = await ${fn}.call(${args.filter(Boolean).join(", ")});`,
+      `${output} += ${env.compileFilters(tokens, "__result", env.options.autoescape)}`,
+      "}"
+    );
+    if (IS_PAIRED) {
+      compiled.push("}");
+    }
+    return compiled.join("\n");
+  };
+  return Object.defineProperty(tag, "name", {
+    value: tagInfo.name + IS_PAIRED ? `PairedTag` : `Tag`
+  });
+}
+
+// src/utils/debuggers.ts
+import createDebugger from "debug";
+var debugBaseNamespace = "Eleventy:Vento";
+var debugMain = createDebugger(debugBaseNamespace);
+var debugCache = createDebugger(`${debugBaseNamespace}:Cache`);
+var debugRender = createDebugger(`${debugBaseNamespace}:Render`);
+
+// src/engine.ts
+function createVentoEngine(options) {
+  const env = createVentoEnv(options);
+  env.utils.eleventyFunctions = { shortcodes: {}, pairedShortcodes: {} };
+  function loadPlugins(plugins) {
+    for (const plugin of plugins) {
+      env.use(plugin);
+    }
+  }
+  function loadFilters(filters) {
+    for (const [name, fn] of Object.entries(filters)) {
+      env.filters[name] = async function(...args) {
+        const { page, eleventy } = this.data;
+        const filterResult = await fn.apply({ ...this, page, eleventy }, args);
+        return filterResult;
+      };
+    }
+  }
+  function loadShortcodes(shortcodes) {
+    for (const [name, fn] of Object.entries(shortcodes)) {
+      env.utils.eleventyFunctions.shortcodes[name] = fn;
+      const shortcodeTag = createVentoTag({ name, group: "shortcodes" });
+      env.tags.push(shortcodeTag);
+    }
+  }
+  function loadPairedShortcodes(pairedShortcodes) {
+    for (const [name, fn] of Object.entries(pairedShortcodes)) {
+      env.utils.eleventyFunctions.pairedShortcodes[name] = fn;
+      const shortcodeTag = createVentoTag({ name, group: "pairedShortcodes" });
+      env.tags.push(shortcodeTag);
+    }
+  }
+  function getTemplateFunction(source, file, useVentoCache = true) {
+    let template = env.cache.get(file);
+    if ((template == null ? void 0 : template.source) === source) {
+      debugCache("Cache HIT for `%s`, used precompiled template", file);
+    } else {
+      template = env.compile(source, file);
+      debugCache(
+        `Cache MISS for \`%s\`, compiled new template:
+Use Vento cache: %o
+
+${template}`,
+        file,
+        useVentoCache
+      );
+      if (useVentoCache) {
+        env.cache.set(file, template);
+      }
+    }
+    return template;
+  }
+  return {
+    cache: env.cache,
+    loadPlugins,
+    loadFilters,
+    loadShortcodes,
+    loadPairedShortcodes,
+    getTemplateFunction
+  };
+}
+async function renderVentoTemplate(template, data, from) {
+  debugRender("Rendering `%s`", from);
+  const { content } = await template(data);
+  return content;
+}
+
+// src/utils/compat-check.ts
+var REQUIRED_API_METHODS = [
+  ["getShortcodes", "v3.0.0-alpha.15"],
+  ["getPairedShortcodes", "v3.0.0-alpha.15"],
+  ["getFilters", "v3.0.0-alpha.15"],
+  ["addExtension", "v1.0.0"]
+];
+function compatibilityCheck(config) {
+  debugMain("Run compatibility check");
+  for (const [method, version] of REQUIRED_API_METHODS) {
+    if (!(method in config)) {
+      console.error(
+        "[eleventy-plugin-vento] Plugin compatibility error:",
+        `\`${method}\``,
+        "not found. Please use Eleventy",
+        version,
+        "or later."
+      );
+    }
+  }
+}
+
+// src/plugin.ts
+function VentoPlugin(eleventyConfig, userOptions) {
+  debugMain("Initializing eleventy-plugin-vento");
+  compatibilityCheck(eleventyConfig);
+  const options = {
+    // Define defaults
+    autotrim: false,
+    plugins: [],
+    filters: true,
+    shortcodes: true,
+    pairedShortcodes: true,
+    ventoOptions: {
+      includes: eleventyConfig.directories.includes
+    },
+    // Merge in user-provided options
+    ...userOptions
+  };
+  debugMain("Merged default and user config: %O", options);
+  const filters = eleventyConfig.getFilters();
+  debugMain("Reading filters from Eleventy: %o", filters);
+  const shortcodes = eleventyConfig.getShortcodes();
+  debugMain("Reading shortcodes from Eleventy: %o", shortcodes);
+  const pairedShortcodes = eleventyConfig.getPairedShortcodes();
+  debugMain("Reading paired shortcodes from Eleventy: %o", pairedShortcodes);
+  if (options.autotrim) {
+    const defaults = ["@vento", "@11ty"];
+    const tagSet = new Set(options.autotrim === true ? defaults : options.autotrim);
+    if (tagSet.has("@vento")) {
+      tagSet.delete("@vento");
+      for (const name of autotrimDefaultTags) {
+        tagSet.add(name);
+      }
+    }
+    if (tagSet.has("@11ty")) {
+      tagSet.delete("@11ty");
+      for (const name in pairedShortcodes) {
+        tagSet.add(name);
+      }
+    }
+    debugMain("Enabled autotrim for tags: %o", tagSet);
+    options.plugins.push(autotrimPlugin({ tags: [...tagSet] }));
+  }
+  debugMain("Initializing Vento environment");
+  const engine = createVentoEngine(options.ventoOptions);
+  debugMain("Loading plugins: %o", options.plugins);
+  engine.loadPlugins(options.plugins);
+  if (options.filters) {
+    debugMain("Loading filters: %o", filters);
+    engine.loadFilters(filters);
+  }
+  if (options.shortcodes) {
+    debugMain("Loading shortcodes: %o", shortcodes);
+    engine.loadShortcodes(shortcodes);
+  }
+  if (options.pairedShortcodes) {
+    debugMain("Loading paired shortcodes: %o", pairedShortcodes);
+    engine.loadPairedShortcodes(pairedShortcodes);
+  }
+  debugMain("Registering Vento cache handler on eleventy.beforeWatch event");
+  eleventyConfig.on("eleventy.beforeWatch", async (updatedFiles) => {
+    for (let file of updatedFiles) {
+      file = path.normalize(file);
+      debugCache("Delete cache entry for %s", file);
+      engine.cache.delete(file);
+    }
+  });
+  debugMain("Registering .vto as a template format");
+  eleventyConfig.addTemplateFormats("vto");
+  debugMain("Registering .vto extension with eleventy");
+  eleventyConfig.addExtension("vto", {
+    outputFileExtension: "html",
+    read: true,
+    compile(inputContent, inputPath) {
+      inputPath = path.normalize(inputPath);
+      debugMain("Getting template function for `%s`", inputPath);
+      const template = engine.getTemplateFunction(inputContent, inputPath, false);
+      return async (data) => await renderVentoTemplate(template, data, inputPath);
+    },
+    compileOptions: {
+      // Custom permalink compilation
+      permalink(permalinkContent, inputPath) {
+        if (typeof permalinkContent !== "string" || !/\{\{\s+.+\s+\}\}/.test(permalinkContent)) {
+          return permalinkContent;
+        }
+        inputPath = "Permalink::" + path.normalize(inputPath);
+        debugMain("Getting template function for `%s`", inputPath);
+        const template = engine.getTemplateFunction(permalinkContent, inputPath);
+        return async (data) => await renderVentoTemplate(template, data, inputPath);
+      }
+    }
+  });
+  debugMain("eleventy-plugin-vento initialized");
+}
+export {
+  VentoPlugin
+};

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "eleventy-plugin-vento",
-  "version": "4.0.1",
+  "version": "4.1.1-beta.0",
   "description": "Adds support for the Vento templating language to Eleventy.",
   "type": "module",
   "engines": {
     "node": ">=18"
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/plugin.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./dist/plugin.js",
+      "types": "./dist/plugin.d.ts"
     }
   },
   "files": [
@@ -36,25 +36,27 @@
   },
   "license": "MIT",
   "dependencies": {
-    "debug": "4.3.7",
-    "ventojs": "1.12.11"
+    "debug": "4.4.0",
+    "ventojs": "1.12.13"
   },
   "devDependencies": {
     "11ty.ts": "0.0.5",
     "@11ty/eleventy": "3.0.0",
-    "@changesets/cli": "2.27.9",
-    "@eslint/js": "9.14.0",
+    "@changesets/cli": "2.27.10",
+    "@eslint/js": "9.16.0",
     "@types/debug": "4.1.12",
     "@types/eslint-config-prettier": "6.11.3",
     "@types/eslint__js": "8.42.3",
-    "@types/node": "22.8.4",
-    "eslint": "9.14.0",
+    "@types/node": "22.10.1",
+    "eslint": "9.16.0",
     "eslint-config-prettier": "9.1.0",
-    "eslint-plugin-unicorn": "56.0.0",
+    "eslint-plugin-unicorn": "56.0.1",
+    "globals": "15.13.0",
     "tsup": "8.3.5",
-    "typescript": "5.6.3",
-    "typescript-eslint": "8.12.2",
-    "vitest": "2.1.4"
+    "type-fest": "4.30.0",
+    "typescript": "5.7.2",
+    "typescript-eslint": "8.18.0",
+    "vitest": "2.1.8"
   },
   "prettier": {
     "bracketSameLine": true,
@@ -64,13 +66,13 @@
   },
   "scripts": {
     "test": "vitest --run",
-    "check": "pnpm --color run '/ts-check|lint/'",
-    "lint": "eslint '.'",
-    "ts-check": "tsc --noEmit",
+    "check": "pnpm --color run '/^check:/'",
+    "check:lint": "eslint '.'",
+    "check:types": "tsc --noEmit",
     "build": "tsup",
+    "dev": "tsup --watch ./src",
     "ci:version": "changeset version && pnpm install --no-frozen-lockfile",
     "ci:publish": "changeset publish",
-    "ci:generate-changesets": "node ./scripts/generate-changesets.js",
     "format": "pnpm dlx prettier --config ./package.json --write ."
   }
 }

package/readme.md

@@ -62,9 +62,6 @@ export default function (eleventyConfig) {
     // to trim the default tags (see section on Auto-trimming)
     autotrim: false,
 
-    // Enable/disable ignore tag syntax (see section on ignoring tags)
-    ignoreTag: false,
-
     // A Vento configuration object
     ventoOptions: {
       includes: eleventyConfig.directories.includes,
@@ -90,6 +87,24 @@ Filters that are added via Eleventy's `.addFilter()` or `.addAsyncFilter()` meth
 
 If you'd prefer to set filters yourself (via a plugin or other method) or prevent Eleventy from loading filters into Vento, set `filters: false` in the plugin options.
 
+### Filters and `this`
+
+Eleventy provides filters with scoped data via the `this.page` and `this.eleventy` objects (see [Filters#Scoped data in Filters](https://www.11ty.dev/docs/filters/#scoped-data-in-filters) in Eleventy's docs for more details). Likewise, Vento provides filters with `this.env` and `this.data` representing the Vento environment and the current template data. This plugin merges both objects together to make `this.page` (and `eleventy`/`env`/`data`) available on all filters processed by Vento.
+
+This feature enables re-use of the Vento environment this plugin provides, within Eleventy filters. As an example use case, you could create a filter that compiles dynamic data and cache it with Vento's own cache to improve performance:
+
+```js
+import 'hash' from 'node:crypto'; // since Node v20.12.0
+
+const sha1Hash(str) => hash('sha1', str, 'hex');
+
+eleventyConfig.addFilter('vento', function (content) {
+  const file = `dynamicString:${sha1Hash(content)}`;
+  const res = this.env.runString(content, this.data, file);
+  return res.content;
+});
+```
+
 ### Relevant documentation
 
 Vento: See [Filters](https://vento.js.org/configuration/#filters) and [Pipes](https://vento.js.org/syntax/pipes/)
@@ -144,7 +159,8 @@ Eleventy: See [Shortcodes](https://www.11ty.dev/docs/shortcodes/) and the sub-se
 
 ## Vento Plugins
 
-_Note: The `auto_trim` plugin that ships with Vento has a specific implementation in the scope of this plugin. See [Auto-Trimming Tags](#auto-trimming-tags) for more details._
+> [!NOTE]
+> The `auto_trim` plugin that ships with Vento has a specific implementation in the scope of this plugin. See [Auto-Trimming Tags](#auto-trimming-tags) for more details.\_
 
 If you'd like to extend the Vento library with any plugins, include them in an array passed to the `plugins` option.
 
@@ -202,7 +218,7 @@ Vento: See [Auto Trim Plugin](https://vento.js.org/plugins/auto-trim/).
 
 Like Eleventy, this plugin uses the [`debug`](https://www.npmjs.com/package/debug) package to handle verbose logging. The following `DEBUG` namespaces are implemented:
 
-- `Eleventy:Vento:Setup` - Logs initial setup of the plugin, loading features, pre-page compile setup steps (like changing `page` and `eleventy` objects)
+- `Eleventy:Vento` - Logs initial setup of the plugin, loading features, pre-page compile setup steps (like changing `page` and `eleventy` objects)
 - `Eleventy:Vento:Cache` - Logs updates to Vento's own internal cache, which is used in tandem with Eleventy's cache.
 - `Eleventy:Vento:Render` - Logs when templates are rendered
 
@@ -215,7 +231,7 @@ $ DEBUG='Eleventy:*' npx @11ty/eleventy
 Alternatively, use a finer grained namespace to see only the output generated by `eleventy-plugin-vento`.
 
 ```sh
-$ DEBUG='Eleventy:Vento:*' npx @11ty/eleventy
+$ DEBUG='Eleventy:Vento*' npx @11ty/eleventy
 ```
 
 ```sh

package/dist/index.js

@@ -1,244 +0,0 @@
-// src/index.ts
-import path from "node:path";
-import autotrimPlugin, { defaultTags as autotrimDefaultTags } from "ventojs/plugins/auto_trim.js";
-
-// src/create-vento-interface.ts
-import { default as ventojs } from "ventojs";
-
-// src/create-vento-tag.ts
-function createVentoTag(spec) {
-  const IS_PAIRED = spec.group === "pairedShortcodes";
-  const tag = (env, code, output, tokens) => {
-    if (!code.startsWith(spec.name)) return;
-    const fn = `__env.utils._11tyFns.${spec.group}.${spec.name}`;
-    const ctx = "__env.utils._11tyCtx";
-    const args = [code.replace(spec.name, "").trim()];
-    const varname = output.startsWith("__shortcode_content") ? `${output}_precomp` : "__shortcode_content";
-    const compiled = [];
-    if (IS_PAIRED) {
-      args.unshift(env.compileFilters(tokens, varname, env.options.autoescape));
-      compiled.push(
-        "{",
-        `let ${varname} = "";`,
-        ...env.compileTokens(tokens, varname, [`/${spec.name}`])
-      );
-      if (tokens.length > 0 && (tokens[0][0] !== "tag" || tokens[0][1] !== `/${spec.name}`)) {
-        throw new Error(`Vento: Missing closing tag for ${spec.name} tag: ${code}`);
-      }
-      tokens.shift();
-    }
-    args.unshift(ctx);
-    compiled.push(
-      "{",
-      `const __shortcode_result = await ${fn}.call(${args.filter(Boolean).join(", ")});`,
-      `${output} += ${env.compileFilters(tokens, "__shortcode_result", env.options.autoescape)}`,
-      "}"
-    );
-    if (IS_PAIRED) {
-      compiled.push("}");
-    }
-    const compiledTag = compiled.join("\n");
-    return compiledTag;
-  };
-  return Object.defineProperty(tag, "name", {
-    value: spec.name + IS_PAIRED ? `PairedTag` : `Tag`
-  });
-}
-
-// src/utils.ts
-import createDebugger from "debug";
-var debugBaseNamespace = "Eleventy:Vento";
-var DEBUG = {
-  setup: createDebugger(`${debugBaseNamespace}:Setup`),
-  cache: createDebugger(`${debugBaseNamespace}:Cache`),
-  render: createDebugger(`${debugBaseNamespace}:Render`)
-};
-var REQUIRED_API_METHODS = [
-  ["getShortcodes", "v3.0.0-alpha.15"],
-  ["getPairedShortcodes", "v3.0.0-alpha.15"],
-  ["getFilters", "v3.0.0-alpha.15"],
-  ["addExtension", "v1.0.0"]
-];
-var CONTEXT_DATA_KEYS = ["page", "eleventy"];
-function runCompatibilityCheck(config) {
-  DEBUG.setup("Run compatibility check");
-  for (const [method, version] of REQUIRED_API_METHODS) {
-    if (!(method in config)) {
-      console.error(
-        "[eleventy-plugin-vento] Plugin compatibility error:",
-        `\`${method}\``,
-        "not found. Please use Eleventy",
-        version,
-        "or later."
-      );
-    }
-  }
-}
-
-// src/create-vento-interface.ts
-function createVentoInterface(options) {
-  const env = ventojs(options);
-  env.utils._11tyFns = { shortcodes: {}, pairedShortcodes: {} };
-  env.utils._11tyCtx = {};
-  function setContext(newContext) {
-    if (env.utils._11tyCtx?.page?.inputPath === newContext?.page?.inputPath) {
-      return;
-    }
-    for (const K of CONTEXT_DATA_KEYS) {
-      env.utils._11tyCtx[K] = newContext[K];
-    }
-    DEBUG.setup("Reload context, new context is: %o", env.utils._11tyCtx);
-  }
-  function loadPlugins(plugins) {
-    for (const plugin of plugins) {
-      env.use(plugin);
-    }
-  }
-  function loadFilters(filters) {
-    for (const [name, fn] of Object.entries(filters)) {
-      env.filters[name] = fn.bind(env.utils._11tyCtx);
-    }
-  }
-  function loadShortcodes(shortcodes) {
-    for (const [name, fn] of Object.entries(shortcodes)) {
-      env.utils._11tyFns.shortcodes[name] = fn;
-      env.tags.push(createVentoTag({ name, group: "shortcodes" }));
-    }
-  }
-  function loadPairedShortcodes(pairedShortcodes) {
-    for (const [name, fn] of Object.entries(pairedShortcodes)) {
-      env.utils._11tyFns.pairedShortcodes[name] = fn;
-      env.tags.push(createVentoTag({ name, group: "pairedShortcodes" }));
-    }
-  }
-  function getTemplateFunction(source, file, useVentoCache = true) {
-    let template = env.cache.get(file);
-    if (template?.source === source) {
-      DEBUG.cache("Cache HIT for `%s`, used precompiled template", file);
-    } else {
-      template = env.compile(source, file);
-      DEBUG.cache(
-        `Cache MISS for \`%s\`, compiled new template:
-Use Vento cache: %o
-
-${template}`,
-        file,
-        useVentoCache
-      );
-      if (useVentoCache) {
-        env.cache.set(file, template);
-      }
-    }
-    return template;
-  }
-  async function render(template, data, from) {
-    setContext(data);
-    DEBUG.render("Rendering `%s`", from);
-    const { content } = await template(data);
-    return content;
-  }
-  return {
-    cache: env.cache,
-    loadPlugins,
-    loadFilters,
-    loadShortcodes,
-    loadPairedShortcodes,
-    getTemplateFunction,
-    render
-  };
-}
-
-// src/index.ts
-function VentoPlugin(eleventyConfig, userOptions) {
-  DEBUG.setup("Initializing eleventy-plugin-vento");
-  runCompatibilityCheck(eleventyConfig);
-  const options = {
-    // Define defaults
-    autotrim: false,
-    plugins: [],
-    filters: true,
-    shortcodes: true,
-    pairedShortcodes: true,
-    ventoOptions: {
-      includes: eleventyConfig.directories.includes
-    },
-    // Merge in user-provided options
-    ...userOptions
-  };
-  DEBUG.setup("Merged default and user config: %O", options);
-  const filters = eleventyConfig.getFilters();
-  DEBUG.setup("Reading filters from Eleventy: %o", filters);
-  const shortcodes = eleventyConfig.getShortcodes();
-  DEBUG.setup("Reading shortcodes from Eleventy: %o", shortcodes);
-  const pairedShortcodes = eleventyConfig.getPairedShortcodes();
-  DEBUG.setup("Reading paired shortcodes from Eleventy: %o", pairedShortcodes);
-  if (options.autotrim) {
-    const defaults = ["@vento", "@11ty"];
-    const tagSet = new Set(options.autotrim === true ? defaults : options.autotrim);
-    if (tagSet.has("@vento")) {
-      tagSet.delete("@vento");
-      for (const name of autotrimDefaultTags) {
-        tagSet.add(name);
-      }
-    }
-    if (tagSet.has("@11ty")) {
-      tagSet.delete("@11ty");
-      for (const name in pairedShortcodes) {
-        tagSet.add(name);
-      }
-    }
-    DEBUG.setup("Enabled autotrim for tags: %o", tagSet);
-    options.plugins.push(autotrimPlugin({ tags: [...tagSet] }));
-  }
-  DEBUG.setup("Initializing Vento environment");
-  const engine = createVentoInterface(options.ventoOptions);
-  DEBUG.setup("Loading plugins: %o", options.plugins);
-  engine.loadPlugins(options.plugins);
-  if (options.filters) {
-    DEBUG.setup("Loading filters: %o", filters);
-    engine.loadFilters(filters);
-  }
-  if (options.shortcodes) {
-    DEBUG.setup("Loading shortcodes: %o", shortcodes);
-    engine.loadShortcodes(shortcodes);
-  }
-  if (options.pairedShortcodes) {
-    DEBUG.setup("Loading paired shortcodes: %o", pairedShortcodes);
-    engine.loadPairedShortcodes(pairedShortcodes);
-  }
-  DEBUG.setup("Registering Vento cache handler on eleventy.beforeWatch event");
-  eleventyConfig.on("eleventy.beforeWatch", async (updatedFiles) => {
-    for (let file of updatedFiles) {
-      file = path.normalize(file);
-      DEBUG.cache("Delete cache entry for %s", file);
-      engine.cache.delete(file);
-    }
-  });
-  DEBUG.setup("Registering .vto as a template format");
-  eleventyConfig.addTemplateFormats("vto");
-  DEBUG.setup("Registering .vto extension with eleventy");
-  eleventyConfig.addExtension("vto", {
-    outputFileExtension: "html",
-    read: true,
-    compile(inputContent, inputPath) {
-      inputPath = path.normalize(inputPath);
-      const template = engine.getTemplateFunction(inputContent, inputPath, false);
-      return async (data) => await engine.render(template, data, inputPath);
-    },
-    compileOptions: {
-      // Custom permalink compilation
-      permalink(permalinkContent, inputPath) {
-        if (typeof permalinkContent === "string" && /\{\{\s+.+\s+\}\}/.test(permalinkContent)) {
-          inputPath = "Permalink::" + path.normalize(inputPath);
-          const template = engine.getTemplateFunction(permalinkContent, inputPath);
-          return async (data) => await engine.render(template, data, inputPath);
-        }
-        return permalinkContent;
-      }
-    }
-  });
-  DEBUG.setup("eleventy-plugin-vento initialized");
-}
-export {
-  VentoPlugin
-};