@nitpicker/core 0.4.1

package/src/types.ts

@@ -0,0 +1,289 @@
+import type { Lanes } from '@d-zero/dealer';
+import type { ExURL as URL } from '@d-zero/shared/parse-url';
+import type { TableValue, Violation } from '@nitpicker/types';
+import type { DOMWindow } from 'jsdom';
+
+/**
+ * Represents a single analyze plugin loaded from the user's configuration.
+ *
+ * Each plugin corresponds to an npm module that exports a {@link PluginFactory}
+ * factory function as its default export. The `settings` object is passed
+ * through to that factory at initialization time.
+ * @see {@link ./load-plugin-settings.ts} for how plugins are discovered from cosmiconfig
+ * @see {@link ./import-modules.ts} for how plugins are dynamically imported
+ */
+export interface Plugin {
+	/**
+	 * Human-readable plugin name. Currently unused at runtime but kept
+	 * for backward compatibility with older config formats.
+	 * @deprecated Use `module` to identify plugins instead.
+	 */
+	name: string;
+
+	/**
+	 * The npm module specifier to `import()` (e.g. `"@nitpicker/analyze-axe"`).
+	 */
+	module: string;
+
+	/**
+	 * Absolute path to the configuration file where this plugin was declared.
+	 * Passed to the plugin so it can resolve relative paths in its own config.
+	 */
+	configFilePath: string;
+
+	/**
+	 * Plugin-specific settings object parsed from the config file.
+	 * The shape is determined by the plugin itself (e.g. `{ lang: "ja" }` for axe).
+	 */
+	settings?: unknown;
+}
+
+/**
+ * Options for {@link ../nitpicker.ts!Nitpicker.analyze}.
+ *
+ * Allows callers to provide an external {@link https://www.npmjs.com/package/@d-zero/dealer | Lanes}
+ * instance for rich progress display, and a verbose flag for non-TTY environments.
+ */
+export interface AnalyzeOptions {
+	/** Lanes instance for per-plugin progress display. If omitted, no progress is shown. */
+	readonly lanes?: Lanes;
+
+	/** When `true`, outputs plain-text progress lines instead of animated Lanes. */
+	readonly verbose?: boolean;
+}
+
+/**
+ * Internal configuration model used by {@link ../nitpicker.ts!Nitpicker}.
+ *
+ * Built by {@link ./load-plugin-settings.ts!loadPluginSettings} from the
+ * user's cosmiconfig file (e.g. `.nitpickerrc.json`). The external config
+ * format (`ConfigJSON` from `@nitpicker/types`) uses a `plugins.analyze`
+ * object keyed by module name; this internal type normalizes it into an
+ * ordered array of fully-resolved {@link Plugin} entries.
+ */
+export interface Config {
+	/** Ordered list of analyze plugins to execute. */
+	analyze: Plugin[];
+}
+
+/**
+ * The runtime interface that every analyze plugin must satisfy after
+ * its factory function ({@link PluginFactory}) has been invoked.
+ *
+ * A plugin may implement one or both callback methods:
+ *
+ * - **`eachPage`** - Runs inside a Worker thread with full JSDOM access.
+ *   Best for DOM-dependent analysis (markup validation, text linting,
+ *   accessibility checks). Each invocation receives a parsed `DOMWindow`,
+ *   so plugins can use standard DOM APIs without additional parsing.
+ *
+ * - **`eachUrl`** - Runs in the main thread, receives only the URL and
+ *   external/internal flag. Suited for lightweight, network-based checks
+ *   (e.g. link validation, SEO URL pattern checks).
+ * @template T - String literal union of the column keys this plugin
+ *   contributes to the report table (e.g. `'title' | 'description'`).
+ * @see {@link ./page-analysis-worker.ts} for how `eachPage` is called inside the worker
+ * @see {@link ./nitpicker.ts} for how `eachUrl` is called from the main thread
+ */
+export interface AnalyzePlugin<T extends string = string> {
+	/**
+	 * Human-readable display label for interactive prompts.
+	 * Shown instead of the raw package name (e.g. `"axe: アクセシビリティチェック"`).
+	 */
+	label?: string;
+
+	/**
+	 * Column header definitions contributed by this plugin.
+	 * Keys are column identifiers (`T`), values are human-readable labels
+	 * shown in the report header row.
+	 */
+	headers?: TableHeaders<T>;
+
+	/**
+	 * Per-page analysis callback executed in a Worker thread.
+	 * @param page - Context for the current page, including the raw HTML,
+	 *   a live JSDOM window, the page URL, and progress counters.
+	 * @param page.url - Parsed URL of the page being analyzed.
+	 * @param page.html - Raw HTML string of the page.
+	 * @param page.window - JSDOM window with the page's DOM tree. Closed after the callback returns.
+	 * @param page.num - Zero-based index of the current page in the batch.
+	 * @param page.total - Total number of pages in the batch.
+	 * @returns Report data for this page, or `null` to skip.
+	 */
+	eachPage?(page: {
+		/** Parsed URL of the page being analyzed. */
+		url: URL;
+		/** Raw HTML string of the page. */
+		html: string;
+		/** JSDOM window with the page's DOM tree. Closed after the callback returns. */
+		window: DOMWindow;
+		/** Zero-based index of the current page in the batch. */
+		num: number;
+		/** Total number of pages in the batch. */
+		total: number;
+	}): Promise<ReportPage<T> | null> | ReportPage<T> | null;
+
+	/**
+	 * Per-URL analysis callback executed in the main thread.
+	 *
+	 * Unlike `eachPage`, this callback does **not** receive HTML or a DOM
+	 * window. It is designed for checks that depend only on URL metadata
+	 * (e.g. checking URL patterns, external link policies).
+	 * @param page - URL context including external/internal classification.
+	 * @param page.url - Parsed URL being analyzed.
+	 * @param page.isExternal - Whether this URL is external to the crawled site.
+	 * @returns Report data for this URL, or `null` to skip.
+	 */
+	eachUrl?(page: {
+		/** Parsed URL being analyzed. */
+		url: URL;
+		/** Whether this URL is external to the crawled site. */
+		isExternal: boolean;
+	}): Promise<ReportPage<T> | null> | ReportPage<T> | null;
+}
+
+/**
+ * The return value of a single {@link AnalyzePlugin.eachPage} or {@link AnalyzePlugin.eachUrl}
+ * invocation for one page/URL.
+ *
+ * A plugin can contribute tabular data (displayed in spreadsheet columns)
+ * and/or violation records (displayed in a dedicated violations sheet).
+ * @template T - Column key union matching the plugin's `headers`.
+ */
+export interface ReportPage<T extends string> {
+	/** Column data for this page. Keys must be a subset of `T`. */
+	page?: TableData<T>;
+	/** Violations detected on this page (e.g. a11y issues, lint errors). */
+	violations?: Violation[];
+}
+
+/**
+ * Aggregated report data from a Worker thread, keyed by page URL.
+ *
+ * This is the message payload returned from the Worker to the main thread
+ * via the `'finish'` message. It aggregates results from all plugins that
+ * ran `eachPage` for a single page.
+ * @template T - Column key union.
+ * @see {@link ./page-analysis-worker.ts} for the Worker entry point that produces this
+ * @see {@link ./worker/run-in-worker.ts!runInWorker} for the main-thread consumer
+ */
+export interface ReportPages<T extends string> {
+	/** Per-URL table data from all plugins. */
+	pages?: TablePages<T>;
+	/** Combined violations from all plugins. */
+	violations?: Violation[];
+}
+
+/**
+ * Factory function signature that every analyze plugin module must
+ * export as its default export.
+ *
+ * The factory receives the user's settings object (`O`) and returns
+ * an {@link AnalyzePlugin} instance (or a Promise thereof). This two-phase
+ * pattern allows plugins to perform async initialization (e.g.
+ * loading locale files, compiling lint configs) once, then reuse
+ * the resulting plugin for every page.
+ *
+ * Use {@link ./hooks/define-plugin.ts!definePlugin} to define a
+ * plugin with full type inference.
+ * @template O - Shape of the plugin's settings from the config file.
+ * @template T - String literal union of column keys the plugin contributes.
+ * @example
+ * ```ts
+ * // In @nitpicker/analyze-search/src/index.ts
+ * import { definePlugin } from '@nitpicker/core';
+ *
+ * type Options = { keywords: string[] };
+ *
+ * export default definePlugin(async (options: Options) => {
+ *   return {
+ *     headers: { found: 'Keywords Found' },
+ *     async eachPage({ html }) {
+ *       const count = options.keywords.filter(k => html.includes(k)).length;
+ *       return { page: { found: { value: count } } };
+ *     },
+ *   };
+ * });
+ * ```
+ * @see {@link AnalyzePlugin} for the runtime interface
+ * @see {@link ./hooks/define-plugin.ts!definePlugin} for the type-safe wrapper
+ */
+export type PluginFactory<O, T extends string = string> = (
+	options: O,
+	configFilePath: string,
+) => Promise<AnalyzePlugin<T>> | AnalyzePlugin<T>;
+
+/**
+ * Column header definitions: maps column key to display label.
+ * @example
+ * ```ts
+ * const headers: TableHeaders<'title' | 'desc'> = {
+ *   title: 'Page Title',
+ *   desc: 'Meta Description',
+ * };
+ * ```
+ */
+export type TableHeaders<K extends string> = Record<K, string>;
+
+/** Internal Map representation of {@link TableHeaders}, used by {@link ../table.ts!Table}. */
+export type TableHeaderMap<K extends string> = Map<K, string>;
+
+/** A single row of cell values keyed by column identifier. */
+export type TableData<K extends string> = Record<K, TableValue>;
+
+/**
+ * Multiple rows of table data keyed by page URL.
+ * This is the serialized form used in Worker message payloads and JSON output.
+ */
+export type TablePages<K extends string> = Record<string, TableData<K>>;
+
+/**
+ * Internal Map representation of page-keyed table data.
+ * Used by {@link ../table.ts!Table} for efficient merge operations.
+ */
+export type TableRow<K extends string> = Map<string, TableData<K>>;
+
+/**
+ * Payload for starting an analyze action.
+ * @internal
+ */
+export interface PluginExecutionContext {
+	/** Human-readable name of the plugin module. */
+	pluginModuleName: string;
+	/** Resolved file system path to the plugin module. */
+	pluginModulePath: string;
+	/** Plugin-specific settings to pass to the hook factory. */
+	settings: unknown;
+	/** Path to the config file where this action was declared. */
+	configFilePath: string;
+	/** Temporary directory where the archive is extracted. */
+	archiveTempDir: string;
+	/** Full resolved configuration. */
+	config: Config;
+}
+
+/**
+ * Event map for the {@link ../nitpicker.ts!Nitpicker} event emitter.
+ *
+ * Consumers can listen to these events via `nitpicker.on('writeFile', ...)`.
+ * @see {@link ../nitpicker.ts!Nitpicker} which extends `TypedAwaitEventEmitter<NitpickerEvent>`
+ */
+export interface NitpickerEvent {
+	/**
+	 * Emitted after the archive file has been successfully written to disk.
+	 */
+	writeFile: {
+		/** Absolute path to the written `.nitpicker` archive file. */
+		filePath: string;
+	};
+
+	/**
+	 * Emitted when a non-fatal error occurs during analysis.
+	 */
+	error: {
+		/** Human-readable error description. */
+		message: string;
+		/** Original Error object, or `null` if unavailable. */
+		error: Error | null;
+	};
+}

