ts-packages 1.0.0 → 3.0.0

package/packages/response-utils/README.md

@@ -1,110 +1,204 @@
 # @naman_deep_singh/response-utils
 
-TypeScript utilities for standardized HTTP API responses with common status codes and error handling. Supports both standalone usage and Express.js integration.
+**Version:** 2.1.4
 
-## Installation
+A flexible, framework-agnostic **TypeScript response utility library** for building consistent, typed, and configurable API responses.
 
-```bash
-npm install @naman_deep_singh/response-utils
-```
+Designed with a clean **core + adapter** architecture.  
+First-class support for **Express.js**, pagination, and standardized HTTP status handling.
+
+---
+
+## 🚀 Features
 
-## Features
+| Feature                                      | Status |
+|---------------------------------------------|:------:|
+| Fully typesafe response envelopes            |   ✅   |
+| Framework-agnostic core                      |   ✅   |
+| Express.js responder adapter                 |   ✅   |
+| Express middleware injection                 |   ✅   |
+| Pagination helpers                           |   ✅   |
+| Centralized responder configuration          |   ✅   |
+| HTTP status constants                        |   ✅   |
 
-- ✅ **Standardized API responses** with consistent format
-- ✅ **Express.js integration** - automatically sets HTTP status codes
-- ✅ **TypeScript support** with full type safety
-- ✅ **Hybrid exports** - use named imports or namespace imports
-- ✅ **Pagination support** with metadata
-- ✅ **Common HTTP status codes** (200, 201, 400, 401, 403, 404, 408, 409, 422, 429, 500)
+---
 
-## Usage
+## 📦 Installation
+
+```sh
+npm install @naman_deep_singh/response-utils
+🧠 Architecture Overview
+response-utils
+├─ core/               → Framework-agnostic responders
+│  ├─ BaseResponder
+│  ├─ config
+│  ├─ factory
+│  └─ types
+│
+├─ adapters/
+│  └─ express/         → ExpressResponder
+│
+├─ middleware/
+│  └─ express/         → responderMiddleware
+│
+├─ constants/          → HTTP status constants
+
+📄 Response Envelope (Default Shape)
+interface ResponseEnvelope<P = unknown, M = Record<string, unknown>> {
+  success: boolean
+  message?: string
+  data?: P
+  error: {
+    message: string
+    code?: string
+    details?: unknown
+  } | null
+  meta: M | null
+}
+🛠️ Usage
+✔ Framework-Agnostic (No Express)
+import { BaseResponder } from '@naman_deep_singh/response-utils'
+
+const responder = new BaseResponder()
+
+const result = responder.ok({ user: 'John' }, 'Loaded')
+
+// When no sender is attached, returns:
+// { status: 200, body: ResponseEnvelope }
+console.log(result)
+🌐 Express Integration
+1️⃣ Register Middleware
+import express from 'express'
+import { responderMiddleware } from '@naman_deep_singh/response-utils'
+
+const app = express()
+
+app.use(responderMiddleware())
+This injects a res.responder() factory into every request.
+
+2️⃣ Controller Usage
+app.get('/user', (req, res) => {
+  const responder = res.responder<{ id: number; name: string }>()
+
+  responder.okAndSend(
+    { id: 1, name: 'John Doe' },
+    'User found'
+  )
+})
+✅ okAndSend() automatically:
+
+sets HTTP status
+
+sends JSON response
+
+returns void for clean controller ergonomics
+
+⚙️ Middleware Configuration
+app.use(
+  responderMiddleware({
+    timestamp: true,
+    extra: { service: 'user-service' },
+  })
+)
+Example response:
+
+{
+  "success": true,
+  "data": { ... },
+  "error": null,
+  "meta": {
+    "timestamp": "2025-11-22T12:00:00Z"
+  },
+  "service": "user-service"
+}
+🔢 Pagination Support
+responder.paginateAndSend(
+  [{ id: 1 }],
+  1,    // page
+  10,   // limit
+  42,   // total
+  'Loaded'
+)
+Pagination metadata is automatically calculated.
+
+📚 Available Methods
+✅ Success Responses
+Method	HTTP
+ok()	200
+created()	201
+noContent()	204
+paginate()	200
+Each method has an Express variant:
+
+okAndSend()
+
+createdAndSend()
+
+paginateAndSend()
+
+❌ Error Responses
+Method	HTTP
+badRequest()	400
+unauthorized()	401
+forbidden()	403
+notFound()	404
+conflict()	409
+unprocessableEntity()	422
+tooManyRequests()	429
+serverError()	500
+Each also has a *AndSend() variant.
+
+🧩 HTTP Status Constants
+import { HTTP_STATUS } from '@naman_deep_singh/response-utils'
+
+HTTP_STATUS.SUCCESS.OK              // 200
+HTTP_STATUS.CLIENT_ERROR.NOT_FOUND  // 404
+HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR // 500
+Categories
+SUCCESS
+
+REDIRECTION
+
+CLIENT_ERROR
+
+SERVER_ERROR
+
+✔ Object.freeze() protected
+✔ Fully literal-typed (as const)
+✔ IDE autocomplete friendly
+
+🧩 TypeScript: Express Response Augmentation (Recommended)
+For full type safety, add this once in your project:
+
+import type { ExpressResponder } from '@naman_deep_singh/response-utils'
+
+declare global {
+  namespace Express {
+    interface Response {
+      responder: <P = unknown>() => ExpressResponder<P>
+    }
+  }
+}
 
-### Named Imports (Tree-shakable)
-```typescript
-import { success, error, created, notFound, paginated } from '@naman_deep_singh/response-utils';
+⚠️ Do not use for new projects.
 
