bantou 0.1.0 → 0.2.0

package/.output/server/node_modules/h3/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "h3",
+  "version": "1.15.11",
+  "description": "Minimal H(TTP) framework built for high performance and portability.",
+  "license": "MIT",
+  "repository": "h3js/h3",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --cache . && prettier -c src test playground examples docs",
+    "lint:fix": "eslint --cache . --fix && prettier -c src test playground examples docs -w",
+    "prepack": "pnpm build",
+    "play": "listhen -w ./playground/app.ts",
+    "profile": "0x -o -D .profile -P 'autocannon -c 100 -p 10 -d 40 http://localhost:$PORT' ./playground/server.cjs",
+    "release": "pnpm test && pnpm build && changelogen --release --publish --publishTag 1x && git push --follow-tags",
+    "test": "pnpm lint && vitest --run --coverage && pnpm test:types",
+    "test:types": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "cookie-es": "^1.2.3",
+    "crossws": "^0.3.5",
+    "defu": "^6.1.6",
+    "destr": "^2.0.5",
+    "iron-webcrypto": "^1.2.1",
+    "node-mock-http": "^1.0.4",
+    "radix3": "^1.1.2",
+    "ufo": "^1.6.3",
+    "uncrypto": "^0.1.3"
+  },
+  "devDependencies": {
+    "0x": "^6.0.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.5.0",
+    "@types/supertest": "^7.2.0",
+    "@typescript/native-preview": "latest",
+    "@vitest/coverage-v8": "^4.1.2",
+    "autocannon": "^8.0.0",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
+    "connect": "^3.7.0",
+    "eslint": "^10.1.0",
+    "eslint-config-unjs": "^0.6.2",
+    "express": "^5.2.1",
+    "get-port": "^7.2.0",
+    "h3": "^1.15.10",
+    "jiti": "^2.6.1",
+    "listhen": "^1.9.0",
+    "node-fetch-native": "^1.6.7",
+    "prettier": "^3.8.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "supertest": "^7.2.2",
+    "typescript": "^6.0.2",
+    "unbuild": "^3.6.1",
+    "undici": "^7.24.7",
+    "vitest": "^4.1.2",
+    "zod": "^4.3.6"
+  },
+  "packageManager": "pnpm@10.28.0"
+}

package/.output/server/node_modules/hookable/dist/index.mjs

