@effected/tsconfig-json 0.1.0

package/ResolvedTsconfig.js

@@ -0,0 +1,245 @@
+//#region src/ResolvedTsconfig.ts
+const CONFIG_DIR_TEMPLATE = `\${configDir}`;
+const CONFIG_DIR_TEMPLATE_LOWER = CONFIG_DIR_TEMPLATE.toLowerCase();
+/** A value is `${configDir}`-prefixed if its leading token matches case-insensitively (E5). */
+const startsWithConfigDir = (value) => value.slice(0, CONFIG_DIR_TEMPLATE.length).toLowerCase() === CONFIG_DIR_TEMPLATE_LOWER;
+const normalizeSlashes = (p) => p.replace(/\\/g, "/");
+/** POSIX `dirname` over the normalized path; a rootless path yields `"."`. */
+const dirname = (p) => {
+	const norm = normalizeSlashes(p);
+	const idx = norm.lastIndexOf("/");
+	if (idx < 0) return ".";
+	if (idx === 0) return "/";
+	return norm.slice(0, idx);
+};
+/** POSIX relative path from directory `from` to directory `to`. */
+const relative = (from, to) => {
+	const f = normalizeSlashes(from).split("/").filter((s) => s.length > 0);
+	const t = normalizeSlashes(to).split("/").filter((s) => s.length > 0);
+	let i = 0;
+	while (i < f.length && i < t.length && f[i] === t[i]) i++;
+	return [...f.slice(i).map(() => ".."), ...t.slice(i)].join("/");
+};
+/** True for POSIX-rooted, Windows-drive-rooted, and UNC paths. */
+const isAbsolutePath = (p) => p.startsWith("/") || p.startsWith("\\\\") || /^[a-zA-Z]:[\\/]/.test(p);
+/**
+* Rebuild a record, mapping each value, using `defineProperty` so an own
+* `__proto__` key is written as data rather than triggering the prototype
+* setter. Preserves every own key (forward tolerance) without pollution.
+*/
+const rebuildRecord = (source, mapValue) => {
+	const out = {};
+	for (const key of Object.keys(source)) Object.defineProperty(out, key, {
+		value: mapValue(key, source[key]),
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return out;
+};
+const PATH_STRING_KEYS = [
+	"outFile",
+	"outDir",
+	"rootDir",
+	"declarationDir",
+	"sourceRoot",
+	"mapRoot",
+	"tsBuildInfoFile",
+	"baseUrl",
+	"generateCpuProfile",
+	"generateTrace"
+];
+const PATH_LIST_KEYS = ["typeRoots", "rootDirs"];
+/**
+* Apply `transform` to every path-typed compilerOptions surface: the R1.4 path
+* strings and path lists, and — when `includePathsValues` — the `paths` record's
+* values (E5's final phase substitutes those; E5's parse phase leaves them
+* verbatim). Non-string values pass through untouched (forward tolerance).
+*/
+const transformCompilerOptionPaths = (co, transform, includePathsValues) => {
+	const out = { ...co };
+	for (const key of PATH_STRING_KEYS) {
+		const value = out[key];
+		if (typeof value === "string") out[key] = transform(value);
+	}
+	for (const key of PATH_LIST_KEYS) {
+		const value = out[key];
+		if (Array.isArray(value)) out[key] = value.map((entry) => typeof entry === "string" ? transform(entry) : entry);
+	}
+	if (includePathsValues) {
+		const paths = out.paths;
+		if (paths !== null && typeof paths === "object") out.paths = rebuildRecord(paths, (_key, arr) => Array.isArray(arr) ? arr.map((entry) => typeof entry === "string" ? transform(entry) : entry) : arr);
+	}
+	return out;
+};
+/**
+* Absolutize a config's path-typed options (E5) against its own `configDir`,
+* using the injected `join` (`Path.Path.resolve` at the call site — so an
+* already-absolute value is preserved). `${configDir}`-prefixed values are
+* exempt (resolved later, in {@link (ResolvedTsconfig:variable).substituteConfigDir}), and
+* `paths` VALUES stay verbatim. Only `compilerOptions` path surfaces are
+* touched; `files`/`include`/`exclude` are re-rooted at merge time instead (E4).
+*
+* @public
+*/
+const absolutize = (doc, configDir, join) => {
+	const co = doc.compilerOptions;
+	if (co === void 0) return doc;
+	const absolutizeValue = (value) => startsWithConfigDir(value) ? value : join(configDir, value);
+	return {
+		...doc,
+		compilerOptions: transformCompilerOptionPaths(co, absolutizeValue, false)
+	};
+};
+const DERIVED_CONSUMED_KEYS = /* @__PURE__ */ new Set([
+	"compilerOptions",
+	"extends",
+	"files",
+	"include",
+	"exclude",
+	"references",
+	"watchOptions",
+	"typeAcquisition",
+	"compileOnSave"
+]);
+const RESOLVED_STRUCTURAL_KEYS = /* @__PURE__ */ new Set([
+	"configPath",
+	"extendedPaths",
+	"compilerOptions",
+	"files",
+	"include",
+	"exclude",
+	"references",
+	"watchOptions",
+	"typeAcquisition",
+	"compileOnSave",
+	"pathsBase",
+	"extends"
+]);
+const extractPassthrough = (source, consumed) => {
+	const out = {};
+	for (const key of Object.keys(source)) {
+		if (consumed.has(key)) continue;
+		Object.defineProperty(out, key, {
+			value: source[key],
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	return out;
+};
+/** Re-root one inherited `files`/`include`/`exclude` entry, exempting absolute and `${configDir}` entries (E4). */
+const rerootEntry = (prefix, entry) => {
+	if (startsWithConfigDir(entry) || isAbsolutePath(entry)) return entry;
+	return prefix === "" ? entry : `${prefix}/${entry}`;
+};
+/**
+* `files`/`include`/`exclude`: the derived (own) config declaring the property
+* wins outright — an own empty array beats an inherited value. Otherwise inherit
+* the base's entries, re-rooted with the relative prefix.
+*/
+const mergeFileList = (baseList, derivedList, rerootPrefix) => {
+	if (derivedList !== void 0) return derivedList;
+	if (baseList === void 0) return void 0;
+	return baseList.map((entry) => rerootEntry(rerootPrefix, entry));
+};
+/** `watchOptions`: per-key shallow merge (derived wins per key). */
+const mergeWatchOptions = (base, derived) => {
+	if (base === void 0) return derived;
+	if (derived === void 0) return base;
+	return {
+		...base,
+		...derived
+	};
+};
+/**
+* Fold one more-derived config onto the accumulated base (E4), derived winning.
+* The loader (Task 8) applies this across the resolution chain, own config last.
+* `derivedPath` is the derived config's absolute normalized path, from which the
+* re-rooting frame and `pathsBase` are computed.
+*
+* @public
+*/
+const merge = (base, derived, derivedPath) => {
+	const finalDir = dirname(derivedPath);
+	const baseDir = dirname(base.configPath);
+	const compilerOptions = {
+		...base.compilerOptions,
+		...derived.compilerOptions
+	};
+	const pathsBase = derived.compilerOptions?.paths !== void 0 ? finalDir : base.pathsBase;
+	const rerootPrefix = relative(finalDir, baseDir);
+	const files = mergeFileList(base.files, derived.files, rerootPrefix);
+	const include = mergeFileList(base.include, derived.include, rerootPrefix);
+	const exclude = mergeFileList(base.exclude, derived.exclude, rerootPrefix);
+	const references = derived.references;
+	const typeAcquisition = derived.typeAcquisition;
+	const compileOnSave = derived.compileOnSave !== void 0 ? derived.compileOnSave : base.compileOnSave === true ? true : void 0;
+	const watchOptions = mergeWatchOptions(base.watchOptions, derived.watchOptions);
+	return {
+		...extractPassthrough(base, RESOLVED_STRUCTURAL_KEYS),
+		...extractPassthrough(derived, DERIVED_CONSUMED_KEYS),
+		configPath: derivedPath,
+		extendedPaths: [...base.extendedPaths, derivedPath],
+		compilerOptions,
+		...files !== void 0 ? { files } : {},
+		...include !== void 0 ? { include } : {},
+		...exclude !== void 0 ? { exclude } : {},
+		...references !== void 0 ? { references } : {},
+		...watchOptions !== void 0 ? { watchOptions } : {},
+		...typeAcquisition !== void 0 ? { typeAcquisition } : {},
+		...compileOnSave !== void 0 ? { compileOnSave } : {},
+		...pathsBase !== void 0 ? { pathsBase } : {}
+	};
+};
+const substituteWatchExcludes = (wo, substitute) => {
+	if (wo === void 0) return void 0;
+	const out = { ...wo };
+	for (const key of ["excludeDirectories", "excludeFiles"]) {
+		const value = out[key];
+		if (Array.isArray(value)) out[key] = value.map((entry) => typeof entry === "string" ? substitute(entry) : entry);
+	}
+	return out;
+};
+/**
+* The E5 final phase: replace a leading `${configDir}` token (case-insensitive,
+* leading position only) with `finalDir` — the top-level extending config's
+* directory — across every eligible surface: compilerOptions path options,
+* `paths` values, `files`/`include`/`exclude`, and `watchOptions`'
+* `excludeDirectories`/`excludeFiles`. Every other field is left untouched.
+*
+* @public
+*/
+const substituteConfigDir = (resolved, finalDir) => {
+	const substitute = (value) => startsWithConfigDir(value) ? finalDir + value.slice(CONFIG_DIR_TEMPLATE.length) : value;
+	const compilerOptions = transformCompilerOptionPaths(resolved.compilerOptions, substitute, true);
+	const files = resolved.files === void 0 ? void 0 : resolved.files.map(substitute);
+	const include = resolved.include === void 0 ? void 0 : resolved.include.map(substitute);
+	const exclude = resolved.exclude === void 0 ? void 0 : resolved.exclude.map(substitute);
+	const watchOptions = substituteWatchExcludes(resolved.watchOptions, substitute);
+	return {
+		...resolved,
+		compilerOptions,
+		...files !== void 0 ? { files } : {},
+		...include !== void 0 ? { include } : {},
+		...exclude !== void 0 ? { exclude } : {},
+		...watchOptions !== void 0 ? { watchOptions } : {}
+	};
+};
+/**
+* The pure extends-merge engine: parse-time path absolutization
+* ({@link (ResolvedTsconfig:variable).absolutize}), the per-field merge fold
+* ({@link (ResolvedTsconfig:variable).merge}), and the `${configDir}` final
+* phase ({@link (ResolvedTsconfig:variable).substituteConfigDir}).
+*
+* @public
+*/
+const ResolvedTsconfig = {
+	absolutize,
+	merge,
+	substituteConfigDir
+};
+
+//#endregion
+export { ResolvedTsconfig };

package/TsEnumCodec.js

@@ -0,0 +1,203 @@
+import { Option } from "effect";
+
+//#region src/TsEnumCodec.ts
+/**
+* Builds a family's forward/reverse maps from its R1.6 row order. The
+* reverse map overwrites on every duplicate value, so the last-listed name
+* for a value is canonical — exactly R1.6's alias/canonical rule.
+*/
+const buildTable = (rows) => {
+	const forward = /* @__PURE__ */ new Map();
+	const reverse = /* @__PURE__ */ new Map();
+	for (const [name, value] of rows) {
+		forward.set(name, value);
+		reverse.set(value, name);
+	}
+	return {
+		forward,
+		reverse
+	};
+};
+const TABLES = {
+	target: buildTable([
+		["es5", 1],
+		["es6", 2],
+		["es2015", 2],
+		["es2016", 3],
+		["es2017", 4],
+		["es2018", 5],
+		["es2019", 6],
+		["es2020", 7],
+		["es2021", 8],
+		["es2022", 9],
+		["es2023", 10],
+		["es2024", 11],
+		["es2025", 12],
+		["esnext", 99]
+	]),
+	module: buildTable([
+		["none", 0],
+		["commonjs", 1],
+		["amd", 2],
+		["umd", 3],
+		["system", 4],
+		["es6", 5],
+		["es2015", 5],
+		["es2020", 6],
+		["es2022", 7],
+		["esnext", 99],
+		["node16", 100],
+		["node18", 101],
+		["node20", 102],
+		["nodenext", 199],
+		["preserve", 200]
+	]),
+	moduleResolution: buildTable([
+		["classic", 1],
+		["node", 2],
+		["node10", 2],
+		["node16", 3],
+		["nodenext", 99],
+		["bundler", 100]
+	]),
+	jsx: buildTable([
+		["preserve", 1],
+		["react", 2],
+		["react-native", 3],
+		["react-jsx", 4],
+		["react-jsxdev", 5]
+	]),
+	newLine: buildTable([["crlf", 0], ["lf", 1]]),
+	moduleDetection: buildTable([
+		["legacy", 1],
+		["auto", 2],
+		["force", 3]
+	]),
+	watchFile: buildTable([
+		["fixedpollinginterval", 0],
+		["prioritypollinginterval", 1],
+		["dynamicprioritypolling", 2],
+		["fixedchunksizepolling", 3],
+		["usefsevents", 4],
+		["usefseventsonparentdirectory", 5]
+	]),
+	watchDirectory: buildTable([
+		["usefsevents", 0],
+		["fixedpollinginterval", 1],
+		["dynamicprioritypolling", 2],
+		["fixedchunksizepolling", 3]
+	]),
+	fallbackPolling: buildTable([
+		["fixedinterval", 0],
+		["priorityinterval", 1],
+		["dynamicpriority", 2],
+		["fixedchunksize", 3]
+	])
+};
+/**
+* Encodes a family's canonical (or alias) string spelling to its numeric
+* form. `Option.none()` for a string with no table entry — never guessed.
+*
+* @public
+*/
+const encode = (family, value) => Option.fromNullishOr(TABLES[family].forward.get(value));
+/**
+* Decodes a family's numeric value to its canonical string spelling.
+* `Option.none()` for a numeric value with no table entry (a future TS enum
+* member) — never guessed.
+*
+* @public
+*/
+const decode = (family, value) => Option.fromNullishOr(TABLES[family].reverse.get(value));
+/**
+* Normalizes any spelling of a `lib` reference — the plain short name
+* (`esnext`), the on-disk file name (`lib.esnext.d.ts`), or an absolute path
+* to one (`/…/typescript/lib/lib.dom.iterable.d.ts`) — to the canonical
+* lowercase short name (`esnext`, `dom.iterable`). Strips a leading
+* directory, the `lib.` prefix and the `.d.ts` suffix; idempotent on an
+* already-short name.
+*
+* @public
+*/
+const normalizeLibReference = (lib) => {
+	const base = (lib.split("/").pop() ?? lib).toLowerCase();
+	const withoutPrefix = base.startsWith("lib.") ? base.slice(4) : base;
+	return withoutPrefix.endsWith(".d.ts") ? withoutPrefix.slice(0, -5) : withoutPrefix;
+};
+/** `compilerOptions` keys whose values are one of the R1.6 enum families. */
+const COMPILER_OPTION_ENUM_KEYS = [
+	["target", "target"],
+	["module", "module"],
+	["moduleResolution", "moduleResolution"],
+	["jsx", "jsx"],
+	["newLine", "newLine"],
+	["moduleDetection", "moduleDetection"]
+];
+/**
+* Encodes a decoded `compilerOptions` object into the numeric-enum-shaped
+* form `ts.CompilerOptions` (and `@typescript/vfs`'s `TsEnvironment`) expect:
+* every R1.6 enum family becomes its numeric value, and `lib` entries become
+* the file-name form (`lib.esnext.d.ts`) — see the module banner for the
+* evidence. Every other key (booleans, strings, arrays, unknown passthrough
+* keys) is copied through untouched.
+*
+* @public
+*/
+const encodeCompilerOptions = (options) => {
+	const source = options;
+	const result = { ...source };
+	for (const [key, family] of COMPILER_OPTION_ENUM_KEYS) {
+		const value = source[key];
+		if (typeof value === "string") {
+			const encoded = encode(family, value);
+			if (Option.isSome(encoded)) result[key] = encoded.value;
+		}
+	}
+	const lib = source.lib;
+	if (Array.isArray(lib)) result.lib = lib.map((entry) => typeof entry === "string" ? `lib.${normalizeLibReference(entry)}.d.ts` : entry);
+	return result;
+};
+/**
+* Decodes a numeric-enum-shaped `compilerOptions` object (as produced by
+* {@link (TsEnumCodec:variable).encodeCompilerOptions} or read off a live
+* `ts.CompilerOptions`) back into the string-enum shape this package's
+* schemas use: every R1.6 enum family becomes its canonical string, and
+* `lib` entries become the short form. A numeric value with no table entry —
+* a future TS enum member — is left as-is (passthrough, never an error) —
+* which is why the return type stays the wider `Record<string, unknown>`
+* rather than {@link (CompilerOptions:variable).Type}: an unmappable
+* passthrough value would violate that narrower type's contract. Every other
+* key is copied through untouched.
+*
+* @public
+*/
+const decodeCompilerOptions = (numeric) => {
+	const result = { ...numeric };
+	for (const [key, family] of COMPILER_OPTION_ENUM_KEYS) {
+		const value = numeric[key];
+		if (typeof value === "number") {
+			const decoded = decode(family, value);
+			if (Option.isSome(decoded)) result[key] = decoded.value;
+		}
+	}
+	const lib = numeric.lib;
+	if (Array.isArray(lib)) result.lib = lib.map((entry) => typeof entry === "string" ? normalizeLibReference(entry) : entry);
+	return result;
+};
+/**
+* The string↔numeric enum codec for `compilerOptions` / `watchOptions`
+* families, per R1.6. Plain data: every lookup is a synchronous map read
+* returning `Option.Option`, never a thrown error.
+*
+* @public
+*/
+const TsEnumCodec = {
+	encode,
+	decode,
+	normalizeLibReference,
+	encodeCompilerOptions,
+	decodeCompilerOptions
+};
+
+//#endregion
+export { TsEnumCodec };

package/TsconfigDiscovery.js

@@ -0,0 +1,29 @@
+import { Effect, Path } from "effect";
+import { Walker } from "@effected/walker";
+
+//#region src/TsconfigDiscovery.ts
+/**
+* Find the nearest `tsconfig.json` (or `options.filename`) at or above
+* `start`, ascending toward the filesystem root. Absence — nowhere on the
+* chain, or every candidate unreadable — is `Option.none()`, never an error;
+* discovery is best-effort per `Walker.findUpward`'s absorption posture, and a
+* permission-denied probe on one directory does not hide a config file above
+* it.
+*
+* @public
+*/
+const findNearest = (start, options) => Effect.gen(function* () {
+	const path = yield* Path.Path;
+	const filename = options?.filename ?? "tsconfig.json";
+	const dirs = yield* Walker.ascend(start, options?.stopAt === void 0 ? {} : { stopAt: options.stopAt });
+	return yield* Walker.findUpward(dirs, (dir) => [path.join(dir, filename)]);
+});
+/**
+* Nearest-config upward discovery for `tsconfig.json`.
+*
+* @public
+*/
+const TsconfigDiscovery = { findNearest };
+
+//#endregion
+export { TsconfigDiscovery };

package/TsconfigJson.js

@@ -0,0 +1,122 @@
+import { CompilerOptions } from "./CompilerOptions.js";
+import { Schema, SchemaTransformation } from "effect";
+import { Jsonc } from "@effected/jsonc";
+
+//#region src/TsconfigJson.ts
+/**
+* Case-insensitive literal-union decode; canonical lowercase encode.
+* Replicated from `CompilerOptions.ts`'s module-private helper (not exported
+* there — reused as house style, not imported, to avoid coupling this
+* module's public schemas to CompilerOptions.ts's internals).
+*/
+const caseInsensitiveLiterals = (literals) => Schema.String.pipe(Schema.decodeTo(Schema.Literals(literals), SchemaTransformation.transform({
+	decode: (s) => s.toLowerCase(),
+	encode: (s) => s
+})));
+/** `watchOptions.watchFile`. @public */
+const WatchFile = caseInsensitiveLiterals([
+	"fixedpollinginterval",
+	"prioritypollinginterval",
+	"dynamicprioritypolling",
+	"fixedchunksizepolling",
+	"usefsevents",
+	"usefseventsonparentdirectory"
+]);
+/** `watchOptions.watchDirectory`. @public */
+const WatchDirectory = caseInsensitiveLiterals([
+	"usefsevents",
+	"fixedpollinginterval",
+	"dynamicprioritypolling",
+	"fixedchunksizepolling"
+]);
+/** `watchOptions.fallbackPolling`. @public */
+const FallbackPolling = caseInsensitiveLiterals([
+	"fixedinterval",
+	"priorityinterval",
+	"dynamicpriority",
+	"fixedchunksize"
+]);
+/**
+* One `references[]` entry: `path` is required and non-empty; every other key
+* is preserved verbatim (per R1.5).
+*
+* @public
+*/
+const Reference = Schema.StructWithRest(Schema.Struct({ path: Schema.String.check(Schema.isMinLength(1)) }), [Schema.Record(Schema.String, Schema.Unknown)]);
+/**
+* `watchOptions` — the three enum fields (R1.2), the two live booleans/arrays
+* (R1.5), and a passthrough record (schemastore's `force` is phantom).
+*
+* @public
+*/
+const WatchOptions = Schema.StructWithRest(Schema.Struct({
+	watchFile: Schema.optionalKey(WatchFile),
+	watchDirectory: Schema.optionalKey(WatchDirectory),
+	fallbackPolling: Schema.optionalKey(FallbackPolling),
+	synchronousWatchDirectory: Schema.optionalKey(Schema.Boolean),
+	excludeDirectories: Schema.optionalKey(Schema.Array(Schema.String)),
+	excludeFiles: Schema.optionalKey(Schema.Array(Schema.String))
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+/**
+* `typeAcquisition` — per R1.5.
+*
+* @public
+*/
+const TypeAcquisition = Schema.StructWithRest(Schema.Struct({
+	enable: Schema.optionalKey(Schema.Boolean),
+	include: Schema.optionalKey(Schema.Array(Schema.String)),
+	exclude: Schema.optionalKey(Schema.Array(Schema.String)),
+	disableFilenameBasedTypeAcquisition: Schema.optionalKey(Schema.Boolean)
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+/**
+* The tsconfig.json document: every typed top-level field (R1.1) optional,
+* plus a passthrough record so unrecognized keys (`buildOptions`, `ts-node`,
+* …) survive decode and re-encode untouched — tsc itself silently ignores
+* unknown top-level keys, and this schema follows suit.
+*
+* @public
+*/
+const TsconfigJson = Schema.StructWithRest(Schema.Struct({
+	compilerOptions: Schema.optionalKey(CompilerOptions),
+	extends: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])),
+	files: Schema.optionalKey(Schema.Array(Schema.String)),
+	include: Schema.optionalKey(Schema.Array(Schema.String)),
+	exclude: Schema.optionalKey(Schema.Array(Schema.String)),
+	references: Schema.optionalKey(Schema.Array(Reference)),
+	watchOptions: Schema.optionalKey(WatchOptions),
+	typeAcquisition: Schema.optionalKey(TypeAcquisition),
+	compileOnSave: Schema.optionalKey(Schema.Boolean),
+	$schema: Schema.optionalKey(Schema.String)
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+/**
+* Decodes a JSONC-encoded tsconfig.json document straight into
+* {@link (TsconfigJson:variable)}. Bound once at module top level —
+* `Jsonc.schema` is schema-producing, and this is the shared instance (the
+* house `FromString` idiom, R3.3; `TsconfigJson` is a `Schema.StructWithRest`
+* value rather than a `Schema.Class`, so the codec is a sibling export, not a
+* static).
+*
+* @public
+*/
+const TsconfigJsonFromString = Jsonc.schema(TsconfigJson);
+/**
+* Raised when a tsconfig.json document fails to parse or decode. `path` is
+* the file path when the failure is file-bound, and the empty string
+* otherwise (e.g. decoding an in-memory string). The loader (Task 8) wraps
+* file-bound decode failures in this error; this module only declares it.
+*
+* @public
+*/
+var TsconfigParseError = class extends Schema.TaggedErrorClass()("TsconfigParseError", {
+	/** The file path that failed to parse, or `""` when not file-bound. */
+	path: Schema.String,
+	/** The underlying decode failure. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return this.path.length > 0 ? `failed to parse tsconfig.json at "${this.path}"` : "failed to parse tsconfig.json";
+	}
+};
+
+//#endregion
+export { FallbackPolling, Reference, TsconfigJson, TsconfigJsonFromString, TsconfigParseError, TypeAcquisition, WatchDirectory, WatchFile, WatchOptions };