-// Success responses
-const userResponse = success({ id: 1, name: 'John' }, 'User found');
-const createdResponse = created({ id: 2, name: 'Jane' });
+🔗 Integration with Other Packages
+With @naman_deep_singh/server-utils
+import { responderMiddleware } from '@naman_deep_singh/response-utils'
 
-// Error responses
-const errorResponse = notFound('User not found');
-const validationResponse = validationError('Invalid input', ['Name is required']);
+server.app.use(responderMiddleware())
+With @naman_deep_singh/errors-utils
+import { expressErrorHandler } from '@naman_deep_singh/errors-utils'
 
-// Paginated responses
-const paginatedUsers = paginated([{id: 1}, {id: 2}], 1, 10, 25);
-```
+server.app.use(expressErrorHandler)
+Provides consistent error responses across services.
 
-### Namespace Import
-```typescript
-import ResponseUtils from '@naman_deep_singh/response-utils';
+🔜 Roadmap
+Fastify adapter
 
-const response = ResponseUtils.success({ id: 1 }, 'Success');
-```
+Hono adapter
 
-### Express.js Integration
-```typescript
-import { success, notFound } from '@naman_deep_singh/response-utils';
-import { Request, Response } from 'express';
+Configurable envelope key mapping
 
-app.get('/users/:id', (req: Request, res: Response) => {
-  const user = findUser(req.params.id);
-  
-  if (!user) {
-    return notFound('User not found', res); // Sets status 404 and sends response
-  }
-  
-  return success(user, 'User found', 200, res); // Sets status 200 and sends response
-});
-```
-
-## API Reference
-
-### Success Responses
-- `success<T>(data: T, message?, statusCode?, res?)` - Generic success response (200)
-- `created<T>(data: T, message?, res?)` - 201 Created response
-- `noContent(message?, res?)` - 204 No Content response
-- `paginated<T>(data: T[], page, limit, total, message?, res?)` - Paginated response with metadata
-
-### Error Responses
-- `error(message, statusCode?, error?, res?)` - Generic error response
-- `badRequest(message?, validationError?, res?)` - 400 Bad Request
-- `unauthorized(message?, res?)` - 401 Unauthorized
-- `forbidden(message?, res?)` - 403 Forbidden
-- `notFound(message?, res?)` - 404 Not Found
-- `timeout(message?, res?)` - 408 Request Timeout
-- `conflict(message?, res?)` - 409 Conflict
-- `validationError(message?, errors[], res?)` - 422 Validation Error
-- `tooManyRequests(message?, res?)` - 429 Too Many Requests
-- `serverError(message?, res?)` - 500 Internal Server Error
-
-### Utility Functions
-- `logError(context: string, error: unknown)` - Structured error logging
-- `getErrorMessage(error: unknown)` - Extract error message safely
-
-## Response Format
-
-All responses follow the `ApiResponse<T>` interface:
-
-```typescript
-interface ApiResponse<T = any> {
-  success: boolean;
-  message: string;
-  data?: T;
-  error?: string;
-  statusCode: number;
-}
-```
-
-## Paginated Response Format
-
-```typescript
-interface PaginatedResponse<T> extends ApiResponse<T[]> {
-  pagination: {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-  };
-}
-```
+📄 License
+MIT © Naman Deep Singh

package/packages/response-utils/dist/cjs/adapters/express/ExpressResponder.d.ts

@@ -0,0 +1,18 @@
+import type { Response } from 'express';
+import { BaseResponder } from '../../core/BaseResponder';
+import type { ResponderConfig } from '../../core/config';
+export declare class ExpressResponder<P = unknown> extends BaseResponder<P> {
+    private readonly res;
+    constructor(cfg: Partial<ResponderConfig> | undefined, res: Response);
+    okAndSend(data?: P, message?: string): void;
+    createdAndSend(data?: P, message?: string): void;
+    badRequestAndSend(message?: string, error?: unknown): void;
+    unauthorizedAndSend(message?: string): void;
+    forbiddenAndSend(message?: string): void;
+    notFoundAndSend(message?: string): void;
+    conflictAndSend(message?: string): void;
+    unprocessableEntityAndSend(message?: string, error?: unknown): void;
+    tooManyRequestsAndSend(message?: string): void;
+    serverErrorAndSend(message?: string, error?: unknown): void;
+    paginateAndSend(data: P[], page: number, limit: number, total: number, message?: string): void;
+}

package/packages/response-utils/dist/cjs/adapters/express/ExpressResponder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressResponder = void 0;
+const BaseResponder_1 = require("../../core/BaseResponder");
+class ExpressResponder extends BaseResponder_1.BaseResponder {
+    constructor(cfg, res) {
+        // attach sender which calls res.status().json()
+        super(cfg, (status, body) => res.status(status).json(body));
+        this.res = res;
+    }
+    // convenience methods that return void for middleware/controller ergonomics
+    okAndSend(data, message) {
+        void this.ok(data, message);
+    }
+    createdAndSend(data, message) {
+        void this.created(data, message);
+    }
+    badRequestAndSend(message, error) {
+        void this.badRequest(message, error);
+    }
+    unauthorizedAndSend(message) {
+        void this.unauthorized(message);
+    }
+    forbiddenAndSend(message) {
+        void this.forbidden(message);
+    }
+    notFoundAndSend(message) {
+        void this.notFound(message);
+    }
+    conflictAndSend(message) {
+        void this.conflict(message);
+    }
+    unprocessableEntityAndSend(message, error) {
+        void this.unprocessableEntity(message, error);
+    }
+    tooManyRequestsAndSend(message) {
+        void this.tooManyRequests(message);
+    }
+    serverErrorAndSend(message, error) {
+        void this.serverError(message, error);
+    }
+    paginateAndSend(data, page, limit, total, message) {
+        void this.paginate(data, page, limit, total, message);
+    }
+}
+exports.ExpressResponder = ExpressResponder;

package/packages/response-utils/dist/cjs/constants/httpStatus.d.ts

@@ -0,0 +1,54 @@
+declare const SUCCESS: Readonly<{
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly ACCEPTED: 202;
+    readonly NO_CONTENT: 204;
+}>;
+declare const REDIRECTION: Readonly<{
+    readonly NOT_MODIFIED: 304;
+}>;
+declare const CLIENT_ERROR: Readonly<{
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly CONFLICT: 409;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly TOO_MANY_REQUESTS: 429;
+}>;
+declare const SERVER_ERROR: Readonly<{
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+}>;
+export declare const HTTP_STATUS: Readonly<{
+    readonly SUCCESS: Readonly<{
+        readonly OK: 200;
+        readonly CREATED: 201;
+        readonly ACCEPTED: 202;
+        readonly NO_CONTENT: 204;
+    }>;
+    readonly REDIRECTION: Readonly<{
+        readonly NOT_MODIFIED: 304;
+    }>;
+    readonly CLIENT_ERROR: Readonly<{
+        readonly BAD_REQUEST: 400;
+        readonly UNAUTHORIZED: 401;
+        readonly FORBIDDEN: 403;
+        readonly NOT_FOUND: 404;
+        readonly METHOD_NOT_ALLOWED: 405;
+        readonly CONFLICT: 409;
+        readonly UNPROCESSABLE_ENTITY: 422;
+        readonly TOO_MANY_REQUESTS: 429;
+    }>;
+    readonly SERVER_ERROR: Readonly<{
+        readonly INTERNAL_SERVER_ERROR: 500;
+        readonly NOT_IMPLEMENTED: 501;
+        readonly BAD_GATEWAY: 502;
+        readonly SERVICE_UNAVAILABLE: 503;
+    }>;
+}>;
+export type HttpStatusCode = (typeof SUCCESS)[keyof typeof SUCCESS] | (typeof REDIRECTION)[keyof typeof REDIRECTION] | (typeof CLIENT_ERROR)[keyof typeof CLIENT_ERROR] | (typeof SERVER_ERROR)[keyof typeof SERVER_ERROR];
+export {};

package/packages/response-utils/dist/cjs/constants/httpStatus.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_STATUS = void 0;
+const SUCCESS = Object.freeze({
+    OK: 200,
+    CREATED: 201,
+    ACCEPTED: 202,
+    NO_CONTENT: 204,
+});
+const REDIRECTION = Object.freeze({
+    NOT_MODIFIED: 304,
+});
+const CLIENT_ERROR = Object.freeze({
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    METHOD_NOT_ALLOWED: 405,
+    CONFLICT: 409,
+    UNPROCESSABLE_ENTITY: 422,
+    TOO_MANY_REQUESTS: 429,
+});
+const SERVER_ERROR = Object.freeze({
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+});
+exports.HTTP_STATUS = Object.freeze({
+    SUCCESS,
+    REDIRECTION,
+    CLIENT_ERROR,
+    SERVER_ERROR,
+});

package/packages/response-utils/dist/cjs/core/BaseResponder.d.ts

@@ -0,0 +1,31 @@
+import { type ResponderConfig } from './config';
+import type { PaginationMeta, ResponseEnvelope, Sender } from './types';
+export declare class BaseResponder<P = unknown, M = PaginationMeta> {
+    protected readonly cfg: ResponderConfig;
+    protected sender?: Sender;
+    constructor(cfg?: Partial<ResponderConfig>, sender?: Sender);
+    attachSender(sender: Sender): void;
+    protected normalizeError(err: unknown): {
+        message: string;
+        code?: string;
+        details?: unknown;
+    };
+    protected buildEnvelope(data?: P, message?: string, error?: unknown, meta?: M): ResponseEnvelope<P, M>;
+    protected send(status: number, envelope: ResponseEnvelope<P, M>): any;
+    /** -----------------------------
+     *  Standard REST Response Helpers
+     * ----------------------------- */
+    ok(data?: P, message?: string): any;
+    created(data?: P, message?: string): any;
+    noContent(message?: string): any;
+    badRequest(message?: string, error?: unknown): any;
+    unauthorized(message?: string): any;
+    forbidden(message?: string): any;
+    notFound(message?: string): any;
+    conflict(message?: string): any;
+    unprocessableEntity(message?: string, error?: unknown): any;
+    tooManyRequests(message?: string): any;
+    serverError(message?: string, error?: unknown): any;
+    paginate(data: P[], page: number, limit: number, total: number, message?: string): any;
+    paginateOffset(data: P[], offset: number, limit: number, total: number, message?: string): any;
+}

package/packages/response-utils/dist/cjs/core/BaseResponder.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResponder = void 0;
+const httpStatus_1 = require("../constants/httpStatus");
+const config_1 = require("./config");
+class BaseResponder {
+    constructor(cfg, sender) {
+        this.cfg = { ...config_1.defaultConfig, ...(cfg ?? {}) };
+        this.sender = sender;
+    }
+    attachSender(sender) {
+        this.sender = sender;
+    }
+    normalizeError(err) {
+        // errors-utils AppError compatibility
+        if (typeof err === 'object' && err !== null) {
+            const e = err;
+            if (typeof e.message === 'string') {
+                return {
+                    message: e.message,
+                    code: typeof e.code === 'string' ? e.code : undefined,
+                    details: e.details,
+                };
+            }
+        }
+        if (err instanceof Error) {
+            return { message: err.message };
+        }
+        if (typeof err === 'string') {
+            return { message: err };
+        }
+        return {
+            message: 'Internal server error',
+            details: err,
+        };
+    }
+    buildEnvelope(data, message, error, meta) {
+        const env = {
+            success: !error,
+            message: message ?? (error ? 'Error' : undefined),
+            data: error ? undefined : data,
+            error: error ? this.normalizeError(error) : null,
+            meta: meta ?? null,
+        };
+        if (this.cfg.timestamp) {
+            env.meta = {
+                ...(env.meta ?? {}),
+                timestamp: new Date().toISOString(),
+            };
+        }
+        if (this.cfg.extra) {
+            Object.assign(env, this.cfg.extra);
+        }
+        return env;
+    }
+    send(status, envelope) {
+        if (!this.sender)
+            return { status, body: envelope };
+        return this.sender(status, envelope);
+    }
+    /** -----------------------------
+     *  Standard REST Response Helpers
+     * ----------------------------- */
+    ok(data, message = 'Success') {
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.OK, this.buildEnvelope(data, message));
+    }
+    created(data, message = 'Created successfully') {
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.CREATED, this.buildEnvelope(data, message));
+    }
+    noContent(message = 'No Content') {
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.NO_CONTENT, this.buildEnvelope(undefined, message));
+    }
+    badRequest(message = 'Bad request', error) {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.BAD_REQUEST, this.buildEnvelope(undefined, message, error));
+    }
+    unauthorized(message = 'Unauthorized') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.UNAUTHORIZED, this.buildEnvelope(undefined, message));
+    }
+    forbidden(message = 'Forbidden') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.FORBIDDEN, this.buildEnvelope(undefined, message));
+    }
+    notFound(message = 'Not found') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.NOT_FOUND, this.buildEnvelope(undefined, message));
+    }
+    conflict(message = 'Conflict') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.CONFLICT, this.buildEnvelope(undefined, message));
+    }
+    unprocessableEntity(message = 'Unprocessable Entity', error) {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.UNPROCESSABLE_ENTITY, this.buildEnvelope(undefined, message, error));
+    }
+    tooManyRequests(message = 'Too Many Requests') {
+        return this.send(httpStatus_1.HTTP_STATUS.CLIENT_ERROR.TOO_MANY_REQUESTS, this.buildEnvelope(undefined, message));
+    }
+    serverError(message = 'Internal server error', error) {
+        return this.send(httpStatus_1.HTTP_STATUS.SERVER_ERROR.INTERNAL_SERVER_ERROR, this.buildEnvelope(undefined, message, error));
+    }
+    paginate(data, page, limit, total, message = 'Success') {
+        const totalPages = Math.max(1, Math.ceil(total / limit));
+        const offset = (page - 1) * limit;
+        const pagination = {
+            page,
+            limit,
+            total,
+            totalPages,
+            offset,
+            hasNext: page < totalPages,
+            hasPrev: page > 1,
+        };
+        return this.send(httpStatus_1.HTTP_STATUS.SUCCESS.OK, this.buildEnvelope(data, message, undefined, pagination));
+    }
+    paginateOffset(data, offset, limit, total, message = 'Success') {
+        const page = Math.floor(offset / limit) + 1;
+        return this.paginate(data, page, limit, total, message);
+    }
+}
+exports.BaseResponder = BaseResponder;

package/packages/response-utils/dist/cjs/core/config.d.ts

@@ -0,0 +1,15 @@
+import type { PlainObject } from './types';
+export type EnvelopeKeys = {
+    success?: string;
+    message?: string;
+    data?: string;
+    error?: string;
+    meta?: string;
+};
+export type ResponderConfig = {
+    envelopeKeys?: EnvelopeKeys;
+    defaultStatus?: number;
+    timestamp?: boolean;
+    extra?: PlainObject | null;
+};
+export declare const defaultConfig: ResponderConfig;

package/packages/response-utils/dist/cjs/core/config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = void 0;
+exports.defaultConfig = {
+    envelopeKeys: {
+        success: 'success',
+        message: 'message',
+        data: 'data',
+        error: 'error',
+        meta: 'meta',
+    },
+    defaultStatus: 200,
+    timestamp: false,
+    extra: null,
+};

package/packages/response-utils/dist/cjs/core/factory.d.ts

@@ -0,0 +1,3 @@
+import { ExpressResponder } from '../adapters/express/ExpressResponder';
+import type { ResponderConfig } from './config';
+export declare const createResponderFactory: (cfg?: Partial<ResponderConfig>) => <P = unknown, _M = Record<string, unknown>>(res: import("express").Response) => ExpressResponder<P>;

package/packages/response-utils/dist/cjs/core/factory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResponderFactory = void 0;
+const ExpressResponder_1 = require("../adapters/express/ExpressResponder");
+const createResponderFactory = (cfg) => {
+    return (res) => {
+        return new ExpressResponder_1.ExpressResponder(cfg, res);
+    };
+};
+exports.createResponderFactory = createResponderFactory;

package/packages/response-utils/dist/cjs/core/types.d.ts

@@ -0,0 +1,32 @@
+export type PlainObject = Record<string, unknown>;
+export type ErrorShape = {
+    code?: string;
+    message: string;
+    details?: unknown;
+};
+export type ResponseEnvelope<T = unknown, M = PlainObject> = {
+    success: boolean;
+    message?: string;
+    data?: T;
+    error?: ErrorShape | null;
+    meta?: M | null;
+};
+export type TransportResult = {
+    status: number;
+    body: unknown;
+};
+export type Sender = (status: number, body: unknown) => Promise<any> | any;
+export interface PaginationMeta {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNext?: boolean;
+    hasPrev?: boolean;
+    offset?: number;
+    links?: {
+        next?: string;
+        prev?: string;
+        self: string;
+    };
+}

package/packages/response-utils/dist/cjs/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });