adaptive-extender 0.9.10 → 0.9.11

package/CHANGELOG.md

@@ -1,4 +1,4 @@
-## 0.9.10 (17.03.2026)
+## 0.9.11 (17.03.2026)
 - Moved `environment` module from [node](./src/node/environment.ts) to [core](./src/core/environment.ts).
 - Added `EnvironmentProvider` class for resolving environment variables.
 - Added `RecordOf` and `MapOf` adapters for portable maps in [portable](./src/core/portable.ts) module.

package/README.md

@@ -1,130 +1,409 @@
 # Adaptive Extender
 
 [![NPM Version](https://img.shields.io/npm/v/adaptive-extender.svg)](https://www.npmjs.com/package/adaptive-extender)
+[![License](https://img.shields.io/npm/l/adaptive-extender.svg)](./LICENSE)
+[![Bundle Size](https://img.shields.io/bundlephobia/minzip/adaptive-extender)](https://bundlephobia.com/package/adaptive-extender)
+[![TypeScript](https://img.shields.io/badge/types-included-3178c6.svg)](https://www.typescriptlang.org/)
 
-Adaptive library for JS/TS development environments.
-
-**Adaptive Extender** enables strict portability, structured time management, and LINQ-like collections by extending native prototypes. It provides a robust standard library layer for enterprise-grade architecture.
+Extends native prototypes and provides missing standard utilities — with a focus on strict typing, safety, and code readability.
 
 [Change log](./CHANGELOG.md)
 
 ---
 
-## Core Systems
+## Installation
+
+```bash
+npm install adaptive-extender
+```
+
+## Packages
+
+| Package                  | Environment             |
+| :----------------------- | :---------------------- |
+| `adaptive-extender/core` | Browser, Node.js, Deno  |
+| `adaptive-extender/node` | Node.js (includes core) |
+| `adaptive-extender/web`  | Browser (includes core) |
+
+```typescript
+// Import once — extensions are active everywhere
+import "adaptive-extender/core";
+import "adaptive-extender/web"; // Browser only
+```
+
+---
+
+## Native Extensions
+
+### Number
 
-### 1. Strict Data Portability (`Portable`)
-Integrates validation and serialization directly into domain models via decorators. The class definition serves as the authoritative schema, enabling automatic type checking and polymorphic resolution.
+```typescript
+volume = volume.clamp(0, 1);
+
+// Normalize into [0, 1] or remap between ranges
+const normalized = currentValue.lerp(sourceMin, sourceMax);
+const pixelX     = angle.lerp(0, 360, 0, canvasWidth);
+
+// True mathematical modulo — works correctly with negative numbers
+const wrappedIndex = (-1).mod(items.length); // → items.length - 1
+
+// Chainable fallback for invalid values
+const ratio = (numerator / denominator).insteadNaN(0).insteadInfinity(1);
+```
+
+### String
 
 ```typescript
-import { Model, Field, ArrayOf } from "adaptive-extender/core";
+if (String.isWhitespace(userInput)) return;
+
+const displayName = username.insteadEmpty("Anonymous");
+
+"hello world".toTitleCase();            // → "Hello World"
+"île-de-france".toLocalTitleCase("fr"); // → "Île-De-France"
+```
 
-class User extends Model {
-    @Field(String) name: string = "Guest";
-    @Field(ArrayOf(Number)) scores: number[] = [];
+### Array
+
+```typescript
+for (const index of Array.range(0, 10)) { ... }
+
+for (const [user, role] of Array.zip(users, roles)) {
+    console.log(`${user.name}: ${role}`);
 }
 
-// 1. Validates types at runtime
-// 2. Instantiates actual 'User' class
-// 3. Throws informative errors on failure
-const user = User.import(json, "api.user"); 
+// Collect an async iterable into an array
+const packets = await Array.fromAsync(readableStream);
+
+items.swap(0, items.length - 1);
+items.resize(10, null);
+const wasRemoved = items.remove(targetItem);
 ```
 
-### 2. Value-Object Time (`Timespan`)
-A dedicated structural type for time intervals. It encapsulates duration logic, preventing logic errors associated with raw millisecond arithmetic.
+### Math
+
+```typescript
+const [integer, fractional] = Math.split(3.75); // → [3, 0.75]
+Math.sqpw(sideLength);                           // sideLength²
+Math.toRadians(90);                              // → Math.PI / 2
+Math.toDegrees(Math.PI);                         // → 180
+
+Math.meanArithmetic(1, 2, 3, 4); // → 2.5
+Math.meanGeometric(4, 16);
+Math.meanHarmonic(1, 2, 4);
+```
+
+### Set / Map / Date
+
+```typescript
+// Like classList.toggle
+selected.toggle(item);        // add if absent, remove if present
+selected.toggle(item, true);  // force add
+selected.toggle(item, false); // force remove
+
+// Add only if key is not already present
+cache.add(requestKey, response); // → false if key exists
+
+// Detect and replace invalid dates
+const safeDate = new Date("invalid").insteadInvalid(new Date());
+```
+
+### Promise
+
+```typescript
+const request = fetch("/api/data");
+
+if (await request.isSettled)  { ... }
+if (await request.isResolved) { ... }
+if (await request.isRejected) { ... }
+
+const responseData = await request.value;  // throws if rejected
+const rejectReason = await request.reason; // throws if resolved
+```
+
+### Error / Global
+
+```typescript
+// Wrap anything into an Error (string, undefined, object)
+const error = Error.from(thrown);
+
+// Assert non-null — throws ReferenceError with a message
+const appRoot = ReferenceError.suppress(document.getElementById("app"));
+
+throw new ImplementationError(); // sealed, cannot be subclassed
+
+// Get type name without typeof / manual checks
+typename(value); // → "String", "Null", "User", ...
+```
+
+---
+
+## Classes
+
+### Timespan
+
+Value object for time intervals. Eliminates raw millisecond arithmetic.
 
 ```typescript
 import { Timespan } from "adaptive-extender/core";
 
-// Readable, safe arithmetic
-const cacheDuration = Timespan.fromComponents(0, 0, 5, 0); // 5 minutes
-const uptime = Timespan.fromValue(process.uptime() * 1000);
+const sessionDuration = Timespan.fromComponents(0, 30, 0); // 30 minutes
+const uptime          = Timespan.fromValue(process.uptime() * 1000);
+const parsed          = Timespan.parse("1.02:30:00.500");  // 1d 2h 30m 0.5s
+
+console.log(uptime.toString()); // "0.00:12:45.123"
 
-// Use valueOf() for precise millisecond comparison
-if (uptime.valueOf() > cacheDuration.valueOf()) {
-    console.log("Cache expired"); 
+uptime.minutes = 0; // other components recalculate automatically
+
+if (uptime.valueOf() > sessionDuration.valueOf()) {
+    console.log("Session expired");
 }
+```
+
+### Color
+
+Full color object with RGB, HSL, HEX support and alpha channel. Changing a component in one color space automatically recalculates the other.
+
+```typescript
+import { Color, ColorFormats } from "adaptive-extender/core";
+
+const orange = Color.fromRGB(255, 128, 0);
+const parsed = Color.parse("#ff8800");
+
+orange.hue   = 200; // RGB recalculates automatically
+orange.alpha = 0.8;
 
-// Structured formatting
-console.log(uptime.toString()); // e.g. "0.00:12:45.123"
+console.log(orange.toString({ format: ColorFormats.hsl, deep: true }));
+// → "hsla(200, 100%, 50%, 0.8)"
 ```
 
-### 3. Native Prototype Extensions
-Native prototypes (`Array`, `String`, `Math`) are augmented with missing standard utility methods. These extensions are non-enumerable and designed to be conflict-free.
+### Random
 
 ```typescript
-// Sequence generation
-for (const i of Array.range(0, 5)) { ... } 
+import { Random } from "adaptive-extender/core";
+
+const rng = Random.global;
+
+rng.boolean(0.9);        // true with 90% probability
+rng.number(0, 1);        // float [0, 1)
+rng.integer(1, 6);       // int [1, 6]
+rng.item(options);       // random element from array
+rng.subarray(items, 3);  // 3 random elements
+rng.shuffle(array);      // shuffle in place
+
+// Weighted selection
+const loot = rng.case(new Map([
+    ["common",    70],
+    ["rare",      25],
+    ["legendary",  5],
+]));
+```
 
-// Parallel iteration
-for (const [user, role] of Array.zip(users, roles)) { ... }
+### Vector
 
-// Safe Swap
-items.swap(0, items.length - 1);
+Mathematical vectors with a LINQ-style iteration API.
+
+```typescript
+import { Vector, Vector2D, Vector3D } from "adaptive-extender/core";
+
+const position  = new Vector2D(3, 4);
+const direction = Vector3D.fromScalar(1); // (1, 1, 1)
+
+// LINQ-like methods over components
+const normalized = Vector3D.fromVector(
+    direction.map(component => component / Math.sqrt(3))
+);
+
+Vector.isFinite(position);
+const safePosition = position.insteadNaN(Vector2D.newZero);
+const point        = Vector2D.parse("(10, 20)"); // → Vector2D { x: 10, y: 20 }
 ```
 
-### 4. Structured Primitives (`Vector`, `Controller`)
-Provides abstract base classes for mathematical vectors and unified controller logic for complex execution flows.
+### Controller
+
+Abstract base class for async tasks with centralized error handling.
 
 ```typescript
 import { Controller } from "adaptive-extender/core";
 
-// Cancellable, error-handling async worker
-class ImportTask extends Controller {
-    async run() { ... }
-    async catch(err) { ... }
+class InitTask extends Controller {
+    async run(): Promise<void> {
+        const response = await fetch("/api/init");
+        // ...
+    }
+
+    async catch(error: Error): Promise<void> {
+        console.error("Init failed:", error.message);
+    }
+}
+
+// Creates an instance and runs it — errors are routed to catch()
+await InitTask.launch();
+```
+
+### EnvironmentProvider
+
+Deserializes environment variables into a strictly typed model. JSON values are parsed automatically.
+
+```typescript
+import { EnvironmentProvider, Model, Field, Optional } from "adaptive-extender/core";
+
+class AppConfig extends Model {
+    @Field(String)           DB_HOST: string  = "localhost";
+    @Field(Number)           DB_PORT: number  = 5432;
+    @Field(Optional(String)) LOG_LEVEL?: string;
 }
+
+const config = EnvironmentProvider.resolve(process.env, AppConfig);
+// config.DB_PORT is a number, not a string
+// Throws TypeError if a required variable is missing or has the wrong type
 ```
 
 ---
 
-## Native Extensions
+## Portable Data System
+
+Binds classes to their schema via decorators. Importing from JSON validates types automatically and returns a real class instance.
 
-A collection of high-performance utilities that eliminate common boilerplate.
+### Basic Usage
+
+```typescript
+import { Model, Field, ArrayOf, Optional, Nullable } from "adaptive-extender/core";
+
+class Tag extends Model {
+    @Field(String) name: string = "";
+}
+
+class Article extends Model {
+    @Field(String)           title: string      = "";
+    @Field(Number)           views: number      = 0;
+    @Field(ArrayOf(Tag))     tags: Tag[]        = [];
+    @Field(Optional(String)) subtitle?: string;
+    @Field(Nullable(String)) draft: string | null = null;
+}
 
-| Feature | Native JavaScript | Adaptive Extender |
-| :--- | :--- | :--- |
-| **Math Clamping** | `Math.min(Math.max(val, 0), 100)` | `val.clamp(0, 100)` |
-| **Math Remap** | `(val - a) * (d - c) / (b - a) + c` | `val.lerp(a, b, c, d)` |
-| **Modulo** | `((val % n) + n) % n` | `val.mod(n)` |
-| **Random** | `Math.floor(Math.random()...` | `Random.global.number(min, max)` |
-| **String Empty** | `!str \|\| str.trim().length === 0` | `String.isWhitespace(str)` |
-| **String Defaults** | `str \|\| "default"` | `str.insteadEmpty("default")` |
-| **Async List** | *Manual loop with `Promise.all`* | `await Array.fromAsync(stream)` |
-| **Promise State** | *n/a* | `await task.isSettled` |
+const article = Article.import(json, "api.article");
+// article instanceof Article → true
+// TypeError with exact path on failure: "api.article.tags[2].name"
+
+const raw = Article.export(article); // → plain object, ready for JSON.stringify
+```
+
+### Polymorphism
+
+```typescript
+import { Model, Field, Descendant, DiscriminatorKey } from "adaptive-extender/core";
+
+class Dog extends Model { @Field(String)  breed: string   = ""; }
+class Cat extends Model { @Field(Boolean) indoor: boolean = true; }
+
+@DiscriminatorKey("kind")
+@Descendant(Dog, "dog")
+@Descendant(Cat, "cat")
+abstract class Animal extends Model {}
+
+// { kind: "dog", breed: "Husky" } → Dog instance
+// { kind: "cat", indoor: true }   → Cat instance
+const animal = Animal.import(json, "api.animal");
+```
+
+### Adapters
+
+| Adapter        | Type                                   |
+| :------------- | :------------------------------------- |
+| `ArrayOf(T)`   | `T[]`                                  |
+| `SetOf(T)`     | `Set<T>` ↔ `T[]`                       |
+| `RecordOf(T)`  | `Map<string, T>` ↔ `Record<string, T>` |
+| `MapOf(K, V)`  | `Map<K, V>` ↔ `[K, V][]`               |
+| `Optional(T)`  | `T \| undefined`                       |
+| `Nullable(T)`  | `T \| null`                            |
+| `Deferred(fn)` | Circular references                    |
 
 ---
 
-## Architecture
+## Web
 
-- **`adaptive-extender/core`**: 
-  Universal utilities. Works in Browser, Node, Deno.
-  *(Math, arrays, promises, portable system, time)*
+### DOM Queries
 
-- **`adaptive-extender/node`**: 
-  Backend-specific tools.
-  *(Enhanced `fs` operations, strict environment variable parsing)*
+Type-safe wrappers over `querySelector` — throw instead of returning `null`.
 
-- **`adaptive-extender/web`**: 
-  Frontend-specific tools.
-  *(DOM element wrappers, parent-node extensions)*
+```typescript
+import "adaptive-extender/web";
 
-## Installation
+const loginForm      = document.getElement(HTMLFormElement, "#login-form");
+const requiredInputs = loginForm.getElements(HTMLInputElement, "input[required]");
+const container      = loginForm.getClosest(HTMLDivElement, ".wrapper");
 
-```bash
-npm install adaptive-extender
+// Async variants — useful with Shadow DOM
+const canvas = await document.getElementAsync(HTMLCanvasElement, "#scene");
 ```
 
-## Usage
+### Game Engines
+
+Three update-loop engines for UI animation or game logic:
 
 ```typescript
-import "adaptive-extender/core";
+import { FastEngine, StaticEngine } from "adaptive-extender/web";
+
+// Fast — requestAnimationFrame based
+const engine = new FastEngine({ launch: true });
+engine.limit = 60;
+
+engine.addEventListener("trigger", () => {
+    const deltaTime = engine.delta; // seconds since last frame
+    // update scene...
+});
+
+// Static — fixed fps via setTimeout
+const fixedEngine = new StaticEngine({ launch: true });
+fixedEngine.limit = 30;
+```
+
+### Archive (localStorage)
+
+Type-safe localStorage with buffered access and auto-save.
+
+```typescript
+import { ArchiveRepository, Model, Field } from "adaptive-extender/web";
 
-// Extensions are now active
-if (String.isEmpty(config.name)) {
-  // ...
+class Settings extends Model {
+    @Field(Boolean) darkMode: boolean = false;
+    @Field(Number)  volume: number    = 1;
 }
+
+const repository = new ArchiveRepository("settings", Settings, new Settings());
+
+const settings = repository.content;
+settings.volume = 0.5;
+
+repository.save();       // persist immediately
+repository.save(3000);   // debounced — persist after 3 seconds
+repository.reset();      // revert to initial state
+```
+
+### Promise Utilities
+
+```typescript
+await Promise.asTimeout(1000);
+
+// AbortController is created and aborted automatically on completion
+const result = await Promise.withSignal((signal, resolve, reject) => {
+    fetch("/api/data", { signal }).then(resolve).catch(reject);
+});
 ```
 
+---
+
+## Reflect Utilities
+
+```typescript
+// Apply a function only if the value is not null / undefined
+const upper   = Reflect.mapNull(maybeNull, text => text.toUpperCase());
+const trimmed = Reflect.mapUndefined(maybeUndefined, text => text.trim());
+const parsed  = Reflect.mapNullable(maybeNullable, text => parseInt(text));
+```
+
+---
+
 ## License
 
 Apache-2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "adaptive-extender",
-	"version": "0.9.10",
+	"version": "0.9.11",
 	"description": "Adaptive library for JS/TS development environments",
 	"type": "module",
 	"main": "./dist/core/index.js",

package/dist/core/archivable.d.ts

@@ -1,19 +0,0 @@
-/**
- * Defines the interface for an archivable object's prototype.
- * @template S The type of the notation returned by the export method.
- */
-export interface ArchivablePrototype<S = any> {
-    /**
-     * Creates a new instance of the archivable object.
-     */
-    new (...args: any): any;
-    /**
-     * Imports data from a source and returns a new instance.
-     * @throws {TypeError} If unable to import the source.
-     */
-    import(source: any, name: string): InstanceType<this>;
-    /**
-     * Exports the state of an instance to a notation.
-     */
-    export(source: InstanceType<this>): S;
-}

package/dist/core/archivable.js

@@ -1,3 +0,0 @@
-"use strict";
-export {};
-//# sourceMappingURL=archivable.js.map

package/dist/core/archivable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"archivable.js","sourceRoot":"","sources":["../../src/core/archivable.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC"}

package/dist/core/debug_types.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/debug_types.js

@@ -1,65 +0,0 @@
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-import { Model, Field } from "./portable";
-// Mock types
-class MyModel extends Model {
-}
-let TestClass = (() => {
-    let _classSuper = Model;
-    let _prop_decorators;
-    let _prop_initializers = [];
-    let _prop_extraInitializers = [];
-    let _date_decorators;
-    let _date_initializers = [];
-    let _date_extraInitializers = [];
-    return class TestClass extends _classSuper {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _prop_decorators = [Field(MyType)];
-            _date_decorators = [Field(Date)];
-            __esDecorate(null, null, _prop_decorators, { kind: "field", name: "prop", static: false, private: false, access: { has: obj => "prop" in obj, get: obj => obj.prop, set: (obj, value) => { obj.prop = value; } }, metadata: _metadata }, _prop_initializers, _prop_extraInitializers);
-            __esDecorate(null, null, _date_decorators, { kind: "field", name: "date", static: false, private: false, access: { has: obj => "date" in obj, get: obj => obj.date, set: (obj, value) => { obj.date = value; } }, metadata: _metadata }, _date_initializers, _date_extraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        // Check if compilation fails or inference is weird
-        prop = __runInitializers(this, _prop_initializers, void 0);
-        date = (__runInitializers(this, _prop_extraInitializers), __runInitializers(this, _date_initializers, void 0));
-        constructor() {
-            super(...arguments);
-            __runInitializers(this, _date_extraInitializers);
-        }
-    };
-})();
-//# sourceMappingURL=debug_types.js.map

package/dist/core/debug_types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug_types.js","sourceRoot":"","sources":["../../src/core/debug_types.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,KAAK,EAAE,KAAK,EAA4B,MAAM,YAAY,CAAC;AAEpE,aAAa;AACb,MAAM,OAAQ,SAAQ,KAAK;CAAG;IAIxB,SAAS;sBAAS,KAAK;;;;;;;iBAAvB,SAAU,SAAQ,WAAK;;;gCAExB,KAAK,CAAC,MAAM,CAAC;gCAGb,KAAK,CAAC,IAAI,CAAC;YAFZ,8JAAA,IAAI,6BAAJ,IAAI,mFAAW;YAGf,8JAAA,IAAI,6BAAJ,IAAI,mFAAQ;;;QALZ,mDAAmD;QAEnD,IAAI,uDAAW;QAGf,IAAI,2GAAQ"}

package/dist/core/repro_issue.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/repro_issue.js

@@ -1,55 +0,0 @@
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-import { Model, Field } from "./portable";
-let TestDate = (() => {
-    let _classSuper = Model;
-    let _dateField_decorators;
-    let _dateField_initializers = [];
-    let _dateField_extraInitializers = [];
-    return class TestDate extends _classSuper {
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _dateField_decorators = [Field(Date)];
-            __esDecorate(null, null, _dateField_decorators, { kind: "field", name: "dateField", static: false, private: false, access: { has: obj => "dateField" in obj, get: obj => obj.dateField, set: (obj, value) => { obj.dateField = value; } }, metadata: _metadata }, _dateField_initializers, _dateField_extraInitializers);
-            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        }
-        dateField = __runInitializers(this, _dateField_initializers, void 0);
-        constructor() {
-            super(...arguments);
-            __runInitializers(this, _dateField_extraInitializers);
-        }
-    };
-})();
-//# sourceMappingURL=repro_issue.js.map

package/dist/core/repro_issue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"repro_issue.js","sourceRoot":"","sources":["../../src/core/repro_issue.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;IAEpC,QAAQ;sBAAS,KAAK;;;;iBAAtB,QAAS,SAAQ,WAAK;;;qCACvB,KAAK,CAAC,IAAI,CAAC;YACZ,6KAAA,SAAS,6BAAT,SAAS,6FAAQ;;;QAAjB,SAAS,4DAAQ"}

package/dist/node/environment.d.ts

@@ -1,20 +0,0 @@
-import "../core/index.js";
-import "dotenv/config";
-/**
- * Represents the system environment and provides utility methods to access environment variables.
- */
-export declare class Environment {
-    /**
-     * Retrieves a new instance of the Environment class.
-     */
-    static get env(): Environment;
-    /**
-     * Checks if a specific key exists within the environment variables.
-     */
-    hasValue(key: string): boolean;
-    /**
-     * Reads and parses the value of a specific environment variable.
-     * @throws {ReferenceError} if the key is missing.
-     */
-    readValue(key: string): any;
-}

package/dist/node/environment.js

@@ -1,37 +0,0 @@
-"use strict";
-import "../core/index.js";
-import "dotenv/config";
-//#region Environment
-/**
- * Represents the system environment and provides utility methods to access environment variables.
- */
-export class Environment {
-    /**
-     * Retrieves a new instance of the Environment class.
-     */
-    static get env() {
-        return new Environment();
-    }
-    /**
-     * Checks if a specific key exists within the environment variables.
-     */
-    hasValue(key) {
-        const { env } = process;
-        return (env[key] !== undefined);
-    }
-    /**
-     * Reads and parses the value of a specific environment variable.
-     * @throws {ReferenceError} if the key is missing.
-     */
-    readValue(key) {
-        const { env } = process;
-        const text = ReferenceError.suppress(env[key], `Key '${key}' at environment not registered`);
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return text;
-        }
-    }
-}
-//# sourceMappingURL=environment.js.map

package/dist/node/environment.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"environment.js","sourceRoot":"","sources":["../../src/node/environment.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,kBAAkB,CAAC;AAC1B,OAAO,eAAe,CAAC;AAEvB,qBAAqB;AACrB;;GAEG;AACH,MAAM,OAAO,WAAW;IACvB;;OAEG;IACH,MAAM,KAAK,GAAG;QACb,OAAO,IAAI,WAAW,EAAE,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,GAAW;QACnB,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;QACxB,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,GAAW;QACpB,MAAM,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;QACxB,MAAM,IAAI,GAAG,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,QAAQ,GAAG,iCAAiC,CAAC,CAAC;QAC7F,IAAI,CAAC;YACJ,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;CACD"}