ventojs 0.8.0 → 0.9.0

package/README.md

@@ -1,7 +1,7 @@
-# VENTO
+# Vento
 
 This is a minimal template engine inspired by other great engines like Nunjucks,
-Liquid, Mustache or EJS.
+Liquid, Mustache, and EJS.
 
 ## Why another template engine?
 
@@ -32,6 +32,7 @@ neither is). The issues I found in existing template engines:
 ### Liquid
 
 - I like:
+
   - The support for async evaluation is less hacky than Nunjucks.
   - The variables are not escaped by default, there's an `escape` filter for
     that.
@@ -91,64 +92,9 @@ First, let's take a look at this syntax example:
 
 ## Getting started
 
-This is a library for Deno. ~~I'm planning to release an NPM version in the
-future.~~
-[There's already an NPM version](https://www.npmjs.com/package/ventojs) that you
-can install with `npm install ventojs`.
-
-Import the library and create an instance:
-
-```ts
-import vento from "https://deno.land/x/vento/mod.ts";
-
-const vto = vento({
-  // Resolve the non-relative includes paths
-  includes: "./path/to/includes",
-});
-```
-
-Or in Node:
-
-```ts
-import vento from "ventojs";
-
-const vto = vento({
-  // Resolve the non-relative includes paths
-  includes: "./path/to/includes",
-});
-```
-
-There are different ways to load, compile and run a template. For example, you
-can use `load` to load and compile a template file and return it.
-
-```ts
-// Load and return a template
-const template = vto.load("my-template.vto");
-
-// Now you can use it passing the data
-const result = template({ title: "Hello world" });
-console.log(result.content);
-```
-
-Alternatively, you can load and run the template file in a single call:
-
-```ts
-const result = vto.run("my-template.vto", { title: "Hello world" });
-console.log(result.content);
-```
-
-If the template code is not a file, you can run it directly:
-
-```ts
-const result = vto.runString("<h1>{{ title }}</h1>", { title: "Hello world" });
-console.log(result.content);
-```
-
-## Visual Studio Code Support
-
-[The Vento extension for VS Code](https://marketplace.visualstudio.com/items?itemName=oscarotero.vento-syntax)
-enables syntax highlight and provides some useful snippets.
+See [Getting started](https://vento.js.org/getting-started/) on the docs.
 
-## API
+## Editor support
 
-[Read the docs](https://oscarotero.github.io/vento/)
+See [Editor integrations](https://vento.js.org/editor-integrations/) on the
+docs.

package/esm/deps/deno.land/std@0.201.0/html/entities.d.ts

@@ -0,0 +1,38 @@
+export type EntityList = Record<string, string>;
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ *
+ * @example
+ * ```ts
+ * import { escape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(escape("<>'&AA"), "&lt;&gt;&#39;&amp;AA");
+ *
+ * // characters that don't need to be escaped will be left alone,
+ * // even if named HTML entities exist for them
+ * assertEquals(escape("þð"), "þð");
+ * ```
+ */
+export declare function escape(str: string): string;
+export type UnescapeOptions = {
+    entityList: EntityList;
+};
+/**
+ * Unescapes HTML entities in text
+ *
+ * @example
+ * ```ts
+ * import { unescape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * // default options (only handles &<>'" and numeric entities)
+ * assertEquals(unescape("&lt;&gt;&apos;&amp;&#65;&#x41;"), "<>'&AA");
+ * assertEquals(unescape("&thorn;&eth;"), "&thorn;&eth;");
+ *
+ * // using the full named entity list from the HTML spec (~47K unminified)
+ * import entityList from "https://deno.land/std@$STD_VERSION/html/named_entity_list.json" assert { type: "json" };
+ * assertEquals(unescape("&thorn;&eth;", { entityList }), "þð");
+ * ```
+ */
+export declare function unescape(str: string, options?: Partial<UnescapeOptions>): string;

package/esm/deps/deno.land/std@0.201.0/html/entities.js

@@ -0,0 +1,76 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+const rawToEntityEntries = [
+    ["&", "&"],
+    ["<", "&lt;"],
+    [">", "&gt;"],
+    ['"', "&quot;"],
+    ["'", "&#39;"],
+];
+const defaultEntityList = Object.fromEntries([
+    ...rawToEntityEntries.map(([raw, entity]) => [entity, raw]),
+    ["&apos;", "'"],
+    ["&nbsp;", "\xa0"],
+]);
+const rawToEntity = new Map(rawToEntityEntries);
+const rawRe = new RegExp(`[${[...rawToEntity.keys()].join("")}]`, "g");
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ *
+ * @example
+ * ```ts
+ * import { escape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(escape("<>'&AA"), "&lt;&gt;&#39;&amp;AA");
+ *
+ * // characters that don't need to be escaped will be left alone,
+ * // even if named HTML entities exist for them
+ * assertEquals(escape("þð"), "þð");
+ * ```
+ */
+export function escape(str) {
+    return str.replaceAll(rawRe, (m) => rawToEntity.get(m));
+}
+const defaultUnescapeOptions = {
+    entityList: defaultEntityList,
+};
+const MAX_CODE_POINT = 0x10ffff;
+const RX_DEC_ENTITY = /&#([0-9]+);/g;
+const RX_HEX_ENTITY = /&#x(\p{AHex}+);/gu;
+const entityListRegexCache = new WeakMap();
+/**
+ * Unescapes HTML entities in text
+ *
+ * @example
+ * ```ts
+ * import { unescape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * // default options (only handles &<>'" and numeric entities)
+ * assertEquals(unescape("&lt;&gt;&apos;&amp;&#65;&#x41;"), "<>'&AA");
+ * assertEquals(unescape("&thorn;&eth;"), "&thorn;&eth;");
+ *
+ * // using the full named entity list from the HTML spec (~47K unminified)
+ * import entityList from "https://deno.land/std@$STD_VERSION/html/named_entity_list.json" assert { type: "json" };
+ * assertEquals(unescape("&thorn;&eth;", { entityList }), "þð");
+ * ```
+ */
+export function unescape(str, options = {}) {
+    const { entityList } = { ...defaultUnescapeOptions, ...options };
+    let entityRe = entityListRegexCache.get(entityList);
+    if (!entityRe) {
+        entityRe = new RegExp(`(${Object.keys(entityList)
+            .sort((a, b) => b.length - a.length)
+            .join("|")})`, "g");
+        entityListRegexCache.set(entityList, entityRe);
+    }
+    return str
+        .replaceAll(entityRe, (m) => entityList[m])
+        .replaceAll(RX_DEC_ENTITY, (_, dec) => codePointStrToChar(dec, 10))
+        .replaceAll(RX_HEX_ENTITY, (_, hex) => codePointStrToChar(hex, 16));
+}
+function codePointStrToChar(codePointStr, radix) {
+    const codePoint = parseInt(codePointStr, radix);
+    return codePoint > MAX_CODE_POINT ? "�" : String.fromCodePoint(codePoint);
+}

package/esm/deps/deno.land/std@0.201.0/html/mod.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Functions for HTML tasks such as escaping or unescaping HTML entities
+ *
+ * @module
+ */
+export * from "./entities.js";

package/esm/deps/deno.land/std@0.201.0/html/mod.js

@@ -0,0 +1,8 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Functions for HTML tasks such as escaping or unescaping HTML entities
+ *
+ * @module
+ */
+export * from "./entities.js";

package/esm/deps.d.ts

@@ -1 +1,2 @@
 export * as path from "./deps/deno.land/std@0.201.0/path/mod.js";
+export * as html from "./deps/deno.land/std@0.201.0/html/mod.js";

package/esm/deps.js

@@ -1 +1,2 @@
 export * as path from "./deps/deno.land/std@0.201.0/path/mod.js";
+export * as html from "./deps/deno.land/std@0.201.0/html/mod.js";

package/esm/mod.d.ts

@@ -2,6 +2,7 @@ import { Environment } from "./src/environment.js";
 import { Loader } from "./src/loader.js";
 export interface Options {
     includes?: string | Loader;
+    useWith?: boolean;
     dataVarname?: string;
     autoescape?: boolean;
 }

package/esm/mod.js

@@ -21,6 +21,7 @@ export default function (options = {}) {
         loader,
         dataVarname: options.dataVarname || "it",
         autoescape: options.autoescape || false,
+        useWith: options.useWith || true,
     });
     // Register basic plugins
     env.use(ifTag());

package/esm/plugins/escape.js

@@ -1,16 +1,6 @@
+import { html } from "../deps.js";
 export default function () {
     return (env) => {
-        env.filters.escape = escape;
+        env.filters.escape = html.escape;
     };
 }
-const escapeMap = {
-    "&": "&",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;",
-    "`": "&#x60;",
-};
-function escape(str) {
-    return str.replace(/[&<>"'`]/g, (match) => escapeMap[match]);
-}

package/esm/plugins/export.js

@@ -8,6 +8,7 @@ function exportTag(env, code, _output, tokens) {
         return;
     }
     const expression = code.replace(/^export\s+/, "");
+    const { dataVarname } = env.options;
     // Value is set (e.g. {{ export foo = "bar" }})
     if (expression.includes("=")) {
         const match = code.match(/^export\s+([\w]+)\s*=\s*([\s\S]+)$/);
@@ -16,19 +17,19 @@ function exportTag(env, code, _output, tokens) {
         }
         const [, variable, value] = match;
         const val = env.compileFilters(tokens, value);
-        return `if (__data.hasOwnProperty("${variable}")) {
+        return `if (${dataVarname}.hasOwnProperty("${variable}")) {
       ${variable} = ${val};
     } else {
       var ${variable} = ${val};
     }
-    __data["${variable}"] = ${variable};
+    ${dataVarname}["${variable}"] = ${variable};
     __exports["${variable}"] = ${variable};
     `;
     }
     // Value is captured (eg: {{ export foo }}bar{{ /export }})
     const compiled = [];
     const compiledFilters = env.compileFilters(tokens, expression);
-    compiled.push(`if (__data.hasOwnProperty("${expression}")) {
+    compiled.push(`if (${dataVarname}.hasOwnProperty("${expression}")) {
     ${expression} = "";
   } else {
     var ${expression} = "";
@@ -40,7 +41,7 @@ function exportTag(env, code, _output, tokens) {
     }
     tokens.shift();
     compiled.push(`${expression} = ${compiledFilters};`);
-    compiled.push(`__data["${expression.trim()}"] = ${expression};`);
+    compiled.push(`${dataVarname}["${expression.trim()}"] = ${expression};`);
     compiled.push(`__exports["${expression.trim()}"] = ${expression};`);
     return compiled.join("\n");
 }

package/esm/plugins/import.js

@@ -3,7 +3,7 @@ export default function () {
         env.tags.push(importTag);
     };
 }
-function importTag(_env, code) {
+function importTag(env, code) {
     if (!code.startsWith("import ")) {
         return;
     }
@@ -11,14 +11,7 @@ function importTag(_env, code) {
     if (!match) {
         throw new Error(`Invalid import: ${code}`);
     }
-    const [_, vars, file] = match;
-    const compiled = [];
-    compiled.push(`__tmp = await __env.run(${file}, {...__data}, __file);`);
-    if (vars.startsWith("{")) {
-        compiled.push(`let ${vars} = __tmp;`);
-    }
-    else {
-        compiled.push(`let ${vars} = __tmp;`);
-    }
-    return compiled.join("\n");
+    const [, vars, file] = match;
+    const { dataVarname } = env.options;
+    return `let ${vars} = await __env.run(${file}, {...${dataVarname}}, __file);`;
 }

package/esm/plugins/include.js

@@ -12,9 +12,10 @@ function includeTag(env, code, output, tokens) {
         throw new Error(`Invalid include: ${code}`);
     }
     const [_, file, data] = match;
+    const { dataVarname } = env.options;
     return `{
-    __tmp = await __env.run(${file},
-      {...__data${data ? `, ${data}` : ""}},
+    const __tmp = await __env.run(${file},
+      {...${dataVarname}${data ? `, ${data}` : ""}},
       __file
     );
     ${output} += ${env.compileFilters(tokens, "__tmp.content")};

package/esm/plugins/layout.js

@@ -16,15 +16,16 @@ function layoutTag(env, code, output, tokens) {
     const compiled = [];
     const compiledFilters = env.compileFilters(tokens, varname);
     compiled.push("{");
-    compiled.push(`var ${varname} = "";`);
+    compiled.push(`let ${varname} = "";`);
     compiled.push(...env.compileTokens(tokens, varname, ["/layout"]));
     if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/layout")) {
         throw new Error(`Missing closing tag for layout tag: ${code}`);
     }
     tokens.shift();
     compiled.push(`${varname} = ${compiledFilters};`);
-    compiled.push(`__tmp = await __env.run(${file},
-      {...__data${data ? `, ${data}` : ""}, content: ${env.compileFilters(tokens, varname)}},
+    const { dataVarname } = env.options;
+    compiled.push(`const __tmp = await __env.run(${file},
+      {...${dataVarname}${data ? `, ${data}` : ""}, content: ${env.compileFilters(tokens, varname)}},
       __file
     );
     ${output} += __tmp.content;`);

package/esm/plugins/set.js

@@ -8,6 +8,7 @@ function setTag(env, code, _output, tokens) {
         return;
     }
     const expression = code.replace(/^set\s+/, "");
+    const { dataVarname } = env.options;
     // Value is set (e.g. {{ set foo = "bar" }})
     if (expression.includes("=")) {
         const match = code.match(/^set\s+([\w]+)\s*=\s*([\s\S]+)$/);
@@ -16,18 +17,18 @@ function setTag(env, code, _output, tokens) {
         }
         const [, variable, value] = match;
         const val = env.compileFilters(tokens, value);
-        return `if (__data.hasOwnProperty("${variable}")) {
+        return `if (${dataVarname}.hasOwnProperty("${variable}")) {
       ${variable} = ${val};
     } else {
       var ${variable} = ${val};
     }
-    __data["${variable}"] = ${variable};
+    ${dataVarname}["${variable}"] = ${variable};
     `;
     }
     // Value is captured (eg: {{ set foo }}bar{{ /set }})
     const compiled = [];
     const compiledFilters = env.compileFilters(tokens, expression);
-    compiled.push(`if (__data.hasOwnProperty("${expression}")) {
+    compiled.push(`if (${dataVarname}.hasOwnProperty("${expression}")) {
     ${expression} = "";
   } else {
     var ${expression} = "";
@@ -39,6 +40,6 @@ function setTag(env, code, _output, tokens) {
     }
     tokens.shift();
     compiled.push(`${expression} = ${compiledFilters};`);
-    compiled.push(`__data["${expression.trim()}"] = ${expression};`);
+    compiled.push(`${dataVarname}["${expression.trim()}"] = ${expression};`);
     return compiled.join("\n");
 }

package/esm/plugins/unescape.js

@@ -1,16 +1,6 @@
+import { html } from "../deps.js";
 export default function () {
     return (env) => {
-        env.filters.unescape = unescape;
+        env.filters.unescape = html.unescape;
     };
 }
-const unescapeMap = {
-    "&": "&",
-    "&lt;": "<",
-    "&gt;": ">",
-    "&quot;": '"',
-    "&#39;": "'",
-    "&#x60;": "`",
-};
-function unescape(str) {
-    return str.replace(/(&amp;|&lt;|&gt;|&quot;|&#39;|&#x60;)/g, (match) => unescapeMap[match]);
-}

package/esm/src/environment.d.ts

@@ -21,6 +21,7 @@ export interface Options {
     loader: Loader;
     dataVarname: string;
     autoescape: boolean;
+    useWith: boolean;
 }
 export declare class Environment {
     cache: Map<string, Template>;

package/esm/src/environment.js

@@ -37,15 +37,12 @@ export class Environment {
         try {
             const tokens = tokenize(source);
             const code = this.compileTokens(tokens).join("\n");
-            const constructor = new Function("__file", "__env", "__defaults", `return${sync ? "" : " async"} function (__data) {
+            const { dataVarname, useWith } = this.options;
+            const constructor = new Function("__file", "__env", "__defaults", `return${sync ? "" : " async"} function (${dataVarname}) {
           try {
-            __data = Object.assign({}, __defaults, __data);
-            const ${this.options.dataVarname} = __data;
-            let __tmp;
+            ${dataVarname} = Object.assign({}, __defaults, ${dataVarname});
             const __exports = { content: "" };
-            with (__data) {
-              ${code}
-            }
+            ${useWith ? `with (${dataVarname}) {${code}}` : code}
             return __exports;
           } catch (cause) {
             throw new Error(\`Error rendering template: \${__file}\`, { cause });
@@ -112,8 +109,11 @@ export class Environment {
             }
             const [_, isAsync, name, args] = match;
             if (!this.filters[name]) {
-                // If a global function
-                if (isGlobal(name)) {
+                if (name === "safe") {
+                    unescaped = true;
+                }
+                else if (isGlobal(name)) {
+                    // If a global function
                     output = `${isAsync ? "await " : ""}${name}(${output}${args ? `, ${args}` : ""})`;
                 }
                 else {
@@ -122,9 +122,6 @@ export class Environment {
                 }
             }
             else {
-                if (name === "unescape") {
-                    unescaped = true;
-                }
                 // It's a filter (e.g. filters.upper())
                 output = `${isAsync ? "await " : ""}__env.filters.${name}(${output}${args ? `, ${args}` : ""})`;
             }

package/package.json

@@ -1,7 +1,8 @@
 {
   "module": "./esm/mod.js",
+  "main": "./script/mod.js",
   "name": "ventojs",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "🌬 A minimal but powerful template engine",
   "license": "MIT",
   "repository": "github:oscarotero/vento",
@@ -9,7 +10,8 @@
   "bugs": "https://github.com/oscarotero/vento/issues",
   "exports": {
     ".": {
-      "import": "./esm/mod.js"
+      "import": "./esm/mod.js",
+      "require": "./script/mod.js"
     }
   },
   "scripts": {

package/script/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deps/deno.land/std@0.201.0/assert/assert.d.ts

@@ -0,0 +1,2 @@
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/script/deps/deno.land/std@0.201.0/assert/assert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+const assertion_error_js_1 = require("./assertion_error.js");
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}
+exports.assert = assert;

package/script/deps/deno.land/std@0.201.0/assert/assertion_error.d.ts

@@ -0,0 +1,4 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}

package/script/deps/deno.land/std@0.201.0/assert/assertion_error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+class AssertionError extends Error {
+    name = "AssertionError";
+    constructor(message) {
+        super(message);
+    }
+}
+exports.AssertionError = AssertionError;

package/script/deps/deno.land/std@0.201.0/html/entities.d.ts

@@ -0,0 +1,38 @@
+export type EntityList = Record<string, string>;
+/**
+ * Escapes text for safe interpolation into HTML text content and quoted attributes
+ *
+ * @example
+ * ```ts
+ * import { escape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(escape("<>'&AA"), "&lt;&gt;&#39;&amp;AA");
+ *
+ * // characters that don't need to be escaped will be left alone,
+ * // even if named HTML entities exist for them
+ * assertEquals(escape("þð"), "þð");
+ * ```
+ */
+export declare function escape(str: string): string;
+export type UnescapeOptions = {
+    entityList: EntityList;
+};
+/**
+ * Unescapes HTML entities in text
+ *
+ * @example
+ * ```ts
+ * import { unescape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * // default options (only handles &<>'" and numeric entities)
+ * assertEquals(unescape("&lt;&gt;&apos;&amp;&#65;&#x41;"), "<>'&AA");
+ * assertEquals(unescape("&thorn;&eth;"), "&thorn;&eth;");
+ *
+ * // using the full named entity list from the HTML spec (~47K unminified)
+ * import entityList from "https://deno.land/std@$STD_VERSION/html/named_entity_list.json" assert { type: "json" };
+ * assertEquals(unescape("&thorn;&eth;", { entityList }), "þð");
+ * ```
+ */
+export declare function unescape(str: string, options?: Partial<UnescapeOptions>): string;