@@ -0,0 +1,257 @@
+function flatHooks(configHooks, hooks = {}, parentName) {
+	for (const key in configHooks) {
+		const subHook = configHooks[key];
+		const name = parentName ? `${parentName}:${key}` : key;
+		if (typeof subHook === "object" && subHook !== null) flatHooks(subHook, hooks, name);
+		else if (typeof subHook === "function") hooks[name] = subHook;
+	}
+	return hooks;
+}
+function mergeHooks(...hooks) {
+	const finalHooks = {};
+	for (const hook of hooks) {
+		const flatenHook = flatHooks(hook);
+		for (const key in flatenHook) if (finalHooks[key]) finalHooks[key].push(flatenHook[key]);
+		else finalHooks[key] = [flatenHook[key]];
+	}
+	for (const key in finalHooks) if (finalHooks[key].length > 1) {
+		const array = finalHooks[key];
+		finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+	} else finalHooks[key] = finalHooks[key][0];
+	return finalHooks;
+}
+function serial(tasks, function_) {
+	return tasks.reduce((promise, task) => promise.then(() => function_(task)), Promise.resolve());
+}
+const createTask = /* @__PURE__ */ (() => {
+	if (console.createTask) return console.createTask;
+	const defaultTask = { run: (fn) => fn() };
+	return () => defaultTask;
+})();
+function callHooks(hooks, args, startIndex, task) {
+	for (let i = startIndex; i < hooks.length; i += 1) try {
+		const result = task ? task.run(() => hooks[i](...args)) : hooks[i](...args);
+		if (result && typeof result.then === "function") return Promise.resolve(result).then(() => callHooks(hooks, args, i + 1, task));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+function serialTaskCaller(hooks, args, name) {
+	if (hooks.length > 0) return callHooks(hooks, args, 0, createTask(name));
+}
+function parallelTaskCaller(hooks, args, name) {
+	if (hooks.length > 0) {
+		const task = createTask(name);
+		return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+	}
+}
+function serialCaller(hooks, arguments_) {
+	return hooks.reduce((promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])), Promise.resolve());
+}
+function parallelCaller(hooks, args) {
+	return Promise.all(hooks.map((hook) => hook(...args || [])));
+}
+function callEachWith(callbacks, arg0) {
+	for (const callback of [...callbacks]) callback(arg0);
+}
+var Hookable = class {
+	_hooks;
+	_before;
+	_after;
+	_deprecatedHooks;
+	_deprecatedMessages;
+	constructor() {
+		this._hooks = {};
+		this._before = void 0;
+		this._after = void 0;
+		this._deprecatedMessages = void 0;
+		this._deprecatedHooks = {};
+		this.hook = this.hook.bind(this);
+		this.callHook = this.callHook.bind(this);
+		this.callHookWith = this.callHookWith.bind(this);
+	}
+	hook(name, function_, options = {}) {
+		if (!name || typeof function_ !== "function") return () => {};
+		const originalName = name;
+		let dep;
+		while (this._deprecatedHooks[name]) {
+			dep = this._deprecatedHooks[name];
+			name = dep.to;
+		}
+		if (dep && !options.allowDeprecated) {
+			let message = dep.message;
+			if (!message) message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+			if (!this._deprecatedMessages) this._deprecatedMessages = /* @__PURE__ */ new Set();
+			if (!this._deprecatedMessages.has(message)) {
+				console.warn(message);
+				this._deprecatedMessages.add(message);
+			}
+		}
+		if (!function_.name) try {
+			Object.defineProperty(function_, "name", {
+				get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+				configurable: true
+			});
+		} catch {}
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(function_);
+		return () => {
+			if (function_) {
+				this.removeHook(name, function_);
+				function_ = void 0;
+			}
+		};
+	}
+	hookOnce(name, function_) {
+		let _unreg;
+		let _function = (...arguments_) => {
+			if (typeof _unreg === "function") _unreg();
+			_unreg = void 0;
+			_function = void 0;
+			return function_(...arguments_);
+		};
+		_unreg = this.hook(name, _function);
+		return _unreg;
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	clearHook(name) {
+		this._hooks[name] = void 0;
+	}
+	deprecateHook(name, deprecated) {
+		this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+		const _hooks = this._hooks[name] || [];
+		this._hooks[name] = void 0;
+		for (const hook of _hooks) this.hook(name, hook);
+	}
+	deprecateHooks(deprecatedHooks) {
+		for (const name in deprecatedHooks) this.deprecateHook(name, deprecatedHooks[name]);
+	}
+	addHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+		return () => {
+			for (const unreg of removeFns) unreg();
+			removeFns.length = 0;
+		};
+	}
+	removeHooks(configHooks) {
+		const hooks = flatHooks(configHooks);
+		for (const key in hooks) this.removeHook(key, hooks[key]);
+	}
+	removeAllHooks() {
+		this._hooks = {};
+	}
+	callHook(name, ...args) {
+		return this.callHookWith(serialTaskCaller, name, args);
+	}
+	callHookParallel(name, ...args) {
+		return this.callHookWith(parallelTaskCaller, name, args);
+	}
+	callHookWith(caller, name, args) {
+		const event = this._before || this._after ? {
+			name,
+			args,
+			context: {}
+		} : void 0;
+		if (this._before) callEachWith(this._before, event);
+		const result = caller(this._hooks[name] ? [...this._hooks[name]] : [], args, name);
+		if (result instanceof Promise) return result.finally(() => {
+			if (this._after && event) callEachWith(this._after, event);
+		});
+		if (this._after && event) callEachWith(this._after, event);
+		return result;
+	}
+	beforeEach(function_) {
+		this._before = this._before || [];
+		this._before.push(function_);
+		return () => {
+			if (this._before !== void 0) {
+				const index = this._before.indexOf(function_);
+				if (index !== -1) this._before.splice(index, 1);
+			}
+		};
+	}
+	afterEach(function_) {
+		this._after = this._after || [];
+		this._after.push(function_);
+		return () => {
+			if (this._after !== void 0) {
+				const index = this._after.indexOf(function_);
+				if (index !== -1) this._after.splice(index, 1);
+			}
+		};
+	}
+};
+function createHooks() {
+	return new Hookable();
+}
+var HookableCore = class {
+	_hooks;
+	constructor() {
+		this._hooks = {};
+	}
+	hook(name, fn) {
+		if (!name || typeof fn !== "function") return () => {};
+		this._hooks[name] = this._hooks[name] || [];
+		this._hooks[name].push(fn);
+		return () => {
+			if (fn) {
+				this.removeHook(name, fn);
+				fn = void 0;
+			}
+		};
+	}
+	removeHook(name, function_) {
+		const hooks = this._hooks[name];
+		if (hooks) {
+			const index = hooks.indexOf(function_);
+			if (index !== -1) hooks.splice(index, 1);
+			if (hooks.length === 0) this._hooks[name] = void 0;
+		}
+	}
+	callHook(name, ...args) {
+		const hooks = this._hooks[name];
+		if (!hooks || hooks.length === 0) return;
+		return callHooks(hooks.slice(), args, 0);
+	}
+};
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+	const options = {
+		inspect: isBrowser,
+		group: isBrowser,
+		filter: () => true,
+		..._options
+	};
+	const _filter = options.filter;
+	const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+	const _tag = options.tag ? `[${options.tag}] ` : "";
+	const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+	const _idCtr = {};
+	const unsubscribeBefore = hooks.beforeEach((event) => {
+		if (filter !== void 0 && !filter(event.name)) return;
+		_idCtr[event.name] = _idCtr[event.name] || 0;
+		event._id = _idCtr[event.name]++;
+		console.time(logPrefix(event));
+	});
+	const unsubscribeAfter = hooks.afterEach((event) => {
+		if (filter !== void 0 && !filter(event.name)) return;
+		if (options.group) console.groupCollapsed(event.name);
+		if (options.inspect) console.timeLog(logPrefix(event), event.args);
+		else console.timeEnd(logPrefix(event));
+		if (options.group) console.groupEnd();
+		_idCtr[event.name]--;
+	});
+	return { close: () => {
+		unsubscribeBefore();
+		unsubscribeAfter();
+	} };
+}
+export { Hookable, HookableCore, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };

package/.output/server/node_modules/hookable/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "hookable",
+  "version": "6.1.2",
+  "description": "Awaitable hook system",
+  "keywords": [
+    "hook",
+    "hookable",
+    "plugin",
+    "tapable",
+    "tappable"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "unjs/hookable"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.6",
+    "@vitest/coverage-v8": "^5",
+    "changelogen": "^0.6.2",
+    "esbuild": "^0.28.2",
+    "eslint-config-unjs": "^0.6.2",
+    "expect-type": "^1.4.0",
+    "hookable-prev": "npm:hookable@^6.1.1",
+    "mitata": "^1.0.34",
+    "obuild": "^0.4.40",
+    "oxfmt": ">=0.67.0",
+    "oxlint": "^1.82.0",
+    "typescript": "^6",
+    "vite": "^8.3.0",
+    "vitest": "^5"
+  },
+  "scripts": {
+    "bench": "node --expose-gc --allow-natives-syntax test/bench.ts",
+    "build": "obuild src/index.ts",
+    "dev": "vitest",
+    "lint": "oxlint . && oxfmt --check src test",
+    "lint:fix": "oxlint . --fix && oxfmt src test",
+    "prepublish": "pnpm build",
+    "release": "pnpm test && pnpm build && changelogen --release --publish --push",
+    "test": "pnpm lint && vitest run --coverage",
+    "test:types": "tsc --noEmit"
+  }
+}

package/.output/server/node_modules/http-shutdown/index.js

@@ -0,0 +1,85 @@
+'use strict';
+var http = require('http');
+var https = require('https');
+
+/**
+ * Expose `addShutdown`.
+ */
+exports = module.exports = addShutdown;
+
+/**
+ * Adds shutdown functionaility to the `http.Server` object
+ * @param {http.Server} server The server to add shutdown functionaility to
+ */
+function addShutdown(server) {
+  var connections = {};
+  var isShuttingDown = false;
+  var connectionCounter = 0;
+
+  function destroy(socket, force) {
+    if (force || (socket._isIdle && isShuttingDown)) {
+      socket.destroy();
+      delete connections[socket._connectionId];
+    }
+  };
+
+  function onConnection(socket) {
+    var id = connectionCounter++;
+    socket._isIdle = true;
+    socket._connectionId = id;
+    connections[id] = socket;
+
+    socket.on('close', function() {
+      delete connections[id];
+    });
+  };
+
+  server.on('request', function(req, res) {
+    req.socket._isIdle = false;
+
+    res.on('finish', function() {
+      req.socket._isIdle = true;
+      destroy(req.socket);
+    });
+  });
+
+  server.on('connection', onConnection);
+  server.on('secureConnection', onConnection);
+
+  function shutdown(force, cb) {
+    isShuttingDown = true;
+    server.close(function(err) {
+      if (cb) {
+        process.nextTick(function() { cb(err); });
+      }
+    });
+
+    Object.keys(connections).forEach(function(key) {
+      destroy(connections[key], force);
+    });
+  };
+
+  server.shutdown = function(cb) {
+    shutdown(false, cb);
+  };
+
+  server.forceShutdown = function(cb) {
+    shutdown(true, cb);
+  };
+
+  return server;
+};
+
+/**
+ * Extends the {http.Server} object with shutdown functionaility.
+ * @return {http.Server} The decorated server object
+ */
+exports.extend = function() {
+  http.Server.prototype.withShutdown = function() {
+    return addShutdown(this);
+  };
+
+  https.Server.prototype.withShutdown = function() {
+    return addShutdown(this);
+  };
+};

package/.output/server/node_modules/http-shutdown/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "http-shutdown",
+  "version": "1.2.2",
+  "description": "Gracefully shutdown a running HTTP server.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "mocha",
+    "test-travis": "node --harmony node_modules/.bin/istanbul cover ./node_modules/.bin/_mocha --report lcovonly -- --reporter dot"
+  },
+  "keywords": [
+    "http",
+    "https",
+    "graceful",
+    "force",
+    "shutdown"
+  ],
+  "author": "Dillon Buchanan",
+  "repository": "thedillonb/http-shutdown",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^12.12.6",
+    "chai": "^3.4.1",
+    "istanbul": "^0.4.1",
+    "mocha": "^2.3.4",
+    "request": "^2.67.0"
+  },
+  "engines": {
+    "iojs": ">= 1.0.0",
+    "node": ">= 0.12.0"
+  }
+}