@mxweb/classable 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-01-17
+
+### Added
+
+- **Type Utilities**
+  - `UnitClass<T>` - Class constructor with no arguments
+  - `ClassType<T, Args>` - Class constructor with specific arguments
+  - `AbstractClassType<T, Args>` - Abstract class constructor
+  - `AnyClass<T>` - Class constructor with any arguments
+  - `AnyAbstractClass<T>` - Abstract class with any arguments
+  - `AnyConstructor` - Union type for any constructor
+  - `Classable<T, Args, Runtime>` - Class or resolver configuration
+  - `ClassableByResolver<T, Args, Runtime>` - Resolver configuration interface
+  - `ThisExtended<Extend>` - Utility for extending Placeholder
+  - `StaticExtended<Extend, T, Args>` - Utility for static class extension
+
+- **classable API**
+  - `classable.is(fn)` - Type guard for class constructors
+  - `classable.isAbstract(fn)` - Type guard for abstract classes
+  - `classable.isResolver(obj)` - Type guard for resolver objects
+  - `classable.create(cls, runtime?)` - Instance creation with sync/async resolver support
+  - `classable.toResolver(cls)` - Convert class to resolver format
+  - `classable.withResolve(base, resolve)` - Create resolver with custom resolve function
+  - `classable.wrap(cls, wrapper)` - Apply decorators/middleware to classes
+  - `classable.getTarget(cls)` - Extract target class from Classable
+  - `classable.getDescriptor(cls)` - Get metadata (type and target name)
+
+- **Utilities**
+  - `Placeholder` class - Marker for unresolved bindings
+  - `placeholder` - Pre-configured placeholder resolver
+
+- **Documentation**
+  - Full JSDoc documentation for all types and methods
+  - Comprehensive README with examples
+  - MIT License
+
+[1.0.0]: https://github.com/mxwebio/mxweb-classable/releases/tag/v1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MXWeb
+
+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,337 @@
+# @mxweb/classable
+
+A TypeScript utility library for working with classes and deferred instantiation through resolver patterns. Provides type-safe class manipulation, dependency injection patterns, and lazy initialization support.
+
+## ESM-only (by design)
+
+Classable relies on the semantic identity of classes:
+
+- native `class` syntax
+- stable constructor identity
+- intact static surfaces
+- predictable module graph
+
+CommonJS transforms classes and breaks these guarantees at runtime.
+
+- This is not a compatibility limitation.
+- It is a design requirement.
+
+## Installation
+
+```bash
+npm install @mxweb/classable
+# or
+yarn add @mxweb/classable
+# or
+pnpm add @mxweb/classable
+```
+
+## Features
+
+- 🎯 **Type-safe class utilities** - Full TypeScript support with precise type inference
+- 🔄 **Resolver pattern** - Separate class instantiation from argument resolution
+- ⏳ **Async support** - Handle async dependency resolution seamlessly
+- 🎁 **Class wrapping** - Apply decorators, mixins, and middleware to classes
+- 🔍 **Type guards** - Runtime checks with TypeScript type narrowing
+- 📦 **Zero dependencies** - Lightweight and self-contained
+
+## Quick Start
+
+```typescript
+import { classable, Classable, ClassableByResolver } from '@mxweb/classable';
+
+// Basic class instantiation
+class Logger {
+  log(msg: string) {
+    console.log(msg);
+  }
+}
+
+const logger = classable.create(Logger);
+logger.log('Hello!');
+```
+
+## Core Concepts
+
+### Classable
+
+A `Classable` is either a plain class constructor or a resolver configuration object:
+
+```typescript
+import { Classable, ClassableByResolver } from '@mxweb/classable';
+
+class User {
+  constructor(public name: string, public age: number) {}
+}
+
+// Plain class
+const cls: Classable<User> = User;
+
+// Resolver with dependency injection
+const resolver: ClassableByResolver<User, [string, number], AppContext> = {
+  target: User,
+  resolve: (ctx) => [ctx.config.userName, ctx.config.userAge]
+};
+```
+
+### ClassableByResolver
+
+A configuration object that separates class instantiation from argument resolution:
+
+```typescript
+interface ClassableByResolver<InstanceType, Args, Runtime> {
+  target: ClassType<InstanceType, Args>;  // The class to instantiate
+  resolve: (runtime: Runtime) => Args | Promise<Args>;  // Argument resolver
+}
+```
+
+## API Reference
+
+### Type Utilities
+
+| Type | Description |
+|------|-------------|
+| `UnitClass<T>` | Class constructor with no arguments |
+| `ClassType<T, Args>` | Class constructor with specific arguments |
+| `AbstractClassType<T, Args>` | Abstract class constructor |
+| `AnyClass<T>` | Class constructor with any arguments |
+| `AnyAbstractClass<T>` | Abstract class with any arguments |
+| `AnyConstructor` | Any class or abstract class |
+| `Classable<T, Args, Runtime>` | Class or resolver configuration |
+| `ClassableByResolver<T, Args, Runtime>` | Resolver configuration |
+
+### `classable` API
+
+#### `classable.is(fn)`
+
+Checks if a value is a class constructor.
+
+```typescript
+class MyClass {}
+classable.is(MyClass);     // true
+classable.is(() => {});    // false
+classable.is({});          // false
+```
+
+#### `classable.isAbstract(fn)`
+
+Checks if a value is an abstract class constructor.
+
+```typescript
+abstract class BaseService {}
+classable.isAbstract(BaseService);  // true
+classable.isAbstract(MyClass);      // false
+```
+
+#### `classable.isResolver(obj)`
+
+Checks if a value is a `ClassableByResolver` object.
+
+```typescript
+const resolver = { target: User, resolve: () => ['John', 30] };
+classable.isResolver(resolver);  // true
+classable.isResolver(User);      // false
+```
+
+#### `classable.create(cls, runtime?)`
+
+Creates an instance from a class or resolver. Handles both sync and async resolvers.
+
+```typescript
+// Plain class
+const logger = classable.create(Logger);
+
+// Sync resolver
+const user = classable.create({
+  target: User,
+  resolve: (ctx) => [ctx.name, ctx.age]
+}, context);
+
+// Async resolver
+const user = await classable.create({
+  target: User,
+  resolve: async (ctx) => {
+    const data = await fetchUserData();
+    return [data.name, data.age];
+  }
+}, context);
+```
+
+#### `classable.toResolver(cls)`
+
+Converts a class constructor to a resolver configuration.
+
+```typescript
+const resolver = classable.toResolver(User);
+// { target: User, resolve: () => [] }
+```
+
+#### `classable.getTarget(cls)`
+
+Extracts the target class from a Classable.
+
+```typescript
+const target = classable.getTarget(resolver);  // User class
+const target2 = classable.getTarget(User);     // User class
+```
+
+#### `classable.withResolve(base, resolve)`
+
+Creates a new resolver with a custom resolve function.
+
+```typescript
+const customResolver = classable.withResolve(User, (ctx) => {
+  return [ctx.name, ctx.age];
+});
+```
+
+#### `classable.wrap(cls, wrapper)`
+
+Wraps a class or resolver's target with a transformation function.
+
+```typescript
+const timestampedLogger = classable.wrap(Logger, (Target) => {
+  return class extends Target {
+    log(msg: string) {
+      super.log(`[${new Date().toISOString()}] ${msg}`);
+    }
+  };
+});
+```
+
+#### `classable.getDescriptor(cls)`
+
+Returns metadata about the classable.
+
+```typescript
+classable.getDescriptor(User);
+// { type: "class", target: "User" }
+
+classable.getDescriptor(resolver);
+// { type: "resolver", target: "User" }
+```
+
+### Placeholder
+
+A utility class for marking unresolved bindings:
+
+```typescript
+import { classable } from '@mxweb/classable';
+
+// Use as default value
+class Container {
+  private bindings = new Map();
+  
+  register(key: string, cls = classable.placeholder) {
+    this.bindings.set(key, cls);
+  }
+}
+```
+
+## Advanced Usage
+
+### Dependency Injection Pattern
+
+```typescript
+interface AppContext {
+  db: Database;
+  config: Config;
+}
+
+class UserService {
+  constructor(
+    private db: Database,
+    private maxUsers: number
+  ) {}
+}
+
+const userServiceResolver: ClassableByResolver<
+  UserService,
+  [Database, number],
+  AppContext
+> = {
+  target: UserService,
+  resolve: (ctx) => [ctx.db, ctx.config.maxUsers]
+};
+
+// Create with context
+const context: AppContext = { db: new Database(), config: { maxUsers: 100 } };
+const service = classable.create(userServiceResolver, context);
+```
+
+### Async Dependency Resolution
+
+```typescript
+const asyncResolver: ClassableByResolver<User, [string], DbContext> = {
+  target: User,
+  resolve: async (ctx) => {
+    const userData = await ctx.db.fetchUser(ctx.userId);
+    return [userData.name];
+  }
+};
+
+// Returns Promise<User>
+const user = await classable.create(asyncResolver, dbContext);
+```
+
+### Class Middleware/Decorators
+
+```typescript
+// Add logging to all methods
+const withLogging = classable.wrap(MyService, (Target) => {
+  return class extends Target {
+    constructor(...args: any[]) {
+      super(...args);
+      console.log(`Created ${Target.name}`);
+    }
+  };
+});
+
+// Chain multiple wrappers
+const enhanced = classable.wrap(
+  classable.wrap(MyService, withLogging),
+  withMetrics
+);
+```
+
+### Type Guards with Narrowing
+
+```typescript
+function processClassable(input: unknown) {
+  if (classable.isResolver(input)) {
+    // TypeScript knows input has 'target' and 'resolve'
+    console.log(`Resolver for: ${input.target.name}`);
+  } else if (classable.is(input)) {
+    // TypeScript knows input is a class
+    console.log(`Class: ${input.name}`);
+  }
+}
+```
+
+## TypeScript Support
+
+This library is written in TypeScript and provides full type inference:
+
+```typescript
+// Types are automatically inferred
+const resolver = {
+  target: User,
+  resolve: (ctx: AppContext) => [ctx.name, ctx.age] as [string, number]
+};
+
+// Return type is correctly inferred as User
+const user = classable.create(resolver, context);
+
+// Async resolver returns Promise<User>
+const asyncResolver = {
+  target: User,
+  resolve: async (ctx: AppContext) => {
+    return [await getName(), await getAge()] as [string, number];
+  }
+};
+const asyncUser = classable.create(asyncResolver, context); // Promise<User>
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Represents a class constructor that takes no arguments.
+ * @template InstanceType - The type of instance created by this constructor.
+ *
+ * @example
+ * ```typescript
+ * class Logger {}
+ * const LoggerClass: UnitClass<Logger> = Logger;
+ * ```
+ */
+export type UnitClass<InstanceType> = new () => InstanceType;
+/**
+ * Represents a class constructor with specific constructor arguments.
+ * @template InstanceType - The type of instance created by this constructor.
+ * @template Args - Tuple type of constructor arguments, defaults to empty array.
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   constructor(name: string, age: number) {}
+ * }
+ * const UserClass: ClassType<User, [string, number]> = User;
+ * ```
+ */
+export type ClassType<InstanceType, Args extends any[] = []> = new (...args: Args) => InstanceType;
+/**
+ * Represents an abstract class constructor.
+ * @template InstanceType - The type of instance this abstract class represents.
+ * @template Args - Tuple type of constructor arguments, defaults to empty array.
+ *
+ * @example
+ * ```typescript
+ * abstract class BaseService {
+ *   abstract execute(): void;
+ * }
+ * const ServiceClass: AbstractClassType<BaseService> = BaseService;
+ * ```
+ */
+export type AbstractClassType<InstanceType, Args extends any[] = []> = abstract new (...args: Args) => InstanceType;
+/**
+ * Shorthand for a class constructor with any arguments.
+ * @template T - The type of instance created by this constructor.
+ */
+export type AnyClass<T> = ClassType<T, any[]>;
+/**
+ * Shorthand for an abstract class constructor with any arguments.
+ * @template T - The type of instance this abstract class represents.
+ */
+export type AnyAbstractClass<T> = AbstractClassType<T, any[]>;
+/**
+ * Union type representing any constructor (class or abstract class).
+ */
+export type AnyConstructor = ClassType<any, any[]> | AbstractClassType<any, any[]>;
+/**
+ * Configuration object for deferred class instantiation with dependency resolution.
+ *
+ * This interface allows you to separate class instantiation from argument resolution,
+ * enabling lazy evaluation and runtime dependency injection.
+ *
+ * @template InstanceType - The type of instance to be created.
+ * @template Args - Tuple type of constructor arguments.
+ * @template Runtime - Optional runtime context type passed to the resolver.
+ *
+ * @example
+ * ```typescript
+ * // Sync resolver
+ * const userResolver: ClassableByResolver<User, [string, number], AppContext> = {
+ *   target: User,
+ *   resolve: (ctx) => [ctx.config.name, ctx.config.age]
+ * };
+ *
+ * // Async resolver
+ * const asyncResolver: ClassableByResolver<User, [string], DbContext> = {
+ *   target: User,
+ *   resolve: async (ctx) => {
+ *     const name = await ctx.db.fetchName();
+ *     return [name];
+ *   }
+ * };
+ * ```
+ */
+export interface ClassableByResolver<InstanceType, Args extends any[] = [], Runtime = never> {
+    /** The target class constructor to instantiate. */
+    target: ClassType<InstanceType, Args>;
+    /**
+     * Function that resolves constructor arguments.
+     * Can return arguments synchronously or as a Promise.
+     */
+    resolve: (...args: Runtime extends never ? [] : [runtime: Runtime]) => Args | Promise<Args>;
+}
+/**
+ * Union type representing either a direct class constructor or a resolver configuration.
+ *
+ * Use this type when a function accepts both plain classes and resolver objects.
+ *
+ * @template InstanceType - The type of instance to be created.
+ * @template Args - Tuple type of constructor arguments.
+ * @template Runtime - Optional runtime context type for resolvers.
+ *
+ * @example
+ * ```typescript
+ * function register<T>(cls: Classable<T>) {
+ *   // Accepts both User and { target: User, resolve: () => [...] }
+ * }
+ *
+ * register(User);
+ * register({ target: User, resolve: () => ["John", 30] });
+ * ```
+ */
+export type Classable<InstanceType, Args extends any[] = [], Runtime = never> = ClassType<InstanceType, Args> | ClassableByResolver<InstanceType, Args, Runtime>;
+/**
+ * A placeholder class used as a marker for unresolved or pending class registrations.
+ * Useful in dependency injection containers or lazy initialization patterns.
+ *
+ * @example
+ * ```typescript
+ * class Container {
+ *   private bindings = new Map<string, Classable<any>>();
+ *
+ *   register(key: string, cls: Classable<any> = classable.placeholder) {
+ *     this.bindings.set(key, cls);
+ *   }
+ * }
+ * ```
+ */
+export declare class Placeholder {
+}
+/**
+ * Pre-configured placeholder resolver that creates an empty Placeholder instance.
+ * Use this as a default value when a classable binding is not yet configured.
+ */
+export declare const placeholder: Readonly<{
+    target: typeof Placeholder;
+    resolve: () => readonly [];
+}>;
+/**
+ * Utility type for extending the Placeholder class in type definitions.
+ * Useful for creating typed placeholders with additional properties.
+ *
+ * @template Extend - Additional properties to add to the Placeholder type.
+ */
+export type ThisExtended<Extend> = Placeholder & Extend;
+/**
+ * Utility type for creating a static class type with additional properties.
+ *
+ * @template Extend - Static properties to add to the class.
+ * @template InstanceType - The instance type of the class.
+ * @template Args - Constructor argument types.
+ */
+export type StaticExtended<Extend, InstanceType = any, Args extends any[] = []> = ClassType<InstanceType, Args> & Extend;
+/**
+ * Interface defining all available methods on the `classable` API object.
+ * This provides type-safe access to class manipulation utilities.
+ */
+export interface ClassableAPI {
+    /** Reference to the Placeholder class constructor. */
+    Placeholder: ClassType<Placeholder>;
+    /** Pre-configured placeholder resolver instance. */
+    placeholder: ClassableByResolver<Placeholder>;
+    /** Checks if a value is a class constructor. */
+    is: (fn: unknown) => fn is AnyClass<any>;
+    /** Checks if a value is an abstract class constructor. */
+    isAbstract: (fn: unknown) => fn is AnyAbstractClass<any>;
+    /** Checks if a value is a ClassableByResolver object. */
+    isResolver: <InstanceType, Args extends any[] = [], Runtime = never>(obj: unknown) => obj is ClassableByResolver<InstanceType, Args, Runtime>;
+    /** Converts a class constructor to a resolver configuration. */
+    toResolver<T, A extends any[] = [], R = never>(cls: ClassType<T, A>, runtime?: R): ClassableByResolver<T, [], R>;
+    /** Extracts the target class from a Classable (class or resolver). */
+    getTarget: <Target>(cls: Classable<Target, any[], any>) => Target;
+    /** Creates a new resolver with a custom resolve function. */
+    withResolve: <InstanceType, Args extends any[] = [], Runtime = never>(base: Classable<InstanceType, Args, Runtime>, resolve: ClassableByResolver<InstanceType, Args, Runtime>["resolve"]) => ClassableByResolver<InstanceType, Args, Runtime>;
+    /** Wraps a class with a transformation function. */
+    wrap<T>(cls: ClassType<T>, wrapper: (target: ClassType<T>) => ClassType<T>): ClassType<T>;
+    /** Wraps a resolver's target with a transformation function. */
+    wrap<T, A extends any[], R>(cls: ClassableByResolver<T, A, R>, wrapper: (target: ClassType<T>) => ClassType<T>): ClassableByResolver<T, A, R>;
+    /** Returns metadata about the classable (type and target name). */
+    getDescriptor: (cls: Classable<any, any[], any>) => {
+        type: "class" | "resolver";
+        target: string;
+    };
+    /** Creates an instance from a plain class. */
+    create<InstanceType>(cls: ClassType<InstanceType>): InstanceType;
+    /** Creates an instance from a resolver with sync resolve function. */
+    create<InstanceType, Args extends any[], Runtime>(cls: ClassableByResolver<InstanceType, Args, Runtime> & {
+        resolve: (runtime: Runtime) => Args;
+    }, runtime: Runtime): InstanceType;
+    /** Creates an instance from a resolver with async resolve function. */
+    create<InstanceType, Args extends any[], Runtime>(cls: ClassableByResolver<InstanceType, Args, Runtime> & {
+        resolve: (runtime: Runtime) => Promise<Args>;
+    }, runtime: Runtime): Promise<InstanceType>;
+}
+/**
+ * The main classable API object providing utilities for working with classes and resolvers.
+ *
+ * This frozen object contains methods for:
+ * - Type checking (`is`, `isAbstract`, `isResolver`)
+ * - Converting between formats (`toResolver`, `withResolve`)
+ * - Instance creation (`create`)
+ * - Class manipulation (`wrap`, `getTarget`, `getDescriptor`)
+ *
+ * @example
+ * ```typescript
+ * // Check if something is a class
+ * if (classable.is(MyClass)) {
+ *   const instance = classable.create(MyClass);
+ * }
+ *
+ * // Create instance with resolver
+ * const resolver = {
+ *   target: User,
+ *   resolve: (ctx: AppContext) => [ctx.userName, ctx.userAge]
+ * };
+ * const user = classable.create(resolver, appContext);
+ *
+ * // Wrap a class with middleware
+ * const wrapped = classable.wrap(Logger, (Target) => {
+ *   return class extends Target {
+ *     log(msg: string) {
+ *       super.log(`[${Date.now()}] ${msg}`);
+ *     }
+ *   };
+ * });
+ * ```
+ */
+export declare const classable: Readonly<ClassableAPI>;

