@navecss/core 0.2.0 → 0.4.0

package/dist/chunk-NKUZNRF4.js

@@ -0,0 +1,42 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import url from 'url';
+
+// src/postcss-extend-module.ts
+function resolveExtendSpecifier(specifier, dir = process.cwd()) {
+  const file = path.resolve(dir, specifier);
+  const stats = fs.existsSync(file) ? fs.statSync(file) : void 0;
+  if (!stats?.isFile()) {
+    throw new Error(`@nave: cannot find extend module "${specifier}" from "${dir}"`);
+  }
+  return file;
+}
+function isJsonPath(file) {
+  return path.extname(file).toLowerCase() === ".json";
+}
+async function importExtendMap(moduleUrl, file) {
+  const value = isJsonPath(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : (await import(moduleUrl)).default;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `@nave: extend module "${file}" must have a default export that is a plain object`
+    );
+  }
+  return value;
+}
+function loadExtendModule(file, cache) {
+  const digest = crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+  const moduleUrl = `${url.pathToFileURL(file).href}?v=${digest}`;
+  const cached = cache.get(moduleUrl);
+  if (cached) return cached;
+  const filePrefix = `${url.pathToFileURL(file).href}?v=`;
+  for (const key of cache.keys()) if (key.startsWith(filePrefix)) cache.delete(key);
+  const pending = importExtendMap(moduleUrl, file);
+  cache.set(moduleUrl, pending);
+  return pending;
+}
+async function applyExtendModule(file, cache, setExtend) {
+  setExtend(await loadExtendModule(file, cache));
+}
+
+export { applyExtendModule, resolveExtendSpecifier };

package/dist/chunk-SYNQJNVB.js

