@savvy-web/tsdown-plugins 0.1.0

package/index.js

@@ -0,0 +1,44 @@
+import { resolveManifest } from "./catalog/resolve-catalogs.js";
+import { createEntryName, extractEntries } from "./entry/extract.js";
+import { defaultManifestTransform, normalizeBinPaths, transformBin, transformExports, transformManifest } from "./manifest/transform.js";
+import { buildEmittedManifest, emitManifest } from "./manifest/emit-manifest.js";
+import { cjsDefaultInterop } from "./build/cjs-default-interop.js";
+import { nodeBuiltinDefaultInterop } from "./build/node-builtin-default-interop.js";
+import { syncPublicDir } from "./build/sync-public.js";
+import { deriveTargetGroupOptions } from "./build/target-groups.js";
+import { buildTargetGroups } from "./build/build-target-groups.js";
+import { removeDeclarationMaps } from "./build/strip-maps.js";
+import { ConfigValidator } from "./config-validation/ConfigValidator.js";
+import { ConfigValidationError, MetaGenerationError } from "./errors.js";
+import { DEFAULT_EXE_NODE_VERSION, normalizeExeOptions } from "./exe/config.js";
+import { isTargetObject } from "./targets/config.js";
+import { resolveTargets } from "./targets/resolve-targets.js";
+import { ConfigValidatorLive } from "./config-validation/ConfigValidatorLive.js";
+import { buildResolvedTsconfig, writeResolvedTsconfig } from "./dts/resolved-tsconfig.js";
+import { packageJsonEntries } from "./entry/package-json-entries.js";
+import { runExeBuild } from "./exe/build.js";
+import { readTsconfigJsx, resolveJsxConfig } from "./jsx/config.js";
+import { normalizeMetaOptions } from "./meta/config.js";
+import { TsconfigResolver, resolvePortableTsconfig } from "./meta/tsconfig-resolver.js";
+import { generateMeta } from "./meta/generate.js";
+import { CiAnnotationsFormatter } from "./report/formatters/ci-annotations.js";
+import { JsonFormatter } from "./report/formatters/json.js";
+import { MarkdownFormatter } from "./report/formatters/markdown.js";
+import { SilentFormatter } from "./report/formatters/silent.js";
+import { createTimer, formatTime } from "./report/timer.js";
+import { TerminalFormatter } from "./report/formatters/terminal.js";
+import { EnvironmentDetector } from "./report/services/EnvironmentDetector.js";
+import { EnvironmentDetectorLive } from "./report/layers/EnvironmentDetectorLive.js";
+import { ExecutorResolver } from "./report/services/ExecutorResolver.js";
+import { ExecutorResolverLive } from "./report/layers/ExecutorResolverLive.js";
+import { FormatSelector } from "./report/services/FormatSelector.js";
+import { FormatSelectorLive } from "./report/layers/FormatSelectorLive.js";
+import { OutputRenderer } from "./report/services/OutputRenderer.js";
+import { OutputRendererLive } from "./report/layers/OutputRendererLive.js";
+import { ReportPipelineLive, renderReport } from "./report/pipeline.js";
+import { BuildReport, ReportTimings, TargetGroupReport } from "./report/schema.js";
+import { generateBuildReportSchema } from "./report/schema-export.js";
+import { writeTargetsBinding } from "./targets/binding.js";
+import { CatalogAssemblyError, CatalogResolutionError } from "workspaces-effect";
+
+export { BuildReport as BuildReportSchema, CatalogAssemblyError, CatalogResolutionError, CiAnnotationsFormatter, ConfigValidationError, ConfigValidator, ConfigValidatorLive, DEFAULT_EXE_NODE_VERSION, EnvironmentDetector, EnvironmentDetectorLive, ExecutorResolver, ExecutorResolverLive, FormatSelector, FormatSelectorLive, JsonFormatter, MarkdownFormatter, MetaGenerationError, OutputRenderer, OutputRendererLive, ReportPipelineLive, ReportTimings, SilentFormatter, TargetGroupReport as TargetGroupReportSchema, TerminalFormatter, TsconfigResolver, buildEmittedManifest, buildResolvedTsconfig, buildTargetGroups, cjsDefaultInterop, createEntryName, createTimer, defaultManifestTransform, deriveTargetGroupOptions, emitManifest, extractEntries, formatTime, generateBuildReportSchema, generateMeta, isTargetObject, nodeBuiltinDefaultInterop, normalizeBinPaths, normalizeExeOptions, normalizeMetaOptions, packageJsonEntries, readTsconfigJsx, removeDeclarationMaps, renderReport, resolveJsxConfig, resolveManifest, resolvePortableTsconfig, resolveTargets, runExeBuild, syncPublicDir, transformBin, transformExports, transformManifest, writeResolvedTsconfig, writeTargetsBinding };

