mancha 0.9.0 → 0.9.4

package/dist/plugins.js

@@ -1,16 +1,6 @@
-import { appendChild, attributeNameToCamelCase, cloneAttribute, createElement, ellipsize, firstElementChild, getAttribute, getNodeValue, insertBefore, nodeToString, removeAttribute, removeChild, replaceChildren, replaceWith, setAttribute, setNodeValue, setTextContent, traverse, } from "./dome.js";
-import { isRelativePath } from "./core.js";
+import { safeAnchorEl, safeAreaEl } from "safevalues/dom";
+import { appendChild, attributeNameToCamelCase, cloneAttribute, ellipsize, firstElementChild, getAttribute, insertBefore, isRelativePath, nodeToString, removeAttribute, removeChild, replaceChildren, replaceWith, setAttribute, traverse, } from "./dome.js";
 import { Iterator } from "./iterator.js";
-import { makeAsyncEvalFunction } from "./store.js";
-const KW_ATTRIBUTES = new Set([
-    ":bind",
-    ":bind-events",
-    ":data",
-    ":for",
-    ":show",
-    "@watch",
-    "$html",
-]);
 /** @internal */
 export var RendererPlugins;
 (function (RendererPlugins) {
@@ -77,52 +67,38 @@ export var RendererPlugins;
         // We have to retrieve the attribute, because the node property is always an absolute path.
         const src = getAttribute(elem, "src");
         const href = getAttribute(elem, "href");
-        const data = getAttribute(elem, "data");
         // Early exit: if there is no element attribute to rebase, we can skip this step.
-        const anyattr = src || href || data;
-        if (!anyattr)
-            return;
-        if (anyattr && isRelativePath(anyattr)) {
-            this.log("Rebasing relative path as:", params.dirpath, "/", anyattr);
-        }
-        if (tagName === "img" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "a" && href && isRelativePath(href)) {
-            setAttribute(elem, "href", `${params.dirpath}/${href}`);
-        }
-        else if (tagName === "link" && href && isRelativePath(href)) {
-            setAttribute(elem, "href", `${params.dirpath}/${href}`);
-        }
-        else if (tagName === "script" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "source" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "audio" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "video" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "track" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "iframe" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "object" && data && isRelativePath(data)) {
-            setAttribute(elem, "data", `${params.dirpath}/${data}`);
-        }
-        else if (tagName === "input" && src && isRelativePath(src)) {
-            setAttribute(elem, "src", `${params.dirpath}/${src}`);
-        }
-        else if (tagName === "area" && href && isRelativePath(href)) {
-            setAttribute(elem, "href", `${params.dirpath}/${href}`);
-        }
-        else if (tagName === "base" && href && isRelativePath(href)) {
-            setAttribute(elem, "href", `${params.dirpath}/${href}`);
+        const pathref = src || href;
+        if (pathref && isRelativePath(pathref)) {
+            const relpath = `${params.dirpath}/${pathref}`;
+            this.log("Rebasing relative path as:", relpath);
+            if (tagName === "img") {
+                elem.src = relpath;
+            }
+            else if (tagName === "a") {
+                safeAnchorEl.setHref(elem, relpath);
+            }
+            else if (tagName === "source") {
+                elem.src = relpath;
+            }
+            else if (tagName === "audio") {
+                elem.src = relpath;
+            }
+            else if (tagName === "video") {
+                elem.src = relpath;
+            }
+            else if (tagName === "track") {
+                elem.src = relpath;
+            }
+            else if (tagName === "input") {
+                elem.src = relpath;
+            }
+            else if (tagName === "area") {
+                safeAreaEl.setHref(elem, relpath);
+            }
+            else {
+                this.log("Unable to rebase relative path for element:", tagName);
+            }
         }
     };
     RendererPlugins.registerCustomElements = async function (node, params) {
@@ -160,7 +136,7 @@ export var RendererPlugins;
         }
     };
     RendererPlugins.resolveTextNodeExpressions = async function (node, params) {
-        const content = getNodeValue(node) || "";
+        const content = node.nodeValue || "";
         if (node.nodeType !== 3 || !content?.trim())
             return;
         this.log(`Processing node content value:\n`, ellipsize(content, 128));
@@ -175,7 +151,7 @@ export var RendererPlugins;
                 const result = this.eval(expr, { $elem: node });
                 updatedContent = updatedContent.replace(`{{ ${expr} }}`, String(result));
             }
-            setNodeValue(node, updatedContent);
+            node.nodeValue = updatedContent;
         });
     };
     RendererPlugins.resolveDataAttribute = async function (node, params) {
@@ -190,9 +166,9 @@ export var RendererPlugins;
             // Create a subrenderer and process the tag, unless it's the root node.
             const subrenderer = params?.rootNode === node ? this : this.clone();
             node.renderer = subrenderer;
-            // Do not call eval() directly, we will use an async version instead.
-            const fn = makeAsyncEvalFunction(dataAttr, this.evalkeys);
-            const result = await fn.call(subrenderer.$, { $elem: node });
+            // Evaluate the expression.
+            const result = subrenderer.eval(dataAttr, { $elem: node });
+            // Await any promises in the result object.
             await Promise.all(Object.entries(result).map(([key, value]) => subrenderer.set(key, value)));
             // Skip all the children of the current node, if it's a subrenderer.
             if (subrenderer !== this) {
@@ -204,18 +180,21 @@ export var RendererPlugins;
             await subrenderer.mount(node, params);
         }
     };