package/src/url-event-bus.spec.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { UrlEventBus } from './url-event-bus.js';
+
+describe('UrlEventBus', () => {
+	it('emits and receives url events', async () => {
+		const emitter = new UrlEventBus();
+		const handler = vi.fn();
+
+		emitter.on('url', handler);
+		await emitter.emit('url', 'https://example.com/');
+
+		expect(handler).toHaveBeenCalledWith('https://example.com/');
+	});
+
+	it('supports multiple listeners', async () => {
+		const emitter = new UrlEventBus();
+		const handler1 = vi.fn();
+		const handler2 = vi.fn();
+
+		emitter.on('url', handler1);
+		emitter.on('url', handler2);
+		await emitter.emit('url', 'https://example.com/page');
+
+		expect(handler1).toHaveBeenCalledOnce();
+		expect(handler2).toHaveBeenCalledOnce();
+	});
+});

package/src/url-event-bus.ts

@@ -0,0 +1,33 @@
+import { TypedAwaitEventEmitter as EventEmitter } from '@d-zero/shared/typed-await-event-emitter';
+
+/**
+ * Event map for {@link UrlEventBus}.
+ *
+ * Currently supports a single event type for URL discovery notifications.
+ */
+export interface UrlEventBusEvent {
+	/**
+	 * Emitted when a URL is discovered or being processed.
+	 * The payload is the URL href string.
+	 */
+	url: string;
+}
+
+/**
+ * Typed event bus for URL discovery notifications.
+ *
+ * Used as a communication channel between Worker threads and the main thread:
+ *
+ * - **Inside Workers**: The each-page worker emits `'url'` events on a local
+ *   UrlEventBus. The Worker thread entry point ({@link ./worker/worker.ts})
+ *   listens for these and forwards them to the main thread via `parentPort.postMessage`.
+ *
+ * - **In the main thread**: {@link ./worker/run-in-worker.ts!runInWorker} creates its own
+ *   UrlEventBus and re-emits `'url'` messages received from the Worker.
+ *
+ * This indirection allows the same plugin code to work both in Worker threads
+ * and in direct execution mode (when `useWorker` is `false`).
+ * @see {@link ./worker/worker.ts} for Worker-side forwarding
+ * @see {@link ./worker/run-in-worker.ts!runInWorker} for main-thread re-emission
+ */
+export class UrlEventBus extends EventEmitter<UrlEventBusEvent> {}