package/jsx/config.js

@@ -0,0 +1,40 @@
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/jsx/config.ts
+/**
+* Resolve the effective JSX config: an explicit override wins; otherwise infer from the tsconfig
+* values. Returns undefined when no JSX transform is needed (preserve/none).
+*/
+function resolveJsxConfig(tsconfig, override) {
+	if (override !== void 0) return override.runtime === "automatic" ? {
+		runtime: "automatic",
+		importSource: override.importSource ?? "react"
+	} : override;
+	const ts = tsconfig.jsx;
+	if (ts === "react-jsx" || ts === "react-jsxdev") return {
+		runtime: "automatic",
+		importSource: tsconfig.jsxImportSource ?? "react"
+	};
+	if (ts === "react") return { runtime: "classic" };
+}
+/**
+* Read the jsx-relevant compilerOptions from a package's own tsconfig.json (best-effort;
+* returns empty on absence or parse error).
+*/
+function readTsconfigJsx(cwd) {
+	const path = join(cwd, "tsconfig.json");
+	if (!existsSync(path)) return {};
+	try {
+		const co = JSON.parse(readFileSync(path, "utf-8")).compilerOptions ?? {};
+		return {
+			...co.jsx !== void 0 ? { jsx: co.jsx } : {},
+			...co.jsxImportSource !== void 0 ? { jsxImportSource: co.jsxImportSource } : {}
+		};
+	} catch {
+		return {};
+	}
+}
+
+//#endregion
+export { readTsconfigJsx, resolveJsxConfig };

package/manifest/emit-manifest.js

@@ -0,0 +1,56 @@
+import { resolveManifest } from "../catalog/resolve-catalogs.js";
+import { transformManifest } from "./transform.js";
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+
+//#region src/manifest/emit-manifest.ts
+/** Compute the final manifest bytes for a TargetGroup (catalog resolution + standard transforms). */
+async function buildEmittedManifest(options) {
+	const { pkg, targetGroup, devManifest, transform } = options;
+	const shouldResolve = targetGroup.isProd || devManifest === "resolve";
+	let base = pkg;
+	if (shouldResolve) base = await resolveManifest(pkg);
+	base = {
+		...base,
+		name: targetGroup.name
+	};
+	return transformManifest(base, {
+		transform: transform ? (p) => transform({
+			pkg: p,
+			targetGroup
+		}) : void 0,
+		dual: options.dual ?? false
+	});
+}
+/** Rolldown plugin: emit the transformed package.json + LICENSE/README into the output pkg/ root. */
+function emitManifest(options) {
+	const sourceDir = options.sourceDir;
+	return {
+		name: "savvy:emit-manifest",
+		async generateBundle() {
+			const manifest = await buildEmittedManifest({
+				pkg: JSON.parse(await readFile(join(sourceDir, "package.json"), "utf-8")),
+				targetGroup: options.targetGroup,
+				devManifest: options.devManifest ?? "preserve",
+				transform: options.transform,
+				dual: options.dual
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: "package.json",
+				source: `${JSON.stringify(manifest, null, "	")}\n`
+			});
+			for (const name of ["LICENSE", "README.md"]) try {
+				const content = await readFile(join(sourceDir, name), "utf-8");
+				this.emitFile({
+					type: "asset",
+					fileName: name,
+					source: content
+				});
+			} catch {}
+		}
+	};
+}
+
+//#endregion
+export { buildEmittedManifest, emitManifest };

package/manifest/transform.js

