@saykit/config 0.0.0 → 0.1.0

package/dist/features/messages/index.cjs

@@ -0,0 +1,100 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hash = require("../../hash-CDfMT76E.cjs");
+//#region src/features/messages/identifier.ts
+const AUTO_INCREMENT_IDENTIFIER = Symbol("auto-increment");
+function assignSequenceIdentifiers(message, sequence = { current: 0 }) {
+	if (message instanceof ArgumentMessage || message instanceof ElementMessage || message instanceof ChoiceMessage) {
+		if (message.identifier === AUTO_INCREMENT_IDENTIFIER) message.identifier = `${sequence.current++}`;
+	}
+	if (message instanceof CompositeMessage || message instanceof ElementMessage) for (const child of message.children) assignSequenceIdentifiers(child, sequence);
+	if (message instanceof ChoiceMessage) for (const branch of message.branches) {
+		if (branch.identifier === AUTO_INCREMENT_IDENTIFIER) branch.identifier = `${sequence.current++}`;
+		assignSequenceIdentifiers(branch.value, sequence);
+	}
+}
+//#endregion
+//#region src/features/messages/types.ts
+var Base = class {
+	toICUString() {
+		return convertMessageToIcu(this);
+	}
+	toHashString() {
+		const context = this instanceof CompositeMessage ? this.descriptor.context : void 0;
+		return require_hash.generateHash(this.toICUString(), context);
+	}
+};
+var LiteralMessage = class extends Base {
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+};
+var ArgumentMessage = class extends Base {
+	constructor(identifier, expression) {
+		super();
+		this.identifier = identifier;
+		this.expression = expression;
+	}
+};
+var ElementMessage = class extends Base {
+	constructor(identifier, children, expression) {
+		super();
+		this.identifier = identifier;
+		this.children = children;
+		this.expression = expression;
+	}
+};
+var ChoiceMessage = class extends Base {
+	constructor(kind, identifier, branches, expression) {
+		super();
+		this.kind = kind;
+		this.identifier = identifier;
+		this.branches = branches;
+		this.expression = expression;
+	}
+};
+var CompositeMessage = class extends Base {
+	constructor(descriptor, comments, references, children, accessor) {
+		super();
+		this.descriptor = descriptor;
+		this.comments = comments;
+		this.references = references;
+		this.children = children;
+		this.accessor = accessor;
+	}
+};
+//#endregion
+//#region src/features/messages/convert.ts
+function convertMessageToIcu(message) {
+	function internalConvertMessageToIcu(message) {
+		switch (true) {
+			case message instanceof LiteralMessage: return String(message.text);
+			case message instanceof ArgumentMessage: return `{${String(message.identifier)}}`;
+			case message instanceof ElementMessage: {
+				const children = message.children.map((m) => internalConvertMessageToIcu(m)).join("");
+				return `<${String(message.identifier)}>${children}</${String(message.identifier)}>`;
+			}
+			case message instanceof ChoiceMessage: {
+				const branches = message.branches.map(({ identifier, value }) => ({
+					identifier: Number.isNaN(+String(identifier)) ? String(identifier) : `=${+String(identifier)}`,
+					value: internalConvertMessageToIcu(value)
+				})).map(({ identifier, value }) => `  ${identifier} {${value}}\n`).join("");
+				const format = message.kind === "ordinal" ? "selectordinal" : message.kind;
+				return `{${String(message.identifier)}, ${format},\n${branches}}`;
+			}
+			case message instanceof CompositeMessage: return Object.entries(message.children).map(([, m]) => internalConvertMessageToIcu(m)).join("");
+			default: throw new Error("Unknown message type", { cause: message });
+		}
+	}
+	return internalConvertMessageToIcu(message).trim();
+}
+//#endregion
+exports.AUTO_INCREMENT_IDENTIFIER = AUTO_INCREMENT_IDENTIFIER;
+exports.ArgumentMessage = ArgumentMessage;
+exports.ChoiceMessage = ChoiceMessage;
+exports.CompositeMessage = CompositeMessage;
+exports.ElementMessage = ElementMessage;
+exports.LiteralMessage = LiteralMessage;
+exports.assignSequenceIdentifiers = assignSequenceIdentifiers;
+exports.convertMessageToIcu = convertMessageToIcu;
+exports.generateHash = require_hash.generateHash;

