@executablemd/testing 0.3.1

package/esm/testing/npm/src/deps/jsr.io/@std/internal/1.0.14/styles.js

@@ -0,0 +1,207 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+// A module to print ANSI terminal colors. Inspired by chalk, kleur, and colors
+// on npm.
+// This code is vendored from `fmt/colors.ts`.
+// deno-lint-ignore no-explicit-any
+import * as dntShim from "../../../../../_dnt.shims.js";
+const { Deno } = dntShim.dntGlobalThis;
+const noColor = typeof Deno?.noColor === "boolean"
+    ? Deno.noColor
+    : false;
+const enabled = !noColor;
+function code(open, close) {
+    return {
+        open: `\x1b[${open.join(";")}m`,
+        close: `\x1b[${close}m`,
+        regexp: new RegExp(`\\x1b\\[${close}m`, "g"),
+    };
+}
+function run(str, code) {
+    return enabled
+        ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}`
+        : str;
+}
+/**
+ * Sets the style of text to be printed to bold.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make bold
+ *
+ * @returns Bold text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bold } from "@std/internal/styles";
+ *
+ * console.log(bold("Hello, world!")); // Prints "Hello, world!" in bold
+ * ```
+ */
+export function bold(str) {
+    return run(str, code([1], 22));
+}
+/**
+ * Sets the color of text to be printed to red.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make red
+ *
+ * @returns Red text for printing
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red } from "@std/internal/styles";
+ *
+ * console.log(red("Hello, world!")); // Prints "Hello, world!" in red
+ * ```
+ */
+export function red(str) {
+    return run(str, code([31], 39));
+}
+/**
+ * Sets the color of text to be printed to green.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make green
+ *
+ * @returns Green text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { green } from "@std/internal/styles";
+ *
+ * console.log(green("Hello, world!")); // Prints "Hello, world!" in green
+ * ```
+ */
+export function green(str) {
+    return run(str, code([32], 39));
+}
+/**
+ * Sets the color of text to be printed to yellow.
+ *
+ * Disable by setting the `NO_COLOR` environmental variable.
+ *
+ * @param str Text to make yellow
+ *
+ * @returns Yellow text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { yellow } from "@std/internal/styles";
+ *
+ * console.log(yellow("Hello, world!")); // Prints "Hello, world!" in yellow
+ * ```
+ */
+export function yellow(str) {
+    return run(str, code([33], 39));
+}
+/**
+ * Sets the color of text to be printed to white.
+ *
+ * @param str Text to make white
+ *
+ * @returns White text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { white } from "@std/internal/styles";
+ *
+ * console.log(white("Hello, world!")); // Prints "Hello, world!" in white
+ * ```
+ */
+export function white(str) {
+    return run(str, code([37], 39));
+}
+/**
+ * Sets the color of text to be printed to gray.
+ *
+ * @param str Text to make gray
+ *
+ * @returns Gray text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { gray } from "@std/internal/styles";
+ *
+ * console.log(gray("Hello, world!")); // Prints "Hello, world!" in gray
+ * ```
+ */
+export function gray(str) {
+    return brightBlack(str);
+}
+/**
+ * Sets the color of text to be printed to bright-black.
+ *
+ * @param str Text to make bright-black
+ *
+ * @returns Bright-black text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { brightBlack } from "@std/internal/styles";
+ *
+ * console.log(brightBlack("Hello, world!")); // Prints "Hello, world!" in bright-black
+ * ```
+ */
+export function brightBlack(str) {
+    return run(str, code([90], 39));
+}
+/**
+ * Sets the background color of text to be printed to red.
+ *
+ * @param str Text to make its background red
+ *
+ * @returns Red background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgRed } from "@std/internal/styles";
+ *
+ * console.log(bgRed("Hello, world!")); // Prints "Hello, world!" with red background
+ * ```
+ */
+export function bgRed(str) {
+    return run(str, code([41], 49));
+}
+/**
+ * Sets the background color of text to be printed to green.
+ *
+ * @param str Text to make its background green
+ *
+ * @returns Green background text for print
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { bgGreen } from "@std/internal/styles";
+ *
+ * console.log(bgGreen("Hello, world!")); // Prints "Hello, world!" with green background
+ * ```
+ */
+export function bgGreen(str) {
+    return run(str, code([42], 49));
+}
+// https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+const ANSI_REGEXP = new RegExp([
+    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
+].join("|"), "g");
+/**
+ * Remove ANSI escape codes from the string.
+ *
+ * @param string Text to remove ANSI escape codes from
+ *
+ * @returns Text without ANSI escape codes
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { red, stripAnsiCode } from "@std/internal/styles";
+ *
+ * console.log(stripAnsiCode(red("Hello, world!"))); // Prints "Hello, world!"
+ * ```
+ */
+export function stripAnsiCode(string) {
+    return string.replace(ANSI_REGEXP, "");
+}

package/esm/testing/npm/src/deps/jsr.io/@std/internal/1.0.14/types.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+export {};

package/esm/testing/npm/src/mod.js

@@ -0,0 +1,27 @@
+/**
+ * @module
+ * Testing vocabulary for executable.md documents (specs/testing-spec.md).
+ *
+ * `<Testing>` activates testing mode for its expanded subtree, `<Test>`
+ * defines an atomic test, and the assertion components map to `@std/assert`.
+ *
+ * Composition with core execution:
+ *
+ * ```ts
+ * import { execute } from "@executablemd/core";
+ * import { useTesting } from "@executablemd/testing";
+ *
+ * const tests = yield* useTesting();
+ * const execution = yield* execute(options);
+ * const outcome = yield* execution;          // Result<string>
+ * const results = yield* tests.results;
+ * ```
+ *
+ * Vocabulary registration (`installTestingVocabulary`) is distinct from
+ * testing-mode activation (`useTesting()` at the root, or a `<Testing>`
+ * element for a subtree).
+ */
+import "./_dnt.polyfills.js";
+export { Test, testing, record, results, TestFailureError } from "./src/test-api.js";
+export { installTestingVocabulary } from "./src/vocabulary.js";
+export { useTesting } from "./src/use-testing.js";

package/esm/testing/npm/src/src/assertions.js

