@e-n-v/env 0.0.2 → 0.0.4

package/dist/resolveChannel-CjAuxy3p.cjs

@@ -0,0 +1,257 @@
+const require_chunk = require('./chunk-pbleEpgJ.cjs');
+const require_EnvSource = require('./EnvSource-BVnmdHku.cjs');
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_chunk.__toESM(node_fs_promises);
+let fs = require("fs");
+fs = require_chunk.__toESM(fs);
+
+//#region ../channels/src/channels/default/DefaultEnvChannel.ts
+/**
+* Default implementation of EnvChannel that works with .env files using envrw
+*/
+var DefaultEnvChannel = class {
+	envSource;
+	/**
+	* Create a new DefaultEnvChannel
+	* @param filePath - Path to the .env file to manage
+	*/
+	constructor(filePath) {
+		this.envSource = new require_EnvSource.EnvSource(filePath);
+	}
+	/**
+	* Get all environment variables
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		return await this.envSource.read();
+	}
+	/**
+	* Set multiple environment variables
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		await this.envSource.write(values);
+	}
+};
+
+//#endregion
+//#region ../channels/src/channels/dotenv/DotEnvChannel.ts
+function isFileNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function normalizeParsed(parsed) {
+	if (!parsed) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(parsed)) {
+		if (typeof value === "undefined") continue;
+		result[key] = value;
+	}
+	return result;
+}
+var DotEnvChannel = class {
+	dotenv;
+	targetPath;
+	absolutePath;
+	encoding;
+	parseOptions;
+	envSource;
+	constructor(dotenv, defaultPath = ".env", getOptions = {}, parseOptions = {}) {
+		this.dotenv = dotenv;
+		this.targetPath = (typeof getOptions.path === "string" ? getOptions.path : void 0) ?? defaultPath;
+		this.absolutePath = (0, node_path.resolve)(process.cwd(), this.targetPath);
+		this.encoding = getOptions.encoding ?? "utf8";
+		this.parseOptions = { ...parseOptions };
+		this.envSource = new require_EnvSource.EnvSource(this.targetPath);
+	}
+	async get() {
+		try {
+			const content = await (0, node_fs_promises.readFile)(this.absolutePath, { encoding: this.encoding });
+			return normalizeParsed(this.dotenv.parse(content, this.parseOptions));
+		} catch (error) {
+			if (isFileNotFound(error)) return {};
+			throw error;
+		}
+	}
+	async set(values) {
+		await this.envSource.write(values);
+		const parsed = await this.get();
+		const mismatches = [];
+		for (const [key, expected] of Object.entries(values)) {
+			const actual = parsed[key];
+			if (actual !== expected) mismatches.push(`${key}=expected(${JSON.stringify(expected)}) actual(${JSON.stringify(actual)})`);
+		}
+		if (mismatches.length > 0) throw new Error(`Failed to correctly write values to ${this.targetPath}: ${mismatches.join(", ")}`);
+	}
+	getPrimaryPath() {
+		return this.targetPath;
+	}
+	clearCache() {}
+};
+
+//#endregion
+//#region ../channels/src/channels/dotenvx/DotEnvXChannel.ts
+/**
+* Simple DotEnvX implementation of EnvChannel that wraps @dotenvx/dotenvx library
+* This is just an API mapping wrapper without caching or complex state management
+*/
+var DotEnvXChannel = class {
+	dotenvx;
+	getOptions;
+	setOptions;
+	defaultPath;
+	/**
+	* Create a new DotEnvXChannel
+	* @param dotenvx - The dotenvx instance to use
+	* @param defaultPath - Default path for env files
+	* @param getOptions - Options for get operations
+	* @param setOptions - Options for set operations
+	*/
+	constructor(dotenvx, defaultPath = ".env", getOptions = {}, setOptions = {}) {
+		this.dotenvx = dotenvx;
+		this.defaultPath = defaultPath;
+		this.getOptions = getOptions;
+		this.setOptions = setOptions;
+	}
+	/**
+	* Get all environment variables
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		try {
+			return this.dotenvx.config({
+				processEnv: {},
+				quiet: true,
+				ignore: ["MISSING_ENV_FILE"],
+				path: this.defaultPath,
+				...this.getOptions
+			}).parsed || {};
+		} catch {
+			return {};
+		}
+	}
+	/**
+	* Set multiple environment variables
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		if (!(0, fs.existsSync)(this.defaultPath)) (0, fs.writeFileSync)(this.defaultPath, "", "utf8");
+		try {
+			const options = {
+				path: this.defaultPath,
+				...this.setOptions
+			};
+			for (const [key, value] of Object.entries(values)) this.dotenvx.set(key, value, options);
+		} catch (error) {
+			throw new Error(`Failed to set environment variables: ${error}`);
+		}
+	}
+	/**
+	* Get the primary path being used for env files
+	* @returns The primary path
+	*/
+	getPrimaryPath() {
+		return this.defaultPath;
+	}
+	/**
+	* Clear any cached data (no-op for this implementation since we don't cache)
+	*/
+	clearCache() {}
+};
+
+//#endregion
+//#region ../channels/src/channels/processenv/ProcessEnvChannel.ts
+/**
+* EnvChannel implementation that works with process.env
+* This channel reads from and writes to the current process environment
+*/
+var ProcessEnvChannel = class {
+	/**
+	* Get all environment variables from process.env
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		const env = {};
+		for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
+		return env;
+	}
+	/**
+	* Set multiple environment variables in process.env
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		for (const [key, value] of Object.entries(values)) process.env[key] = value;
+	}
+};
+
+//#endregion
+//#region ../channels/src/resolveChannel.ts
+/**
+* Resolve channel options into an EnvChannel instance
+* @param options - The channel options to resolve
+* @param defaultPath - Default path to use for env files (default: ".env")
+* @returns An EnvChannel instance
+*/
+function resolveChannel(options, defaultPath = ".env") {
+	if (options === void 0 || options === "default") return new DefaultEnvChannel(defaultPath);
+	if (options === "processenv") return new ProcessEnvChannel();
+	if (typeof options === "object" && options !== null) {
+		if ("dotenv" in options) {
+			const { dotenv, get: getOptions = {}, parse: parseOptions = {}, path } = options;
+			if (!dotenv) throw new Error("Dotenv instance is required for dotenv channel");
+			const resolvedPath = path ?? defaultPath;
+			const mergedGetOptions = { ...getOptions };
+			if (typeof mergedGetOptions.path !== "string") mergedGetOptions.path = resolvedPath;
+			return new DotEnvChannel(dotenv, resolvedPath, mergedGetOptions, parseOptions ?? {});
+		}
+		if ("dotenvx" in options) {
+			const { dotenvx, get: getOptions = {}, set: setOptions = {} } = options;
+			if (!dotenvx) throw new Error("DotEnvX instance is required for dotenvx channel");
+			return new DotEnvXChannel(dotenvx, defaultPath, getOptions, setOptions);
+		}
+		if ("process" in options) {
+			if (options.process && typeof options.process === "object" && "env" in options.process) return new ProcessEnvChannel();
+			throw new Error("Invalid process object provided to channel config");
+		}
+		if ("name" in options) if (options.name === "default") return new DefaultEnvChannel(defaultPath);
+		else if (options.name === "processenv") return new ProcessEnvChannel();
+		else throw new Error(`Unknown channel name: ${options.name}`);
+	}
+	throw new Error(`Invalid channel options: ${options}`);
+}
+
+//#endregion
+Object.defineProperty(exports, 'DefaultEnvChannel', {
+  enumerable: true,
+  get: function () {
+    return DefaultEnvChannel;
+  }
+});
+Object.defineProperty(exports, 'DotEnvChannel', {
+  enumerable: true,
+  get: function () {
+    return DotEnvChannel;
+  }
+});
+Object.defineProperty(exports, 'DotEnvXChannel', {
+  enumerable: true,
+  get: function () {
+    return DotEnvXChannel;
+  }
+});
+Object.defineProperty(exports, 'ProcessEnvChannel', {
+  enumerable: true,
+  get: function () {
+    return ProcessEnvChannel;
+  }
+});
+Object.defineProperty(exports, 'resolveChannel', {
+  enumerable: true,
+  get: function () {
+    return resolveChannel;
+  }
+});

package/dist/resolveChannel-v9BDsw-M.js

@@ -0,0 +1,224 @@
+import { t as EnvSource } from "./EnvSource-DA3ZGlES.js";
+import { resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { existsSync, writeFileSync } from "fs";
+
+//#region ../channels/src/channels/default/DefaultEnvChannel.ts
+/**
+* Default implementation of EnvChannel that works with .env files using envrw
+*/
+var DefaultEnvChannel = class {
+	envSource;
+	/**
+	* Create a new DefaultEnvChannel
+	* @param filePath - Path to the .env file to manage
+	*/
+	constructor(filePath) {
+		this.envSource = new EnvSource(filePath);
+	}
+	/**
+	* Get all environment variables
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		return await this.envSource.read();
+	}
+	/**
+	* Set multiple environment variables
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		await this.envSource.write(values);
+	}
+};
+
+//#endregion
+//#region ../channels/src/channels/dotenv/DotEnvChannel.ts
+function isFileNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function normalizeParsed(parsed) {
+	if (!parsed) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(parsed)) {
+		if (typeof value === "undefined") continue;
+		result[key] = value;
+	}
+	return result;
+}
+var DotEnvChannel = class {
+	dotenv;
+	targetPath;
+	absolutePath;
+	encoding;
+	parseOptions;
+	envSource;
+	constructor(dotenv, defaultPath = ".env", getOptions = {}, parseOptions = {}) {
+		this.dotenv = dotenv;
+		this.targetPath = (typeof getOptions.path === "string" ? getOptions.path : void 0) ?? defaultPath;
+		this.absolutePath = resolve(process.cwd(), this.targetPath);
+		this.encoding = getOptions.encoding ?? "utf8";
+		this.parseOptions = { ...parseOptions };
+		this.envSource = new EnvSource(this.targetPath);
+	}
+	async get() {
+		try {
+			const content = await readFile(this.absolutePath, { encoding: this.encoding });
+			return normalizeParsed(this.dotenv.parse(content, this.parseOptions));
+		} catch (error) {
+			if (isFileNotFound(error)) return {};
+			throw error;
+		}
+	}
+	async set(values) {
+		await this.envSource.write(values);
+		const parsed = await this.get();
+		const mismatches = [];
+		for (const [key, expected] of Object.entries(values)) {
+			const actual = parsed[key];
+			if (actual !== expected) mismatches.push(`${key}=expected(${JSON.stringify(expected)}) actual(${JSON.stringify(actual)})`);
+		}
+		if (mismatches.length > 0) throw new Error(`Failed to correctly write values to ${this.targetPath}: ${mismatches.join(", ")}`);
+	}
+	getPrimaryPath() {
+		return this.targetPath;
+	}
+	clearCache() {}
+};
+
+//#endregion
+//#region ../channels/src/channels/dotenvx/DotEnvXChannel.ts
+/**
+* Simple DotEnvX implementation of EnvChannel that wraps @dotenvx/dotenvx library
+* This is just an API mapping wrapper without caching or complex state management
+*/
+var DotEnvXChannel = class {
+	dotenvx;
+	getOptions;
+	setOptions;
+	defaultPath;
+	/**
+	* Create a new DotEnvXChannel
+	* @param dotenvx - The dotenvx instance to use
+	* @param defaultPath - Default path for env files
+	* @param getOptions - Options for get operations
+	* @param setOptions - Options for set operations
+	*/
+	constructor(dotenvx, defaultPath = ".env", getOptions = {}, setOptions = {}) {
+		this.dotenvx = dotenvx;
+		this.defaultPath = defaultPath;
+		this.getOptions = getOptions;
+		this.setOptions = setOptions;
+	}
+	/**
+	* Get all environment variables
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		try {
+			return this.dotenvx.config({
+				processEnv: {},
+				quiet: true,
+				ignore: ["MISSING_ENV_FILE"],
+				path: this.defaultPath,
+				...this.getOptions
+			}).parsed || {};
+		} catch {
+			return {};
+		}
+	}
+	/**
+	* Set multiple environment variables
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		if (!existsSync(this.defaultPath)) writeFileSync(this.defaultPath, "", "utf8");
+		try {
+			const options = {
+				path: this.defaultPath,
+				...this.setOptions
+			};
+			for (const [key, value] of Object.entries(values)) this.dotenvx.set(key, value, options);
+		} catch (error) {
+			throw new Error(`Failed to set environment variables: ${error}`);
+		}
+	}
+	/**
+	* Get the primary path being used for env files
+	* @returns The primary path
+	*/
+	getPrimaryPath() {
+		return this.defaultPath;
+	}
+	/**
+	* Clear any cached data (no-op for this implementation since we don't cache)
+	*/
+	clearCache() {}
+};
+
+//#endregion
+//#region ../channels/src/channels/processenv/ProcessEnvChannel.ts
+/**
+* EnvChannel implementation that works with process.env
+* This channel reads from and writes to the current process environment
+*/
+var ProcessEnvChannel = class {
+	/**
+	* Get all environment variables from process.env
+	* @returns Promise that resolves to object containing all environment variable key-value pairs
+	*/
+	async get() {
+		const env = {};
+		for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
+		return env;
+	}
+	/**
+	* Set multiple environment variables in process.env
+	* @param values - Object containing key-value pairs to set
+	* @returns Promise that resolves when the values have been set
+	*/
+	async set(values) {
+		for (const [key, value] of Object.entries(values)) process.env[key] = value;
+	}
+};
+
+//#endregion
+//#region ../channels/src/resolveChannel.ts
+/**
+* Resolve channel options into an EnvChannel instance
+* @param options - The channel options to resolve
+* @param defaultPath - Default path to use for env files (default: ".env")
+* @returns An EnvChannel instance
+*/
+function resolveChannel(options, defaultPath = ".env") {
+	if (options === void 0 || options === "default") return new DefaultEnvChannel(defaultPath);
+	if (options === "processenv") return new ProcessEnvChannel();
+	if (typeof options === "object" && options !== null) {
+		if ("dotenv" in options) {
+			const { dotenv, get: getOptions = {}, parse: parseOptions = {}, path } = options;
+			if (!dotenv) throw new Error("Dotenv instance is required for dotenv channel");
+			const resolvedPath = path ?? defaultPath;
+			const mergedGetOptions = { ...getOptions };
+			if (typeof mergedGetOptions.path !== "string") mergedGetOptions.path = resolvedPath;
+			return new DotEnvChannel(dotenv, resolvedPath, mergedGetOptions, parseOptions ?? {});
+		}
+		if ("dotenvx" in options) {
+			const { dotenvx, get: getOptions = {}, set: setOptions = {} } = options;
+			if (!dotenvx) throw new Error("DotEnvX instance is required for dotenvx channel");
+			return new DotEnvXChannel(dotenvx, defaultPath, getOptions, setOptions);
+		}
+		if ("process" in options) {
+			if (options.process && typeof options.process === "object" && "env" in options.process) return new ProcessEnvChannel();
+			throw new Error("Invalid process object provided to channel config");
+		}
+		if ("name" in options) if (options.name === "default") return new DefaultEnvChannel(defaultPath);
+		else if (options.name === "processenv") return new ProcessEnvChannel();
+		else throw new Error(`Unknown channel name: ${options.name}`);
+	}
+	throw new Error(`Invalid channel options: ${options}`);
+}
+
+//#endregion
+export { DefaultEnvChannel as a, DotEnvChannel as i, ProcessEnvChannel as n, DotEnvXChannel as r, resolveChannel as t };

package/dist/root.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+require('./EnvSource-BVnmdHku.cjs');
+require('./resolveChannel-CjAuxy3p.cjs');
+const require_src = require('./src-DWYoqPX1.cjs');
+const require_src$1 = require('./src-meUnCASg.cjs');
+require('./custom-D_Rqjm09.cjs');
+require('./coerce-b7UVodS9.cjs');
+const require_src$2 = require('./src-XjL5cyPG.cjs');
+const require_src$3 = require('./src-Cjo2XA4n.cjs');
+require('./redis-EcC7TX3K.cjs');
+const require_src$4 = require('./src-DZmpNGrQ.cjs');
+const require_vars = require('./vars-CYOaskkK.cjs');
+
+//#region src/root.ts
+var root_default = {
+	parse: require_src$3.parse,
+	prompt: require_src.prompt,
+	define: require_src$2.define
+};
+
+//#endregion
+exports.default = root_default;
+exports.define = require_src$2.define;
+exports.parse = require_src$3.parse;
+exports.preprocessors = require_src$1.preprocessors;
+exports.processors = require_src$1.processors;
+exports.prompt = require_src.prompt;
+exports.s = require_src$1.s;
+exports.schema = require_src$1.schema;
+Object.defineProperty(exports, 'schemas', {
+  enumerable: true,
+  get: function () {
+    return require_src$4.src_exports;
+  }
+});
+exports.vars = require_vars.vars;

package/dist/root.d.cts

@@ -0,0 +1,21 @@
+import "./EnvChannelOptions-BPkWDrmr.cjs";
+import "./StringEnvVarSchema-BF6C0nyT.cjs";
+import { _ as preprocessors, v as processors } from "./validate-BxA3a-ns.cjs";
+import "./BooleanMap-B2eIP3tZ.cjs";
+import "./EnvChannel-LMIRYvT1.cjs";
+import { n as schema, t as s } from "./schema-DH4GiW9A.cjs";
+import "./EnvModel-CrGclUpJ.cjs";
+import { t as define } from "./model-ft0WhSSS.cjs";
+import { t as parse } from "./parse-BT1QSa5e.cjs";
+import { t as prompt } from "./prompt-C5WudV9x.cjs";
+import { t as index_d_exports } from "./index-D8pslhp4.cjs";
+import { t as vars } from "./vars-CptZRPX5.cjs";
+
+//#region src/root.d.ts
+declare const _default: {
+  parse: typeof parse;
+  prompt: typeof prompt;
+  define: typeof define;
+};
+//#endregion
+export { _default as default, define, parse, preprocessors, processors, prompt, s, schema, index_d_exports as schemas, vars };

package/dist/root.d.ts

@@ -0,0 +1,21 @@
+import "./EnvChannelOptions-CRwDLWjd.js";
+import "./StringEnvVarSchema-B8MT7htU.js";
+import { _ as preprocessors, v as processors } from "./validate-CyxrRacF.js";
+import "./BooleanMap-DmFnCA-O.js";
+import "./EnvChannel-w27PEm7x.js";
+import { n as schema, t as s } from "./schema-jN4EtvEP.js";
+import "./EnvModel-D8rt0EJ6.js";
+import { t as define } from "./model-Dic8IJsf.js";
+import { t as parse } from "./parse-DwtLpVhC.js";
+import { t as prompt } from "./prompt-yKdccbtZ.js";
+import { t as index_d_exports } from "./index-Dq_0aeAL.js";
+import { t as vars } from "./vars-BNVI6k89.js";
+
+//#region src/root.d.ts
+declare const _default: {
+  parse: typeof parse;
+  prompt: typeof prompt;
+  define: typeof define;
+};
+//#endregion
+export { _default as default, define, parse, preprocessors, processors, prompt, s, schema, index_d_exports as schemas, vars };

package/dist/root.js

@@ -0,0 +1,21 @@
+import "./EnvSource-DA3ZGlES.js";
+import "./resolveChannel-v9BDsw-M.js";
+import { t as prompt } from "./src-Dtv7TlJx.js";
+import { i as preprocessors, n as schema, t as s, u as processors } from "./src-CLTURaoo.js";
+import "./custom-Bt_wnxIu.js";
+import "./coerce-DNIuYAx4.js";
+import { t as define } from "./src-CVdUqK3q.js";
+import { t as parse } from "./src-BBwjK5SK.js";
+import "./redis-CJOpRPjc.js";
+import { t as src_exports } from "./src-B7FG1rak.js";
+import { t as vars } from "./vars-DOW0LiiN.js";
+
+//#region src/root.ts
+var root_default = {
+	parse,
+	prompt,
+	define
+};
+
+//#endregion
+export { root_default as default, define, parse, preprocessors, processors, prompt, s, schema, src_exports as schemas, vars };

package/dist/schema-DH4GiW9A.d.cts

@@ -0,0 +1,18 @@
+import { a as EnumEnvVarSchema, c as BooleanEnvVarSchemaInput, i as NumberEnvVarSchemaInput, n as StringEnvVarSchemaInput, o as EnumEnvVarSchemaInput, r as NumberEnvVarSchema, s as BooleanEnvVarSchema, t as StringEnvVarSchema } from "./StringEnvVarSchema-BF6C0nyT.cjs";
+
+//#region ../core/src/schemas/schema.d.ts
+
+declare const schema: {
+  string: (input?: StringEnvVarSchemaInput) => StringEnvVarSchema;
+  number: (input?: NumberEnvVarSchemaInput) => NumberEnvVarSchema;
+  boolean: (input?: BooleanEnvVarSchemaInput) => BooleanEnvVarSchema;
+  enum: <T extends string = string>(input: EnumEnvVarSchemaInput<T>) => EnumEnvVarSchema<T>;
+};
+declare const s: {
+  string: (input?: StringEnvVarSchemaInput) => StringEnvVarSchema;
+  number: (input?: NumberEnvVarSchemaInput) => NumberEnvVarSchema;
+  boolean: (input?: BooleanEnvVarSchemaInput) => BooleanEnvVarSchema;
+  enum: <T extends string = string>(input: EnumEnvVarSchemaInput<T>) => EnumEnvVarSchema<T>;
+};
+//#endregion
+export { schema as n, s as t };

package/dist/schema-jN4EtvEP.d.ts

@@ -0,0 +1,18 @@
+import { a as EnumEnvVarSchema, c as BooleanEnvVarSchemaInput, i as NumberEnvVarSchemaInput, n as StringEnvVarSchemaInput, o as EnumEnvVarSchemaInput, r as NumberEnvVarSchema, s as BooleanEnvVarSchema, t as StringEnvVarSchema } from "./StringEnvVarSchema-B8MT7htU.js";
+
+//#region ../core/src/schemas/schema.d.ts
+
+declare const schema: {
+  string: (input?: StringEnvVarSchemaInput) => StringEnvVarSchema;
+  number: (input?: NumberEnvVarSchemaInput) => NumberEnvVarSchema;
+  boolean: (input?: BooleanEnvVarSchemaInput) => BooleanEnvVarSchema;
+  enum: <T extends string = string>(input: EnumEnvVarSchemaInput<T>) => EnumEnvVarSchema<T>;
+};
+declare const s: {
+  string: (input?: StringEnvVarSchemaInput) => StringEnvVarSchema;
+  number: (input?: NumberEnvVarSchemaInput) => NumberEnvVarSchema;
+  boolean: (input?: BooleanEnvVarSchemaInput) => BooleanEnvVarSchema;
+  enum: <T extends string = string>(input: EnumEnvVarSchemaInput<T>) => EnumEnvVarSchema<T>;
+};
+//#endregion
+export { schema as n, s as t };