mancha 0.4.1 → 0.5.1

package/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["github.copilot"]
+}

package/.vscode/launch.json

@@ -0,0 +1,44 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Mocha All",
+            "type": "node",
+            "request": "launch",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "args": [
+                "-r",
+                "ts-node/register",
+                "--no-timeouts",
+                "--colors",
+                "${workspaceFolder}/dist/**/*.test.ts"
+            ],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
+            "skipFiles": [
+                "<node_internals>/**/*.js"
+            ]
+        },
+        {
+            "name": "Mocha Current File",
+            "type": "node",
+            "request": "launch",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "args": [
+                "-r",
+                "ts-node/register",
+                "--no-timeouts",
+                "--colors",
+                "${file}"
+            ],
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
+            "skipFiles": [
+                "<node_internals>/**/*.js"
+            ]
+        }
+    ]
+}

package/README.md

@@ -39,7 +39,7 @@ index.html:
 
 ```html
 <div>
-  <include src="./hello-world.html" data-name="World"></include>
+  <include src="./hello-name.html" data-name="World"></include>
 </div>
 ```
 
@@ -133,7 +133,7 @@ will need to be separately hosted by a static server, although you can also gene
 containing HTML on demand.
 
 ```js
-import { renderRemotePath } from "mancha/dist/web"
+import { renderRemotePath } from "mancha/dist/core"
 
 const VARS = {...};
 const HTML_ROOT = "https://example.com/html";

package/dist/attributes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts from an attribute name to camelCase, e.g. `foo-bar` becomes `fooBar`.
+ * @param name attribute name
+ * @returns camel-cased attribute name
+ */
+export declare function attributeNameToCamelCase(name: string): string;

package/dist/attributes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attributeNameToCamelCase = void 0;
+/**
+ * Converts from an attribute name to camelCase, e.g. `foo-bar` becomes `fooBar`.
+ * @param name attribute name
+ * @returns camel-cased attribute name
+ */
+function attributeNameToCamelCase(name) {
+    return name.replace(/-./g, (c) => c[1].toUpperCase());
+}
+exports.attributeNameToCamelCase = attributeNameToCamelCase;

package/dist/browser.d.ts

@@ -1,2 +1,10 @@
-import * as Mancha from "./web.js";
+import { IRenderer } from "./core";
+import { ParserParams, RenderParams } from "./interfaces";
+declare class RendererImpl extends IRenderer {
+    protected readonly dirpath: string;
+    parseHTML(content: string, params?: ParserParams): DocumentFragment;
+    serializeHTML(root: Node | DocumentFragment): string;
+    preprocessLocal(fpath: string, params?: RenderParams & ParserParams): Promise<DocumentFragment>;
+}
+declare const Mancha: RendererImpl;
 export default Mancha;

package/dist/browser.js

@@ -10,21 +10,41 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 var _a, _b, _c, _d;
 Object.defineProperty(exports, "__esModule", { value: true });
-const Mancha = require("./web.js");
+const core_1 = require("./core");
+class RendererImpl extends core_1.IRenderer {
+    constructor() {
+        super(...arguments);
+        this.dirpath = (0, core_1.dirname)(self.location.href);
+    }
+    parseHTML(content, params = { root: false }) {
+        if (params.root) {
+            return new DOMParser().parseFromString(content, "text/html");
+        }
+        else {
+            const range = document.createRange();
+            range.selectNodeContents(document.body);
+            return range.createContextualFragment(content);
+        }
+    }
+    serializeHTML(root) {
+        return new XMLSerializer().serializeToString(root).replace(/\s?xmlns="[^"]+"/gm, "");
+    }
+    preprocessLocal(fpath, params) {
+        // In the browser, "local" paths (i.e., relative) can still be fetched.
+        return this.preprocessRemote(fpath, params);
+    }
+}
+const Mancha = new RendererImpl();
 self["Mancha"] = Mancha;
-if ((_b = (_a = self.document) === null || _a === void 0 ? void 0 : _a.currentScript) === null || _b === void 0 ? void 0 : _b.hasAttribute("init")) {
-    const vars = Mancha.datasetAttributes(self.document.currentScript.attributes);
-    const attributes = Array.from(((_c = self.document.currentScript) === null || _c === void 0 ? void 0 : _c.attributes) || []).reduce((dict, attr) => Object.assign(dict, { [attr.name]: attr.value }), {});
-    const targets = ((_d = attributes["target"]) === null || _d === void 0 ? void 0 : _d.split(",")) || ["body"];
-    const renderings = targets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
-        const node = self.document[target];
-        node.innerHTML = yield Mancha.renderContent(node.innerHTML, vars);
+const currentScript = (_a = self.document) === null || _a === void 0 ? void 0 : _a.currentScript;
+if ((_c = (_b = self.document) === null || _b === void 0 ? void 0 : _b.currentScript) === null || _c === void 0 ? void 0 : _c.hasAttribute("init")) {
+    Mancha.update(Object.assign({}, currentScript === null || currentScript === void 0 ? void 0 : currentScript.dataset));
+    const debug = currentScript === null || currentScript === void 0 ? void 0 : currentScript.hasAttribute("debug");
+    const cachePolicy = currentScript === null || currentScript === void 0 ? void 0 : currentScript.getAttribute("cache");
+    const targets = ((_d = currentScript === null || currentScript === void 0 ? void 0 : currentScript.getAttribute("target")) === null || _d === void 0 ? void 0 : _d.split(",")) || ["body"];
+    targets.map((target) => __awaiter(void 0, void 0, void 0, function* () {
+        const fragment = self.document.querySelector(target);
+        yield Mancha.mount(fragment, { cache: cachePolicy, debug });
     }));
-    Promise.all(renderings).then(() => {
-        if (attributes["onrender"]) {
-            eval(attributes["onrender"]);
-        }
-        dispatchEvent(new Event("mancha-render", { bubbles: true }));
-    });
 }
 exports.default = Mancha;

package/dist/cli.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const yargs_1 = require("yargs");
 const helpers_1 = require("yargs/helpers");
-const Mancha = require("./index.js");
+const index_1 = require("./index");
 const fs = require("fs/promises");
 const args = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .describe("input", "Input HMTL file to render")
@@ -11,11 +11,11 @@ const args = (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .describe("vars", "JSON-formatted variables")
     .demand(["input"])
     .parse();
-Mancha.renderLocalPath(args["input"], JSON.parse(args.vars || "{}")).then((result) => {
+index_1.Mancha.preprocessLocal(args["input"], JSON.parse(args.vars || "{}")).then((result) => {
     if (!args.output || args.output === "-") {
         console.log(result + "\n");
     }
     else {
-        return fs.writeFile(args.output, result);
+        return fs.writeFile(args.output, index_1.Mancha.serializeHTML(result));
     }
 });

package/dist/core.d.ts

@@ -0,0 +1,27 @@
+import { ReactiveProxyStore } from "./reactive";
+import { ParserParams, RenderParams } from "./interfaces";
+export declare function traverse(root: Node | DocumentFragment | Document, skip?: Set<Node>): Generator<ChildNode>;
+export declare function dirname(fpath: string): string;
+export declare function isRelativePath(fpath: string): boolean;
+export declare function safeEval(code: string, context: any, args?: {
+    [key: string]: any;
+}): Promise<any>;
+export declare abstract class IRenderer extends ReactiveProxyStore {
+    protected readonly dirpath: string;
+    readonly skipNodes: Set<Node>;
+    abstract parseHTML(content: string, params?: ParserParams): DocumentFragment;
+    abstract serializeHTML(root: DocumentFragment | Node): string;
+    fetchRemote(fpath: string, params?: RenderParams): Promise<string>;
+    fetchLocal(fpath: string, params?: RenderParams): Promise<string>;
+    preprocessString(content: string, params?: RenderParams & ParserParams): Promise<DocumentFragment>;
+    preprocessLocal(fpath: string, params?: RenderParams & ParserParams): Promise<DocumentFragment>;
+    preprocessRemote(fpath: string, params?: RenderParams & ParserParams): Promise<DocumentFragment>;
+    clone(): IRenderer;
+    log(params?: RenderParams, ...args: any[]): void;
+    eval(expr: string, args?: {
+        [key: string]: any;
+    }, params?: RenderParams): Promise<any>;
+    preprocessNode(root: Document | DocumentFragment | Node, params?: RenderParams): Promise<void>;
+    renderNode(root: Document | DocumentFragment | Node, params?: RenderParams): Promise<void>;
+    mount(root: Document | DocumentFragment | Node, params?: RenderParams): Promise<void>;
+}

package/dist/core.js

@@ -0,0 +1,163 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IRenderer = exports.safeEval = exports.isRelativePath = exports.dirname = exports.traverse = void 0;
+const reactive_1 = require("./reactive");
+const iterator_1 = require("./iterator");
+const plugins_1 = require("./plugins");
+function* traverse(root, skip = new Set()) {
+    const explored = new Set();
+    const frontier = Array.from(root.childNodes).filter((node) => !skip.has(node));
+    // Also yield the root node.
+    yield root;
+    while (frontier.length) {
+        const node = frontier.pop();
+        if (!explored.has(node)) {
+            explored.add(node);
+            yield node;
+        }
+        if (node.childNodes) {
+            Array.from(node.childNodes)
+                .filter((node) => !skip.has(node))
+                .forEach((node) => frontier.push(node));
+        }
+    }
+}
+exports.traverse = traverse;
+function dirname(fpath) {
+    if (!fpath.includes("/")) {
+        return "";
+    }
+    else {
+        return fpath.split("/").slice(0, -1).join("/");
+    }
+}
+exports.dirname = dirname;
+function isRelativePath(fpath) {
+    return (!fpath.includes("://") &&
+        !fpath.startsWith("/") &&
+        !fpath.startsWith("#") &&
+        !fpath.startsWith("data:"));
+}
+exports.isRelativePath = isRelativePath;
+function safeEval(code, context, args = {}) {
+    const inner = `with (this) { return (async () => (${code}))(); }`;
+    return new Function(...Object.keys(args), inner).call(context, ...Object.values(args));
+}
+exports.safeEval = safeEval;
+class IRenderer extends reactive_1.ReactiveProxyStore {
+    constructor() {
+        super(...arguments);
+        this.dirpath = "";
+        this.skipNodes = new Set();
+    }
+    fetchRemote(fpath, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return fetch(fpath, { cache: (_a = params === null || params === void 0 ? void 0 : params.cache) !== null && _a !== void 0 ? _a : "default" }).then((res) => res.text());
+        });
+    }
+    fetchLocal(fpath, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetchRemote(fpath, params);
+        });
+    }
+    preprocessString(content, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log(params, "Preprocessing string content with params:\n", params);
+            const fragment = this.parseHTML(content, params);
+            yield this.preprocessNode(fragment, params);
+            return fragment;
+        });
+    }
+    preprocessLocal(fpath, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const content = yield this.fetchLocal(fpath, params);
+            return this.preprocessString(content, Object.assign(Object.assign({}, params), { dirpath: dirname(fpath), root: (_a = params === null || params === void 0 ? void 0 : params.root) !== null && _a !== void 0 ? _a : !fpath.endsWith(".tpl.html") }));
+        });
+    }
+    preprocessRemote(fpath, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const cache = (params === null || params === void 0 ? void 0 : params.cache) || "default";
+            const content = yield fetch(fpath, { cache }).then((res) => res.text());
+            return this.preprocessString(content, Object.assign(Object.assign({}, params), { dirpath: dirname(fpath), root: (_a = params === null || params === void 0 ? void 0 : params.root) !== null && _a !== void 0 ? _a : !fpath.endsWith(".tpl.html") }));
+        });
+    }
+    clone() {
+        return new this.constructor(Object.fromEntries(this.store.entries()));
+    }
+    log(params, ...args) {
+        if (params === null || params === void 0 ? void 0 : params.debug)
+            console.debug(...args);
+    }
+    eval(expr_1) {
+        return __awaiter(this, arguments, void 0, function* (expr, args = {}, params) {
+            const proxy = (0, reactive_1.proxify)(this);
+            const result = yield safeEval(expr, proxy, Object.assign({}, args));
+            this.log(params, `eval \`${expr}\` => `, result);
+            return result;
+        });
+    }
+    preprocessNode(root, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            params = Object.assign({ dirpath: this.dirpath, maxdepth: 10 }, params);
+            const promises = new iterator_1.Iterator(traverse(root, this.skipNodes)).map((node) => __awaiter(this, void 0, void 0, function* () {
+                this.log(params, "Preprocessing node:\n", node);
+                // Resolve all the includes in the node.
+                yield plugins_1.resolveIncludes.call(this, node, params);
+                // Resolve all the relative paths in the node.
+                yield plugins_1.rebaseRelativePaths.call(this, node, params);
+            }));
+            // Wait for all the rendering operations to complete.
+            yield Promise.all(promises.generator());
+        });
+    }
+    renderNode(root, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Iterate over all the nodes and apply appropriate handlers.
+            // Do these steps one at a time to avoid any potential race conditions.
+            for (const node of traverse(root, this.skipNodes)) {
+                this.log(params, "Rendering node:\n", node);
+                // Resolve the :data attribute in the node.
+                yield plugins_1.resolveDataAttribute.call(this, node, params);
+                // Resolve the :for attribute in the node.
+                yield plugins_1.resolveForAttribute.call(this, node, params);
+                // Resolve the $html attribute in the node.
+                yield plugins_1.resolveHtmlAttribute.call(this, node, params);
+                // Resolve the :show attribute in the node.
+                yield plugins_1.resolveShowAttribute.call(this, node, params);
+                // Resolve the @watch attribute in the node.
+                yield plugins_1.resolveWatchAttribute.call(this, node, params);
+                // Resolve the :bind attribute in the node.
+                yield plugins_1.resolveBindAttribute.call(this, node, params);
+                // Resolve all $attributes in the node.
+                yield plugins_1.resolvePropAttributes.call(this, node, params);
+                // Resolve all :attributes in the node.
+                yield plugins_1.resolveAttrAttributes.call(this, node, params);
+                // Resolve all @attributes in the node.
+                yield plugins_1.resolveEventAttributes.call(this, node, params);
+                // Replace all the {{ variables }} in the text.
+                yield plugins_1.resolveTextNodeExpressions.call(this, node, params);
+            }
+        });
+    }
+    mount(root, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Preprocess all the elements recursively first.
+            yield this.preprocessNode(root, params);
+            // Now that the DOM is complete, render all the nodes.
+            yield this.renderNode(root, params);
+        });
+    }
+}
+exports.IRenderer = IRenderer;

