@cronn/lib-file-snapshots 0.19.0 → 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,163 @@
+//#region src/types/serializer.d.ts
+interface SnapshotSerializer {
+  /**
+   * The file extension associated with the serialized value
+   */
+  readonly fileExtension: string;
+  /**
+   * Returns true when value can be serialized
+   *
+   * @param value The value to be serialized
+   */
+  canSerialize(value: unknown): boolean;
+  /**
+   * Serializes value
+   *
+   * @param value The value to be serialized
+   * @return {string} The serialized value
+   * @throws {Error} Will throw an error if value cannot be serialized.
+   */
+  serialize(value: unknown): string;
+}
+//#endregion
+//#region src/serializers/json-serializer.d.ts
+interface JsonSerializerOptions {
+  /**
+   * Serializes `undefined` properties in objects. By default, they are omitted.
+   *
+   * @default false
+   */
+  includeUndefinedObjectProperties?: boolean;
+  /**
+   * Custom normalizers to apply before serialization
+   */
+  normalizers?: Array<JsonNormalizer>;
+  /**
+   * Indentation size in spaces
+   *
+   * @default 2
+   */
+  indentSize?: number;
+}
+type JsonNormalizer = (value: unknown, context: JsonNormalizerContext) => unknown;
+interface JsonNormalizerContext {
+  key?: string;
+  index?: number;
+}
+declare class JsonSerializer implements SnapshotSerializer {
+  readonly fileExtension = "json";
+  private readonly includeUndefinedObjectProperties;
+  private readonly normalizers;
+  private readonly indentSize;
+  constructor(options?: JsonSerializerOptions);
+  canSerialize(_value: unknown): boolean;
+  serialize(value: unknown): string;
+  private normalizeValueRecursive;
+  private normalizeNumber;
+  private normalizeArray;
+  private normalizeObject;
+  private normalizeDate;
+  private normalizePlainObject;
+  private normalizeMap;
+  private serializedValue;
+  private assertKeyType;
+  private applyCustomNormalizers;
+}
+//#endregion
+//#region src/serializers/text-serializer.d.ts
+interface TextSerializerOptions {
+  /**
+   * Custom normalizers to apply before serialization
+   */
+  normalizers?: Array<TextNormalizer>;
+  /**
+   * File extension used for storing the text file
+   *
+   * @default "txt"
+   */
+  fileExtension?: string;
+}
+type TextNormalizer = (value: string) => string;
+declare class TextSerializer implements SnapshotSerializer {
+  readonly fileExtension: string;
+  private readonly normalizers;
+  constructor(options?: TextSerializerOptions);
+  canSerialize(value: unknown): value is string;
+  serialize(value: unknown): string;
+  private normalizeValue;
+}
+//#endregion
+//#region src/types/matcher.d.ts
+interface ValidationFileMatcherConfig {
+  /**
+   * Directory in which golden masters are stored
+   */
+  validationDir: string;
+  /**
+   * Directory in which file snapshots from test runs are stored
+   */
+  outputDir: string;
+  /**
+   * The full path to the snapshot file
+   *
+   * @example "src/tests/feature/test/when_x_then_y"
+   */
+  filePath: string;
+  /**
+   * The serializer to use for the snapshot
+   */
+  serializer: SnapshotSerializer;
+  /**
+   * Whether to update golden masters with the actual result.
+   *
+   * @default "missing"
+   */
+  updateSnapshots?: UpdateSnapshotsType;
+}
+type UpdateSnapshotsType = "all" | "missing" | "none";
+interface ValidationFileMatcherResult {
+  actual: string;
+  expected: string;
+  outputFilePath: string;
+  validationFilePath: string;
+  message: () => string;
+  writeFileSnapshots: () => void;
+}
+type FilePathResolver = (params: FilePathResolverParams) => string;
+interface FilePathResolverParams {
+  testPath: string;
+  titlePath: Array<string>;
+  name?: string;
+}
+//#endregion
+//#region src/matcher/validation-file-matcher.d.ts
+declare class ValidationFileMatcher {
+  private readonly updateSnapshots;
+  private readonly serializer;
+  private readonly filePaths;
+  private validationFile;
+  constructor(config: ValidationFileMatcherConfig);
+  get isValidationFileMissing(): boolean;
+  get isUpdate(): boolean;
+  matchFileSnapshot(actual: unknown): ValidationFileMatcherResult;
+  private buildFilePaths;
+  private readValidationFile;
+  private createMatcherResult;
+  private writeFileSnapshots;
+  private resolveExpected;
+}
+//#endregion
+//#region src/matcher/file-path-resolver.d.ts
+declare function resolveNameAsFile(params: FilePathResolverParams): string;
+declare function resolveNameAsFileSuffix(params: FilePathResolverParams): string;
+//#endregion
+//#region src/utils/file.d.ts
+declare function normalizeFileName(testName: string): string;
+//#endregion
+//#region src/utils/guards.d.ts
+declare function isString(value: unknown): value is string;
+declare function isArray(value: unknown): value is Array<unknown>;
+type PlainObject = Record<PropertyKey, unknown>;
+declare function isPlainObject(value: unknown): value is PlainObject;
+//#endregion
+export { type FilePathResolver, type FilePathResolverParams, type JsonNormalizer, type JsonNormalizerContext, JsonSerializer, type PlainObject, type SnapshotSerializer, type TextNormalizer, TextSerializer, type UpdateSnapshotsType, ValidationFileMatcher, type ValidationFileMatcherResult, isArray, isPlainObject, isString, normalizeFileName, resolveNameAsFile, resolveNameAsFileSuffix };