@@ -0,0 +1,302 @@
+import { atoms } from './chunk-CUL5PLPI.js';
+import { atomClassMap } from './chunk-GZL2VW7C.js';
+
+// src/directive/diagnostics-format.ts
+function vocabulary(extend) {
+  const extendKeys = new Set(Object.keys(extend));
+  const names = [];
+  for (const [name, definition] of Object.entries(atoms)) {
+    if (definition && !extendKeys.has(name)) names.push(name);
+  }
+  for (const [name, definition] of Object.entries(extend)) {
+    if (definition) names.push(name);
+  }
+  return names;
+}
+function distance(a, b) {
+  const d = [];
+  for (let i = 0; i <= a.length; i++) d.push([i]);
+  for (let j = 0; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let best = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        best = Math.min(best, d[i - 2][j - 2] + 1);
+      }
+      d[i][j] = best;
+    }
+  }
+  return d[a.length][b.length];
+}
+function normalize(name) {
+  const lower = name.toLowerCase();
+  const withoutPrefix = lower.startsWith("nave-") ? lower.slice(5) : lower;
+  return withoutPrefix.replaceAll("-", "");
+}
+function groupByDistance(normalizedTyped, names) {
+  let minDistance = Infinity;
+  const byDistance = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const d = distance(normalizedTyped, normalize(name));
+    if (!byDistance.has(d)) byDistance.set(d, []);
+    byDistance.get(d).push(name);
+    if (d < minDistance) minDistance = d;
+  }
+  return { byDistance, minDistance };
+}
+function hasCamelCaseNote(typed, candidates, minDistance, extend) {
+  if (minDistance !== 0 || candidates.length !== 1) return false;
+  if (!typed.includes("-")) return false;
+  const candidate = candidates[0];
+  const shadow = extend[candidate];
+  if (shadow) return false;
+  return Object.hasOwn(atomClassMap, candidate);
+}
+function findHint(typed, extend) {
+  const normalizedTyped = normalize(typed);
+  const { byDistance, minDistance } = groupByDistance(normalizedTyped, vocabulary(extend));
+  if (minDistance > 2 || minDistance >= normalizedTyped.length / 2) return void 0;
+  const candidates = byDistance.get(minDistance) ?? [];
+  if (candidates.length === 0) return void 0;
+  return { candidates, camelCaseNote: hasCamelCaseNote(typed, candidates, minDistance, extend) };
+}
+function quoteList(items) {
+  if (items.length === 1) return `"${items[0]}"`;
+  return `${items.slice(0, -1).map((i) => `"${i}"`).join(", ")} or "${items.at(-1)}"`;
+}
+function formatUnknownAtom(name, extend) {
+  const first = `@nave: unknown atom "${name}".`;
+  const hint = findHint(name, extend);
+  if (hint) {
+    const camelCase = hint.camelCaseNote ? ` Atom names are camelCase; "${atomClassMap[hint.candidates[0]]}" is its class.` : "";
+    return `${first} Did you mean ${quoteList(hint.candidates)}?${camelCase}`;
+  }
+  const available = vocabulary(extend).join(", ");
+  return `${first} If it is an atom of your own, pass it in the extend option.
+Available: ${available}`;
+}
+var ANSWERED_BY_STANDALONE = /* @__PURE__ */ new Set([
+  "@navecss/core",
+  "@navecss/core/atomic",
+  "@navecss/core/layers",
+  "@navecss/core/reset",
+  "@navecss/core/standalone",
+  "@navecss/tokens/css"
+]);
+var STANDALONE_PATH = "node_modules/@navecss/core/dist/standalone.css";
+var STANDALONE_CDN_URL = "https://cdn.jsdelivr.net/npm/@navecss/core@<version>/dist/standalone.css";
+var NO_TOKENS_PATH = "node_modules/@navecss/core/dist/no-tokens.css";
+var NO_TOKENS_CDN_URL = "https://cdn.jsdelivr.net/npm/@navecss/core@<version>/dist/no-tokens.css";
+var BAD_PARENT_WORKAROUND = ". A directive here can be written `& { @nave ...; }` inside the group rule instead.";
+function formatBadParent(diagnostic) {
+  const workaround = diagnostic.detail === "nested-group" ? BAD_PARENT_WORKAROUND : "";
+  return `@nave must be the direct child of a CSS rule selector block${workaround}`;
+}
+var FIXED_TEXTS = {
+  "bad-token": (d) => `@nave: unexpected "${d.text ?? ""}"; a directive takes only atom names (separate atom names with spaces)`,
+  "bare-import": (d) => {
+    const specifier = d.text ?? "";
+    const quoted = JSON.stringify(specifier);
+    if (ANSWERED_BY_STANDALONE.has(specifier)) {
+      return `@import ${quoted} names a package, so a browser cannot load it. Link Nave's self-contained stylesheet from the page instead, ahead of your own stylesheets: ${STANDALONE_PATH}, or ${STANDALONE_CDN_URL} with <version> replaced by the version you installed.`;
+    }
+    if (specifier === "@navecss/core/no-tokens") {
+      return `@import ${quoted} names a package, so a browser cannot load it. Link that entry's own file from the page instead, ahead of your own stylesheets: ${NO_TOKENS_PATH}, or ${NO_TOKENS_CDN_URL} with <version> replaced by the version you installed. Not the self-contained stylesheet: it holds Nave's token layer, which this entry leaves out.`;
+    }
+    return `@import ${quoted} names no file relative to the output, so a browser cannot load it. Point it at a file the page can reach, by a path that works from the output or by a URL, or bundle the stylesheet.`;
+  },
+  "has-block": () => "@nave: a directive with a {} block is not supported",
+  "in-keyframes": () => "@nave cannot be used inside @keyframes",
+  "missing-declarations": (d) => `@nave: atom "${d.name ?? ""}" is registered without a declarations object`,
+  "no-atom": () => "@nave: directive names no atom"
+};
+function formatDiagnostic(diagnostic, options = {}) {
+  if (diagnostic.code === "unknown-atom")
+    return formatUnknownAtom(diagnostic.name, options.extend ?? {});
+  if (diagnostic.code === "bad-parent") return formatBadParent(diagnostic);
+  return FIXED_TEXTS[diagnostic.code](diagnostic);
+}
+
+// src/directive/source-map.ts
+var BASE64_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var NEWLINE_CHARS = /* @__PURE__ */ new Set(["\n", "\r", "\f"]);
+function encodeVLQ(n) {
+  let value = n < 0 ? (-n << 1) + 1 : n << 1;
+  let result = "";
+  do {
+    let digit = value & 31;
+    value >>>= 5;
+    if (value > 0) digit |= 32;
+    result += BASE64_DIGITS[digit];
+  } while (value > 0);
+  return result;
+}
+var BASE64_VALUE = new Map([...BASE64_DIGITS].map((c, i) => [c, i]));
+function decodeVLQSegment(mappings, start) {
+  let value = 0;
+  let shift = 0;
+  let i = start;
+  for (; ; ) {
+    const digit = BASE64_VALUE.get(mappings[i]);
+    i++;
+    value += (digit & 31) << shift;
+    if ((digit & 32) === 0) break;
+    shift += 5;
+  }
+  const isNegative = (value & 1) === 1;
+  const magnitude = value >>> 1;
+  return { value: isNegative ? -magnitude : magnitude, next: i };
+}
+var MappingsBuilder = class {
+  hasSegmentOnLine = false;
+  lines = [[]];
+  outputColumn = 0;
+  outputLine = 0;
+  // A lone trailing `\r`, possibly half of a CRLF pair split across two
+  // `advance()` calls by a removed directive: consumed by the next call's
+  // leading `\n`, if any, instead of double-counted.
+  pendingCR = false;
+  prevGeneratedColumn = 0;
+  prevSourceColumn = 0;
+  prevSourceIndex = 0;
+  prevSourceLine = 0;
+  /**
+   * A plain indexed loop, not `for...of` (which iterates by code point, so
+   * a surrogate pair would advance the column by one instead of two — every
+   * position here is in UTF-16 code units). A line break is CR, FF, LF or a
+   * CRLF pair, CSS Syntax 3's own "newline" (§4.2).
+   */
+  advance(text) {
+    let i = this.consumePendingCR(text);
+    while (i < text.length) {
+      const c = text[i];
+      if (c !== void 0 && NEWLINE_CHARS.has(c)) {
+        i = this.advancePastNewline(text, i, c);
+        continue;
+      }
+      this.outputColumn++;
+      i++;
+    }
+  }
+  /**
+   * `i` past the line break `c` (at `i`): past the whole pair for a `\r`
+   * immediately followed by `\n`, and `pendingCR` set instead when `\r` is
+   * the last character `text` has to offer.
+   */
+  advancePastNewline(text, i, c) {
+    let next = i + 1;
+    if (c === "\r" && text[next] === "\n") {
+      next++;
+    } else if (c === "\r" && next === text.length) {
+      this.pendingCR = true;
+    }
+    this.outputLine++;
+    this.outputColumn = 0;
+    this.lines.push([]);
+    this.prevGeneratedColumn = 0;
+    this.hasSegmentOnLine = false;
+    return next;
+  }
+  /**
+   * How far into `text` `advance` should start: `1` for a lone `\n` that is
+   * really the other half of a CRLF pair split across two calls; `0`
+   * otherwise.
+   */
+  consumePendingCR(text) {
+    if (text.length === 0) return 0;
+    const skip = this.pendingCR && text.startsWith("\n") ? 1 : 0;
+    this.pendingCR = false;
+    return skip;
+  }
+  mark(position) {
+    const sourceIndex = position.sourceIndex ?? 0;
+    const sourceLine = position.line - 1;
+    const generatedColumnDelta = this.hasSegmentOnLine ? this.outputColumn - this.prevGeneratedColumn : this.outputColumn;
+    const sourceIndexDelta = sourceIndex - this.prevSourceIndex;
+    const sourceLineDelta = sourceLine - this.prevSourceLine;
+    const sourceColumnDelta = position.column - this.prevSourceColumn;
+    this.lines[this.outputLine].push(
+      encodeVLQ(generatedColumnDelta) + encodeVLQ(sourceIndexDelta) + encodeVLQ(sourceLineDelta) + encodeVLQ(sourceColumnDelta)
+    );
+    this.prevGeneratedColumn = this.outputColumn;
+    this.prevSourceIndex = sourceIndex;
+    this.prevSourceLine = sourceLine;
+    this.prevSourceColumn = position.column;
+    this.hasSegmentOnLine = true;
+  }
+  toMappings() {
+    return this.lines.map((segments) => segments.join(",")).join(";");
+  }
+};
+function findCandidate(segments, position) {
+  const generatedLine = position.line - 1;
+  let low = 0;
+  let high = segments.length - 1;
+  let candidate;
+  while (low <= high) {
+    const mid = low + high >> 1;
+    const segment = segments[mid];
+    const isAtOrBefore = segment.generatedLine < generatedLine || segment.generatedLine === generatedLine && segment.generatedColumn <= position.column;
+    if (isAtOrBefore) {
+      candidate = segment;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return candidate?.generatedLine === generatedLine ? candidate : void 0;
+}
+function decodeIncomingMap(map) {
+  const sources = map.sources;
+  const segments = decodeSegments(map.mappings);
+  return {
+    sources,
+    sourceRoot: map.sourceRoot,
+    sourcesContent: map.sourcesContent,
+    originalPositionFor(position) {
+      const candidate = findCandidate(segments, position);
+      if (!candidate) return;
+      return {
+        source: sources[candidate.sourceIndex],
+        sourceIndex: candidate.sourceIndex,
+        line: candidate.sourceLine + 1,
+        column: candidate.sourceColumn
+      };
+    }
+  };
+}
+function decodeOneSegment(state, raw, generatedLine) {
+  const col = decodeVLQSegment(raw, 0);
+  state.generatedColumn += col.value;
+  if (col.next >= raw.length) return void 0;
+  const srcIdx = decodeVLQSegment(raw, col.next);
+  state.sourceIndex += srcIdx.value;
+  const srcLine = decodeVLQSegment(raw, srcIdx.next);
+  state.sourceLine += srcLine.value;
+  const srcCol = decodeVLQSegment(raw, srcLine.next);
+  state.sourceColumn += srcCol.value;
+  return {
+    generatedLine,
+    generatedColumn: state.generatedColumn,
+    sourceIndex: state.sourceIndex,
+    sourceLine: state.sourceLine,
+    sourceColumn: state.sourceColumn
+  };
+}
+function decodeSegments(mappings) {
+  const segments = [];
+  const state = { generatedColumn: 0, sourceIndex: 0, sourceLine: 0, sourceColumn: 0 };
+  const lines = mappings.split(";");
+  for (const [generatedLine, line] of lines.entries()) {
+    state.generatedColumn = 0;
+    if (line === "") continue;
+    for (const raw of line.split(",")) {
+      const segment = decodeOneSegment(state, raw, generatedLine);
+      if (segment) segments.push(segment);
+    }
+  }
+  return segments;
+}
+
+export { MappingsBuilder, decodeIncomingMap, formatDiagnostic };

package/dist/chunk-UANF3FGO.js

@@ -0,0 +1,115 @@
+import { createPositionFinder, tokenize, matchBrackets, readItem, isNaveAtKeyword } from './chunk-NFS2REPQ.js';
+
+// src/directive/find-survivors.ts
+var NATURAL_STOP_CHARS = /* @__PURE__ */ new Set(["\n", ";", "}"]);
+function naturalTextAfter(css, offset) {
+  let end = css.length;
+  for (let i = offset; i < css.length; i++) {
+    if (NATURAL_STOP_CHARS.has(css[i])) {
+      end = i;
+      break;
+    }
+  }
+  return css.slice(offset, end).trim();
+}
+function isStructural(token) {
+  return token.type !== "whitespace-token" && token.type !== "comment";
+}
+function skipInert(tokens, i, limit) {
+  let j = i;
+  while (j < limit && !isStructural(tokens[j])) j++;
+  return j;
+}
+var Scan = class {
+  closerFor;
+  css;
+  survivors = [];
+  tokens;
+  constructor(css) {
+    this.css = css;
+    this.tokens = tokenize(css);
+    this.closerFor = matchBrackets(this.tokens);
+  }
+};
+function scanForNaveTokens(scan, start, end, selector) {
+  for (let i = start; i < end; i++) {
+    const token = scan.tokens[i];
+    if (isNaveAtKeyword(token))
+      scan.survivors.push({
+        offset: token.startIndex,
+        text: naturalTextAfter(scan.css, token.startIndex),
+        selector
+      });
+  }
+}
+function ruleSelector(scan, item) {
+  const braceIndex = item.blockStart - 1;
+  return scan.css.slice(scan.tokens[item.start].startIndex, scan.tokens[braceIndex].startIndex).trim();
+}
+function childFrameFor(scan, item, selector) {
+  if (item.blockStart === void 0 || item.blockEnd === void 0) return void 0;
+  const childSelector = item.kind === "rule" ? ruleSelector(scan, item) : selector;
+  return {
+    i: skipInert(scan.tokens, item.blockStart, item.blockEnd),
+    limit: item.blockEnd,
+    selector: childSelector
+  };
+}
+function preludeEnd(item) {
+  return item.blockStart === void 0 ? item.end : item.blockStart - 1;
+}
+function visitItem(scan, item, selector) {
+  switch (item.kind) {
+    case "at-rule":
+    case "rule": {
+      scanForNaveTokens(scan, item.start, preludeEnd(item), selector);
+      return childFrameFor(scan, item, selector);
+    }
+    case "declaration":
+    case "invalid": {
+      scanForNaveTokens(scan, item.start, item.end, selector);
+      return void 0;
+    }
+  }
+}
+function walkBlock(scan, start, limit, selector) {
+  const stack = [{ i: skipInert(scan.tokens, start, limit), limit, selector }];
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (frame.i >= frame.limit) {
+      stack.pop();
+      continue;
+    }
+    const item = readItem(scan.tokens, frame.i, frame.limit, scan.closerFor);
+    frame.i = skipInert(scan.tokens, item.end, frame.limit);
+    const child = visitItem(scan, item, frame.selector);
+    if (child) stack.push(child);
+  }
+}
+function findSurvivors(css) {
+  const scan = new Scan(css);
+  walkBlock(scan, 0, scan.tokens.length, void 0);
+  return scan.survivors;
+}
+
+// src/directive/findings.ts
+function findingsInText(file, raw) {
+  const css = raw.startsWith("\uFEFF") ? raw.slice(1) : raw;
+  const positionAt = createPositionFinder(css);
+  return findSurvivors(css).map((survivor) => {
+    const position = positionAt(survivor.offset);
+    return {
+      file,
+      line: position.line,
+      column: position.column + 1,
+      text: survivor.text,
+      ...survivor.selector !== void 0 && { selector: survivor.selector }
+    };
+  });
+}
+function formatFinding(finding) {
+  const where = finding.selector === void 0 ? "" : ` (in ${finding.selector.replaceAll(/\s+/g, " ")})`;
+  return `${finding.file}:${finding.line}:${finding.column}: ${finding.text}${where}`;
+}
+
+export { findingsInText, formatFinding };

package/dist/chunk-XQQCDUV6.js

@@ -0,0 +1,152 @@
+import { findingsInText } from './chunk-UANF3FGO.js';
+import { readFile, stat, realpath, readdir } from 'fs/promises';
+import path from 'path';
+
+var NotAStylesheetPathError = class extends Error {
+  path;
+  constructor(path2) {
+    super(`${path2} is not a stylesheet file`);
+    this.path = path2;
+    this.name = "NotAStylesheetPathError";
+  }
+};
+function hasCssExtension(name) {
+  return path.extname(name).toLowerCase() === ".css";
+}
+async function entryKind(entry, entryPath, state) {
+  if (entry.isDirectory()) return "directory";
+  if (entry.isFile()) return hasCssExtension(entry.name) ? "css-file" : "skip";
+  if (!entry.isSymbolicLink()) return "skip";
+  let targetStats;
+  try {
+    targetStats = await stat(entryPath);
+  } catch {
+    if (hasCssExtension(entry.name)) state.unreadablePaths.push(entryPath);
+    return "skip";
+  }
+  if (targetStats.isDirectory()) return "directory";
+  if (targetStats.isFile()) return hasCssExtension(entry.name) ? "css-file" : "skip";
+  return "skip";
+}
+async function listSubdirectory(entryPath, state) {
+  let canonicalPath;
+  try {
+    canonicalPath = await realpath(entryPath);
+  } catch {
+    state.unreadablePaths.push(entryPath);
+    return [];
+  }
+  if (state.visitedDirs.has(canonicalPath)) return [];
+  state.visitedDirs.add(canonicalPath);
+  return listDirectory(entryPath, state);
+}
+async function cssFileIfNew(entryPath, state) {
+  let canonicalFile;
+  try {
+    canonicalFile = await realpath(entryPath);
+  } catch {
+    state.unreadablePaths.push(entryPath);
+    return void 0;
+  }
+  if (state.reportedRealFiles.has(canonicalFile)) return void 0;
+  state.reportedRealFiles.add(canonicalFile);
+  return entryPath;
+}
+async function listDirectory(dir, state) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    state.unreadablePaths.push(dir);
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path.join(dir, entry.name);
+    const kind = await entryKind(entry, entryPath, state);
+    if (kind === "directory") {
+      files.push(...await listSubdirectory(entryPath, state));
+    } else if (kind === "css-file") {
+      const file = await cssFileIfNew(entryPath, state);
+      if (file) files.push(file);
+    }
+  }
+  return files;
+}
+async function listCssFiles(source) {
+  const stats = await stat(source);
+  if (!stats.isDirectory()) {
+    if (!stats.isFile()) throw new NotAStylesheetPathError(source);
+    return { files: [source], unreadablePaths: [] };
+  }
+  const canonicalRoot = await realpath(source);
+  const state = {
+    reportedRealFiles: /* @__PURE__ */ new Set(),
+    unreadablePaths: [],
+    visitedDirs: /* @__PURE__ */ new Set([canonicalRoot])
+  };
+  const files = await listDirectory(source, state);
+  return { files, unreadablePaths: state.unreadablePaths };
+}
+
+// src/directive/check-run.ts
+async function wasFileRead(file, findings) {
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch {
+    return false;
+  }
+  for (const finding of findingsInText(file, raw)) findings.push(finding);
+  return true;
+}
+async function sourceOutcome(source) {
+  try {
+    return { kind: "listing", listing: await listCssFiles(source) };
+  } catch (error) {
+    if (error instanceof NotAStylesheetPathError) return { kind: "not-a-stylesheet" };
+    return { kind: "unreadable" };
+  }
+}
+function statusFor(hasUnreadableSource, stylesheetsRead, findingCount) {
+  if (hasUnreadableSource || stylesheetsRead === 0) return 2;
+  return findingCount > 0 ? 1 : 0;
+}
+async function runCheck(source) {
+  const findings = [];
+  const unreadablePaths = [];
+  const notStylesheetPaths = [];
+  let stylesheetsRead = 0;
+  let hasUnreadableSource = false;
+  for (const one of source) {
+    const outcome = await sourceOutcome(one);
+    if (outcome.kind === "unreadable") {
+      hasUnreadableSource = true;
+      unreadablePaths.push(one);
+      continue;
+    }
+    if (outcome.kind === "not-a-stylesheet") {
+      hasUnreadableSource = true;
+      notStylesheetPaths.push(one);
+      continue;
+    }
+    const listing = outcome.listing;
+    if (listing.unreadablePaths.length > 0) {
+      hasUnreadableSource = true;
+      unreadablePaths.push(...listing.unreadablePaths);
+    }
+    for (const file of listing.files) {
+      const wasReadable = await wasFileRead(file, findings);
+      if (wasReadable) {
+        stylesheetsRead++;
+      } else {
+        hasUnreadableSource = true;
+        unreadablePaths.push(file);
+      }
+    }
+  }
+  const status = statusFor(hasUnreadableSource, stylesheetsRead, findings.length);
+  return { result: { status, findings, stylesheetsRead }, unreadablePaths, notStylesheetPaths };
+}
+
+export { runCheck };