package/dist/index.mjs

@@ -0,0 +1 @@
+function e(e,t){return"object"==typeof e&&null!==e&&Object.prototype.hasOwnProperty.call(e,t)}class t{}const r=Object.freeze({target:t,resolve:()=>[]}),o=Object.freeze({Placeholder:t,placeholder:r,is:e=>"function"==typeof e&&/^class\s/.test(Function.prototype.toString.call(e)),isAbstract:e=>"function"==typeof e&&/^abstract\s+class\s/.test(Function.prototype.toString.call(e)),isResolver:t=>e(t,"target")&&o.is(t.target)&&e(t,"resolve")&&"function"==typeof t.resolve,toResolver:e=>o.isResolver(e)?e:{target:e,resolve:()=>[]},create:(e,t)=>{if(o.isResolver(e)){const r=e.resolve(...void 0===t?[]:[t]);return r instanceof Promise?r.then(t=>new e.target(...t)):new e.target(...r)}return new e(...[])},getTarget:e=>o.isResolver(e)?e.target:e,withResolve:(e,t)=>({target:(o.isResolver(e)?e:o.toResolver(e)).target,resolve:t}),wrap:(e,t)=>o.isResolver(e)?{target:t(e.target),resolve:e.resolve}:t(e),getDescriptor:e=>o.isResolver(e)?{type:"resolver",target:e.target.name}:{type:"class",target:e.name}});export{t as Placeholder,o as classable,r as placeholder};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@mxweb/classable",
+  "version": "1.0.0",
+  "description": "A class-first abstraction for defining logic as resolvable units without runtime assumptions.",
+  "license": "MIT",
+  "keywords": [
+    "classable",
+    "class-first",
+    "logic-units",
+    "declarative",
+    "resolver",
+    "meta-programming",
+    "framework-agnostic",
+    "esm-only"
+  ],
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "MxWeb Team <mxwebio@gmail.com>",
+  "homepage": "https://edge.mxweb.io/classable",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "url": "https://github.com/mxwebio/mxweb-classable"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "yarn clean && yarn lint && rollup -c",
+    "build:watch": "rollup -c -w",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx,json,md}\""
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.6",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
+    "glob": "^13.0.0",
+    "prettier": "^3.8.0",
+    "rimraf": "^6.1.2",
+    "rollup": "^4.55.1",
+    "tslib": "^2.8.1",
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ]
+}