package/dist/features/messages/index.d.cts

@@ -0,0 +1,62 @@
+//#region src/features/messages/identifier.d.ts
+declare const AUTO_INCREMENT_IDENTIFIER: unique symbol;
+declare function assignSequenceIdentifiers(message: Message, sequence?: {
+  current: number;
+}): void;
+//#endregion
+//#region src/features/messages/types.d.ts
+declare abstract class Base {
+  toICUString(this: Message): string;
+  toHashString(this: Message): string;
+}
+declare class LiteralMessage extends Base {
+  readonly text: string;
+  constructor(text: string);
+}
+declare class ArgumentMessage extends Base {
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly expression: any;
+  constructor(identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, expression: any);
+}
+declare class ElementMessage extends Base {
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly children: Message[];
+  readonly expression: any;
+  constructor(identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, children: Message[], expression: any);
+}
+declare class ChoiceMessage extends Base {
+  readonly kind: string;
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly branches: {
+    identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+    readonly value: Message;
+  }[];
+  readonly expression: any;
+  constructor(kind: string, identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, branches: {
+    identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+    readonly value: Message;
+  }[], expression: any);
+}
+declare class CompositeMessage extends Base {
+  readonly descriptor: {
+    id?: string;
+    context?: string;
+  };
+  readonly comments: string[];
+  readonly references: string[];
+  readonly children: Message[];
+  readonly accessor: any;
+  constructor(descriptor: {
+    id?: string;
+    context?: string;
+  }, comments: string[], references: string[], children: Message[], accessor: any);
+}
+type Message = LiteralMessage | ArgumentMessage | ElementMessage | ChoiceMessage | CompositeMessage;
+//#endregion
+//#region src/features/messages/convert.d.ts
+declare function convertMessageToIcu(message: Message): string;
+//#endregion
+//#region src/features/messages/hash.d.ts
+declare function generateHash(input: string, context?: string): string;
+//#endregion
+export { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, assignSequenceIdentifiers, convertMessageToIcu, generateHash };

package/dist/features/messages/index.d.mts

@@ -0,0 +1,62 @@
+//#region src/features/messages/identifier.d.ts
+declare const AUTO_INCREMENT_IDENTIFIER: unique symbol;
+declare function assignSequenceIdentifiers(message: Message, sequence?: {
+  current: number;
+}): void;
+//#endregion
+//#region src/features/messages/types.d.ts
+declare abstract class Base {
+  toICUString(this: Message): string;
+  toHashString(this: Message): string;
+}
+declare class LiteralMessage extends Base {
+  readonly text: string;
+  constructor(text: string);
+}
+declare class ArgumentMessage extends Base {
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly expression: any;
+  constructor(identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, expression: any);
+}
+declare class ElementMessage extends Base {
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly children: Message[];
+  readonly expression: any;
+  constructor(identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, children: Message[], expression: any);
+}
+declare class ChoiceMessage extends Base {
+  readonly kind: string;
+  identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+  readonly branches: {
+    identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+    readonly value: Message;
+  }[];
+  readonly expression: any;
+  constructor(kind: string, identifier: string | typeof AUTO_INCREMENT_IDENTIFIER, branches: {
+    identifier: string | typeof AUTO_INCREMENT_IDENTIFIER;
+    readonly value: Message;
+  }[], expression: any);
+}
+declare class CompositeMessage extends Base {
+  readonly descriptor: {
+    id?: string;
+    context?: string;
+  };
+  readonly comments: string[];
+  readonly references: string[];
+  readonly children: Message[];
+  readonly accessor: any;
+  constructor(descriptor: {
+    id?: string;
+    context?: string;
+  }, comments: string[], references: string[], children: Message[], accessor: any);
+}
+type Message = LiteralMessage | ArgumentMessage | ElementMessage | ChoiceMessage | CompositeMessage;
+//#endregion
+//#region src/features/messages/convert.d.ts
+declare function convertMessageToIcu(message: Message): string;
+//#endregion
+//#region src/features/messages/hash.d.ts
+declare function generateHash(input: string, context?: string): string;
+//#endregion
+export { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, Message, assignSequenceIdentifiers, convertMessageToIcu, generateHash };