package/dist/gulp.d.ts

@@ -3,13 +3,13 @@ import * as stream from "stream";
 /**
  * Main entrypoint to be used in Gulp. Usage:
  *
- *     var mancha = require('gulp-mancha')
+ *     var mancha = require('mancha/dist/gulp')
  *     gulp.src(...).pipe(mancha({myvar: myval})).pipe(...)
  *
- * @param vars <key, value> pairs of literal string replacements. `key` will become `{{key}}` before
- * replacing it with `value` in the processed files.
+ * @param context <key, value> pairs of literal string replacements. `key` will become `{{ key }}`
+ * before replacing it with `value` in the processed files.
  */
-declare function mancha(vars?: {
+declare function mancha(context?: {
     [key: string]: string;
 }, wwwroot?: string): stream.Transform;
 export default mancha;

package/dist/gulp.js

@@ -1,61 +1,75 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const stream = require("stream");
 const through = require("through2");
-const Mancha = require("./index.js");
+const index_1 = require("./index");
 /**
  * Main entrypoint to be used in Gulp. Usage:
  *
- *     var mancha = require('gulp-mancha')
+ *     var mancha = require('mancha/dist/gulp')
  *     gulp.src(...).pipe(mancha({myvar: myval})).pipe(...)
  *
- * @param vars <key, value> pairs of literal string replacements. `key` will become `{{key}}` before
- * replacing it with `value` in the processed files.
+ * @param context <key, value> pairs of literal string replacements. `key` will become `{{ key }}`
+ * before replacing it with `value` in the processed files.
  */
-function mancha(vars = {}, wwwroot = process.cwd()) {
+function mancha(context = {}, wwwroot = process.cwd()) {
+    const renderer = new index_1.RendererImpl(context);
     return through.obj(function (file, encoding, callback) {
         const catcher = (err) => {
             console.log(err);
             callback(err, file);
         };
-        const fsroot = path.dirname(file.path);
-        const relpath = path.relative(file.path, wwwroot) || ".";
-        const newvars = Object.assign(vars, { wwwroot: relpath });
+        const dirpath = path.dirname(file.path);
         if (file.isNull()) {
             callback(null, file);
         }
         else {
             if (file.isBuffer()) {
-                const fragment = file.contents.toString(encoding);
-                Mancha.renderContent(fragment, newvars, fsroot)
-                    .then((content) => {
+                const chunk = file.contents.toString(encoding);
+                renderer
+                    .preprocessString(chunk, { dirpath, root: !file.path.endsWith(".tpl.html") })
+                    .then((fragment) => __awaiter(this, void 0, void 0, function* () {
+                    yield renderer.renderNode(fragment);
+                    const content = renderer.serializeHTML(fragment);
                     file.contents = Buffer.from(content, encoding);
                     callback(null, file);
-                })
+                }))
                     .catch(catcher);
             }
             else if (file.isStream()) {
-                let fragment = "";
+                let docstr = "";
                 file.contents
                     .on("data", (chunk) => {
                     if (Buffer.isBuffer(chunk)) {
-                        fragment += chunk.toString(encoding);
+                        docstr += chunk.toString(encoding);
                     }
                     else {
-                        fragment += chunk.toString();
+                        docstr += chunk.toString();
                     }
                 })
                     .on("end", () => {
-                    Mancha.renderContent(fragment, newvars, fsroot)
-                        .then((content) => {
+                    renderer
+                        .preprocessString(docstr, { dirpath, root: !file.path.endsWith(".tpl.html") })
+                        .then((document) => __awaiter(this, void 0, void 0, function* () {
+                        yield renderer.renderNode(document);
+                        const content = renderer.serializeHTML(document);
                         const readable = new stream.Readable();
                         readable._read = function () { };
                         readable.push(content);
                         readable.push(null);
                         file.contents = readable;
                         callback(null, file);
-                    })
+                    }))
                         .catch(catcher);
                 });
             }

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="node" />
-export declare function renderLocalPath(fpath: string, vars?: {
-    [key: string]: string;
-}, encoding?: BufferEncoding): Promise<string>;
-export declare function renderContent(content: string, vars?: {
-    [key: string]: string;
-}, fsroot?: string | null, maxdepth?: number): Promise<string>;
-export { preprocess, folderPath, resolvePath, renderRemotePath, encodeHtmlAttrib, decodeHtmlAttrib, } from "./web";
+import { RendererImpl as WorkerRendererImpl } from "./worker";
+import { ParserParams, RenderParams } from "./interfaces";
+/** The Node Mancha renderer is just like the worker renderer, but it also uses the filesystem. */
+export declare class RendererImpl extends WorkerRendererImpl {
+    fetchLocal(fpath: string, params?: RenderParams & ParserParams): Promise<string>;
+}
+export declare const Mancha: RendererImpl;

package/dist/index.js

@@ -9,28 +9,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeHtmlAttrib = exports.encodeHtmlAttrib = exports.renderRemotePath = exports.resolvePath = exports.folderPath = exports.preprocess = exports.renderContent = exports.renderLocalPath = void 0;
+exports.Mancha = exports.RendererImpl = void 0;
 const fs = require("fs/promises");
-const web_1 = require("./web");
-function renderLocalPath(fpath, vars = {}, encoding = "utf8") {
-    return __awaiter(this, void 0, void 0, function* () {
-        const content = yield fs.readFile(fpath, { encoding: encoding });
-        return renderContent(content, vars, (0, web_1.folderPath)(fpath));
-    });
-}
-exports.renderLocalPath = renderLocalPath;
-function renderContent(content, vars = {}, fsroot = null, maxdepth = 10) {
-    return __awaiter(this, void 0, void 0, function* () {
-        fsroot = fsroot || ".";
-        return (0, web_1.renderContent)(content, vars, fsroot, maxdepth, renderLocalPath);
-    });
+const worker_1 = require("./worker");
+/** The Node Mancha renderer is just like the worker renderer, but it also uses the filesystem. */
+class RendererImpl extends worker_1.RendererImpl {
+    fetchLocal(fpath, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs.readFile(fpath, { encoding: (params === null || params === void 0 ? void 0 : params.encoding) || "utf8" });
+        });
+    }
 }
-exports.renderContent = renderContent;
-// Re-exports from web.
-var web_2 = require("./web");
-Object.defineProperty(exports, "preprocess", { enumerable: true, get: function () { return web_2.preprocess; } });
-Object.defineProperty(exports, "folderPath", { enumerable: true, get: function () { return web_2.folderPath; } });
-Object.defineProperty(exports, "resolvePath", { enumerable: true, get: function () { return web_2.resolvePath; } });
-Object.defineProperty(exports, "renderRemotePath", { enumerable: true, get: function () { return web_2.renderRemotePath; } });
-Object.defineProperty(exports, "encodeHtmlAttrib", { enumerable: true, get: function () { return web_2.encodeHtmlAttrib; } });
-Object.defineProperty(exports, "decodeHtmlAttrib", { enumerable: true, get: function () { return web_2.decodeHtmlAttrib; } });
+exports.RendererImpl = RendererImpl;
+// Export the renderer instance directly.
+exports.Mancha = new RendererImpl();

package/dist/interfaces.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { IRenderer } from "./core";
+export interface ParserParams {
+    /** Whether the file parsed is a root document, or a document fragment. */
+    root?: boolean;
+    /** Encoding to use when processing local files. */
+    encoding?: BufferEncoding;
+}
+/** The RendererParams interface defines the parameters that can be passed to the renderer. */
+export interface RenderParams {
+    /** The current directory of the file being rendered. */
+    dirpath?: string;
+    /** Maximum level of recursion allowed when resolving includes. */
+    maxdepth?: number;
+    /** Cache policy used when resolving remote paths. */
+    cache?: RequestCache | null;
+    /** Whether to print debug information. */
+    debug?: boolean;
+}
+export type RendererPlugin = (this: IRenderer, node: ChildNode, params: RenderParams) => Promise<void>;

package/dist/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/iterator.d.ts

@@ -0,0 +1,10 @@
+export declare class Iterator<T> {
+    private readonly iterable;
+    constructor(iter: Iterable<T>);
+    filter(fn: (val: T) => boolean): Iterator<T>;
+    map<S>(fn: (val: T) => S): Iterator<S>;
+    array(): T[];
+    generator(): Iterable<T>;
+    static filterGenerator<T>(fn: (val: T) => boolean, iter: Iterable<T>): Iterable<T>;
+    static mapGenerator<T, S>(fn: (val: T) => S, iter: Iterable<T>): Iterable<S>;
+}

package/dist/iterator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Iterator = void 0;
+class Iterator {
+    constructor(iter) {
+        this.iterable = iter;
+    }
+    filter(fn) {
+        return new Iterator(Iterator.filterGenerator(fn, this.iterable));
+    }
+    map(fn) {
+        return new Iterator(Iterator.mapGenerator(fn, this.iterable));
+    }
+    array() {
+        return Array.from(this.iterable);
+    }
+    *generator() {
+        for (const val of this.iterable) {
+            yield val;
+        }
+    }
+    static *filterGenerator(fn, iter) {
+        for (const val of iter) {
+            if (fn(val))
+                yield val;
+        }
+    }
+    static *mapGenerator(fn, iter) {
+        for (const val of iter) {
+            yield fn(val);
+        }
+    }
+}
+exports.Iterator = Iterator;