eaa-kit 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,5 +1,63 @@
 import { t as ImpactLevel } from "./impact-EEB9ZXmC.js";
-import { z } from "zod";
+//#region src/schema.d.ts
+/**
+ * The small amount of schema validation this package actually needs.
+ *
+ * It replaced zod, which is 6.4 MB of a 37 MB install for three closed schemas
+ * — the config file, the JSON report and the baseline — each already wrapped in
+ * hand-written error messages. Paying that on every install of an accessibility
+ * linter was not a good trade.
+ *
+ * The shape mirrors what it replaced closely enough that the call sites did not
+ * change: `safeParse` returns either the parsed value or a list of issues with
+ * a path, and the callers turn those into their own messages.
+ *
+ * Deliberately not a general-purpose validator. It does what these three
+ * schemas need and no more; anything else should be added here when a schema
+ * needs it, rather than guessed at now.
+ */
+interface Issue {
+  /** Where in the document, e.g. ['provider', 'email'] or ['pages', 0, 'path']. */
+  path: Array<string | number>;
+  message: string;
+}
+/**
+ * A validator that reads `value` and either returns a value of type T or
+ * records why it could not.
+ *
+ * `read` returns undefined when it recorded an issue. Callers must check
+ * `issues.length` rather than the return value, since undefined is also a legal
+ * parsed value for an optional field.
+ */
+interface Schema<T> {
+  read(value: unknown, path: Array<string | number>, issues: Issue[]): T | undefined;
+  /** Present when the field may be absent, so objects know not to require it. */
+  readonly isOptional?: boolean;
+  /** Supplies a value when the field is absent. */
+  readonly fallback?: () => T;
+}
+/**
+ * Marks a field that may be absent from the output object, not merely undefined
+ * in it. `withDefault` is absent from the *input* but always present in the
+ * output, so only `optional` carries this.
+ */
+declare const OPTIONAL: unique symbol;
+type OptionalSchema<T> = Schema<T | undefined> & {
+  readonly [OPTIONAL]: true;
+};
+type Infer<S> = S extends OptionalSchema<infer T> ? T | undefined : S extends Schema<infer T> ? T : never;
+type OptionalKeys<S> = { [K in keyof S]: S[K] extends OptionalSchema<unknown> ? K : never; }[keyof S];
+/** Optional fields become optional keys, so `exactOptionalPropertyTypes` holds. */
+type ObjectOf<S> = { [K in Exclude<keyof S, OptionalKeys<S>>]: Infer<S[K]>; } & { [K in OptionalKeys<S>]?: Infer<S[K]>; };
+/**
+ * A field with a default: absent from what an author writes, always present in
+ * what comes out.
+ */
+declare const DEFAULTED: unique symbol;
+type DefaultedSchema<T> = Schema<T> & {
+  readonly [DEFAULTED]: true;
+};
+//#endregion
 //#region src/config/define.d.ts
 /** Countries with their own supervisory body and statute text. */
 declare const COUNTRIES: readonly ['AT', 'DE', 'CH'];
@@ -23,70 +81,102 @@ type AssessmentMethod = (typeof ASSESSMENT_METHODS)[number];
  */
 declare const ISSUE_REASONS: readonly ['disproportionate-burden', 'out-of-scope', 'fix-planned'];
 type IssueReason = (typeof ISSUE_REASONS)[number];