package/dist/features/messages/index.mjs

@@ -0,0 +1,91 @@
+import { t as generateHash } from "../../hash-Cs0dRdGf.mjs";
+//#region src/features/messages/identifier.ts
+const AUTO_INCREMENT_IDENTIFIER = Symbol("auto-increment");
+function assignSequenceIdentifiers(message, sequence = { current: 0 }) {
+	if (message instanceof ArgumentMessage || message instanceof ElementMessage || message instanceof ChoiceMessage) {
+		if (message.identifier === AUTO_INCREMENT_IDENTIFIER) message.identifier = `${sequence.current++}`;
+	}
+	if (message instanceof CompositeMessage || message instanceof ElementMessage) for (const child of message.children) assignSequenceIdentifiers(child, sequence);
+	if (message instanceof ChoiceMessage) for (const branch of message.branches) {
+		if (branch.identifier === AUTO_INCREMENT_IDENTIFIER) branch.identifier = `${sequence.current++}`;
+		assignSequenceIdentifiers(branch.value, sequence);
+	}
+}
+//#endregion
+//#region src/features/messages/types.ts
+var Base = class {
+	toICUString() {
+		return convertMessageToIcu(this);
+	}
+	toHashString() {
+		const context = this instanceof CompositeMessage ? this.descriptor.context : void 0;
+		return generateHash(this.toICUString(), context);
+	}
+};
+var LiteralMessage = class extends Base {
+	constructor(text) {
+		super();
+		this.text = text;
+	}
+};
+var ArgumentMessage = class extends Base {
+	constructor(identifier, expression) {
+		super();
+		this.identifier = identifier;
+		this.expression = expression;
+	}
+};
+var ElementMessage = class extends Base {
+	constructor(identifier, children, expression) {
+		super();
+		this.identifier = identifier;
+		this.children = children;
+		this.expression = expression;
+	}
+};
+var ChoiceMessage = class extends Base {
+	constructor(kind, identifier, branches, expression) {
+		super();
+		this.kind = kind;
+		this.identifier = identifier;
+		this.branches = branches;
+		this.expression = expression;
+	}
+};
+var CompositeMessage = class extends Base {
+	constructor(descriptor, comments, references, children, accessor) {
+		super();
+		this.descriptor = descriptor;
+		this.comments = comments;
+		this.references = references;
+		this.children = children;
+		this.accessor = accessor;
+	}
+};
+//#endregion
+//#region src/features/messages/convert.ts
+function convertMessageToIcu(message) {
+	function internalConvertMessageToIcu(message) {
+		switch (true) {
+			case message instanceof LiteralMessage: return String(message.text);
+			case message instanceof ArgumentMessage: return `{${String(message.identifier)}}`;
+			case message instanceof ElementMessage: {
+				const children = message.children.map((m) => internalConvertMessageToIcu(m)).join("");
+				return `<${String(message.identifier)}>${children}</${String(message.identifier)}>`;
+			}
+			case message instanceof ChoiceMessage: {
+				const branches = message.branches.map(({ identifier, value }) => ({
+					identifier: Number.isNaN(+String(identifier)) ? String(identifier) : `=${+String(identifier)}`,
+					value: internalConvertMessageToIcu(value)
+				})).map(({ identifier, value }) => `  ${identifier} {${value}}\n`).join("");
+				const format = message.kind === "ordinal" ? "selectordinal" : message.kind;
+				return `{${String(message.identifier)}, ${format},\n${branches}}`;
+			}
+			case message instanceof CompositeMessage: return Object.entries(message.children).map(([, m]) => internalConvertMessageToIcu(m)).join("");
+			default: throw new Error("Unknown message type", { cause: message });
+		}
+	}
+	return internalConvertMessageToIcu(message).trim();
+}
+//#endregion
+export { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, assignSequenceIdentifiers, convertMessageToIcu, generateHash };

package/dist/hash-CDfMT76E.cjs