package/src/worker/run-in-worker.ts

@@ -0,0 +1,155 @@
+import type { UrlEventBus } from '../url-event-bus.js';
+
+import path from 'node:path';
+import { Worker } from 'node:worker_threads';
+
+import { runner } from './runner.js';
+
+const __filename = new URL(import.meta.url).pathname;
+const __dirname = path.dirname(__filename);
+
+/** Resolved path to the compiled Worker thread entry point ({@link ./worker.ts}). */
+const workerPath = path.resolve(__dirname, 'worker.js');
+
+/**
+ * Feature flag controlling whether plugin execution uses Worker threads.
+ * When `true` (default), each plugin invocation runs in an isolated Worker,
+ * providing memory isolation and crash protection. When `false`, the runner
+ * executes directly in the main thread (useful for debugging).
+ */
+const useWorker = true;
+
+/**
+ * Parameters for {@link runInWorker}.
+ * @template I - Shape of the additional data merged into `workerData`.
+ */
+export interface RunInWorkerParams<I extends Record<string, unknown>> {
+	/** Absolute path to the module to execute in the Worker. */
+	readonly filePath: string;
+	/** Zero-based index of the current item (for progress display). */
+	readonly num: number;
+	/** Total number of items in the batch. */
+	readonly total: number;
+	/** URL event bus; `'url'` messages from the Worker are re-emitted here. */
+	readonly emitter: UrlEventBus;
+	/** Plugin-specific data to pass to the Worker module. */
+	readonly initialData: I;
+}
+
+/**
+ * Spawns a Worker thread to execute a plugin module and returns its result.
+ *
+ * This is the bridge between the main thread's `deal()` parallelism and the
+ * per-page Worker execution. Each call creates a new Worker, passes the
+ * initial data via `workerData`, and listens for messages until the Worker
+ * signals completion.
+ *
+ * ## Why Worker threads?
+ *
+ * DOM-heavy plugins (JSDOM + axe-core, markuplint, etc.) allocate significant
+ * memory per page. Running them in Workers ensures:
+ * - **Memory isolation**: JSDOM windows are fully GC'd when the Worker exits
+ * - **Crash containment**: A plugin segfault/OOM kills only the Worker, not the process
+ * - **Signal handling**: Graceful cleanup on SIGABRT, SIGQUIT, and other signals
+ *
+ * ## Message protocol
+ *
+ * The Worker sends two types of messages:
+ * - `{ type: 'url', url: string }` - URL discovery notification, forwarded to the emitter
+ * - `{ type: 'finish', result: R }` - Execution complete, resolves the Promise
+ *
+ * ## Fallback mode
+ *
+ * When `useWorker` is `false`, execution delegates directly to
+ * {@link ./runner.ts!runner} in the main thread.
+ * @template I - Shape of the additional data merged into `workerData`.
+ * @template R - Return type expected from the Worker module.
+ * @param params - Parameters containing file path, progress info, emitter, and data.
+ * @returns The result produced by the Worker module's default export.
+ * @see {@link ./worker.ts} for the Worker-side entry point
+ * @see {@link ./runner.ts!runner} for the direct (non-Worker) execution path
+ */
+export function runInWorker<I extends Record<string, unknown>, R>(
+	params: RunInWorkerParams<I>,
+) {
+	const { filePath, num, total, emitter, initialData } = params;
+	if (useWorker) {
+		const worker = new Worker(workerPath, {
+			workerData: {
+				filePath,
+				num,
+				total,
+				...initialData,
+			},
+		});
+		return new Promise<R>((resolve, reject) => {
+			const killWorker = async (sig: NodeJS.Signals) => {
+				await worker.terminate();
+				worker.unref();
+				worker.removeAllListeners();
+
+				process.removeListener('SIGABRT', killWorker);
+				process.removeListener('SIGLOST', killWorker);
+				process.removeListener('SIGQUIT', killWorker);
+				process.removeListener('disconnect', killWorker);
+				process.removeListener('exit', killWorker);
+				process.removeListener('uncaughtException', killWorker);
+				process.removeListener('uncaughtExceptionMonitor', killWorker);
+				process.removeListener('unhandledRejection', killWorker);
+
+				// eslint-disable-next-line no-console
+				console.log(`Kill Worker cause: %O`, sig);
+				reject(`SIG: ${sig}`);
+			};
+
+			// Changed from old issue
+			// @see https://github.com/nodejs/node-v0.x-archive/issues/6339
+			// process.once('SIGKILL', killWorker);
+			// process.once('SIGSTOP', killWorker);
+
+			process.once('SIGABRT', killWorker);
+			process.once('SIGLOST', killWorker);
+			process.once('SIGQUIT', killWorker);
+			process.once('disconnect', killWorker);
+			process.once('exit', killWorker);
+			process.once('uncaughtException', killWorker);
+			process.once('uncaughtExceptionMonitor', killWorker);
+			process.once('unhandledRejection', killWorker);
+			worker.once('error', killWorker);
+			worker.once('messageerror', killWorker);
+
+			worker.on('message', async (message) => {
+				if (!message) {
+					return;
+				}
+				if (message.type === 'url') {
+					void emitter.emit('url', message.url);
+				}
+				if (message.type === 'finish') {
+					await worker.terminate();
+					worker.removeAllListeners();
+					worker.unref();
+					process.removeListener('SIGABRT', killWorker);
+					process.removeListener('SIGLOST', killWorker);
+					process.removeListener('SIGQUIT', killWorker);
+					process.removeListener('disconnect', killWorker);
+					process.removeListener('exit', killWorker);
+					process.removeListener('uncaughtException', killWorker);
+					process.removeListener('uncaughtExceptionMonitor', killWorker);
+					process.removeListener('unhandledRejection', killWorker);
+					resolve(message.result);
+				}
+			});
+		});
+	}
+
+	return runner<I, R>(
+		{
+			filePath,
+			num,
+			total,
+			...initialData,
+		},
+		emitter,
+	);
+}