@@ -0,0 +1,123 @@
+import { createEntryName } from "../entry/extract.js";
+import sortPackageJson from "sort-package-json";
+
+//#region src/manifest/transform.ts
+const isDualKey = (dual, exportKey) => typeof dual === "boolean" ? dual : dual.has(exportKey);
+/**
+* Package.json fields that are never wanted in a published manifest: they describe
+* how the package is BUILT/DEVELOPED, not how it is CONSUMED. The bundler reads
+* everything it needs from the source manifest before transforms run (entry
+* detection, `publishConfig.targets` for the byte-variant groups, catalog
+* resolution), so dropping these from the emitted manifest is always safe.
+*/
+const NON_PUBLISHED_FIELDS = [
+	"devDependencies",
+	"bundleDependencies",
+	"scripts",
+	"publishConfig",
+	"packageManager",
+	"devEngines"
+];
+/**
+* The default `transform` applied to every package's manifest when its
+* `savvy.build.ts` does not provide one of its own. Strips the build/dev-only
+* fields in {@link NON_PUBLISHED_FIELDS} from the emitted package.json.
+*
+* This is the pattern nearly every package repeated by hand (inherited from
+* rslib-builder); `defineBuild` now applies it automatically so a package needs a
+* `transform` only when it has genuinely custom manifest work to do (e.g. silk
+* promoting workspace deps to peerDependencies). A custom transform REPLACES this
+* default — re-export it and call it from a custom transform to keep the stripping.
+*
+* `targetGroup` is accepted (so this is assignable wherever the full transform
+* signature is expected) but unused; the strip is identical for every group.
+*
+* Pure: the supplied `pkg` is NOT mutated — a shallow copy with the fields removed
+* is returned, so external callers invoking this from a custom transform keep their
+* input intact.
+*/
+function defaultManifestTransform({ pkg }) {
+	const out = { ...pkg };
+	for (const field of NON_PUBLISHED_FIELDS) delete out[field];
+	return out;
+}
+const stripLeadingDotSlash = (p) => p.startsWith("./") ? p.slice(2) : p;
+/**
+* Built .js output basename for an export, derived from the entry NAME (the basename
+* the build actually emits) rather than the source path. The entry namer flattens
+* nested subpaths to a dash-joined basename (e.g. `./commitlint` to `commitlint.js`,
+* `./changesets/markdownlint` to `changesets-markdownlint.js`), so the declared path
+* always matches the file tsdown emits. The build never sets exportsAsIndexes, so the
+* manifest mirrors the flat (false) naming here.
+*/
+const toBuiltJs = (exportKey) => `./${createEntryName(exportKey, false)}.js`;
+const toBuiltDts = (exportKey) => toBuiltJs(exportKey).replace(/\.js$/, ".d.ts");
+const toBuiltCjs = (exportKey) => toBuiltJs(exportKey).replace(/\.js$/, ".cjs");
+const isTs = (p) => p.endsWith(".ts") || p.endsWith(".tsx");
+/** Build the conditions object for a TS export target (adds require when dual-format). */
+const tsConditions = (exportKey, dual) => ({
+	types: toBuiltDts(exportKey),
+	import: toBuiltJs(exportKey),
+	...dual ? { require: toBuiltCjs(exportKey) } : {}
+});
+/**
+* Rewrite an exports map: TS string targets become a types/import conditions object.
+* Each TS condition also gets a `require` entry when `dual` is `true` (uniform) or when
+* the export key is in the `dual` Set (per-entry).
+*
+* The output path is derived from the export KEY via the shared entry-name function,
+* never from the source path, so the manifest target always matches the emitted file.
+*/
+function transformExports(exports, dual = false) {
+	if (typeof exports === "string") return isTs(exports) ? tsConditions(".", isDualKey(dual, ".")) : exports;
+	if (exports && typeof exports === "object") {
+		const out = {};
+		for (const [key, value] of Object.entries(exports)) {
+			if (key === "./package.json" || key.endsWith(".json")) {
+				out[key] = value;
+				continue;
+			}
+			if (typeof value === "string" && isTs(value)) out[key] = tsConditions(key, isDualKey(dual, key));
+			else out[key] = transformExports(value, dual);
+		}
+		return out;
+	}
+	return exports;
+}
+/** Rewrite bin: TS targets to bin/[command].js (string to bin/cli.js); strip leading ./ otherwise. */
+function transformBin(bin) {
+	if (typeof bin === "string") return isTs(bin) ? "bin/cli.js" : stripLeadingDotSlash(bin);
+	if (bin && typeof bin === "object") {
+		const out = {};
+		for (const [command, p] of Object.entries(bin)) out[command] = isTs(p) ? `bin/${command}.js` : stripLeadingDotSlash(p);
+		return out;
+	}
+	return bin;
+}
+/** FINAL guard: strip leading ./ from bin paths (npm 11.x drops ./-prefixed bins). */
+function normalizeBinPaths(bin) {
+	if (typeof bin === "string") return stripLeadingDotSlash(bin);
+	if (bin && typeof bin === "object") {
+		const out = {};
+		for (const [command, p] of Object.entries(bin)) out[command] = stripLeadingDotSlash(p);
+		return out;
+	}
+	return bin;
+}
+/** Apply the full standard manifest transform (excluding catalog resolution, done upstream). */
+function transformManifest(pkg, options = {}) {
+	const { publishConfig, scripts, ...rest } = pkg;
+	const isPrivate = !(publishConfig?.access === "public");
+	let result = {
+		...rest,
+		private: isPrivate
+	};
+	if (result.exports) result.exports = transformExports(result.exports, options.dual ?? false);
+	if (result.bin) result.bin = transformBin(result.bin);
+	if (options.transform) result = options.transform(result);
+	if (result.bin) result.bin = normalizeBinPaths(result.bin);
+	return sortPackageJson(result);
+}
+
+//#endregion
+export { defaultManifestTransform, normalizeBinPaths, transformBin, transformExports, transformManifest };