@@ -0,0 +1,17 @@
+require("./index.cjs");
+let js_sha256 = require("js-sha256");
+//#region src/features/messages/hash.ts
+function generateHash(input, context) {
+	const hasher = js_sha256.sha256.create();
+	hasher.update(`${input}\u{001F}${context || ""}`);
+	const elements = hasher.toString().match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) || [];
+	const bytes = Uint8Array.from(elements);
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "").slice(0, 6);
+}
+//#endregion
+Object.defineProperty(exports, "generateHash", {
+	enumerable: true,
+	get: function() {
+		return generateHash;
+	}
+});

package/dist/hash-Cs0dRdGf.mjs

@@ -0,0 +1,11 @@
+import { sha256 } from "js-sha256";
+//#region src/features/messages/hash.ts
+function generateHash(input, context) {
+	const hasher = sha256.create();
+	hasher.update(`${input}\u{001F}${context || ""}`);
+	const elements = hasher.toString().match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) || [];
+	const bytes = Uint8Array.from(elements);
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "").slice(0, 6);
+}
+//#endregion
+export { generateHash as t };

package/dist/index.cjs

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch, 1);
+let zod = require("zod");
+zod = __toESM(zod, 1);
+zod.object({
+	message: zod.string(),
+	translation: zod.string().optional(),
+	id: zod.string().optional(),
+	context: zod.string().optional(),
+	comments: zod.string().array(),
+	references: zod.string().array()
+});
+const Formatter = zod.object({
+	extension: zod.templateLiteral([".", zod.string()]),
+	parse: zod.custom((v) => typeof v === "function"),
+	stringify: zod.custom((v) => typeof v === "function")
+});
+const Transformer = zod.object({
+	match: zod.custom((v) => typeof v === "function"),
+	extract: zod.custom((v) => typeof v === "function"),
+	transform: zod.custom((v) => typeof v === "function")
+});
+const Bucket = zod.object({
+	include: zod.string().array(),
+	exclude: zod.string().array().optional(),
+	output: zod.templateLiteral([
+		zod.string(),
+		"{locale}",
+		zod.string(),
+		".{extension}"
+	]),
+	formatter: Formatter,
+	transformer: Transformer.transform((t) => [t]).or(Transformer.array()).transform((t) => ({
+		match: (id) => t.some((t) => t.match(id)),
+		extract: (code, id) => t.flatMap((t) => t.match(id) ? t.extract(code, id) : []),
+		transform: (code, id) => t.reduce((p, t) => t.match(id) ? t.transform(p, id) : p, code)
+	}))
+}).transform((v) => ({
+	...v,
+	match: (0, picomatch.default)(v.include, { ignore: v.exclude }),
+	output: Object.assign(v.output, { match: (0, picomatch.default)(v.output.replace("{locale}", "*").replace("{extension}", v.formatter.extension.slice(1))) })
+}));
+const Config = zod.object({
+	locales: zod.tuple([zod.string()], zod.string()),
+	buckets: Bucket.array()
+});
+//#endregion
+//#region src/index.ts
+function defineConfig(config) {
+	return Config.parse(config);
+}
+//#endregion
+exports.__toESM = __toESM;
+exports.defineConfig = defineConfig;

package/dist/index.d.cts

@@ -0,0 +1,38 @@
+import { a as Transformer, i as Message, n as Config, r as Formatter, t as Bucket } from "./shapes-CJyTfZXd.cjs";
+import { input } from "zod";
+import * as _$picomatch_lib_picomatch_js0 from "picomatch/lib/picomatch.js";
+
+//#region src/index.d.ts
+declare function defineConfig<C extends input<typeof Config>>(config: C): {
+  locales: [string, ...string[]];
+  buckets: {
+    match: (id: string) => boolean;
+    output: `${string}{locale}${string}.{extension}` & {
+      match: _$picomatch_lib_picomatch_js0.Matcher;
+    };
+    include: string[];
+    formatter: {
+      extension: `.${string}`;
+      parse: (content: string) => Message[];
+      stringify: (messages: Message[], context: {
+        locale: string;
+        existingContent?: string;
+      }) => string;
+    };
+    transformer: {
+      match: (id: string) => boolean;
+      extract: (code: string, id: string) => {
+        message: string;
+        comments: string[];
+        references: string[];
+        translation?: string | undefined;
+        id?: string | undefined;
+        context?: string | undefined;
+      }[];
+      transform: (code: string, id: string) => string;
+    };
+    exclude?: string[] | undefined;
+  }[];
+};
+//#endregion
+export { Bucket, Config, Formatter, Message, Transformer, defineConfig };