package/dist/index.mjs

@@ -0,0 +1,266 @@
+import * as fs$1 from "node:fs";
+import fs from "node:fs";
+import os from "node:os";
+import * as path$1 from "node:path";
+import path from "node:path";
+
+//#region src/utils/file.ts
+const NEW_LINE_SEPARATOR = "\n";
+const EMOJI_REGEXP = /(?!(\*|#|\d))[\p{Extended_Pictographic}\p{Emoji_Component}]|[\u0030-\u0039]\ufe0f?[\u20e3]|[\u002A\u0023]?\ufe0f?[\u20e3]/gu;
+function normalizeFileName(testName) {
+	return testName.replaceAll(EMOJI_REGEXP, "").replaceAll(/[+*%~<>?!$#'"`|\\/()[\]{}]/g, "").replaceAll(/[\s.:,;]+/g, "_").replaceAll(/_{2,}/g, "_");
+}
+function readSnapshotFile(filePath) {
+	const contents = fs.readFileSync(filePath, { encoding: "utf8" });
+	if (os.EOL === NEW_LINE_SEPARATOR) return contents;
+	return contents.replace(new RegExp(os.EOL, "g"), NEW_LINE_SEPARATOR);
+}
+function writeSnapshotFile(filePath, data) {
+	mkdirRecursive(path.dirname(filePath));
+	fs.writeFileSync(filePath, data, { encoding: "utf8" });
+}
+function mkdirRecursive(dirPath) {
+	fs.mkdirSync(dirPath, { recursive: true });
+}
+function addTrailingNewLine(data) {
+	return `${data}${NEW_LINE_SEPARATOR}`;
+}
+function addMissingFileMarker(data) {
+	return `===== missing file =====${NEW_LINE_SEPARATOR}${data}`;
+}
+
+//#endregion
+//#region src/utils/guards.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !isArray(value);
+}
+function isPlainObject(value) {
+	if (!isObject(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+}
+
+//#endregion
+//#region src/utils/validators.ts
+function isPositiveInteger(value) {
+	return Number.isInteger(value) && value > 0;
+}
+
+//#endregion
+//#region src/serializers/json-serializer.ts
+var JsonSerializer = class {
+	fileExtension = "json";
+	includeUndefinedObjectProperties;
+	normalizers;
+	indentSize;
+	constructor(options = {}) {
+		if (options.indentSize !== void 0 && !isPositiveInteger(options.indentSize)) throw new Error("Invalid option indentSize: value must be a positive integer.");
+		this.includeUndefinedObjectProperties = options.includeUndefinedObjectProperties ?? false;
+		this.normalizers = options.normalizers ?? [];
+		this.indentSize = options.indentSize ?? 2;
+	}
+	canSerialize(_value) {
+		return true;
+	}
+	serialize(value) {
+		const jsonValue = this.normalizeValueRecursive(value);
+		return addTrailingNewLine(JSON.stringify(jsonValue, void 0, this.indentSize));
+	}
+	normalizeValueRecursive(value, context) {
+		const customValue = this.applyCustomNormalizers(value, context);
+		if (customValue === void 0) return this.serializedValue("undefined");
+		if (customValue === null || isString(customValue) || typeof customValue === "boolean") return context === void 0 ? this.serializedValue(typeof customValue, { value: customValue }) : customValue;
+		if (typeof customValue === "number") return this.normalizeNumber(customValue);
+		if (typeof customValue === "bigint") return this.serializedValue("bigint", { value: customValue.toString() });
+		if (typeof customValue === "symbol") return this.serializedValue("symbol", { description: customValue.description });
+		if (typeof customValue === "function") return this.serializedValue("function", { name: customValue.name });
+		if (typeof customValue === "object") return this.normalizeObject(customValue);
+		throw new Error(`Missing JSON normalization for value of type ${typeof customValue}.`);
+	}
+	normalizeNumber(value) {
+		if (Number.isNaN(value)) return this.serializedValue("number", { value: "Number.NaN" });
+		switch (value) {
+			case Number.MIN_VALUE: return this.serializedValue("number", { value: "Number.MIN_VALUE" });
+			case Number.MAX_VALUE: return this.serializedValue("number", { value: "Number.MAX_VALUE" });
+			case Number.MIN_SAFE_INTEGER: return this.serializedValue("number", { value: "Number.MIN_SAFE_INTEGER" });
+			case Number.MAX_SAFE_INTEGER: return this.serializedValue("number", { value: "Number.MAX_SAFE_INTEGER" });
+			case Number.NEGATIVE_INFINITY: return this.serializedValue("number", { value: "Number.NEGATIVE_INFINITY" });
+			case Number.POSITIVE_INFINITY: return this.serializedValue("number", { value: "Number.POSITIVE_INFINITY" });
+			default: return value;
+		}
+	}
+	normalizeArray(value) {
+		return value.map((item, index) => this.normalizeValueRecursive(item, { index }));
+	}
+	normalizeObject(value) {
+		if (isArray(value)) return this.normalizeArray(value);
+		if (isPlainObject(value)) return this.normalizePlainObject(value);
+		if (value instanceof Date) return this.normalizeDate(value);
+		if (value instanceof Promise) return this.serializedValue("Promise");
+		if (value instanceof Set) return this.serializedValue("Set", { values: this.normalizeArray(Array.from(value.values())) });
+		if (value instanceof Map) {
+			const mapAsObject = this.normalizeMap(value);
+			return this.serializedValue("Map", { values: this.normalizePlainObject(mapAsObject) });
+		}
+		throw new Error(`Missing JSON normalization for object of type ${Object.getPrototypeOf(value)}`);
+	}
+	normalizeDate(value) {
+		if (Number.isNaN(value.getTime())) return this.serializedValue("Date", { value: "Invalid date" });
+		return this.serializedValue("Date", { value: value.toISOString() });
+	}
+	normalizePlainObject(value) {
+		const normalizedObject = {};
+		for (const [key, propertyValue] of Object.entries(value)) {
+			if (propertyValue === void 0 && !this.includeUndefinedObjectProperties) continue;
+			this.assertKeyType(key);
+			normalizedObject[key] = this.normalizeValueRecursive(propertyValue, { key });
+		}
+		return normalizedObject;
+	}
+	normalizeMap(value) {
+		return Array.from(value.entries()).reduce((object, [key, propertyValue]) => {
+			this.assertKeyType(key);
+			object[key] = propertyValue;
+			return object;
+		}, {});
+	}
+	serializedValue(type, additionalProps = {}) {
+		return {
+			$type: type,
+			...additionalProps
+		};
+	}
+	assertKeyType(key) {
+		if (!isString(key)) throw new Error(`Key of type ${typeof key} cannot be normalized.`);
+	}
+	applyCustomNormalizers(value, context = {}) {
+		let normalizedValue = value;
+		for (const normalizer of this.normalizers) normalizedValue = normalizer(normalizedValue, context);
+		return normalizedValue;
+	}
+};
+
+//#endregion
+//#region src/serializers/text-serializer.ts
+var TextSerializer = class {
+	fileExtension;
+	normalizers;
+	constructor(options = {}) {
+		this.normalizers = options.normalizers ?? [];
+		this.fileExtension = options.fileExtension ?? "txt";
+	}
+	canSerialize(value) {
+		return isString(value);
+	}
+	serialize(value) {
+		if (!this.canSerialize(value)) throw new Error(`Missing text serialization for value of type ${typeof value}.`);
+		return addTrailingNewLine(this.normalizeValue(value));
+	}
+	normalizeValue(value) {
+		let normalizedValue = value;
+		for (const normalizer of this.normalizers) normalizedValue = normalizer(normalizedValue);
+		return normalizedValue.trim();
+	}
+};
+
+//#endregion
+//#region src/matcher/validation-file-matcher.ts
+var ValidationFileMatcher = class {
+	updateSnapshots;
+	serializer;
+	filePaths;
+	validationFile;
+	constructor(config) {
+		this.updateSnapshots = config.updateSnapshots ?? "missing";
+		this.serializer = config.serializer;
+		this.filePaths = this.buildFilePaths(config);
+		this.validationFile = this.readValidationFile();
+	}
+	get isValidationFileMissing() {
+		return this.validationFile === void 0;
+	}
+	get isUpdate() {
+		return this.updateSnapshots === "all" || this.isValidationFileMissing && this.updateSnapshots === "missing";
+	}
+	matchFileSnapshot(actual) {
+		if (!this.serializer.canSerialize(actual)) throw new Error(`Cannot serialize value of type ${typeof actual}`);
+		const serializedActual = this.serializer.serialize(actual);
+		const expected = this.resolveExpected(serializedActual);
+		return this.createMatcherResult({
+			actual: serializedActual,
+			expected
+		});
+	}
+	buildFilePaths(config) {
+		const { validationDir, outputDir, filePath, serializer } = config;
+		const filePathWithExtension = `${filePath}.${serializer.fileExtension}`;
+		return {
+			outputFilePath: path$1.join(outputDir, filePathWithExtension),
+			validationFilePath: path$1.join(validationDir, filePathWithExtension)
+		};
+	}
+	readValidationFile() {
+		const { validationFilePath } = this.filePaths;
+		if (!fs$1.existsSync(validationFilePath)) return;
+		return readSnapshotFile(validationFilePath);
+	}
+	createMatcherResult(params) {
+		const { actual, expected } = params;
+		const { outputFilePath, validationFilePath } = this.filePaths;
+		const isValidationFileMissing = this.isValidationFileMissing;
+		return {
+			actual,
+			expected,
+			outputFilePath,
+			validationFilePath,
+			message: () => isValidationFileMissing ? `Missing validation file '${validationFilePath}'` : `Output file '${outputFilePath}'\ndoes not match validation file '${validationFilePath}'`,
+			writeFileSnapshots: () => this.writeFileSnapshots(params)
+		};
+	}
+	writeFileSnapshots(matcherResult) {
+		const { actual, expected } = matcherResult;
+		const { outputFilePath, validationFilePath } = this.filePaths;
+		writeSnapshotFile(outputFilePath, actual);
+		if (this.isUpdate) {
+			const validationFileData = this.isValidationFileMissing ? expected : actual;
+			writeSnapshotFile(validationFilePath, validationFileData);
+			this.validationFile = validationFileData;
+		}
+	}
+	resolveExpected(actual) {
+		if (this.validationFile === void 0) return addMissingFileMarker(actual);
+		return this.validationFile;
+	}
+};
+
+//#endregion
+//#region src/matcher/file-path-resolver.ts
+function resolveNameAsFile(params) {
+	return resolveFilePath(params, ({ basePath, normalizedName }) => path.join(basePath, normalizedName));
+}
+function resolveNameAsFileSuffix(params) {
+	return resolveFilePath(params, ({ basePath, normalizedName }) => `${basePath}_${normalizedName}`);
+}
+function resolveBasePath(params) {
+	const { testPath, titlePath } = params;
+	const normalizedTitlePath = titlePath.map(normalizeFileName);
+	return path.join(testPath, ...normalizedTitlePath);
+}
+function resolveFilePath(params, resolveNamedFilePath) {
+	const { name, ...baseParams } = params;
+	const basePath = resolveBasePath(baseParams);
+	if (name === void 0) return basePath;
+	return resolveNamedFilePath({
+		basePath,
+		normalizedName: normalizeFileName(name)
+	});
+}
+
+//#endregion
+export { JsonSerializer, TextSerializer, ValidationFileMatcher, isArray, isPlainObject, isString, normalizeFileName, resolveNameAsFile, resolveNameAsFileSuffix };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cronn/lib-file-snapshots",
-  "version": "0.19.0",
+  "version": "1.0.0",
   "description": "The library agnostic core for testing file snapshots",
   "keywords": [
     "file snapshots"
@@ -12,7 +12,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/cronn/file-snapshots.git",
+    "url": "git+https://github.com/cronn/file-snapshots.git",
     "directory": "packages/lib-file-snapshots"
   },
   "homepage": "https://github.com/cronn/file-snapshots",
@@ -35,25 +35,27 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "devDependencies": {
+    "@arethetypeswrong/core": "0.18.2",
     "@trivago/prettier-plugin-sort-imports": "6.0.2",
-    "@types/node": "24.10.9",
-    "@vitest/coverage-v8": "4.0.17",
-    "eslint": "9.39.2",
+    "@typescript/native-preview": "7.0.0-dev.20260218.1",
+    "@types/node": "24.10.13",
+    "@vitest/coverage-v8": "4.0.18",
+    "eslint": "10.0.1",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-unused-imports": "4.3.0",
-    "prettier": "3.8.0",
-    "tsup": "8.5.1",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.53.1",
-    "vitest": "4.0.17",
+    "eslint-plugin-unused-imports": "4.4.1",
+    "prettier": "3.8.1",
+    "publint": "0.3.17",
+    "tsdown": "0.20.3",
+    "typescript-eslint": "8.56.0",
+    "vitest": "4.0.18",
     "@cronn/shared-configs": "0.0.0"
   },
   "scripts": {
@@ -61,7 +63,7 @@
     "lint:fix": "eslint src/ --max-warnings=0 --fix",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "compile": "tsc",
-    "build": "tsup"
+    "compile": "tsgo",
+    "build": "tsdown"
   }
 }

package/dist/index.d.ts

@@ -1,155 +0,0 @@
-interface SnapshotSerializer {
-    /**
-     * The file extension associated with the serialized value
-     */
-    readonly fileExtension: string;
-    /**
-     * Returns true when value can be serialized
-     *
-     * @param value The value to be serialized
-     */
-    canSerialize(value: unknown): boolean;
-    /**
-     * Serializes value
-     *
-     * @param value The value to be serialized
-     * @return {string} The serialized value
-     * @throws {Error} Will throw an error if value cannot be serialized.
-     */
-    serialize(value: unknown): string;
-}
-
-interface JsonSerializerOptions {
-    /**
-     * Serializes `undefined` properties in objects. By default, they are omitted.
-     *
-     * @default false
-     */
-    includeUndefinedObjectProperties?: boolean;
-    /**
-     * Custom normalizers to apply before serialization
-     */
-    normalizers?: Array<JsonNormalizer>;
-    /**
-     * Indentation size in spaces
-     *
-     * @default 2
-     */
-    indentSize?: number;
-}
-type JsonNormalizer = (value: unknown, context: JsonNormalizerContext) => unknown;
-interface JsonNormalizerContext {
-    key?: string;
-    index?: number;
-}
-declare class JsonSerializer implements SnapshotSerializer {
-    readonly fileExtension = "json";
-    private readonly includeUndefinedObjectProperties;
-    private readonly normalizers;
-    private readonly indentSize;
-    constructor(options?: JsonSerializerOptions);
-    canSerialize(_value: unknown): boolean;
-    serialize(value: unknown): string;
-    private normalizeValueRecursive;
-    private normalizeNumber;
-    private normalizeArray;
-    private normalizeObject;
-    private normalizeDate;
-    private normalizePlainObject;
-    private normalizeMap;
-    private serializedValue;
-    private assertKeyType;
-    private applyCustomNormalizers;
-}
-
-interface TextSerializerOptions {
-    /**
-     * Custom normalizers to apply before serialization
-     */
-    normalizers?: Array<TextNormalizer>;
-    /**
-     * File extension used for storing the text file
-     *
-     * @default "txt"
-     */
-    fileExtension?: string;
-}
-type TextNormalizer = (value: string) => string;
-declare class TextSerializer implements SnapshotSerializer {
-    readonly fileExtension: string;
-    private readonly normalizers;
-    constructor(options?: TextSerializerOptions);
-    canSerialize(value: unknown): value is string;
-    serialize(value: unknown): string;
-    private normalizeValue;
-}
-
-interface ValidationFileMatcherConfig {
-    /**
-     * Directory in which golden masters are stored
-     */
-    validationDir: string;
-    /**
-     * Directory in which file snapshots from test runs are stored
-     */
-    outputDir: string;
-    /**
-     * The full path to the snapshot file
-     *
-     * @example "src/tests/feature/test/when_x_then_y"
-     */
-    filePath: string;
-    /**
-     * The serializer to use for the snapshot
-     */
-    serializer: SnapshotSerializer;
-    /**
-     * Whether to update golden masters with the actual result.
-     *
-     * @default "missing"
-     */
-    updateSnapshots?: UpdateSnapshotsType;
-}
-type UpdateSnapshotsType = "all" | "missing" | "none";
-interface ValidationFileMatcherResult {
-    actual: string;
-    expected: string;
-    outputFilePath: string;
-    validationFilePath: string;
-    message: () => string;
-    writeFileSnapshots: () => void;
-}
-type FilePathResolver = (params: FilePathResolverParams) => string;
-interface FilePathResolverParams {
-    testPath: string;
-    titlePath: Array<string>;
-    name?: string;
-}
-
-declare class ValidationFileMatcher {
-    private readonly updateSnapshots;
-    private readonly serializer;
-    private readonly filePaths;
-    private validationFile;
-    constructor(config: ValidationFileMatcherConfig);
-    get isValidationFileMissing(): boolean;
-    get isUpdate(): boolean;
-    matchFileSnapshot(actual: unknown): ValidationFileMatcherResult;
-    private buildFilePaths;
-    private readValidationFile;
-    private createMatcherResult;
-    private writeFileSnapshots;
-    private resolveExpected;
-}
-
-declare function resolveNameAsFile(params: FilePathResolverParams): string;
-declare function resolveNameAsFileSuffix(params: FilePathResolverParams): string;
-
-declare function normalizeFileName(testName: string): string;
-
-declare function isString(value: unknown): value is string;
-declare function isArray(value: unknown): value is Array<unknown>;
-type PlainObject = Record<PropertyKey, unknown>;
-declare function isPlainObject(value: unknown): value is PlainObject;
-
-export { type FilePathResolver, type FilePathResolverParams, type JsonNormalizer, type JsonNormalizerContext, JsonSerializer, type PlainObject, type SnapshotSerializer, type TextNormalizer, TextSerializer, type UpdateSnapshotsType, ValidationFileMatcher, type ValidationFileMatcherResult, isArray, isPlainObject, isString, normalizeFileName, resolveNameAsFile, resolveNameAsFileSuffix };

package/dist/index.js

@@ -1,365 +0,0 @@
-// src/utils/file.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
-var NEW_LINE_SEPARATOR = "\n";
-var EMOJI_REGEXP = /(?!(\*|#|\d))[\p{Extended_Pictographic}\p{Emoji_Component}]|[\u0030-\u0039]\ufe0f?[\u20e3]|[\u002A\u0023]?\ufe0f?[\u20e3]/gu;
-function normalizeFileName(testName) {
-  return testName.replaceAll(EMOJI_REGEXP, "").replaceAll(/[+*%~<>?!$#'"`|\\/()[\]{}]/g, "").replaceAll(/[\s.:,;]+/g, "_").replaceAll(/_{2,}/g, "_");
-}
-function readSnapshotFile(path4) {
-  const contents = fs.readFileSync(path4, { encoding: "utf8" });
-  if (os.EOL === NEW_LINE_SEPARATOR) {
-    return contents;
-  }
-  return contents.replace(new RegExp(os.EOL, "g"), NEW_LINE_SEPARATOR);
-}
-function writeSnapshotFile(file, data) {
-  mkdirRecursive(path.dirname(file));
-  fs.writeFileSync(file, data, { encoding: "utf8" });
-}
-function mkdirRecursive(path4) {
-  fs.mkdirSync(path4, { recursive: true });
-}
-function addTrailingNewLine(data) {
-  return `${data}${NEW_LINE_SEPARATOR}`;
-}
-function addMissingFileMarker(data) {
-  return `===== missing file =====${NEW_LINE_SEPARATOR}${data}`;
-}
-
-// src/utils/guards.ts
-function isString(value) {
-  return typeof value === "string";
-}
-function isArray(value) {
-  return Array.isArray(value);
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null && !isArray(value);
-}
-function isPlainObject(value) {
-  if (!isObject(value)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
-}
-
-// src/utils/validators.ts
-function isPositiveInteger(value) {
-  return Number.isInteger(value) && value > 0;
-}
-
-// src/serializers/json-serializer.ts
-var JsonSerializer = class {
-  fileExtension = "json";
-  includeUndefinedObjectProperties;
-  normalizers;
-  indentSize;
-  constructor(options = {}) {
-    if (options.indentSize !== void 0 && !isPositiveInteger(options.indentSize)) {
-      throw new Error(
-        "Invalid option indentSize: value must be a positive integer."
-      );
-    }
-    this.includeUndefinedObjectProperties = options.includeUndefinedObjectProperties ?? false;
-    this.normalizers = options.normalizers ?? [];
-    this.indentSize = options.indentSize ?? 2;
-  }
-  canSerialize(_value) {
-    return true;
-  }
-  serialize(value) {
-    const jsonValue = this.normalizeValueRecursive(value);
-    const jsonString = JSON.stringify(jsonValue, void 0, this.indentSize);
-    return addTrailingNewLine(jsonString);
-  }
-  normalizeValueRecursive(value, context) {
-    const customValue = this.applyCustomNormalizers(value, context);
-    if (customValue === void 0) {
-      return this.serializedValue("undefined");
-    }
-    if (customValue === null || isString(customValue) || typeof customValue === "boolean") {
-      const isRoot = context === void 0;
-      return isRoot ? this.serializedValue(typeof customValue, {
-        value: customValue
-      }) : customValue;
-    }
-    if (typeof customValue === "number") {
-      return this.normalizeNumber(customValue);
-    }
-    if (typeof customValue === "bigint") {
-      return this.serializedValue("bigint", {
-        value: customValue.toString()
-      });
-    }
-    if (typeof customValue === "symbol") {
-      return this.serializedValue("symbol", {
-        description: customValue.description
-      });
-    }
-    if (typeof customValue === "function") {
-      return this.serializedValue("function", { name: customValue.name });
-    }
-    if (typeof customValue === "object") {
-      return this.normalizeObject(customValue);
-    }
-    throw new Error(
-      `Missing JSON normalization for value of type ${typeof customValue}.`
-    );
-  }
-  normalizeNumber(value) {
-    if (Number.isNaN(value)) {
-      return this.serializedValue("number", { value: "Number.NaN" });
-    }
-    switch (value) {
-      case Number.MIN_VALUE:
-        return this.serializedValue("number", { value: "Number.MIN_VALUE" });
-      case Number.MAX_VALUE:
-        return this.serializedValue("number", { value: "Number.MAX_VALUE" });
-      case Number.MIN_SAFE_INTEGER:
-        return this.serializedValue("number", {
-          value: "Number.MIN_SAFE_INTEGER"
-        });
-      case Number.MAX_SAFE_INTEGER:
-        return this.serializedValue("number", {
-          value: "Number.MAX_SAFE_INTEGER"
-        });
-      case Number.NEGATIVE_INFINITY:
-        return this.serializedValue("number", {
-          value: "Number.NEGATIVE_INFINITY"
-        });
-      case Number.POSITIVE_INFINITY:
-        return this.serializedValue("number", {
-          value: "Number.POSITIVE_INFINITY"
-        });
-      default:
-        return value;
-    }
-  }
-  normalizeArray(value) {
-    return value.map(
-      (item, index) => this.normalizeValueRecursive(item, { index })
-    );
-  }
-  normalizeObject(value) {
-    if (isArray(value)) {
-      return this.normalizeArray(value);
-    }
-    if (isPlainObject(value)) {
-      return this.normalizePlainObject(value);
-    }
-    if (value instanceof Date) {
-      return this.normalizeDate(value);
-    }
-    if (value instanceof Promise) {
-      return this.serializedValue("Promise");
-    }
-    if (value instanceof Set) {
-      return this.serializedValue("Set", {
-        values: this.normalizeArray(Array.from(value.values()))
-      });
-    }
-    if (value instanceof Map) {
-      const mapAsObject = this.normalizeMap(value);
-      return this.serializedValue("Map", {
-        values: this.normalizePlainObject(mapAsObject)
-      });
-    }
-    throw new Error(
-      `Missing JSON normalization for object of type ${Object.getPrototypeOf(value)}`
-    );
-  }
-  normalizeDate(value) {
-    if (Number.isNaN(value.getTime())) {
-      return this.serializedValue("Date", { value: "Invalid date" });
-    }
-    return this.serializedValue("Date", { value: value.toISOString() });
-  }
-  normalizePlainObject(value) {
-    const normalizedObject = {};
-    for (const [key, propertyValue] of Object.entries(value)) {
-      if (propertyValue === void 0 && !this.includeUndefinedObjectProperties) {
-        continue;
-      }
-      this.assertKeyType(key);
-      normalizedObject[key] = this.normalizeValueRecursive(propertyValue, {
-        key
-      });
-    }
-    return normalizedObject;
-  }
-  normalizeMap(value) {
-    return Array.from(value.entries()).reduce(
-      (object, [key, value2]) => {
-        this.assertKeyType(key);
-        object[key] = value2;
-        return object;
-      },
-      {}
-    );
-  }
-  serializedValue(type, additionalProps = {}) {
-    return { $type: type, ...additionalProps };
-  }
-  assertKeyType(key) {
-    if (!isString(key)) {
-      throw new Error(`Key of type ${typeof key} cannot be normalized.`);
-    }
-  }
-  applyCustomNormalizers(value, context = {}) {
-    let normalizedValue = value;
-    for (const normalizer of this.normalizers) {
-      normalizedValue = normalizer(normalizedValue, context);
-    }
-    return normalizedValue;
-  }
-};
-
-// src/serializers/text-serializer.ts
-var TextSerializer = class {
-  fileExtension;
-  normalizers;
-  constructor(options = {}) {
-    this.normalizers = options.normalizers ?? [];
-    this.fileExtension = options.fileExtension ?? "txt";
-  }
-  canSerialize(value) {
-    return isString(value);
-  }
-  serialize(value) {
-    if (!this.canSerialize(value)) {
-      throw new Error(
-        `Missing text serialization for value of type ${typeof value}.`
-      );
-    }
-    const normalizedValue = this.normalizeValue(value);
-    return addTrailingNewLine(normalizedValue);
-  }
-  normalizeValue(value) {
-    let normalizedValue = value;
-    for (const normalizer of this.normalizers) {
-      normalizedValue = normalizer(normalizedValue);
-    }
-    return normalizedValue.trim();
-  }
-};
-
-// src/matcher/validation-file-matcher.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-var ValidationFileMatcher = class {
-  updateSnapshots;
-  serializer;
-  filePaths;
-  validationFile;
-  constructor(config) {
-    this.updateSnapshots = config.updateSnapshots ?? "missing";
-    this.serializer = config.serializer;
-    this.filePaths = this.buildFilePaths(config);
-    this.validationFile = this.readValidationFile();
-  }
-  get isValidationFileMissing() {
-    return this.validationFile === void 0;
-  }
-  get isUpdate() {
-    return this.updateSnapshots === "all" || this.isValidationFileMissing && this.updateSnapshots === "missing";
-  }
-  matchFileSnapshot(actual) {
-    if (!this.serializer.canSerialize(actual)) {
-      throw new Error(`Cannot serialize value of type ${typeof actual}`);
-    }
-    const serializedActual = this.serializer.serialize(actual);
-    const expected = this.resolveExpected(serializedActual);
-    return this.createMatcherResult({
-      actual: serializedActual,
-      expected
-    });
-  }
-  buildFilePaths(config) {
-    const { validationDir, outputDir, filePath, serializer } = config;
-    const filePathWithExtension = `${filePath}.${serializer.fileExtension}`;
-    return {
-      outputFilePath: path2.join(outputDir, filePathWithExtension),
-      validationFilePath: path2.join(validationDir, filePathWithExtension)
-    };
-  }
-  readValidationFile() {
-    const { validationFilePath } = this.filePaths;
-    if (!fs2.existsSync(validationFilePath)) {
-      return void 0;
-    }
-    return readSnapshotFile(validationFilePath);
-  }
-  createMatcherResult(params) {
-    const { actual, expected } = params;
-    const { outputFilePath, validationFilePath } = this.filePaths;
-    const isValidationFileMissing = this.isValidationFileMissing;
-    return {
-      actual,
-      expected,
-      outputFilePath,
-      validationFilePath,
-      message: () => isValidationFileMissing ? `Missing validation file '${validationFilePath}'` : `Output file '${outputFilePath}'
-does not match validation file '${validationFilePath}'`,
-      writeFileSnapshots: () => this.writeFileSnapshots(params)
-    };
-  }
-  writeFileSnapshots(matcherResult) {
-    const { actual, expected } = matcherResult;
-    const { outputFilePath, validationFilePath } = this.filePaths;
-    writeSnapshotFile(outputFilePath, actual);
-    if (this.isUpdate) {
-      const validationFileData = this.isValidationFileMissing ? expected : actual;
-      writeSnapshotFile(validationFilePath, validationFileData);
-      this.validationFile = validationFileData;
-    }
-  }
-  resolveExpected(actual) {
-    if (this.validationFile === void 0) {
-      return addMissingFileMarker(actual);
-    }
-    return this.validationFile;
-  }
-};
-
-// src/matcher/file-path-resolver.ts
-import path3 from "path";
-function resolveNameAsFile(params) {
-  return resolveFilePath(
-    params,
-    ({ basePath, normalizedName }) => path3.join(basePath, normalizedName)
-  );
-}
-function resolveNameAsFileSuffix(params) {
-  return resolveFilePath(
-    params,
-    ({ basePath, normalizedName }) => `${basePath}_${normalizedName}`
-  );
-}
-function resolveBasePath(params) {
-  const { testPath, titlePath } = params;
-  const normalizedTitlePath = titlePath.map(normalizeFileName);
-  return path3.join(testPath, ...normalizedTitlePath);
-}
-function resolveFilePath(params, resolveNamedFilePath) {
-  const { name, ...baseParams } = params;
-  const basePath = resolveBasePath(baseParams);
-  if (name === void 0) {
-    return basePath;
-  }
-  const normalizedName = normalizeFileName(name);
-  return resolveNamedFilePath({ basePath, normalizedName });
-}
-export {
-  JsonSerializer,
-  TextSerializer,
-  ValidationFileMatcher,
-  isArray,
-  isPlainObject,
-  isString,
-  normalizeFileName,
-  resolveNameAsFile,
-  resolveNameAsFileSuffix
-};