package/meta/api-extractor.js

@@ -0,0 +1,59 @@
+import { MetaGenerationError } from "../errors.js";
+import { createMessageSuppressor } from "./message-suppressor.js";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+import { Extractor, ExtractorConfig, ExtractorLogLevel } from "@microsoft/api-extractor";
+import { TSDocConfigFile } from "@microsoft/tsdoc-config";
+
+//#region src/meta/api-extractor.ts
+const require_ = createRequire(import.meta.url);
+/** Run API Extractor over a single entry's .d.ts, writing the .api.json (and optionally tsdoc-metadata.json). Throws on failure. */
+function runApiExtractor(options) {
+	const suppressor = createMessageSuppressor(options.suppressWarnings);
+	const typescriptCompilerFolder = dirname(require_.resolve("typescript/package.json"));
+	const tsdocConfigFile = TSDocConfigFile.loadForFolder(dirname(options.tsdocConfigPath));
+	const extractorConfig = ExtractorConfig.prepare({
+		configObject: {
+			projectFolder: options.cwd,
+			mainEntryPointFilePath: options.entryDtsPath,
+			enumMemberOrder: "preserve",
+			compiler: { tsconfigFilePath: options.tsconfigPath },
+			docModel: {
+				enabled: true,
+				apiJsonFilePath: options.apiJsonPath
+			},
+			...options.tsdocMetadataPath !== void 0 ? { tsdocMetadata: {
+				enabled: true,
+				tsdocMetadataFilePath: options.tsdocMetadataPath
+			} } : {},
+			dtsRollup: { enabled: false },
+			apiReport: { enabled: false }
+		},
+		packageJsonFullPath: options.packageJsonPath,
+		configObjectFullPath: void 0,
+		tsdocConfigFile
+	});
+	const result = Extractor.invoke(extractorConfig, {
+		typescriptCompilerFolder,
+		localBuild: true,
+		showVerboseMessages: false,
+		messageCallback: (message) => {
+			if (suppressor.matches(message.messageId, message.text)) {
+				message.logLevel = ExtractorLogLevel.None;
+				message.handled = true;
+				return;
+			}
+			if (message.messageId === "console-compiler-version-notice" || message.messageId === "console-preamble") {
+				message.logLevel = ExtractorLogLevel.None;
+				message.handled = true;
+			}
+		}
+	});
+	if (!result.succeeded) throw new MetaGenerationError({
+		entry: options.entryDtsPath,
+		reason: `API Extractor reported ${result.errorCount} error(s) and ${result.warningCount} warning(s)`
+	});
+}
+
+//#endregion
+export { runApiExtractor };

package/meta/config.js