package/dist/index.d.mts

@@ -0,0 +1,38 @@
+import { a as Transformer, i as Message, n as Config, r as Formatter, t as Bucket } from "./shapes-DETrtvZf.mjs";
+import { input } from "zod";
+import * as _$picomatch_lib_picomatch_js0 from "picomatch/lib/picomatch.js";
+
+//#region src/index.d.ts
+declare function defineConfig<C extends input<typeof Config>>(config: C): {
+  locales: [string, ...string[]];
+  buckets: {
+    match: (id: string) => boolean;
+    output: `${string}{locale}${string}.{extension}` & {
+      match: _$picomatch_lib_picomatch_js0.Matcher;
+    };
+    include: string[];
+    formatter: {
+      extension: `.${string}`;
+      parse: (content: string) => Message[];
+      stringify: (messages: Message[], context: {
+        locale: string;
+        existingContent?: string;
+      }) => string;
+    };
+    transformer: {
+      match: (id: string) => boolean;
+      extract: (code: string, id: string) => {
+        message: string;
+        comments: string[];
+        references: string[];
+        translation?: string | undefined;
+        id?: string | undefined;
+        context?: string | undefined;
+      }[];
+      transform: (code: string, id: string) => string;
+    };
+    exclude?: string[] | undefined;
+  }[];
+};
+//#endregion
+export { Bucket, Config, Formatter, Message, Transformer, defineConfig };

package/dist/index.mjs

@@ -0,0 +1,51 @@
+import picomatch from "picomatch";
+import * as z from "zod";
+z.object({
+	message: z.string(),
+	translation: z.string().optional(),
+	id: z.string().optional(),
+	context: z.string().optional(),
+	comments: z.string().array(),
+	references: z.string().array()
+});
+const Formatter = z.object({
+	extension: z.templateLiteral([".", z.string()]),
+	parse: z.custom((v) => typeof v === "function"),
+	stringify: z.custom((v) => typeof v === "function")
+});
+const Transformer = z.object({
+	match: z.custom((v) => typeof v === "function"),
+	extract: z.custom((v) => typeof v === "function"),
+	transform: z.custom((v) => typeof v === "function")
+});
+const Bucket = z.object({
+	include: z.string().array(),
+	exclude: z.string().array().optional(),
+	output: z.templateLiteral([
+		z.string(),
+		"{locale}",
+		z.string(),
+		".{extension}"
+	]),
+	formatter: Formatter,
+	transformer: Transformer.transform((t) => [t]).or(Transformer.array()).transform((t) => ({
+		match: (id) => t.some((t) => t.match(id)),
+		extract: (code, id) => t.flatMap((t) => t.match(id) ? t.extract(code, id) : []),
+		transform: (code, id) => t.reduce((p, t) => t.match(id) ? t.transform(p, id) : p, code)
+	}))
+}).transform((v) => ({
+	...v,
+	match: picomatch(v.include, { ignore: v.exclude }),
+	output: Object.assign(v.output, { match: picomatch(v.output.replace("{locale}", "*").replace("{extension}", v.formatter.extension.slice(1))) })
+}));
+const Config = z.object({
+	locales: z.tuple([z.string()], z.string()),
+	buckets: Bucket.array()
+});
+//#endregion
+//#region src/index.ts
+function defineConfig(config) {
+	return Config.parse(config);
+}
+//#endregion
+export { defineConfig };

package/dist/loader-CGuahnrc.mjs

