guarden 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Avinashvelu03
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,370 @@
+<div align="center">
+
+# 🛡️ Guarden
+
+### TypeScript-First Runtime Safety Toolkit
+
+[![npm version](https://img.shields.io/npm/v/guarden.svg?style=flat-square&color=cb3837)](https://www.npmjs.com/package/guarden)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/guarden?style=flat-square&color=6ead0a)](https://bundlephobia.com/package/guarden)
+[![license](https://img.shields.io/npm/l/guarden.svg?style=flat-square&color=blue)](https://github.com/Avinashvelu03/guarden/blob/main/LICENSE)
+[![tests](https://img.shields.io/badge/tests-298%20passed-brightgreen?style=flat-square)](https://github.com/Avinashvelu03/guarden/actions)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.5+-3178c6?style=flat-square&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![zero deps](https://img.shields.io/badge/dependencies-0-success?style=flat-square)](https://www.npmjs.com/package/guarden)
+
+**Guard your runtime. Harden your types.**
+
+Blazing-fast, tree-shakeable utilities for bridging TypeScript's compile-time safety with real-world runtime guarantees. Type guards, assertions, Result/Option monads, data pipelines, and environment validation — all in one lightweight, zero-dependency package.
+
+[Getting Started](#-getting-started) · [API Reference](#-api-reference) · [Why Guarden?](#-why-guarden) · [Contributing](CONTRIBUTING.md)
+
+</div>
+
+---
+
+## ✨ Highlights
+
+- 🔒 **60+ type guards** with automatic TypeScript narrowing
+- ⚡ **Zero dependencies** — nothing to audit, nothing to break
+- 🌳 **Tree-shakeable** — import only what you use
+- 📦 **Dual ESM/CJS** — works everywhere
+- 🧪 **298 tests** — battle-tested reliability
+- 🎯 **TypeScript-first** — written in TypeScript, for TypeScript
+- 🏗️ **5 modules** — Guards, Assert, Result/Option, Transform, Env
+
+## 📦 Getting Started
+
+### Installation
+
+```bash
+npm install guarden
+```
+
+```bash
+yarn add guarden
+```
+
+```bash
+pnpm add guarden
+```
+
+### Quick Example
+
+```typescript
+import {
+  isString, isNumber, shape,    // Guards
+  assert, invariant,             // Assertions
+  Ok, Err, type Result,          // Result monad
+  pipe, slugify, escapeHtml,     // Transform
+  createEnv, envString, envNumber // Env validation
+} from 'guarden';
+
+// 🛡️ Type Guards — automatic narrowing
+const input: unknown = getApiResponse();
+if (isString(input)) {
+  input.toUpperCase(); // ✅ TypeScript knows it's a string
+}
+
+// 🏗️ Object Shape Validation
+const isUser = shape({
+  name: isString,
+  age: isNumber,
+});
+
+if (isUser(data)) {
+  console.log(data.name); // ✅ Fully typed
+}
+
+// ⚡ Result Monad — no more try/catch
+function divide(a: number, b: number): Result<number, string> {
+  if (b === 0) return Err('Division by zero');
+  return Ok(a / b);
+}
+
+divide(10, 2).match({
+  ok: (value) => console.log(`Result: ${value}`),
+  err: (error) => console.error(`Error: ${error}`),
+});
+
+// 🔄 Data Pipelines
+const slug = pipe(
+  '  Hello, World! 🌍  ',
+  (s) => s.trim(),
+  slugify,
+);
+// → "hello-world"
+```
+
+## 🔌 Modular Imports
+
+Import the entire library or just the modules you need:
+
+```typescript
+// Full import
+import { isString, Ok, pipe } from 'guarden';
+
+// Module-specific imports (optimal tree-shaking)
+import { isString, shape, arrayOf } from 'guarden/guards';
+import { assert, invariant } from 'guarden/assert';
+import { Ok, Err, Some, None } from 'guarden/result';
+import { pipe, slugify, escapeHtml } from 'guarden/transform';
+import { createEnv, envString } from 'guarden/env';
+```
+
+## 📖 API Reference
+
+### 🛡️ Guards
+
+Type guards that automatically narrow TypeScript types:
+
+#### Primitives
+```typescript
+isString(value)          // value is string
+isNumber(value)          // value is number (excludes NaN)
+isBoolean(value)         // value is boolean
+isBigInt(value)          // value is bigint
+isSymbol(value)          // value is symbol
+isNull(value)            // value is null
+isUndefined(value)       // value is undefined
+isNullish(value)         // value is null | undefined
+isNonNullish(value)      // value is NonNullable<T>
+isFunction(value)        // value is Function
+isPrimitive(value)       // value is string | number | boolean | ...
+isFiniteNumber(value)    // value is number (excludes NaN & Infinity)
+```
+
+#### Structures
+```typescript
+isArray(value)           // value is unknown[]
+isObject(value)          // value is Record<string, unknown>
+isPlainObject(value)     // value is plain {} (not class instance)
+isMap(value)             // value is Map
+isSet(value)             // value is Set
+isDate(value)            // value is Date
+isValidDate(value)       // value is Date (valid, not NaN)
+isRegExp(value)          // value is RegExp
+isError(value)           // value is Error
+isPromise(value)         // value is Promise (or thenable)
+isTypedArray(value)      // value is Uint8Array, Float32Array, etc.
+```
+
+#### Advanced
+```typescript
+isNonEmptyString(value)  // non-empty string
+isEmail(value)           // valid email format
+isURL(value)             // valid URL
+isUUID(value)            // valid UUID v1-v5
+isISO8601(value)         // valid ISO 8601 date string
+isJSONString(value)      // valid JSON string
+isHexColor(value)        // valid hex color (#fff, #ffffff)
+isPositiveNumber(value)  // number > 0
+isNegativeNumber(value)  // number < 0
+isInteger(value)         // integer number
+isSafeInteger(value)     // safe integer
+isNonEmptyArray(value)   // array with 1+ elements
+```
+
+#### Factory Guards
+```typescript
+isInRange(0, 100)(value)              // number in range [0, 100]
+isOneOf(['a', 'b', 'c'] as const)    // value is 'a' | 'b' | 'c'
+isMatch(/^[a-z]+$/)(value)           // string matches regex
+isMinLength(3)(value)                 // string.length >= 3
+isMaxLength(100)(value)               // string.length <= 100
+isInstanceOf(TypeError)(value)        // value instanceof TypeError
+```
+
+#### Combinators
+```typescript
+// Compose guards for complex validation
+const isPositiveInt = and(isInteger, isPositiveNumber);
+const isStringOrNum = or(isString, isNumber);
+const isNotNull = not(isNull);
+
+// Object shape validation
+const isUser = shape({
+  name: isString,
+  age: isNumber,
+  email: isEmail,
+});
+
+// Collection guards
+const isStringArray = arrayOf(isString);
+const isCoord = tuple(isNumber, isNumber);
+const isScoreMap = mapOf(isString, isNumber);
+const isConfig = recordOf(isString);
+
+// Refinement
+const isEven = refine(isNumber, n => n % 2 === 0);
+
+// Optional/Nullable
+const isOptName = optional(isString);  // string | undefined
+const isNullName = nullable(isString); // string | null
+```
+
+---
+
+### ✅ Assert
+
+Runtime assertions with TypeScript type narrowing:
+
+```typescript
+// Basic assertion
+assert(condition, 'Something went wrong');
+
+// Narrowing assertions
+assertDefined(value);       // narrows away undefined
+assertNonNull(value);       // narrows away null | undefined
+assertType(value, isString); // narrows to string
+assertTruthy(value);        // narrows away falsy values
+
+// Invariant (for bug detection)
+invariant(items.length > 0, 'items should never be empty here');
+
+// Exhaustive checking
+type Dir = 'up' | 'down';
+function move(dir: Dir) {
+  switch (dir) {
+    case 'up': return goUp();
+    case 'down': return goDown();
+    default: unreachable(dir); // compile error if case missing!
+  }
+}
+```
+
+---
+
+### 🎯 Result & Option
+
+Rust-inspired monadic error handling:
+
+```typescript
+// Result<T, E> — explicit success/failure
+const result = Ok(42);
+result.map(v => v * 2);           // Ok(84)
+result.andThen(v => Ok(v + 1));   // Ok(43)
+result.unwrapOr(0);               // 42
+result.match({
+  ok: v => `Got ${v}`,
+  err: e => `Failed: ${e}`,
+});
+
+// Catch exceptions safely
+const parsed = ResultUtils.from(() => JSON.parse(input));
+
+// Async support
+const data = await ResultAsync.from(fetch('/api'))
+  .map(res => res.json())
+  .unwrapOr(defaultData);
+
+// Option<T> — explicit null handling
+const user = OptionUtils.from(getUserById(id));
+const name = user.map(u => u.name).unwrapOr('Anonymous');
+
+// Collect multiple Results
+const all = ResultUtils.all([Ok(1), Ok(2), Ok(3)]); // Ok([1, 2, 3])
+```
+
+---
+
+### 🔄 Transform
+
+Type-safe data pipelines and string utilities:
+
+```typescript
+// Pipe — chain transformations
+const result = pipe(
+  '  Hello World  ',
+  trim,
+  lowercase,
+  slugify,
+); // → "hello-world"
+
+// Flow — create reusable pipelines
+const processTitle = flow(trim, capitalize, (s) => truncate(s, 50));
+processTitle('  hello world  '); // → "Hello world"
+
+// Type coercion (returns Result!)
+toNumber('42');          // Ok(42)
+toNumber('abc');         // Err(CoercionError)
+toBoolean('yes');        // true
+toDate('2024-01-15');    // Ok(Date)
+toArray(42);             // [42]
+toArray([1, 2]);         // [1, 2]
+toArray(null);           // []
+
+// String sanitization
+camelCase('hello world');         // "helloWorld"
+kebabCase('helloWorld');          // "hello-world"
+snakeCase('helloWorld');          // "hello_world"
+slugify('Hello, World! 🌍');     // "hello-world"
+escapeHtml('<script>alert(1)');   // "&lt;script&gt;alert(1)"
+truncate('Long text...', 10);    // "Long te..."
+stripHtml('<p>Hello</p>');       // "Hello"
+collapseWhitespace('a  b   c');  // "a b c"
+reverse('hello');                 // "olleh"
+countOccurrences('aaa', 'a');    // 3 (non-overlapping: 3)
+```
+
+---
+
+### 🌍 Env
+
+Validated, type-safe environment variables:
+
+```typescript
+import { createEnv, envString, envNumber, envBoolean, envEnum } from 'guarden/env';
+
+export const env = createEnv({
+  DATABASE_URL: envString().url().required(),
+  PORT: envNumber().port().default(3000),
+  DEBUG: envBoolean().default(false),
+  NODE_ENV: envEnum(['development', 'production', 'test'] as const),
+  API_KEY: envString().minLength(16),
+  ALLOWED_ORIGINS: envString().matches(/^https?:\/\//),
+});
+
+// Fully typed! 🎉
+env.DATABASE_URL  // string
+env.PORT          // number
+env.DEBUG         // boolean
+env.NODE_ENV      // 'development' | 'production' | 'test'
+
+// Throws descriptive errors at startup if invalid:
+// EnvConfigError: Environment configuration is invalid:
+//   DATABASE_URL: is required but not set
+//   PORT: must be a valid port (1-65535)
+```
+
+---
+
+## 🤔 Why Guarden?
+
+| Feature | Guarden | Zod | neverthrow | ts-pattern |
+|---|---|---|---|---|
+| Type Guards | ✅ 60+ | ❌ | ❌ | ❌ |
+| Assertions | ✅ | ❌ | ❌ | ❌ |
+| Result/Option | ✅ | ❌ | ✅ | ❌ |
+| Data Transform | ✅ | ✅ (parse) | ❌ | ❌ |
+| Env Validation | ✅ | 🔶 (manual) | ❌ | ❌ |
+| Zero Dependencies | ✅ | ✅ | ✅ | ✅ |
+| Tree-Shakeable | ✅ | 🔶 | ✅ | ✅ |
+| Bundle Size | ~3KB | ~14KB | ~5KB | ~3KB |
+
+**Guarden** is the only library that provides a **complete runtime safety toolkit** in one package. Instead of installing 4+ separate libraries, get everything you need from one dependency.
+
+## 🔧 Requirements
+
+- **Node.js** >= 18.0.0
+- **TypeScript** >= 5.0 (recommended 5.5+)
+
+## 📄 License
+
+[MIT](LICENSE) © [Avinashvelu03](https://github.com/Avinashvelu03)
+
+---
+
+<div align="center">
+
+**If Guarden helps your project, consider giving it a ⭐ on [GitHub](https://github.com/Avinashvelu03/guarden)!**
+
+</div>

package/dist/cjs/assert/assertions.js

@@ -0,0 +1,82 @@
+"use strict";
+// ============================================================================
+// Guarden — Runtime Assertions
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+exports.assertDefined = assertDefined;
+exports.assertNonNull = assertNonNull;
+exports.assertType = assertType;
+exports.assertTruthy = assertTruthy;
+const errors_js_1 = require("../utils/errors.js");
+/**
+ * Assert that a condition is true. Throws `AssertionError` if false.
+ * Narrows the condition to `true` in the subsequent code.
+ *
+ * @example
+ * ```ts
+ * assert(user !== null, 'User must exist');
+ * user.name; // OK — TypeScript knows user is not null
+ * ```
+ */
+function assert(condition, message) {
+    if (!condition) {
+        throw new errors_js_1.AssertionError(message ?? 'Assertion failed');
+    }
+}
+/**
+ * Assert that a value is defined (not undefined).
+ * Narrows away `undefined`.
+ *
+ * @example
+ * ```ts
+ * const val: string | undefined = getConfig('key');
+ * assertDefined(val, 'Config key is required');
+ * val.toUpperCase(); // OK
+ * ```
+ */
+function assertDefined(value, message) {
+    if (value === undefined) {
+        throw new errors_js_1.AssertionError(message ?? 'Expected value to be defined, but got undefined');
+    }
+}
+/**
+ * Assert that a value is not null and not undefined.
+ * Narrows away `null | undefined`.
+ *
+ * @example
+ * ```ts
+ * assertNonNull(result);
+ * result.doSomething(); // OK
+ * ```
+ */
+function assertNonNull(value, message) {
+    if (value === null || value === undefined) {
+        throw new errors_js_1.AssertionError(message ?? `Expected non-null value, but got ${value === null ? 'null' : 'undefined'}`);
+    }
+}
+/**
+ * Assert that a value passes a type guard.
+ * Narrows to the guarded type.
+ *
+ * @example
+ * ```ts
+ * assertType(input, isString, 'Expected string input');
+ * input.toUpperCase(); // OK — narrowed to string
+ * ```
+ */
+function assertType(value, guard, message) {
+    if (!guard(value)) {
+        throw new errors_js_1.AssertionError(message ?? `Type assertion failed: value ${JSON.stringify(value)} did not pass guard`);
+    }
+}
+/**
+ * Assert that a value is truthy.
+ * Narrows away falsy values (false, 0, '', null, undefined, NaN).
+ */
+function assertTruthy(value, message) {
+    if (!value) {
+        throw new errors_js_1.AssertionError(message ?? `Expected truthy value, but got ${JSON.stringify(value)}`);
+    }
+}
+//# sourceMappingURL=assertions.js.map

package/dist/cjs/assert/assertions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.js","sourceRoot":"","sources":["../../../src/assert/assertions.ts"],"names":[],"mappings":";AAAA,+EAA+E;AAC/E,+BAA+B;AAC/B,+EAA+E;;AAe/E,wBAIC;AAaD,sCAOC;AAYD,sCASC;AAYD,gCAUC;AAMD,oCASC;AA/FD,kDAAoD;AAGpD;;;;;;;;;GASG;AACH,SAAgB,MAAM,CAAC,SAAkB,EAAE,OAAgB;IACzD,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,0BAAc,CAAC,OAAO,IAAI,kBAAkB,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,aAAa,CAC3B,KAAQ,EACR,OAAgB;IAEhB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,0BAAc,CAAC,OAAO,IAAI,iDAAiD,CAAC,CAAC;IACzF,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,aAAa,CAC3B,KAAQ,EACR,OAAgB;IAEhB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QAC1C,MAAM,IAAI,0BAAc,CACtB,OAAO,IAAI,oCAAoC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,EAAE,CACvF,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,UAAU,CACxB,KAAc,EACd,KAAe,EACf,OAAgB;IAEhB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAClB,MAAM,IAAI,0BAAc,CACtB,OAAO,IAAI,gCAAgC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,qBAAqB,CACtF,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY,CAC1B,KAAQ,EACR,OAAgB;IAEhB,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,0BAAc,CACtB,OAAO,IAAI,kCAAkC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CACrE,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/cjs/assert/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unreachable = exports.invariant = exports.assertTruthy = exports.assertType = exports.assertNonNull = exports.assertDefined = exports.assert = void 0;
+var assertions_js_1 = require("./assertions.js");
+Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return assertions_js_1.assert; } });
+Object.defineProperty(exports, "assertDefined", { enumerable: true, get: function () { return assertions_js_1.assertDefined; } });
+Object.defineProperty(exports, "assertNonNull", { enumerable: true, get: function () { return assertions_js_1.assertNonNull; } });
+Object.defineProperty(exports, "assertType", { enumerable: true, get: function () { return assertions_js_1.assertType; } });
+Object.defineProperty(exports, "assertTruthy", { enumerable: true, get: function () { return assertions_js_1.assertTruthy; } });
+var invariant_js_1 = require("./invariant.js");
+Object.defineProperty(exports, "invariant", { enumerable: true, get: function () { return invariant_js_1.invariant; } });
+Object.defineProperty(exports, "unreachable", { enumerable: true, get: function () { return invariant_js_1.unreachable; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/assert/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/assert/index.ts"],"names":[],"mappings":";;;AAAA,iDAMyB;AALvB,uGAAA,MAAM,OAAA;AACN,8GAAA,aAAa,OAAA;AACb,8GAAA,aAAa,OAAA;AACb,2GAAA,UAAU,OAAA;AACV,6GAAA,YAAY,OAAA;AAGd,+CAAwD;AAA/C,yGAAA,SAAS,OAAA;AAAE,2GAAA,WAAW,OAAA"}

package/dist/cjs/assert/invariant.js

@@ -0,0 +1,43 @@
+"use strict";
+// ============================================================================
+// Guarden — Invariants & Unreachable
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invariant = invariant;
+exports.unreachable = unreachable;
+const errors_js_1 = require("../utils/errors.js");
+/**
+ * Assert an invariant condition. Throws `InvariantError` if violated.
+ * Use this for conditions that indicate a bug in your code if broken.
+ *
+ * @example
+ * ```ts
+ * invariant(items.length > 0, 'items should never be empty at this point');
+ * ```
+ */
+function invariant(condition, message) {
+    if (!condition) {
+        throw new errors_js_1.InvariantError(message);
+    }
+}
+/**
+ * Mark code as unreachable. Useful for exhaustive switch/if checks.
+ * Throws `UnreachableError` at runtime if reached.
+ *
+ * @example
+ * ```ts
+ * type Direction = 'up' | 'down';
+ *
+ * function move(dir: Direction) {
+ *   switch (dir) {
+ *     case 'up':    return goUp();
+ *     case 'down':  return goDown();
+ *     default:      unreachable(dir); // TypeScript error if case missing
+ *   }
+ * }
+ * ```
+ */
+function unreachable(value) {
+    throw new errors_js_1.UnreachableError(value);
+}
+//# sourceMappingURL=invariant.js.map

package/dist/cjs/assert/invariant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invariant.js","sourceRoot":"","sources":["../../../src/assert/invariant.ts"],"names":[],"mappings":";AAAA,+EAA+E;AAC/E,qCAAqC;AACrC,+EAA+E;;AAa/E,8BAIC;AAmBD,kCAEC;AApCD,kDAAsE;AAEtE;;;;;;;;GAQG;AACH,SAAgB,SAAS,CAAC,SAAkB,EAAE,OAAe;IAC3D,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,MAAM,IAAI,0BAAc,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,WAAW,CAAC,KAAY;IACtC,MAAM,IAAI,4BAAgB,CAAC,KAAK,CAAC,CAAC;AACpC,CAAC"}

package/dist/cjs/env/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvField = exports.envEnum = exports.envBoolean = exports.envNumber = exports.envString = exports.createEnv = void 0;
+var schema_js_1 = require("./schema.js");
+Object.defineProperty(exports, "createEnv", { enumerable: true, get: function () { return schema_js_1.createEnv; } });
+Object.defineProperty(exports, "envString", { enumerable: true, get: function () { return schema_js_1.envString; } });
+Object.defineProperty(exports, "envNumber", { enumerable: true, get: function () { return schema_js_1.envNumber; } });
+Object.defineProperty(exports, "envBoolean", { enumerable: true, get: function () { return schema_js_1.envBoolean; } });
+Object.defineProperty(exports, "envEnum", { enumerable: true, get: function () { return schema_js_1.envEnum; } });
+Object.defineProperty(exports, "EnvField", { enumerable: true, get: function () { return schema_js_1.EnvField; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/env/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/env/index.ts"],"names":[],"mappings":";;;AAAA,yCAOqB;AANnB,sGAAA,SAAS,OAAA;AACT,sGAAA,SAAS,OAAA;AACT,sGAAA,SAAS,OAAA;AACT,uGAAA,UAAU,OAAA;AACV,oGAAA,OAAO,OAAA;AACP,qGAAA,QAAQ,OAAA"}