qhttpx 1.8.0

package/.eslintrc.json

@@ -0,0 +1,22 @@
+{
+  "root": true,
+  "env": {
+    "es2020": true,
+    "node": true
+  },
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "./tsconfig.json",
+    "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended"
+  ],
+  "rules": {
+    "@typescript-eslint/no-explicit-any": "off"
+  },
+  "ignorePatterns": ["dist/**", "node_modules/**"]
+}

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  pull_request:
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Test
+        run: npm test
+

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,37 @@
+name: Publish to NPM
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Test
+        run: npm test
+
+      - name: Publish to NPM
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/release.yml

@@ -0,0 +1,21 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          generate_release_notes: true

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "singleQuote": true,
+  "semi": true,
+  "trailingComma": "all",
+  "printWidth": 80,
+  "endOfLine": "auto"
+}

package/CHANGELOG.md

@@ -0,0 +1,145 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.8.0] - 2026-01-20
+**"The Full-Stack Update"**
+
+### Added
+- **Compression Middleware**: Native support for Gzip, Brotli, and Deflate response compression with auto-thresholding (default 1KB) and stream piping.
+- **Server-Sent Events (SSE)**: Built-in `createSSE()` helper for easy real-time event streaming with automatic header management and connection persistence.
+- **Advanced Static Files**: Completely rewritten `static` middleware with support for **Streaming**, **Range Requests** (for video), and **HTTP Caching** (ETag/Last-Modified/304).
+- **Multipart Support**: Integrated `busboy` for high-performance `multipart/form-data` parsing. Files are automatically available in `ctx.files`.
+- **View Engine**: New `ViewEngine` interface and `ctx.render()` method for server-side template rendering (supports EJS, Pug, etc. via adapters).
+- **WebSocket Channels**: Enhanced WebSocket support with a Pub/Sub "Rooms" system for easy broadcasting to specific groups of clients.
+- **Zod Integration**: Official support for Zod schemas in `ctx.validate()`, enabling robust type-safe validation.
+
+## [1.7.0] - 2026-01-20
+**"The Developer Experience Update"**
+
+### Added
+- **QCLI**: New Command Line Interface (`qhttpx`) for streamlined development and deployment.
+- **Cluster Mode**: `qhttpx start <file>` automatically forks workers across all CPU cores for maximum performance.
+- **Dev Mode**: `qhttpx dev <file>` provides hot-reloading and TypeScript support out of the box.
+- **Resilience**: Built-in worker monitoring and automatic restart on crash in production mode.
+
+## [1.6.0] - 2026-01-20
+**"The Extension Update"**
+
+### Added
+- **Plugin System**: Full-featured Extension Protocol allowing modular architecture via `app.register()`.
+- **Scoped Routing**: Plugins run in isolated scopes with automatic path prefixing (e.g., `app.register(api, { prefix: '/api' })`).
+- **Async Initialization**: Plugins can be async (e.g., for database connections), and the server waits for them.
+- **Nested Plugins**: Plugins can register other plugins, inheriting and concatenating prefixes automatically.
+- **Encapsulation**: `QHTTPXScope` ensures plugins don't accidentally pollute the global namespace.
+
+## [1.5.0] - 2026-01-20
+**"The Aegis Update"**
+
+### Added
+- **Aegis Rate Limiter**: High-performance, Token Bucket-based rate limiting middleware to protect against DDoS and abuse.
+- **Dual-Layer Storage**: Default in-memory storage with automatic cleanup, designed to be swappable with Redis/KV stores.
+- **Smart Headers**: Automatic `X-RateLimit-*` and `Retry-After` header injection for standard compliance.
+- **Flexible Keys**: Support for custom key generators (IP, API Key, User ID) to enable tiered rate limiting.
+
+## [1.4.0] - 2026-01-20
+**"The Quantum Collapse Update"**
+
+### Added
+- **Request Fusion Engine**: A revolutionary request-level coalescing system (Layer 2) that collapses simultaneous requests to the same endpoint into a single execution.
+- **In-Flight Deduplication**: Simultaneous requests for the same resource (based on semantic key) are merged into a "Leader-Follower" model where only one handler runs.
+- **Micro-TTL Caching**: Optional short-lived cache (5-20ms) to coalesce burst traffic that arrives slightly out of sync.
+- **Semantic Hashing**: Intelligent request key generation based on Method + Route + Query + Body + Vary Headers.
+- **Vary Header Support**: Automatic isolation of authenticated requests (Authorization, Cookie) to prevent cross-user data leaks.
+
+## [1.3.0] - 2026-01-20
+**"The Documentation Update"**
+
+### Added
+- **OpenAPI Generator**: New `app.getOpenAPI()` method automatically generates OpenAPI 3.0 specs from your routes and schemas.
+- **Schema Mapping**: `SimpleValidator` schemas are automatically converted to Swagger-compatible JSON schemas.
+- **Auto-Discovery**: Automatically infers path parameters (e.g., `/{id}`) and query parameters from your code.
+
+## [1.2.0] - 2026-01-20
+**"The Guardrails Update"**
+
+### Added
+- **Input Validation**: Built-in, zero-dependency `SimpleValidator` for Request Body, Query Parameters, and URL Params.
+- **Automatic Coercion**: Query parameters (e.g., `?page=1`) are automatically converted to numbers/booleans if defined in the schema.
+- **Type Safety**: Routes now reject invalid requests with `400 Bad Request` and detailed error messages before they reach your handler.
+- **Extensible Validation**: Support for custom validators (e.g., Zod, Joi) via the `Validator` interface.
+- **Route Schema**: New `schema` structure supporting `{ body, query, params, response }`.
+
+## [1.1.0] - 2026-01-20
+**"The Database & Batch Engine Update"**
+
+### Added
+- **Multi-Database Engine**: New `DatabaseManager` supporting multiple database backends with connection pooling.
+- **Database Adapters**: Built-in, zero-dependency adapters for:
+  - **PostgreSQL**: High-performance pooling via `pg`.
+  - **MongoDB**: Native query and aggregation support via `mongodb`.
+  - **Memory**: In-memory database for testing and prototyping.
+- **Smart Query Fusion**: `QueryCoalescer` automatically merges identical queries (e.g., `SELECT ... WHERE id = ?`) into single batched queries (e.g., `WHERE id IN (...)`) to reduce network roundtrips.
+- **Batch Execution Engine**: New `BatchExecutor` allows clients to send multiple operations in a single HTTP request, automatically routed to fused database queries.
+- **Dynamic Imports**: Database drivers (`pg`, `mongodb`) are now optional peer dependencies, keeping the core lightweight.
+- **Flexible Registration**: Support for bringing your own pre-initialized database connections via `registerConnection()`.
+
+## [1.0.0] - 2026-01-19
+**"The Enterprise Release"**
+
+### Added
+- **Simplification**: Introduced `createHttpApp()` for instant, Express-like server setup.
+- **WebSocket Support**: Full WebSocket upgrade handling via `app.websocket()` and `WebSocketManager`.
+- **Cookie Management**: Native cookie parsing and serialization support (`ctx.cookies`, `ctx.setCookie`).
+- **Body Parsing**: Integrated `BodyParser` for automatic JSON and URL-encoded body handling.
+- **Developer Experience**: Enhanced logging with color-coded status and precise timing.
+
+### Changed
+- **Architecture**: Complete codebase restructuring into modular domains (`core`, `router`, `middleware`, `utils`).
+- **Refactoring**: Decoupled monolithic `server.ts` into specialized components.
+- **Imports**: Optimized internal imports and fixed circular dependencies.
+
+### Fixed
+- **Logging**: Fixed 200 OK logs appearing for 404/500 errors.
+- **Timing**: Corrected request duration metrics (0ms bug).
+- **Stability**: Resolved port conflicts and improved error propagation in async handlers.
+
+## [0.9.0] - 2025-12-20
+**"The Performance Update"**
+
+### Added
+- **Resource Management**: Added `BufferPool` for efficient memory reuse during high-load I/O.
+- **Context Pooling**: Implemented zero-allocation `QHTTPXContext` reuse to reduce GC pressure.
+- **Adaptive Scaling**: Added automatic worker calculation based on CPU cores (`calculateWorkerCount`).
+- **Overload Protection**: Added `isResourceOverloaded` checks for memory/CPU thresholds.
+
+### Changed
+- **Performance**: Optimized request pipeline to minimize closure allocations.
+
+## [0.8.0] - 2025-11-15
+**"The Task Engine Update"**
+
+### Added
+- **Background Tasks**: Introduced `TaskEngine` and `Scheduler` for async job processing.
+- **API**: Added `app.task()` for registering job handlers and `app.enqueue()` for dispatching jobs.
+- **Observability**: Added `/metrics` endpoint exposing task queue depths and worker status.
+
+## [0.5.0] - 2025-10-01
+**"The Middleware Update"**
+
+### Added
+- **Middleware Pipeline**: Implemented `app.use()` and the recursive middleware execution model.
+- **Standard Middleware**: Added built-in middleware for:
+  - `cors`: Cross-Origin Resource Sharing support.
+  - `static`: Efficient static file serving.
+  - `security`: Helmet-like security headers.
+  - `logger`: Request/Response logging.
+
+## [0.1.0] - 2025-09-01
+**"Genesis"**
+
+### Added
+- **Core Server**: Initial HTTP server implementation using Node.js native `http` module.
+- **Routing**: High-performance Radix Tree router (O(1) lookup) for dynamic and static routes.
+- **Context API**: Unified `ctx` object wrapping `req` and `res` (inspired by Koa/Fastify).
+- **JSON Support**: Basic `ctx.json()` helper.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Quantam Open Source
+
+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,343 @@
+<div align="center">
+  <img src="https://placehold.co/200x200?text=QHTTPX" alt="QHTTPX Logo" width="200" height="200" />
+</div>
+
+# QHTTPX
+
+[![npm version](https://img.shields.io/npm/v/qhttpx.svg)](https://www.npmjs.com/package/qhttpx)
+[![License](https://img.shields.io/npm/l/qhttpx.svg)](https://github.com/Quantam-Open-Source/qhttpx/blob/main/LICENSE)
+[![Downloads](https://img.shields.io/npm/dm/qhttpx.svg)](https://www.npmjs.com/package/qhttpx)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+**URL:** https://qhttpx.gridrr.com
+
+QHTTPX is a high-performance, concurrency-native hybrid HTTP runtime for Node.js, designed to outperform traditional frameworks like Express and Fastify under real-world load, even on low-resource machines (1GB RAM and small CPUs).
+
+It is built from the ground up for:
+- Extreme concurrency  
+- Non-blocking execution  
+- Adaptive scaling  
+- Zero-waste resource usage  
+- Async-first, task-aware scheduling  
+
+QHTTPX is not just a web framework. It is a runtime engine for HTTP, background tasks, and streaming workloads sharing one unified scheduler.
+
+---
+
+## Vision
+
+- One engine.  
+- Millions of concurrent connections.  
+- No blocking. No stalls. No wasted CPU.  
+- From 1GB VPS to multi-core servers — same code, linear scale.  
+
+---
+
+## Key Features
+
+### 1. Concurrency-Native Core
+- Cooperative async scheduler  
+- Backpressure-aware pipelines  
+- No blocking in hot paths  
+- Request, stream, and task execution share the same engine  
+
+### 2. Hybrid Runtime
+QHTTPX runs:
+- HTTP requests  
+- Streaming responses  
+- Background jobs  
+- Long-running async workflows  
+
+All inside one unified concurrency model.
+
+### 3. Ultra-Fast Routing
+- Radix tree based  
+- Zero regex  
+- O(1) static route resolution  
+- Minimal allocations per request  
+
+### 4. Resource-Aware Scaling
+- Auto worker scaling  
+- CPU pressure detection  
+- Memory pressure detection  
+- Adaptive queue limits  
+- Graceful overload handling (no crashes, no OOM)  
+
+### 5. Zero-Overhead Pipeline
+- Flattened async middleware  
+- No deep stacks  
+- No promise churn  
+- Context reuse and pooling  
+
+### 7. Full-Stack Ready
+- **Native Ecosystem**: Works with `jose` (JWT), `ioredis`, `Prisma`, `Drizzle`.
+- **Advanced Static Files**: Streaming, Range Requests (Video), and Caching.
+- **Real-Time**: Built-in SSE and WebSocket Rooms.
+- **Multipart**: Native file upload support.
+
+---
+
+## Installation (Preview)
+
+```bash
+npm install qhttpx
+```
+
+---
+
+## Basic Usage
+
+```ts
+import { createHttpApp } from "qhttpx";
+
+// Create an app (Express-style)
+// Automatically includes: CORS, Security Headers, Logging, Body Parsing
+const app = createHttpApp();
+
+app.get("/", (ctx) => {
+  ctx.json({ message: "Hello from QHTTPX" });
+});
+
+// Cookie & Helper Support
+app.get("/hello", (ctx) => {
+  ctx.setCookie("name", "QHTTPX");
+  ctx.html("<h1>Hello World</h1>");
+});
+
+app.listen(3000, "127.0.0.1").then(({ port }) => {
+  console.log(`Server running at http://localhost:${port}`);
+});
+```
+
+## Features
+
+### 🍪 Built-in Cookie Support
+RFC-compliant cookie parsing and serialization out of the box.
+
+```ts
+app.get('/', (ctx) => {
+  const token = ctx.cookies['token'];
+  ctx.setCookie('visited', 'true', { httpOnly: true, maxAge: 3600 });
+});
+```
+
+### 🛠️ DX Helpers
+Built-in helpers for common tasks:
+- `ctx.json(data, status)`
+- `ctx.html(content, status)`
+- `ctx.send(body, status)`
+- `ctx.redirect(url, status)`
+
+## Advanced Usage
+
+For full control over the runtime configuration:
+
+```ts
+import { QHTTPX } from "qhttpx";
+
+const app = new QHTTPX({
+  workers: "auto",
+  maxConcurrency: 1000,
+  requestTimeoutMs: 2_000,
+  maxMemoryBytes: 512 * 1024 * 1024,
+});
+
+
+---
+
+## Core API
+
+### Server
+
+```ts
+new QHTTPX(options);
+```
+
+**Options**
+
+| Option            | Description                                      |
+| ----------------- | ------------------------------------------------ |
+| `workers`         | Number of workers or `"auto"`                    |
+| `maxConcurrency`  | Hard limit for in-flight scheduled tasks        |
+| `requestTimeoutMs`| Per-request timeout in milliseconds              |
+| `maxMemoryBytes`  | RSS threshold for returning 503 overload        |
+
+### Routing
+
+```ts
+app.get(path, handler);
+app.post(path, handler);
+app.put(path, handler);
+app.delete(path, handler);
+```
+
+**Example**
+
+```ts
+app.get("/users/:id", ctx => {
+  return ctx.json({ id: ctx.params.id });
+});
+```
+
+---
+
+## Middleware
+
+```ts
+app.use(async (ctx, next) => {
+  const start = Date.now();
+  await next();
+  const duration = Date.now() - start;
+  ctx.res.setHeader("x-response-time", `${duration}ms`);
+});
+```
+
+### Built-in helpers
+
+```ts
+import {
+  createCorsMiddleware,
+  createSecurityHeadersMiddleware,
+  createStaticMiddleware,
+  createLoggerMiddleware,
+} from "qhttpx";
+
+app.use(createCorsMiddleware());
+app.use(createSecurityHeadersMiddleware());
+app.use(
+  createStaticMiddleware({
+    root: "./public",
+    index: "index.html",
+    fallthrough: true,
+  }),
+);
+app.use(createLoggerMiddleware());
+```
+
+These helpers provide:
+
+- CORS headers and preflight handling  
+- Security headers (CSP, referrer policy, X-Frame-Options, etc.)  
+- Static file serving from a directory  
+- Structured request logging with pluggable sink  
+
+---
+
+## Context
+
+Each request receives a high-performance context:
+
+- `ctx.req`        – raw Node request  
+- `ctx.res`        – raw Node response  
+- `ctx.body`       – parsed body (JSON for application/json, otherwise Buffer)  
+- `ctx.query`      – parsed query parameters  
+- `ctx.params`     – route params from the path  
+- `ctx.json()`     – fast JSON response helper  
+- `ctx.send()`     – buffer / text response helper  
+
+### Streaming helpers
+
+QHTTPX also exposes helpers for streaming and Server-Sent Events:
+
+```ts
+import { createSseStream, sendStream } from "qhttpx";
+
+app.get("/events", (ctx) => {
+  const sse = createSseStream(ctx, { retryMs: 2000 });
+  sse.send({ message: "hello" });
+  sse.close();
+});
+
+app.get("/download", async (ctx) => {
+  const fileStream = fs.createReadStream("big-file.dat");
+  await sendStream(ctx, fileStream, {
+    contentType: "application/octet-stream",
+    status: 200,
+  });
+});
+```
+
+---
+
+## Hybrid Task Engine (v0.2+)
+
+```ts
+app.task("email-worker", async job => {
+  // background execution using same scheduler as HTTP
+});
+```
+
+The same scheduler that powers HTTP requests also powers background tasks and long-running async workflows.
+
+---
+
+## Built-in Observability
+
+**Endpoints**
+- `/__qhttpx/health`  
+- `/__qhttpx/metrics`  
+
+**Metrics include**
+- Requests per second  
+- Active workers  
+- Event loop lag  
+- Memory usage  
+- Queue depth  
+- P50 / P95 / P99 latency  
+
+---
+
+## Performance Goals
+
+QHTTPX v1.0 targets:
+
+| Metric        | Goal                                  |
+| ------------- | ------------------------------------- |
+| Throughput    | Faster than Fastify by 15–30%        |
+| Latency       | Lower P99 than Fastify               |
+| Memory        | Lower per-connection footprint       |
+| Cold start    | < 30ms                               |
+| 1GB RAM       | No OOM under 100k concurrent connections |
+
+---
+
+## Philosophy
+
+- Fastify optimizes HTTP.  
+- Express simplifies developer experience.  
+- QHTTPX optimizes execution itself.  
+
+It treats HTTP as just one workload type inside a high-performance concurrency engine.
+
+---
+
+## Roadmap
+
+### v0.1.0
+- Core runtime  
+- Scheduler  
+- Radix router  
+- HTTP/1.1  
+- Worker scaling  
+- Metrics  
+- Graceful shutdown  
+
+### v0.5.0
+- HTTP/2  
+- Zero-copy serializers  
+- C++ / WASM hot path  
+- Kernel socket tuning  
+
+### v1.0.0
+- Outperform Fastify in real benchmarks  
+- Hybrid task + HTTP engine  
+- Distributed mesh mode  
+- Quantam workflow native integration  
+
+---
+
+## Positioning Statement
+
+**QHTTPX**  
+A concurrency-native hybrid HTTP runtime built to extract maximum throughput from minimal hardware, designed to outperform Fastify and Express under extreme load while serving as the execution core for next-generation async systems.
+

package/dist/package.json

@@ -0,0 +1,61 @@
+{
+    "name": "qhttpx",
+    "version": "1.8.0",
+    "description": "**URL:** https://qhttpx.gridrr.com",
+    "main": "index.js",
+    "bin": {
+        "qhttpx": "./dist/src/cli/index.js"
+    },
+    "directories": {
+        "doc": "docs"
+    },
+    "scripts": {
+        "build": "tsc -p tsconfig.json",
+        "lint": "eslint src tests --ext .ts",
+        "test": "vitest run",
+        "example": "npx tsx examples/api-server.ts",
+        "bench": "npm run build && node dist/src/benchmarks/simple-json.js",
+        "bench:quantam": "npm run build && node dist/src/benchmarks/quantam-users.js",
+        "bench:compare": "npm run build && node dist/src/benchmarks/compare-frameworks.js",
+        "bench:ultra": "npm run build && node dist/src/benchmarks/ultra-mode.js"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "ISC",
+    "type": "commonjs",
+    "devDependencies": {
+        "@types/autocannon": "^7.12.7",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/busboy": "^1.5.4",
+        "@types/express": "^5.0.6",
+        "@types/ioredis": "^4.28.10",
+        "@types/mongodb": "^4.0.6",
+        "@types/node": "^25.0.9",
+        "@types/pg": "^8.16.0",
+        "@types/ws": "^8.18.1",
+        "@typescript-eslint/eslint-plugin": "^8.53.0",
+        "@typescript-eslint/parser": "^8.53.0",
+        "autocannon": "^8.0.0",
+        "eslint": "^9.39.2",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-prettier": "^5.5.5",
+        "mongodb": "^7.0.0",
+        "pg": "^8.17.1",
+        "prettier": "^3.8.0",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.17"
+    },
+    "dependencies": {
+        "better-sqlite3": "^12.6.2",
+        "busboy": "^1.6.0",
+        "express": "^5.2.1",
+        "fast-json-stringify": "^5.15.1",
+        "fastify": "^5.7.1",
+        "pino": "^10.2.0",
+        "pino-pretty": "^13.1.3",
+        "quantam-async": "^0.1.1",
+        "ws": "^8.19.0",
+        "zod": "^4.3.5"
+    }
+}