-    RendererPlugins.resolveWatchAttribute = async function (node, params) {
+    RendererPlugins.resolveClassAttribute = async function (node, params) {
         if (this._skipNodes.has(node))
             return;
         const elem = node;
-        const watchAttr = getAttribute(elem, "@watch");
-        if (watchAttr) {
-            this.log("@watch attribute found in:\n", nodeToString(node, 128));
+        const classAttr = getAttribute(elem, ":class");
+        if (classAttr) {
+            this.log(":class attribute found in:\n", nodeToString(node, 128));
             // Remove the attribute from the node.
-            removeAttribute(elem, "@watch");
+            removeAttribute(elem, ":class");
+            // Store the original class attribute, if any.
+            const originalClass = getAttribute(elem, "class") || "";
             // Compute the function's result.
-            await this.effect(function () {
-                return this.eval(watchAttr, { $elem: node });
+            return this.effect(function () {
+                const result = this.eval(classAttr, { $elem: node });
+                setAttribute(elem, "class", (result ? `${originalClass} ${result}` : originalClass).trim());
             });
         }
     };
@@ -223,14 +202,15 @@ export var RendererPlugins;
         if (this._skipNodes.has(node))
             return;
         const elem = node;
-        const textAttr = getAttribute(elem, "$text");
+        const textAttr = getAttribute(elem, ":text");
         if (textAttr) {
-            this.log("$text attribute found in:\n", nodeToString(node, 128));
+            this.log(":text attribute found in:\n", nodeToString(node, 128));
             // Remove the attribute from the node.
-            removeAttribute(elem, "$text");
+            removeAttribute(elem, ":text");
             // Compute the function's result and track dependencies.
+            const setTextContent = (content) => this.textContent(node, content);
             return this.effect(function () {
-                setTextContent(node, this.eval(textAttr, { $elem: node }));
+                setTextContent(this.eval(textAttr, { $elem: node }));
             });
         }
     };
@@ -238,11 +218,11 @@ export var RendererPlugins;
         if (this._skipNodes.has(node))
             return;
         const elem = node;
-        const htmlAttr = getAttribute(elem, "$html");
+        const htmlAttr = getAttribute(elem, ":html");
         if (htmlAttr) {
-            this.log("$html attribute found in:\n", nodeToString(node, 128));
+            this.log(":html attribute found in:\n", nodeToString(node, 128));
             // Remove the attribute from the node.
-            removeAttribute(elem, "$html");
+            removeAttribute(elem, ":html");
             // Compute the function's result and track dependencies.
             return this.effect(function () {
                 const result = this.eval(htmlAttr, { $elem: node });
@@ -255,50 +235,16 @@ export var RendererPlugins;
             });
         }
     };
-    RendererPlugins.resolvePropAttributes = async function (node, params) {
-        if (this._skipNodes.has(node))
-            return;
-        const elem = node;
-        for (const attr of Array.from(elem.attributes || [])) {
-            if (attr.name.startsWith("$") && !KW_ATTRIBUTES.has(attr.name)) {
-                this.log(attr.name, "attribute found in:\n", nodeToString(node, 128));
-                // Remove the attribute from the node.
-                removeAttribute(elem, attr.name);
-                // Compute the function's result and track dependencies.
-                const propName = attributeNameToCamelCase(attr.name.slice(1));
-                await this.effect(function () {
-                    node[propName] = this.eval(attr.value, { $elem: node });
-                });
-            }
-        }
-    };
-    RendererPlugins.resolveAttrAttributes = async function (node, params) {
-        if (this._skipNodes.has(node))
-            return;
-        const elem = node;
-        for (const attr of Array.from(elem.attributes || [])) {
-            if (attr.name.startsWith(":") && !KW_ATTRIBUTES.has(attr.name)) {
-                this.log(attr.name, "attribute found in:\n", nodeToString(node, 128));
-                // Remove the processed attributes from node.
-                removeAttribute(elem, attr.name);
-                // Compute the function's result and track dependencies.
-                const attrName = attr.name.slice(1);
-                this.effect(function () {
-                    setAttribute(elem, attrName, this.eval(attr.value, { $elem: node }));
-                });
-            }
-        }
-    };
     RendererPlugins.resolveEventAttributes = async function (node, params) {
         if (this._skipNodes.has(node))
             return;
         const elem = node;
         for (const attr of Array.from(elem.attributes || [])) {
-            if (attr.name.startsWith("@") && !KW_ATTRIBUTES.has(attr.name)) {
+            if (attr.name.startsWith(":on:")) {
                 this.log(attr.name, "attribute found in:\n", nodeToString(node, 128));
                 // Remove the processed attributes from node.
                 removeAttribute(elem, attr.name);
-                node.addEventListener?.(attr.name.substring(1), (event) => {
+                node.addEventListener?.(attr.name.substring(4), (event) => {
                     return this.eval(attr.value, { $elem: node, $event: event });
                 });
             }
@@ -319,7 +265,7 @@ export var RendererPlugins;
             }
             // Place the template node into a template element.
             const parent = node.parentNode;
-            const template = createElement("template", node.ownerDocument);
+            const template = this.createElement("template", node.ownerDocument);
             insertBefore(parent, template, node);
             removeChild(parent, node);
             appendChild(template, node);
@@ -380,16 +326,15 @@ export var RendererPlugins;
             this.log(":bind attribute found in:\n", nodeToString(node, 128));
             // The change events we listen for can be overriden by user.
             const defaultEvents = ["change", "input"];
-            const updateEvents = getAttribute(elem, ":bind-events")?.split(",") || defaultEvents;
+            const updateEvents = getAttribute(elem, ":bind:on")?.split(",") || defaultEvents;
             // Remove the processed attributes from node.
             removeAttribute(elem, ":bind");
-            removeAttribute(elem, ":bind-events");
+            removeAttribute(elem, ":bind:on");
             // If the element is of type checkbox, we bind to the "checked" property.
             const prop = getAttribute(elem, "type") === "checkbox" ? "checked" : "value";
             // Watch for updates in the store and bind our property ==> node value.
-            const propExpr = `$elem.${prop} = ${bindExpr}`;
             this.effect(function () {
-                const result = this.eval(propExpr, { $elem: node });
+                const result = this.eval(bindExpr, { $elem: node });
                 elem[prop] = result;
             });
             // Bind node value ==> our property.
@@ -432,4 +377,21 @@ export var RendererPlugins;
             });
         }
     };
+    RendererPlugins.resolveCustomAttribute = async function (node, params) {
+        if (this._skipNodes.has(node))
+            return;
+        const elem = node;
+        for (const attr of Array.from(elem.attributes || [])) {
+            if (attr.name.startsWith(":")) {
+                this.log(attr.name, "attribute found in:\n", nodeToString(node, 128));
+                // Remove the processed attributes from node.
+                removeAttribute(elem, attr.name);
+                const propName = attributeNameToCamelCase(attr.name.substring(1));
+                this.effect(function () {
+                    const propValue = this.eval(attr.value, { $elem: node });
+                    elem[propName] = propValue;
+                });
+            }
+        }
+    };
 })(RendererPlugins || (RendererPlugins = {}));