@@ -0,0 +1,115 @@
+import { createRequire } from "node:module";
+import { dirname, extname, join, parse } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+//#region src/features/loader/files.ts
+const SUPPORTED_CONFIG_FILES = [
+	"saykit.config.js",
+	"saykit.config.cjs",
+	"saykit.config.mjs",
+	"saykit.config.ts",
+	"saykit.config.mts",
+	"saykit.config.cts"
+];
+function getConfigFileCandidates(name) {
+	return SUPPORTED_CONFIG_FILES.map((file) => file.replace("saykit", name));
+}
+function findConfigFile(moduleName, projectDir) {
+	for (const fileName of getConfigFileCandidates(moduleName)) {
+		const id = join(projectDir, fileName);
+		if (existsSync(id)) return { id };
+	}
+	return null;
+}
+//#endregion
+//#region src/features/loader/module.ts
+function findNearestTsConfig(fromPath) {
+	let dir = dirname(fromPath);
+	const { root } = parse(dir);
+	while (true) {
+		const candidate = join(dir, "tsconfig.json");
+		if (existsSync(candidate)) return candidate;
+		if (dir === root) return null;
+		dir = dirname(dir);
+	}
+}
+function findCacheDir(fromPath) {
+	let dir = dirname(fromPath);
+	const { root } = parse(dir);
+	while (true) {
+		const nm = join(dir, "node_modules");
+		if (existsSync(nm)) return join(nm, ".cache", "saykit", "config");
+		if (dir === root) return join(tmpdir(), "saykit", "config");
+		dir = dirname(dir);
+	}
+}
+function transpile(path, tsConfigPath, require) {
+	const ts = require("typescript");
+	const { config: tsConfig, error } = tsConfigPath ? ts.readConfigFile(tsConfigPath, ts.sys.readFile) : {
+		config: {},
+		error: null
+	};
+	if (error) throw error;
+	tsConfig.compilerOptions = {
+		...tsConfig.compilerOptions,
+		allowJs: true,
+		esModuleInterop: true,
+		module: ts.ModuleKind.CommonJS,
+		moduleResolution: ts.ModuleResolutionKind.NodeJs,
+		target: ts.ScriptTarget.ES2022,
+		noEmit: false
+	};
+	return ts.transpileModule(readFileSync(path, "utf8"), tsConfig).outputText;
+}
+function loadWithCache(path) {
+	const require = createRequire(path);
+	const mtimeMs = statSync(path).mtimeMs;
+	const tsConfigPath = findNearestTsConfig(path);
+	const tsConfigMtimeMs = tsConfigPath ? statSync(tsConfigPath).mtimeMs : 0;
+	const hash = createHash("sha1").update(`${path}\0${tsConfigPath ?? ""}\0${tsConfigMtimeMs}`).digest("hex").slice(0, 16);
+	const cacheDir = findCacheDir(path);
+	const cachePath = join(cacheDir, `${hash}.${mtimeMs}.cjs`);
+	try {
+		if (!existsSync(cachePath)) {
+			mkdirSync(cacheDir, { recursive: true });
+			writeFileSync(cachePath, transpile(path, tsConfigPath, require));
+			if (existsSync(cacheDir)) {
+				for (const entry of readdirSync(cacheDir)) if (entry.startsWith(`${hash}.`) && entry !== `${hash}.${mtimeMs}.cjs`) try {
+					unlinkSync(join(cacheDir, entry));
+				} catch {}
+			}
+		}
+		const resolved = require.resolve(cachePath);
+		delete require.cache[resolved];
+		const module = require(cachePath);
+		delete require.cache[resolved];
+		return module?.default ?? module;
+	} catch (error) {
+		throw new Error("Failed to import module", { cause: error });
+	}
+}
+const js = (path) => loadWithCache(path);
+const ts = (path) => loadWithCache(path);
+const configLoaders = Object.freeze({
+	".js": js,
+	".mjs": js,
+	".cjs": js,
+	".ts": ts,
+	".mts": ts,
+	".cts": ts
+});
+//#endregion
+//#region src/features/loader/resolve.ts
+function resolveConfig(name = "saykit") {
+	const file = findConfigFile(name, process.cwd());
+	if (!file) throw new Error(`Could not find config file for "${name}"`);
+	const ext = extname(file.id).toLowerCase();
+	const load = ext in configLoaders ? configLoaders[ext] : null;
+	if (!load) throw new Error(`Unsupported config file type "${ext}" for "${name}"`);
+	const config = load(file.id);
+	if (!config || typeof config !== "object") throw new Error(`Invalid config file for "${name}"`);
+	return config;
+}
+//#endregion
+export { resolveConfig as t };