package/src/worker/runner.ts

@@ -0,0 +1,38 @@
+import type { WorkerData } from './types.js';
+import type { UrlEventBus } from '../url-event-bus.js';
+
+/**
+ * Dynamically imports and executes a plugin worker module.
+ *
+ * This function is the final execution step in the worker pipeline:
+ * 1. It `import()`s the module specified by `data.filePath`
+ * 2. Calls the module's default export with the remaining data, emitter,
+ *    and progress counters
+ * 3. Returns the result
+ *
+ * The `filePath` field is deleted from `data` before passing it to the
+ * module function, so the module only receives its own domain-specific data.
+ *
+ * This function is called both from the Worker thread ({@link ./worker.ts})
+ * and as a direct fallback when `useWorker` is `false` in {@link ./run-in-worker.ts}.
+ * @template I - Shape of the caller's initial data (minus the worker infrastructure fields).
+ * @template R - Return type of the plugin module's default export.
+ * @param data - Combined worker data containing the module path and plugin-specific payload.
+ * @param emitter - Event emitter for URL discovery notifications (forwarded to the plugin).
+ * @returns The result produced by the dynamically imported module.
+ * @see {@link ./types.ts!WorkerData} for the data shape
+ * @see {@link ../page-analysis-worker.ts} for a typical module loaded by this runner
+ */
+export async function runner<I extends Record<string, unknown>, R>(
+	data: WorkerData<I>,
+	emitter: UrlEventBus,
+): Promise<R> {
+	const { filePath, num, total } = data;
+
+	const mod = await import(filePath);
+	const fn = mod.default;
+	// @ts-expect-error
+	delete data.filePath;
+	const result = await fn(data, emitter, num, total);
+	return result;
+}