package/dist/safe_browser.d.ts

@@ -0,0 +1,7 @@
+import { Renderer as BrowserRenderer } from "./browser.js";
+import { ParserParams } from "./interfaces.js";
+export declare class Renderer extends BrowserRenderer {
+    protected readonly dirpath: string;
+    parseHTML(content: string, params?: ParserParams): Document | DocumentFragment;
+}
+export declare const Mancha: Renderer;

package/dist/safe_browser.js

@@ -0,0 +1,19 @@
+import { sanitizeHtml } from "safevalues";
+import { safeRange, safeDomParser } from "safevalues/dom";
+import { Renderer as BrowserRenderer } from "./browser.js";
+import { dirname } from "./dome.js";
+export class Renderer extends BrowserRenderer {
+    dirpath = dirname(self.location.href);
+    parseHTML(content, params = { rootDocument: false }) {
+        if (params.rootDocument) {
+            const parser = new DOMParser();
+            return safeDomParser.parseFromString(parser, sanitizeHtml(content), "text/html");
+        }
+        else {
+            const range = document.createRange();
+            range.selectNodeContents(document.body);
+            return safeRange.createContextualFragment(range, sanitizeHtml(content));
+        }
+    }
+}
+export const Mancha = new Renderer();

package/dist/store.d.ts