@@ -0,0 +1,250 @@
+/**
+ * Assertion components (specs/testing-spec.md §Assertions).
+ *
+ * Each component maps to an `@std/assert` export with the same name and
+ * parameter names. Expression props evaluate LIVE against the merged binding
+ * environment — never through JSON serialization, which would destroy
+ * `RegExp`s, `undefined`, and object identity.
+ *
+ * The assertion runs on the raw values BEFORE any diagnostic formatting, so
+ * formatting arbitrary values (mutating or throwing getters/toJSON/toString)
+ * can never change the assertion outcome. Diagnostics are built afterwards
+ * under guarded fallback.
+ */
+import { assert, assertEquals, assertExists, assertFalse, assertGreater, assertGreaterOrEqual, AssertionError, assertLess, assertLessOrEqual, assertMatch, assertNotEquals, assertNotMatch, assertNotStrictEquals, assertStrictEquals, assertStringIncludes, } from "../deps/jsr.io/@std/assert/1.0.19/mod.js";
+import { DocumentOutput, env, renderSegments } from "@executablemd/core";
+import { inTest, testing, verbose } from "./test-api.js";
+function entry(name, kind, run) {
+    const allowsExpectedChildren = kind === "binary-eq" || kind === "string-includes";
+    return [name, { name, kind, run, allowsExpectedChildren }];
+}
+export const ASSERTIONS = new Map([
+    entry("Assert", "unary-truthy", (v) => assert(v.expr, v.msg)),
+    entry("AssertFalse", "unary-truthy", (v) => assertFalse(v.expr, v.msg)),
+    entry("AssertExists", "unary-exists", (v) => assertExists(v.actual, v.msg)),
+    entry("AssertEquals", "binary-eq", (v) => assertEquals(v.actual, v.expected, v.msg)),
+    entry("AssertNotEquals", "binary-eq", (v) => assertNotEquals(v.actual, v.expected, v.msg)),
+    entry("AssertStrictEquals", "binary-eq", (v) => assertStrictEquals(v.actual, v.expected, v.msg)),
+    entry("AssertNotStrictEquals", "binary-eq", (v) => assertNotStrictEquals(v.actual, v.expected, v.msg)),
+    entry("AssertStringIncludes", "string-includes", (v) => assertStringIncludes(coerceString(v.actual), coerceString(v.expected), v.msg)),
+    entry("AssertMatch", "match", (v) => assertMatch(coerceString(v.actual), requireRegExp(v.expected), v.msg)),
+    entry("AssertNotMatch", "match", (v) => assertNotMatch(coerceString(v.actual), requireRegExp(v.expected), v.msg)),
+    entry("AssertGreater", "numeric", (v) => assertGreater(v.actual, v.expected, v.msg)),
+    entry("AssertGreaterOrEqual", "numeric", (v) => assertGreaterOrEqual(v.actual, v.expected, v.msg)),
+    entry("AssertLess", "numeric", (v) => assertLess(v.actual, v.expected, v.msg)),
+    entry("AssertLessOrEqual", "numeric", (v) => assertLessOrEqual(v.actual, v.expected, v.msg)),
+]);
+function coerceString(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new AssertionError(`expected a string "actual"/"expected" value, got ${typeof value}`);
+}
+function requireRegExp(value) {
+    if (value instanceof RegExp) {
+        return value;
+    }
+    throw new AssertionError("match assertions require a RegExp through the expected prop — use expected={/pattern/}");
+}
+// ---------------------------------------------------------------------------
+// Live expression evaluation
+// ---------------------------------------------------------------------------
+const IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function evaluateExpression(expression, values) {
+    const names = Object.keys(values).filter((name) => IDENTIFIER_RE.test(name));
+    const fn = new Function(...names, `return (${expression});`);
+    return fn(...names.map((name) => values[name]));
+}
+// ---------------------------------------------------------------------------
+// Guarded value formatting — runs only AFTER the assertion outcome is fixed
+// ---------------------------------------------------------------------------
+function safeFormat(value) {
+    try {
+        if (typeof value === "string") {
+            return JSON.stringify(value);
+        }
+        if (value instanceof RegExp) {
+            return String(value);
+        }
+        const json = JSON.stringify(value);
+        if (json !== undefined) {
+            return json;
+        }
+        return String(value);
+    }
+    catch {
+        try {
+            return String(value);
+        }
+        catch {
+            return "<unformattable value>";
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Diagnostic-carrying assertion error
+// ---------------------------------------------------------------------------
+/**
+ * An assertion failure enriched with its Markdown diagnostic. Still an
+ * `AssertionError`, so containment and classification treat it as the
+ * original @std/assert failure.
+ */
+export class AssertionDiagnostic extends AssertionError {
+    name = "AssertionDiagnostic";
+    diagnostic;
+    detail;
+    constructor(cause, diagnostic, detail) {
+        super(cause.message);
+        this.diagnostic = diagnostic;
+        this.detail = detail;
+        this.cause = cause;
+    }
+}
+// ---------------------------------------------------------------------------
+// expandAssertion
+// ---------------------------------------------------------------------------
+const KIND_PROPS = {
+    "unary-truthy": { allowed: ["expr", "msg"], required: ["expr"] },
+    "unary-exists": { allowed: ["actual", "msg"], required: ["actual"] },
+    "binary-eq": { allowed: ["actual", "expected", "msg"], required: ["actual"] },
+    "string-includes": { allowed: ["actual", "expected", "msg"], required: ["actual"] },
+    match: { allowed: ["actual", "expected", "msg"], required: ["actual", "expected"] },
+    numeric: { allowed: ["actual", "expected", "msg"], required: ["actual", "expected"] },
+};
+function validationError(name, message) {
+    return { type: "error", message: `<${name}> ${message}`, source: name };
+}
+/**
+ * Expand one assertion component: validate props, resolve raw values, run the
+ * @std/assert function, then build the diagnostic. Returns diagnostic text on
+ * a visible pass; throws `AssertionDiagnostic` on failure.
+ */
+export function* expandAssertion(assertion, invocation, ctx) {
+    const rules = KIND_PROPS[assertion.kind];
+    const supplied = [...Object.keys(invocation.props), ...Object.keys(invocation.expressions)];
+    for (const name of supplied) {
+        if (!rules.allowed.includes(name)) {
+            return [
+                validationError(assertion.name, `does not accept a "${name}" prop (allowed: ${rules.allowed.join(", ")}).`),
+            ];
+        }
+    }
+    const hasChildren = !invocation.selfClosing && invocation.children.length > 0;
+    if (hasChildren && !assertion.allowsExpectedChildren) {
+        return [validationError(assertion.name, "does not accept expected children.")];
+    }
+    if (hasChildren && supplied.includes("expected")) {
+        return [
+            validationError(assertion.name, 'accepts either an "expected" prop or expected children, not both.'),
+        ];
+    }
+    for (const name of rules.required) {
+        const suppliedByChildren = name === "expected" && hasChildren;
+        if (!supplied.includes(name) && !suppliedByChildren) {
+            return [validationError(assertion.name, `requires the "${name}" prop.`)];
+        }
+    }
+    if (assertion.kind === "binary-eq" || assertion.kind === "string-includes") {
+        if (!supplied.includes("expected") && !hasChildren) {
+            return [validationError(assertion.name, 'requires an "expected" prop or expected children.')];
+        }
+    }
+    // Resolve raw values: literal props as-is, expression props evaluated live
+    // against caller-projected bindings merged under the current environment
+    // (the same precedence core uses for projected children).
+    const currentEnv = yield* env;
+    const merged = {
+        ...(ctx.projectedEnv?.values ?? {}),
+        ...(currentEnv?.values ?? {}),
+    };
+    const resolved = {};
+    const resolutionOrder = [
+        "expr",
+        "actual",
+        "expected",
+        "msg",
+    ];
+    for (const name of resolutionOrder) {
+        if (name in invocation.expressions) {
+            try {
+                resolved[name] = evaluateExpression(invocation.expressions[name], merged);
+            }
+            catch (error) {
+                return [
+                    validationError(assertion.name, `failed to evaluate the "${name}" expression: ${error instanceof Error ? error.message : String(error)}`),
+                ];
+            }
+        }
+        else if (name in invocation.props) {
+            resolved[name] = invocation.props[name];
+        }
+    }
+    // @std/assert takes msg as a string; a non-string is rejected by TYPE
+    // CHECK alone — formatting it here would run hostile toJSON/toString
+    // side effects before the assertion outcome is established.
+    if ("msg" in resolved && typeof resolved.msg !== "string") {
+        return [validationError(assertion.name, 'requires "msg" to be a string when supplied.')];
+    }
+    const values = {
+        expr: resolved.expr,
+        actual: resolved.actual,
+        expected: resolved.expected,
+        msg: typeof resolved.msg === "string" ? resolved.msg : undefined,
+    };
+    if (hasChildren) {
+        const expanded = yield* ctx.expand(invocation.children);
+        values.expected = renderSegments(expanded).replace(/\s+$/, "");
+    }
+    // Run the assertion on the raw values — the outcome is fixed before any
+    // diagnostic formatting can observe (or mutate) them.
+    let failure;
+    try {
+        assertion.run(values);
+    }
+    catch (error) {
+        failure = error instanceof Error ? error : new Error(String(error));
+    }
+    const detail = {};
+    if (assertion.kind === "unary-truthy") {
+        detail.actual = safeFormat(values.expr);
+    }
+    else {
+        detail.actual = safeFormat(values.actual);
+        if (assertion.kind !== "unary-exists") {
+            detail.expected = safeFormat(values.expected);
+        }
+    }
+    if (failure) {
+        const diagnostic = buildDiagnostic(assertion.name, "failed", values.msg, detail, failure);
+        const visible = (yield* testing) || (yield* verbose);
+        const inTestScope = yield* inTest;
+        if (visible && !inTestScope) {
+            // Outside a test the throw below aborts expansion before the segment
+            // could render — emit the diagnostic directly so it reaches the output.
+            yield* DocumentOutput.operations.output(diagnostic);
+        }
+        throw new AssertionDiagnostic(failure, diagnostic, detail);
+    }
+    const visible = (yield* testing) || (yield* verbose);
+    if (!visible) {
+        return [];
+    }
+    return [{ type: "text", content: buildDiagnostic(assertion.name, "passed", values.msg, detail) }];
+}
+function buildDiagnostic(name, outcome, msg, detail, failure) {
+    const icon = outcome === "passed" ? "✅" : "❌";
+    const lines = [`> ${icon} **${name}** ${outcome}${msg ? ` — ${msg}` : ""}`];
+    if (detail.actual !== undefined) {
+        lines.push(`> actual: ${detail.actual}`);
+    }
+    if (detail.expected !== undefined) {
+        lines.push(`> expected: ${detail.expected}`);
+    }
+    if (failure) {
+        const message = failure.message.split("\n")[0];
+        if (message) {
+            lines.push(`> ${message}`);
+        }
+    }
+    return `\n${lines.join("\n")}\n`;
+}