package/src/worker/types.ts

@@ -0,0 +1,25 @@
+/**
+ * Data payload passed to a Worker thread via `workerData`.
+ *
+ * This type merges the worker infrastructure fields (`filePath`, `num`, `total`)
+ * with the caller-supplied initial data (`I`). The `filePath` points to the
+ * module whose default export will be invoked by the {@link ../runner.ts!runner}.
+ * @template I - Shape of the additional data the caller provides
+ *   (e.g. {@link ../../page-analysis-worker.ts!PageAnalysisWorkerData}).
+ * @see {@link ../run-in-worker.ts!runInWorker} for where this payload is constructed
+ * @see {@link ../runner.ts!runner} for where it is consumed
+ */
+export type WorkerData<I extends Record<string, unknown>> = {
+	/**
+	 * Absolute path to the compiled JS module to `import()` and execute.
+	 * The module must export a default function matching the
+	 * `(data, emitter, num, total) => Promise<R>` signature.
+	 */
+	filePath: string;
+
+	/** Zero-based index of the current item in the batch (for progress tracking). */
+	num: number;
+
+	/** Total number of items in the batch (for progress tracking). */
+	total: number;
+} & I;

package/src/worker/worker.ts

@@ -0,0 +1,64 @@
+/**
+ * Worker thread entry point for plugin execution.
+ *
+ * This module runs inside a `new Worker(...)` created by {@link ./run-in-worker.ts!runInWorker}.
+ * It uses a message-based protocol to communicate with the main thread:
+ *
+ * ## Message protocol (Worker -> Main)
+ *
+ * | `type`     | Payload          | Description                                    |
+ * |------------|------------------|------------------------------------------------|
+ * | `'url'`    | `{ url: string }` | A URL was discovered during analysis           |
+ * | `'finish'` | `{ result: R }`  | Analysis complete, carries the plugin result   |
+ *
+ * ## Lifecycle
+ *
+ * 1. Reads `workerData` containing the module path + plugin data
+ * 2. Creates a local {@link ../url-event-bus.ts!UrlEventBus} that forwards `'url'`
+ *    events to the main thread via `parentPort.postMessage`
+ * 3. Delegates to {@link ./runner.ts!runner} for dynamic import and execution
+ * 4. Posts the `'finish'` message with the result
+ *
+ * The main thread terminates this Worker after receiving `'finish'`.
+ * @see {@link ./run-in-worker.ts!runInWorker} for the main-thread counterpart
+ * @see {@link ./runner.ts!runner} for the actual module loading logic
+ * @module
+ */
+
+import type { WorkerData } from './types.js';
+
+import { parentPort, workerData } from 'node:worker_threads';
+
+import { UrlEventBus } from '../url-event-bus.js';
+
+import { runner } from './runner.js';
+
+const data: WorkerData<Record<string, unknown>> = workerData;
+
+const emitter = new UrlEventBus();
+
+/**
+ * Forward URL discovery events from the plugin to the main thread.
+ * The main thread's {@link ../url-event-bus.ts!UrlEventBus} re-emits these
+ * so that the orchestrator can track discovered URLs.
+ */
+emitter.on('url', (url) => {
+	if (!parentPort) {
+		throw new Error('Use in worker thread');
+	}
+	parentPort.postMessage({
+		type: 'url',
+		url,
+	});
+});
+
+const result = await runner(data, emitter);
+
+if (!parentPort) {
+	throw new Error('Use in worker thread');
+}
+
+parentPort.postMessage({
+	type: 'finish',
+	result,
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+	"extends": "../../../tsconfig.json",
+	"compilerOptions": {
+		"composite": true,
+		"outDir": "./lib",
+		"rootDir": "./src"
+	},
+	"references": [{ "path": "../types" }, { "path": "../crawler" }],
+	"include": ["./src/**/*"],
+	"exclude": ["node_modules", "lib", "./src/**/*.spec.ts"]
+}