-declare const configSchema: z.ZodObject<{
-  site: z.ZodObject<{
-    name: z.ZodString;
-    url: z.ZodURL;
-    locale: z.ZodString;
-  }, z.core.$strip>;
-  provider: z.ZodObject<{
-    legalName: z.ZodString;
-    email: z.ZodEmail;
-    phone: z.ZodOptional<z.ZodString>;
-    address: z.ZodOptional<z.ZodString>;
-    feedbackUrl: z.ZodOptional<z.ZodURL>;
-  }, z.core.$strip>;
-  compliance: z.ZodObject<{
-    status: z.ZodEnum<{
-      compliant: "compliant";
-      "non-compliant": "non-compliant";
-      "partially-compliant": "partially-compliant";
-    }>;
-    standard: z.ZodDefault<z.ZodString>;
-    knownIssues: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<{
-      description: string;
-    }, string>>, z.ZodObject<{
-      description: z.ZodString;
-      successCriteria: z.ZodDefault<z.ZodArray<z.ZodString>>;
-      en301549: z.ZodDefault<z.ZodArray<z.ZodString>>;
-      reason: z.ZodOptional<z.ZodEnum<{
-        "disproportionate-burden": "disproportionate-burden";
-        "fix-planned": "fix-planned";
-        "out-of-scope": "out-of-scope";
-      }>>;
-      remedyBy: z.ZodOptional<z.ZodISODate>;
-    }, z.core.$strip>>, z.ZodObject<{
-      description: z.ZodString;
-      successCriteria: z.ZodDefault<z.ZodArray<z.ZodString>>;
-      en301549: z.ZodDefault<z.ZodArray<z.ZodString>>;
-      reason: z.ZodOptional<z.ZodEnum<{
-        "disproportionate-burden": "disproportionate-burden";
-        "fix-planned": "fix-planned";
-        "out-of-scope": "out-of-scope";
-      }>>;
-      remedyBy: z.ZodOptional<z.ZodISODate>;
-    }, z.core.$strip>]>>>;
-    assessedOn: z.ZodISODate;
-    assessmentMethod: z.ZodDefault<z.ZodEnum<{
-      "external-audit": "external-audit";
-      "self-assessment": "self-assessment";
-    }>>;
-    auditReason: z.ZodDefault<z.ZodEnum<{
-      "disproportionate-burden": "disproportionate-burden";
-      "fix-planned": "fix-planned";
-      "out-of-scope": "out-of-scope";
-    }>>;
-  }, z.core.$strip>;
-  enforcement: z.ZodObject<{
-    country: z.ZodEnum<{
-      AT: "AT";
-      CH: "CH";
-      DE: "DE";
-    }>;
-  }, z.core.$strip>;
-}, z.core.$strip>;
-type EaaConfigInput = z.input<typeof configSchema>;
-type EaaConfig = z.output<typeof configSchema>;
+declare const configSchema: Schema<ObjectOf<{
+  site: Schema<ObjectOf<{
+    name: Schema<string>;
+    url: Schema<string>;
+    /** BCP 47 tag of the site itself, e.g. 'de-AT'. */
+    locale: Schema<string>;
+  }>>;
+  provider: Schema<ObjectOf<{
+    /** The legal entity answerable for the service. */
+    legalName: Schema<string>;
+    /**
+     * The feedback address. Required: the EAA obliges providers to offer a way
+     * to report accessibility barriers, and a statement without one is not
+     * usable for its purpose.
+     */
+    email: Schema<string>;
+    phone: OptionalSchema<string>;
+    address: OptionalSchema<string>;
+    /**
+     * A contact or feedback form, offered alongside the address rather than
+     * instead of it: the EAA requires a way to report barriers, and a form is
+     * the one channel a visitor who cannot use email may still be able to use.
+     */
+    feedbackUrl: OptionalSchema<string>;
+  }>>;
+  compliance: Schema<ObjectOf<{
+    status: Schema<"compliant" | "non-compliant" | "partially-compliant">;
+    standard: DefaultedSchema<string>;
+    knownIssues: DefaultedSchema<ObjectOf<{
+      /** What is not accessible, in the statement's language. */
+      description: Schema<string>;
+      /** WCAG success criteria, e.g. ['1.4.3']. */
+      successCriteria: DefaultedSchema<string[]>;
+      /** EN 301 549 clauses, e.g. ['9.1.4.3']. */
+      en301549: DefaultedSchema<string[]>;
+      reason: OptionalSchema<"disproportionate-burden" | "fix-planned" | "out-of-scope">;
+      /** ISO date by which the barrier is expected to be removed. */
+      remedyBy: OptionalSchema<string>;
+    }>[]>;
+    /** When the assessment was carried out. */
+    assessedOn: Schema<string>;
+    assessmentMethod: DefaultedSchema<"external-audit" | "self-assessment">;
+    /**
+     * Reason attached to barriers taken from an audit report, which carries no
+     * reason of its own. 'fix-planned' is the honest default for a barrier an
+     * automated run just found; the other two are claims only a human can make.
+     */
+    auditReason: DefaultedSchema<"disproportionate-burden" | "fix-planned" | "out-of-scope">;
+  }>>;
+  enforcement: Schema<ObjectOf<{
+    /** Drives which supervisory body and statute the template names. */
+    country: Schema<"AT" | "CH" | "DE">;
+  }>>;
+}>>;
+/**
+ * What an author writes in `eaa.config.ts`.
+ *
+ * Written out rather than inferred from the schema. It is the type people see
+ * in their editor while filling the file in, so it is worth being readable, and
+ * it differs from the parsed type in two ways inference makes awkward: fields
+ * with defaults may be left out, and a known issue may be a bare string.
+ */
+interface EaaConfigInput {
+  site: {
+    name: string;
+    url: string;
+    locale: string;
+  };
+  provider: {
+    legalName: string;
+    email: string;
+    phone?: string;
+    address?: string;
+    feedbackUrl?: string;
+  };
+  compliance: {
+    status: ComplianceStatus;
+    standard?: string;
+    knownIssues?: Array<string | KnownIssueInput>;
+    assessedOn: string;
+    assessmentMethod?: AssessmentMethod;
+    auditReason?: IssueReason;
+  };
+  enforcement: {
+    country: Country;
+  };
+}
+/** One barrier, as written in a config file. */
+interface KnownIssueInput {
+  description: string;
+  successCriteria?: string[];
+  en301549?: string[];
+  reason?: IssueReason;
+  remedyBy?: string;
+}
+type EaaConfig = Infer<typeof configSchema>;
 type KnownIssue = EaaConfig['compliance']['knownIssues'][number];
 /**
  * Identity function that gives `eaa.config.ts` its types. Deliberately does not

package/dist/index.js

@@ -1,2 +1,3 @@
-import { _ as defineConfig, a as summariseAuditReport, c as findConfigFile, d as COMPLIANCE_STATUSES, f as COUNTRIES, g as configSchema, h as STATEMENT_LOCALES, i as readAuditReport, l as loadConfig, m as ISSUE_REASONS, n as toHtmlBody, o as StatementError, p as ConfigError, r as toHtmlDocument, s as CONFIG_FILENAMES, t as renderStatement, u as ASSESSMENT_METHODS, v as parseConfig } from "./render-K9KxDDSA.js";
+import { a as COMPLIANCE_STATUSES, c as ISSUE_REASONS, d as defineConfig, f as parseConfig, i as ASSESSMENT_METHODS, l as STATEMENT_LOCALES, n as findConfigFile, o as COUNTRIES, r as loadConfig, s as ConfigError, t as CONFIG_FILENAMES, u as configSchema } from "./load-sCkKsvGQ.js";
+import { a as summariseAuditReport, i as readAuditReport, n as toHtmlBody, o as StatementError, r as toHtmlDocument, t as renderStatement } from "./render-BO0nVrrZ.js";
 export { ASSESSMENT_METHODS, COMPLIANCE_STATUSES, CONFIG_FILENAMES, COUNTRIES, ConfigError, ISSUE_REASONS, STATEMENT_LOCALES, StatementError, configSchema, defineConfig, findConfigFile, loadConfig, parseConfig, readAuditReport, renderStatement, summariseAuditReport, toHtmlBody, toHtmlDocument };

package/dist/init-DRKIdpK1.js

@@ -0,0 +1,110 @@
+import { o as COUNTRIES, t as CONFIG_FILENAMES } from "./load-sCkKsvGQ.js";
+import { readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import pc from "picocolors";
+import { createInterface } from "node:readline/promises";
+//#region src/cli/init.ts
+const COUNTRY_LOCALES = {
+	AT: "de-AT",
+	DE: "de-DE",
+	CH: "de-CH"
+};
+/**
+* Everything the project already says about itself.
+*
+* A guess that is wrong is worse than an empty field somebody has to fill, so
+* this only reads what a project states outright.
+*/
+async function detectDefaults(cwd) {
+	const detected = {};
+	try {
+		const pkg = JSON.parse(await readFile(path.join(cwd, "package.json"), "utf8"));
+		if (typeof pkg.name === "string" && pkg.name !== "") detected.name = pkg.name.replace(/^@[^/]+\//, "");
+		if (typeof pkg.homepage === "string" && /^https?:\/\//.test(pkg.homepage)) detected.url = pkg.homepage;
+	} catch {}
+	return detected;
+}
+/** Whether a config is already there, so init never overwrites one silently. */
+async function existingConfig(cwd) {
+	for (const name of CONFIG_FILENAMES) try {
+		await stat(path.join(cwd, name));
+		return name;
+	} catch {}
+}
+/** Reads answers, showing what each will be if the reader just hits enter. */
+function terminalPrompt() {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	return {
+		ask: async (question, fallback) => {
+			const shown = fallback === "" ? "" : pc.dim(` (${fallback})`);
+			const answer = (await rl.question(`${question}${shown}: `)).trim();
+			return answer === "" ? fallback : answer;
+		},
+		close: () => rl.close()
+	};
+}
+async function runInitCommand(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const target = path.resolve(cwd, options.output ?? "eaa.config.json");
+	const already = await existingConfig(cwd);
+	if (already !== void 0 && !options.force) {
+		process.stderr.write(`${pc.yellow("warning")} ${already} already exists. Pass --force to overwrite it.\n`);
+		return { exitCode: 1 };
+	}
+	const detected = await detectDefaults(cwd);
+	const terminal = options.ask === void 0 && !options.yes && process.stdin.isTTY === true ? terminalPrompt() : void 0;
+	const rl = options.ask ?? terminal?.ask;
+	const ask = async (question, fallback) => rl === void 0 ? fallback : rl(question, fallback);
+	if (rl !== void 0) process.stderr.write(`${pc.bold("eaa-kit init")}\n${pc.dim("Everything here is a claim you are making. Press enter to take a default.\n\n")}`);
+	const name = await ask("Site name", detected.name ?? "");
+	const url = await ask("Site URL", detected.url ?? "https://example.com");
+	const country = normaliseCountry(await ask(`Country whose law applies (${COUNTRIES.join("/")})`, "AT"));
+	const locale = await ask("Language of the site", COUNTRY_LOCALES[country]);
+	const legalName = await ask("Legal entity answerable for the site", name);
+	const email = await ask("Feedback email", "");
+	const feedbackUrl = await ask("Feedback or contact form URL (optional)", "");
+	terminal?.close();
+	const config = {
+		site: {
+			name,
+			url,
+			locale
+		},
+		provider: {
+			legalName,
+			email,
+			...feedbackUrl === "" ? {} : { feedbackUrl }
+		},
+		compliance: {
+			status: "partially-compliant",
+			assessedOn: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+			assessmentMethod: "self-assessment",
+			knownIssues: []
+		},
+		enforcement: { country }
+	};
+	try {
+		await writeFile(target, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	} catch (cause) {
+		process.stderr.write(`${pc.red("error")} Could not write ${path.basename(target)}: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return { exitCode: 2 };
+	}
+	process.stderr.write(`Wrote ${path.relative(cwd, target) || path.basename(target)}\n`);
+	const missing = [name === "" ? "site.name" : void 0, email === "" ? "provider.email" : void 0].filter((field) => field !== void 0);
+	if (missing.length > 0) process.stderr.write(`${pc.yellow("warning")} ${missing.join(" and ")} ${missing.length === 1 ? "is" : "are"} empty and required. Fill ${missing.length === 1 ? "it" : "them"} in before generating a statement.\n`);
+	process.stderr.write(pc.dim("Read it before publishing anything from it: status is partially-compliant,\nwhich is the honest default before an audit has run.\n\nNext:  eaa-kit audit  ·  eaa-kit statement\n"));
+	return {
+		file: target,
+		exitCode: 0
+	};
+}
+/** Falls back rather than failing: a typo should not throw away the answers. */
+function normaliseCountry(value) {
+	const upper = value.trim().toUpperCase();
+	return COUNTRIES.includes(upper) ? upper : "AT";
+}
+//#endregion
+export { runInitCommand };

package/dist/{json-1ESNIiHY.js → json-C9xS1PNC.js}

@@ -23,7 +23,9 @@ function buildJsonReport(audits, options) {
 		generatedAt,
 		engine: audits[0]?.engine ?? "jsdom",
 		target: {
-			directory: options.directory,
+			source: options.directory,
+			kind: options.sourceKind ?? "directory",
+			directory: (options.sourceKind ?? "directory") === "directory" ? options.directory : null,
 			baseUrl: options.baseUrl ?? null
 		},
 		summary: buildSummary(audits, options.failOn),

package/dist/load-sCkKsvGQ.js

@@ -0,0 +1,192 @@
+import { _ as withDefault, c as object, f as safeParse, g as url, h as union, i as isoDate, l as optional, m as transform, n as email, p as string, r as enumeration, t as array, u as pipe } from "./schema-CMZ8ItGk.js";
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/config/define.ts
+/** Countries with their own supervisory body and statute text. */
+const COUNTRIES = [
+	"AT",
+	"DE",
+	"CH"
+];
+/** Languages a statement can be rendered in. */
+const STATEMENT_LOCALES = ["de", "en"];
+/**
+* Wording follows the EU model statement: fully, partially, or not conformant
+* with the standard. "partially-compliant" is the honest answer for most sites
+* and the one that carries obligations to list what is missing.
+*/
+const COMPLIANCE_STATUSES = [
+	"compliant",
+	"partially-compliant",
+	"non-compliant"
+];
+const ASSESSMENT_METHODS = ["self-assessment", "external-audit"];
+/**
+* Why a known barrier still exists. The first two are the grounds the EU regime
+* recognises for leaving something inaccessible; the third is a plain promise to
+* fix it, which is what most small sites actually mean.
+*/
+const ISSUE_REASONS = [
+	"disproportionate-burden",
+	"out-of-scope",
+	"fix-planned"
+];
+const knownIssueObject = object({
+	/** What is not accessible, in the statement's language. */
+	description: string({ min: 1 }),
+	/** WCAG success criteria, e.g. ['1.4.3']. */
+	successCriteria: withDefault(array(string()), () => []),
+	/** EN 301 549 clauses, e.g. ['9.1.4.3']. */
+	en301549: withDefault(array(string()), () => []),
+	reason: optional(enumeration(ISSUE_REASONS)),
+	/** ISO date by which the barrier is expected to be removed. */
+	remedyBy: optional(isoDate())
+});
+/**
+* A bare string is accepted as shorthand for `{ description }`. It is put
+* through the object schema so both branches produce the same output type,
+* rather than a union that callers have to narrow before reading `remedyBy`.
+*/
+const knownIssueSchema = union([pipe(transform(string({ min: 1 }), (description) => ({ description })), knownIssueObject), knownIssueObject], "expected a description, or an object with one");
+const configSchema = object({
+	site: object({
+		name: string({ min: 1 }),
+		url: url(),
+		/** BCP 47 tag of the site itself, e.g. 'de-AT'. */
+		locale: string({ min: 2 })
+	}),
+	provider: object({
+		/** The legal entity answerable for the service. */
+		legalName: string({ min: 1 }),
+		/**
+		* The feedback address. Required: the EAA obliges providers to offer a way
+		* to report accessibility barriers, and a statement without one is not
+		* usable for its purpose.
+		*/
+		email: email(),
+		phone: optional(string({ min: 1 })),
+		address: optional(string({ min: 1 })),
+		/**
+		* A contact or feedback form, offered alongside the address rather than
+		* instead of it: the EAA requires a way to report barriers, and a form is
+		* the one channel a visitor who cannot use email may still be able to use.
+		*/
+		feedbackUrl: optional(url())
+	}),
+	compliance: object({
+		status: enumeration(COMPLIANCE_STATUSES),
+		standard: withDefault(string({ min: 1 }), () => "EN 301 549 V3.2.1 (WCAG 2.2 AA)"),
+		knownIssues: withDefault(array(knownIssueSchema), () => []),
+		/** When the assessment was carried out. */
+		assessedOn: isoDate(),
+		assessmentMethod: withDefault(enumeration(ASSESSMENT_METHODS), () => "self-assessment"),
+		/**
+		* Reason attached to barriers taken from an audit report, which carries no
+		* reason of its own. 'fix-planned' is the honest default for a barrier an
+		* automated run just found; the other two are claims only a human can make.
+		*/
+		auditReason: withDefault(enumeration(ISSUE_REASONS), () => "fix-planned")
+	}),
+	enforcement: object({ 
+	/** Drives which supervisory body and statute the template names. */
+country: enumeration(COUNTRIES) })
+});
+/**
+* Identity function that gives `eaa.config.ts` its types. Deliberately does not
+* validate: a config file is loaded and checked in one place, so that an error
+* points at the file rather than at wherever the module happened to be
+* imported.
+*/
+function defineConfig(config) {
+	return config;
+}
+var ConfigError = class extends Error {
+	issues;
+	name = "ConfigError";
+	constructor(message, issues = []) {
+		super(message);
+		this.issues = issues;
+	}
+};
+/** Validate an already-loaded config object. */
+function parseConfig(value, source = "config") {
+	const result = safeParse(configSchema, value);
+	if (result.success) return result.data;
+	const issues = result.error.issues.map((issue) => {
+		const path = issue.path.join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	});
+	throw new ConfigError(`${source} is not valid`, issues);
+}
+//#endregion
+//#region src/config/load.ts
+/** Checked in this order, first match wins. */
+const CONFIG_FILENAMES = [
+	"eaa.config.ts",
+	"eaa.config.mts",
+	"eaa.config.js",
+	"eaa.config.mjs",
+	"eaa.config.json"
+];
+/**
+* Find and load `eaa.config.{ts,mts,js,mjs,json}`.
+*
+* TypeScript configs are imported directly: Node strips types natively from
+* 22.18 onwards, which is below this package's floor, so no bundler or loader
+* dependency is needed. The failure mode that remains is a project with no
+* package.json at all, where Node cannot tell ESM from CommonJS; the error says
+* so rather than surfacing "Unexpected token 'export'".
+*/
+async function loadConfig(options = {}) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const file = options.path ? path.resolve(cwd, options.path) : await findConfigFile(cwd);
+	if (!file) throw new ConfigError(`No config file found in ${cwd} or its parent directories`, CONFIG_FILENAMES.map((name) => `looked for ${name}`));
+	if (!await isFile(file)) throw new ConfigError(`Config file not found: ${file}`);
+	return {
+		config: parseConfig(file.endsWith(".json") ? await importJson(file) : await importModule(file), path.basename(file)),
+		path: file
+	};
+}
+/** Walks up from `cwd`, so the CLI works from a subdirectory of the project. */
+async function findConfigFile(cwd) {
+	let directory = path.resolve(cwd);
+	while (true) {
+		for (const name of CONFIG_FILENAMES) {
+			const candidate = path.join(directory, name);
+			if (await isFile(candidate)) return candidate;
+		}
+		const parent = path.dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+async function importJson(file) {
+	const raw = await readFile(file, "utf8");
+	try {
+		return JSON.parse(raw);
+	} catch (cause) {
+		throw new ConfigError(`${path.basename(file)} is not valid JSON`, [cause instanceof Error ? cause.message : String(cause)]);
+	}
+}
+async function importModule(file) {
+	let module;
+	try {
+		module = await import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		const hint = message.includes("Unexpected token") ? "If the project has no package.json, Node cannot tell ESM from CommonJS. Add one with \"type\": \"module\", or use eaa.config.json." : message;
+		throw new ConfigError(`Could not load ${path.basename(file)}`, [hint]);
+	}
+	if (module.default === void 0) throw new ConfigError(`${path.basename(file)} has no default export`, ["Expected: export default defineConfig({ … })"]);
+	return module.default;
+}
+async function isFile(candidate) {
+	try {
+		return (await stat(candidate)).isFile();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { COMPLIANCE_STATUSES as a, ISSUE_REASONS as c, defineConfig as d, parseConfig as f, ASSESSMENT_METHODS as i, STATEMENT_LOCALES as l, findConfigFile as n, COUNTRIES as o, loadConfig as r, ConfigError as s, CONFIG_FILENAMES as t, configSchema as u };

package/dist/{playwright-BfWuTG_u.js → playwright-DWux49V3.js}

@@ -144,7 +144,7 @@ async function runBrowserAudit(directory, pages, options = {}) {
 	const tags = options.tags ?? DEFAULT_TAGS;
 	const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
 	const viewport = options.viewport ?? DEFAULT_VIEWPORT;
-	const server = await serveDirectory(directory);
+	const server = directory === void 0 ? void 0 : await serveDirectory(directory);
 	const browser = await chromium.launch({ headless: true });
 	try {
 		const context = await browser.newContext({
@@ -152,7 +152,7 @@ async function runBrowserAudit(directory, pages, options = {}) {
 			bypassCSP: true
 		});
 		const audits = [];
-		for (const page of pages) audits.push(await auditOne(context, server.origin, page, {
+		for (const page of pages) audits.push(await auditOne(context, server?.origin, page, {
 			tags,
 			timeout,
 			...options
@@ -161,7 +161,7 @@ async function runBrowserAudit(directory, pages, options = {}) {
 		return audits;
 	} finally {
 		await browser.close();
-		await server.close();
+		await server?.close();
 	}
 }
 async function auditOne(context, origin, page, options) {
@@ -175,7 +175,7 @@ async function auditOne(context, origin, page, options) {
 	const tab = await context.newPage();
 	try {
 		tab.setDefaultTimeout(options.timeout);
-		const target = servedUrl(origin, page.relativePath);
+		const target = origin === void 0 ? page.absolutePath : servedUrl(origin, page.relativePath);
 		const response = await tab.goto(target, {
 			waitUntil: "load",
 			timeout: options.timeout