@@ -0,0 +1,14 @@
+//#region src/meta/config.ts
+/** Fill defaults so downstream code never branches on undefined. */
+function normalizeMetaOptions(meta) {
+	return {
+		localPaths: meta.localPaths ?? [],
+		tsdoc: {
+			suppressWarnings: meta.tsdoc?.suppressWarnings ?? [],
+			tagDefinitions: meta.tsdoc?.tagDefinitions ?? []
+		}
+	};
+}
+
+//#endregion
+export { normalizeMetaOptions };

package/meta/generate.js

@@ -0,0 +1,76 @@
+import { runApiExtractor } from "./api-extractor.js";
+import { mergeApiModels } from "./merge-models.js";
+import { resolvePortableTsconfig } from "./tsconfig-resolver.js";
+import { writeTsdocConfig } from "./tsdoc-config.js";
+import { join } from "node:path";
+import { copyFileSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+
+//#region src/meta/generate.ts
+function unscopedName(name) {
+	const slash = name.lastIndexOf("/");
+	return slash >= 0 ? name.slice(slash + 1) : name;
+}
+/**
+* Generate the api-model meta bundle from already-emitted .d.ts. Writes tsdoc.json (idempotent),
+* runs the extractor per entry, merges if needed, and writes the "virtual TS env" trio to
+* outMetaDir (`<unscoped>.api.json` + the final `package.json` + a portable `tsconfig.json`),
+* copying that trio into each localPaths dir. The api-extractor `tsdoc-metadata.json` is a
+* published-package artifact and is written into `dtsDir` (the built pkg/), not the meta bundle.
+*/
+async function generateMeta(options) {
+	const { cwd, packageName, tsconfigPath, dtsDir, entries, exportPaths, outMetaDir, localPaths, tsdoc } = options;
+	const tsdocConfigPath = writeTsdocConfig(cwd, tsdoc);
+	const packageJsonPath = join(cwd, "package.json");
+	mkdirSync(outMetaDir, { recursive: true });
+	const apiJsonFilename = `${unscopedName(packageName)}.api.json`;
+	const tsdocMetadataPath = join(dtsDir, "tsdoc-metadata.json");
+	const entryNames = Object.keys(entries);
+	const perEntryModels = /* @__PURE__ */ new Map();
+	const intermediateApiJsons = [];
+	let mainEntryDidTsdocMetadata = false;
+	for (const entryName of entryNames) {
+		const entryDtsPath = join(dtsDir, `${entries[entryName]}.d.ts`);
+		const perEntryApiJson = join(outMetaDir, `${entryName.replace(/[\\/]/g, "__")}.entry.api.json`);
+		intermediateApiJsons.push(perEntryApiJson);
+		const isMain = (exportPaths[entryName] ?? (entryName === "index" ? "." : `./${entryName}`)) === ".";
+		runApiExtractor({
+			cwd,
+			packageJsonPath,
+			entryDtsPath,
+			tsconfigPath,
+			tsdocConfigPath,
+			apiJsonPath: perEntryApiJson,
+			...isMain && !mainEntryDidTsdocMetadata ? { tsdocMetadataPath } : {},
+			suppressWarnings: tsdoc.suppressWarnings
+		});
+		if (isMain) mainEntryDidTsdocMetadata = true;
+		perEntryModels.set(entryName, JSON.parse(readFileSync(perEntryApiJson, "utf-8")));
+	}
+	const finalModel = perEntryModels.size === 1 ? perEntryModels.values().next().value : mergeApiModels({
+		perEntryModels,
+		packageName,
+		exportPaths
+	});
+	const apiJsonPath = join(outMetaDir, apiJsonFilename);
+	writeFileSync(apiJsonPath, `${JSON.stringify(finalModel, null, 2)}\n`, "utf-8");
+	for (const intermediate of intermediateApiJsons) rmSync(intermediate, { force: true });
+	const bundlePackageJson = join(outMetaDir, "package.json");
+	copyFileSync(join(dtsDir, "package.json"), bundlePackageJson);
+	const bundleTsconfig = join(outMetaDir, "tsconfig.json");
+	const portableTsconfig = resolvePortableTsconfig(cwd, tsconfigPath);
+	writeFileSync(bundleTsconfig, `${JSON.stringify(portableTsconfig, null, 2)}\n`, "utf-8");
+	for (const localPath of localPaths) {
+		const dest = join(cwd, localPath);
+		mkdirSync(dest, { recursive: true });
+		copyFileSync(apiJsonPath, join(dest, apiJsonFilename));
+		copyFileSync(bundlePackageJson, join(dest, "package.json"));
+		copyFileSync(bundleTsconfig, join(dest, "tsconfig.json"));
+	}
+	return {
+		apiJsonPath,
+		apiJsonFilename
+	};
+}
+
+//#endregion
+export { generateMeta };

package/meta/merge-models.js

@@ -0,0 +1,44 @@
+//#region src/meta/merge-models.ts
+/** Rewrite every nested member canonicalReference that starts with originalPrefix to use newPrefix. Skips the EntryPoint node itself. */
+function rewriteCanonicalReferences(node, originalPrefix, newPrefix) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) rewriteCanonicalReferences(item, originalPrefix, newPrefix);
+		return;
+	}
+	const obj = node;
+	if (typeof obj.canonicalReference === "string" && obj.kind !== "EntryPoint") {
+		const ref = obj.canonicalReference;
+		if (ref.startsWith(originalPrefix)) obj.canonicalReference = ref.replace(originalPrefix, newPrefix);
+	}
+	if (Array.isArray(obj.members)) for (const member of obj.members) rewriteCanonicalReferences(member, originalPrefix, newPrefix);
+}
+/** Merge per-entry API models into one Package model. Each input is a Package with one EntryPoint; the output keeps the main entry (".") canonical and rewrites sub-entries to `${packageName}/${subpath}!`. */
+function mergeApiModels(options) {
+	const { perEntryModels, packageName, exportPaths } = options;
+	if (perEntryModels.size === 0) throw new Error("Cannot merge zero API models");
+	const firstModel = perEntryModels.values().next().value;
+	const merged = JSON.parse(JSON.stringify(firstModel));
+	const entryPointMembers = [];
+	for (const [entryName, model] of perEntryModels) {
+		const entryPoints = model.members;
+		if (!entryPoints || entryPoints.length === 0) continue;
+		const entryPoint = JSON.parse(JSON.stringify(entryPoints[0]));
+		const exportPath = exportPaths[entryName] ?? (entryName === "index" ? "." : `./${entryName}`);
+		if (exportPath === ".") entryPointMembers.unshift(entryPoint);
+		else {
+			const subpath = exportPath.replace(/^\.\//, "");
+			const originalPrefix = `${packageName}!`;
+			const newPrefix = `${packageName}/${subpath}!`;
+			entryPoint.canonicalReference = newPrefix;
+			entryPoint.name = subpath;
+			rewriteCanonicalReferences(entryPoint, originalPrefix, newPrefix);
+			entryPointMembers.push(entryPoint);
+		}
+	}
+	merged.members = entryPointMembers;
+	return merged;
+}
+
+//#endregion
+export { mergeApiModels };

package/meta/message-suppressor.js

@@ -0,0 +1,37 @@
+//#region src/meta/message-suppressor.ts
+function compileRule(rule) {
+	if (rule.pattern === void 0) return {
+		messageId: rule.messageId,
+		regex: void 0,
+		substring: void 0
+	};
+	try {
+		return {
+			messageId: rule.messageId,
+			regex: new RegExp(rule.pattern),
+			substring: void 0
+		};
+	} catch {
+		return {
+			messageId: rule.messageId,
+			regex: void 0,
+			substring: rule.pattern
+		};
+	}
+}
+/** Build a suppressor that matches a message when its id matches exactly AND (if a pattern is set) the text matches the regex/substring. */
+function createMessageSuppressor(rules) {
+	const compiled = rules.map(compileRule);
+	return { matches(messageId, text) {
+		for (const rule of compiled) {
+			if (rule.messageId !== messageId) continue;
+			if (rule.regex === void 0 && rule.substring === void 0) return true;
+			if (rule.regex?.test(text)) return true;
+			if (rule.substring !== void 0 && text.includes(rule.substring)) return true;
+		}
+		return false;
+	} };
+}
+
+//#endregion
+export { createMessageSuppressor };