@@ -8,14 +8,6 @@ declare abstract class IDebouncer {
 }
 /** Default debouncer time in millis. */
 export declare const REACTIVE_DEBOUNCE_MILLIS = 10;
-/**
- * Creates an evaluation function based on the provided code and arguments.
- * @param code The code to be evaluated.
- * @param args The arguments to be passed to the evaluation function. Default is an empty array.
- * @returns The evaluation function.
- */
-export declare function makeEvalFunction(code: string, args?: string[]): Function;
-export declare function makeAsyncEvalFunction(code: string, args?: string[]): Function;
 export declare class SignalStore extends IDebouncer {
     protected readonly evalkeys: string[];
     protected readonly expressionCache: Map<string, Function>;
@@ -38,7 +30,13 @@ export declare class SignalStore extends IDebouncer {
     private proxify;
     get $(): SignalStoreProxy;
     /**
-     * Retrieves or creates a cached expression function based on the provided expression.
+     * Creates an evaluation function for the provided expression.
+     * @param expr The expression to be evaluated.
+     * @returns The evaluation function.
+     */
+    private makeEvalFunction;
+    /**
+     * Retrieves or creates a cached expression function for the provided expression.
      * @param expr - The expression to retrieve or create a cached function for.
      * @returns The cached expression function.
      */

package/dist/store.js

@@ -1,3 +1,4 @@
+import * as jexpr from "jexpr";
 class IDebouncer {
     timeouts = new Map();
     debounce(millis, callback) {
@@ -19,18 +20,8 @@ class IDebouncer {
 }
 /** Default debouncer time in millis. */
 export const REACTIVE_DEBOUNCE_MILLIS = 10;
-/**
- * Creates an evaluation function based on the provided code and arguments.
- * @param code The code to be evaluated.
- * @param args The arguments to be passed to the evaluation function. Default is an empty array.
- * @returns The evaluation function.
- */
-export function makeEvalFunction(code, args = []) {
-    return new Function(...args, `with (this) { return (${code}); }`);
-}
-export function makeAsyncEvalFunction(code, args = []) {
-    return new Function(...args, `with (this) { return (async () => (${code}))(); }`);
-}
+/** Shared AST factory. */
+const AST_FACTORY = new jexpr.EvalAstFactory();
 function isProxified(object) {
     return object instanceof SignalStore || object["__is_proxy__"];
 }
@@ -152,13 +143,46 @@ export class SignalStore extends IDebouncer {
         return this.proxify();
     }
     /**
-     * Retrieves or creates a cached expression function based on the provided expression.
+     * Creates an evaluation function for the provided expression.
+     * @param expr The expression to be evaluated.
+     * @returns The evaluation function.
+     */
+    makeEvalFunction(expr) {
+        // Throw an error if the expression is not a simple one-liner.
+        if (expr.includes(";")) {
+            throw new Error("Complex expressions are not supported.");
+        }
+        // If the expression includes assignment, save the left-hand side for later.
+        let assignResult = null;
+        if (expr.includes("=")) {
+            const [lhs, rhs] = expr.split("=");
+            assignResult = lhs.trim();
+            expr = rhs.trim();
+        }
+        // Otherwise, just return the simple expression function.
+        return (thisArg, args) => {
+            const ast = jexpr.parse(expr, AST_FACTORY);
+            const ctx = ast
+                ?.getIds([])
+                ?.map((id) => [id, args[id] ?? thisArg[id] ?? globalThis[id]]);
+            const res = ast?.evaluate(Object.fromEntries(ctx || []));
+            if (assignResult) {
+                thisArg[assignResult] = res;
+            }
+            else {
+                return res;
+            }
+        };
+    }
+    /**
+     * Retrieves or creates a cached expression function for the provided expression.
      * @param expr - The expression to retrieve or create a cached function for.
      * @returns The cached expression function.
      */
     cachedExpressionFunction(expr) {
+        expr = expr.trim();
         if (!this.expressionCache.has(expr)) {
-            this.expressionCache.set(expr, makeEvalFunction(expr, this.evalkeys));
+            this.expressionCache.set(expr, this.makeEvalFunction(expr));
         }
         return this.expressionCache.get(expr);
     }
@@ -172,11 +196,7 @@ export class SignalStore extends IDebouncer {
         else {
             // Otherwise, perform the expression evaluation.
             const fn = this.cachedExpressionFunction(expr);
-            const argvals = this.evalkeys.map((key) => args[key]);
-            if (Object.keys(args).some((key) => !this.evalkeys.includes(key))) {
-                throw new Error(`Invalid argument key, must be one of: ${this.evalkeys.join(", ")}`);
-            }
-            return fn.call(thisArg, ...argvals);
+            return fn(thisArg, args);
         }
     }
 }

package/dist/test_utils.d.ts

@@ -0,0 +1,2 @@
+export declare function innerHTML(elem: Element): string;
+export declare function getTextContent(elem: Element): string | null;

package/dist/test_utils.js

@@ -0,0 +1,14 @@
+import { DomUtils } from "htmlparser2";
+import { hasProperty } from "./dome.js";
+export function innerHTML(elem) {
+    if (hasProperty(elem, "innerHTML"))
+        return elem.innerHTML;
+    else
+        return DomUtils.getInnerHTML(elem);
+}
+export function getTextContent(elem) {
+    if (hasProperty(elem, "textContent"))
+        return elem.textContent;
+    else
+        return DomUtils.textContent(elem);
+}

package/dist/worker.d.ts

@@ -1,7 +1,9 @@
 import { IRenderer } from "./core.js";
 import { ParserParams } from "./interfaces.js";
 export declare class Renderer extends IRenderer {
-    parseHTML(content: string, params?: ParserParams): DocumentFragment;
+    parseHTML(content: string, params?: ParserParams): Document | DocumentFragment;
     serializeHTML(root: Node | DocumentFragment | Document): string;
+    createElement(tag: string, owner?: Document | null): globalThis.Element;
+    textContent(node: Node, content: string): void;
 }
 export declare const Mancha: Renderer;

package/dist/worker.js

@@ -1,4 +1,5 @@
 import * as htmlparser2 from "htmlparser2";
+import { Element, Text } from "domhandler";
 import { render as renderDOM } from "dom-serializer";
 import { IRenderer } from "./core.js";
 export class Renderer extends IRenderer {
@@ -8,6 +9,12 @@ export class Renderer extends IRenderer {
     serializeHTML(root) {
         return renderDOM(root);
     }
+    createElement(tag, owner) {
+        return new Element(tag, {});
+    }
+    textContent(node, content) {
+        node.children = [new Text(content)];
+    }
 }
 // Export the renderer instance directly.
 export const Mancha = new Renderer();

package/gulpfile.js

@@ -13,7 +13,7 @@ GulpClient.task("clean", function (done) {
 
 GulpClient.task("ts", function () {
   // The gulp-typescript plugin is deprecated.
-  return run("tsc -p .").exec();
+  return run("tsec -p .").exec();
 });
 
 GulpClient.task("css", function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mancha",
-  "version": "0.9.0",
+  "version": "0.9.4",
   "description": "Javscript HTML rendering engine",
   "main": "dist/index.js",
   "type": "module",
@@ -9,7 +9,7 @@
   "scripts": {
     "clean": "rm -rf dist/",
     "build": "gulp build && webpack",
-    "test": "mocha dist/*.test.js",
+    "test": "node --test dist/*.test.js",
     "webpack": "webpack",
     "cli": "node dist/cli.js"
   },
@@ -31,17 +31,14 @@
   "dependencies": {
     "dom-serializer": "^2.0.0",
     "htmlparser2": "^9.1.0",
+    "jexpr": "^1.0.0-pre.9",
     "jsdom": "^24.0.0",
-    "through2": "^4.0.2",
-    "yargs": "^17.7.2"
+    "safevalues": "^0.6.0"
   },
   "devDependencies": {
-    "@types/gulp": "^4.0.8",
     "@types/jsdom": "^21.1.6",
-    "@types/mocha": "^10.0.3",
     "@types/node": "^20.12.11",
     "@types/path-browserify": "^1.0.1",
-    "@types/through2": "^2.0.36",
     "@types/yargs": "^17.0.29",
     "css-loader": "^7.1.2",
     "csso": "^5.0.5",
@@ -49,11 +46,13 @@
     "gulp-csso": "^4.0.1",
     "gulp-run": "^1.7.1",
     "gulp-typescript": "^6.0.0-alpha.1",
-    "mocha": "^10.2.0",
     "static-server": "^3.0.0",
+    "terser-webpack-plugin": "^5.3.10",
     "ts-node": "^10.9.2",
+    "tsec": "^0.2.8",
     "typescript": "5.4.5",
     "webpack": "5.91.0",
-    "webpack-cli": "^5.1.4"
+    "webpack-cli": "^5.1.4",
+    "yargs": "^17.7.2"
   }
 }

package/tsconfig.json

@@ -1,14 +1,20 @@
 {
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "ES2022",
-        "outDir": "dist",
-        "rootDir": "src",
-        "declaration": true,
-        "noImplicitAny": true,
-        "skipLibCheck": true,
-        "strict": true,
-        "stripInternal": true,
-        "moduleResolution": "node",
-    },
-}
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "noImplicitAny": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "stripInternal": true,
+    "moduleResolution": "node",
+    "plugins": [
+      {
+        "name": "tsec",
+        "exemptionConfig": "./tsec_exemptions.json"
+      }
+    ]
+  }
+}

package/tsec_exemptions.json

@@ -0,0 +1,4 @@
+{
+    "ban-domparser-parsefromstring": ["src/browser.ts"],
+    "ban-range-createcontextualfragment": ["src/browser.ts"]
+}

package/webpack.config.js

@@ -1,16 +1,14 @@
+import TerserPlugin from "terser-webpack-plugin";
 
 export default {
   target: "web",
   mode: "production",
   entry: {
-    mancha: "./dist/browser.js",
+    mancha: "./dist/mancha.js",
   },
   output: {
     filename: "[name].js",
   },
-  externals: {
-    htmlparser2: "window.htmlparser2",
-  },
   module: {
     rules: [
       {
@@ -19,4 +17,8 @@ export default {
       },
     ],
   },
+  optimization: {
+    minimize: true,
+    minimizer: [new TerserPlugin({ extractComments: false })],
+  },
 };

package/dist/css_raw_basic.css

@@ -1 +0,0 @@
-html{max-width:70ch;padding:2em 1em;margin:auto;line-height:1.75;font-size:1.25em;font-family:sans-serif}h1,h2,h3,h4,h5,h6{margin:1em 0 .5em}ol,p,ul{margin-bottom:1em;color:#1d1d1d}

package/dist/gulp_plugin.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import * as stream from "stream";
-/**
- * Main entrypoint to be used in Gulp. Usage:
- *
- *     var mancha = require('mancha/dist/gulp')
- *     gulp.src(...).pipe(mancha({myvar: myval})).pipe(...)
- *
- * @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(context?: {
-    [key: string]: string;
-}): stream.Transform;
-export default mancha;