laminark 2.22.2 → 2.22.4

package/plugin/node_modules/@hono/node-server/README.md

@@ -1,357 +0,0 @@
-# Node.js Adapter for Hono
-
-This adapter `@hono/node-server` allows you to run your Hono application on Node.js.
-Initially, Hono wasn't designed for Node.js, but with this adapter, you can now use Hono on Node.js.
-It utilizes web standard APIs implemented in Node.js version 18 or higher.
-
-## Benchmarks
-
-Hono is 3.5 times faster than Express.
-
-Express:
-
-```txt
-$ bombardier -d 10s --fasthttp http://localhost:3000/
-
-Statistics        Avg      Stdev        Max
-  Reqs/sec     16438.94    1603.39   19155.47
-  Latency        7.60ms     7.51ms   559.89ms
-  HTTP codes:
-    1xx - 0, 2xx - 164494, 3xx - 0, 4xx - 0, 5xx - 0
-    others - 0
-  Throughput:     4.55MB/s
-```
-
-Hono + `@hono/node-server`:
-
-```txt
-$ bombardier -d 10s --fasthttp http://localhost:3000/
-
-Statistics        Avg      Stdev        Max
-  Reqs/sec     58296.56    5512.74   74403.56
-  Latency        2.14ms     1.46ms   190.92ms
-  HTTP codes:
-    1xx - 0, 2xx - 583059, 3xx - 0, 4xx - 0, 5xx - 0
-    others - 0
-  Throughput:    12.56MB/s
-```
-
-## Requirements
-
-It works on Node.js versions greater than 18.x. The specific required Node.js versions are as follows:
-
-- 18.x => 18.14.1+
-- 19.x => 19.7.0+
-- 20.x => 20.0.0+
-
-Essentially, you can simply use the latest version of each major release.
-
-## Installation
-
-You can install it from the npm registry with `npm` command:
-
-```sh
-npm install @hono/node-server
-```
-
-Or use `yarn`:
-
-```sh
-yarn add @hono/node-server
-```
-
-## Usage
-
-Just import `@hono/node-server` at the top and write the code as usual.
-The same code that runs on Cloudflare Workers, Deno, and Bun will work.
-
-```ts
-import { serve } from '@hono/node-server'
-import { Hono } from 'hono'
-
-const app = new Hono()
-app.get('/', (c) => c.text('Hono meets Node.js'))
-
-serve(app, (info) => {
-  console.log(`Listening on http://localhost:${info.port}`) // Listening on http://localhost:3000
-})
-```
-
-For example, run it using `ts-node`. Then an HTTP server will be launched. The default port is `3000`.
-
-```sh
-ts-node ./index.ts
-```
-
-Open `http://localhost:3000` with your browser.
-
-## Options
-
-### `port`
-
-```ts
-serve({
-  fetch: app.fetch,
-  port: 8787, // Port number, default is 3000
-})
-```
-
-### `createServer`
-
-```ts
-import { createServer } from 'node:https'
-import fs from 'node:fs'
-
-//...
-
-serve({
-  fetch: app.fetch,
-  createServer: createServer,
-  serverOptions: {
-    key: fs.readFileSync('test/fixtures/keys/agent1-key.pem'),
-    cert: fs.readFileSync('test/fixtures/keys/agent1-cert.pem'),
-  },
-})
-```
-
-### `overrideGlobalObjects`
-
-The default value is `true`. The Node.js Adapter rewrites the global Request/Response and uses a lightweight Request/Response to improve performance. If you don't want to do that, set `false`.
-
-```ts
-serve({
-  fetch: app.fetch,
-  overrideGlobalObjects: false,
-})
-```
-
-### `autoCleanupIncoming`
-
-The default value is `true`. The Node.js Adapter automatically cleans up (explicitly call `destroy()` method) if application is not finished to consume the incoming request. If you don't want to do that, set `false`.
-
-If the application accepts connections from arbitrary clients, this cleanup must be done otherwise incomplete requests from clients may cause the application to stop responding. If your application only accepts connections from trusted clients, such as in a reverse proxy environment and there is no process that returns a response without reading the body of the POST request all the way through, you can improve performance by setting it to `false`.
-
-```ts
-serve({
-  fetch: app.fetch,
-  autoCleanupIncoming: false,
-})
-```
-
-## Middleware
-
-Most built-in middleware also works with Node.js.
-Read [the documentation](https://hono.dev/middleware/builtin/basic-auth) and use the Middleware of your liking.
-
-```ts
-import { serve } from '@hono/node-server'
-import { Hono } from 'hono'
-import { prettyJSON } from 'hono/pretty-json'
-
-const app = new Hono()
-
-app.get('*', prettyJSON())
-app.get('/', (c) => c.json({ 'Hono meets': 'Node.js' }))
-
-serve(app)
-```
-
-## Serve Static Middleware
-
-Use Serve Static Middleware that has been created for Node.js.
-
-```ts
-import { serveStatic } from '@hono/node-server/serve-static'
-
-//...
-
-app.use('/static/*', serveStatic({ root: './' }))
-```
-
-If using a relative path, `root` will be relative to the current working directory from which the app was started.
-
-This can cause confusion when running your application locally.
-
-Imagine your project structure is:
-
-```
-my-hono-project/
-  src/
-    index.ts
-  static/
-    index.html
-```
-
-Typically, you would run your app from the project's root directory (`my-hono-project`),
-so you would need the following code to serve the `static` folder:
-
-```ts
-app.use('/static/*', serveStatic({ root: './static' }))
-```
-
-Notice that `root` here is not relative to `src/index.ts`, rather to `my-hono-project`.
-
-### Options
-
-#### `rewriteRequestPath`
-
-If you want to serve files in `./.foojs` with the request path `/__foo/*`, you can write like the following.
-
-```ts
-app.use(
-  '/__foo/*',
-  serveStatic({
-    root: './.foojs/',
-    rewriteRequestPath: (path: string) => path.replace(/^\/__foo/, ''),
-  })
-)
-```
-
-#### `onFound`
-
-You can specify handling when the requested file is found with `onFound`.
-
-```ts
-app.use(
-  '/static/*',
-  serveStatic({
-    // ...
-    onFound: (_path, c) => {
-      c.header('Cache-Control', `public, immutable, max-age=31536000`)
-    },
-  })
-)
-```
-
-#### `onNotFound`
-
-The `onNotFound` is useful for debugging. You can write a handle for when a file is not found.
-
-```ts
-app.use(
-  '/static/*',
-  serveStatic({
-    root: './non-existent-dir',
-    onNotFound: (path, c) => {
-      console.log(`${path} is not found, request to ${c.req.path}`)
-    },
-  })
-)
-```
-
-#### `precompressed`
-
-The `precompressed` option checks if files with extensions like `.br` or `.gz` are available and serves them based on the `Accept-Encoding` header. It prioritizes Brotli, then Zstd, and Gzip. If none are available, it serves the original file.
-
-```ts
-app.use(
-  '/static/*',
-  serveStatic({
-    precompressed: true,
-  })
-)
-```
-
-## ConnInfo Helper
-
-You can use the [ConnInfo Helper](https://hono.dev/docs/helpers/conninfo) by importing `getConnInfo` from `@hono/node-server/conninfo`.
-
-```ts
-import { getConnInfo } from '@hono/node-server/conninfo'
-
-app.get('/', (c) => {
-  const info = getConnInfo(c) // info is `ConnInfo`
-  return c.text(`Your remote address is ${info.remote.address}`)
-})
-```
-
-## Accessing Node.js API
-
-You can access the Node.js API from `c.env` in Node.js. For example, if you want to specify a type, you can write the following.
-
-```ts
-import { serve } from '@hono/node-server'
-import type { HttpBindings } from '@hono/node-server'
-import { Hono } from 'hono'
-
-const app = new Hono<{ Bindings: HttpBindings }>()
-
-app.get('/', (c) => {
-  return c.json({
-    remoteAddress: c.env.incoming.socket.remoteAddress,
-  })
-})
-
-serve(app)
-```
-
-The APIs that you can get from `c.env` are as follows.
-
-```ts
-type HttpBindings = {
-  incoming: IncomingMessage
-  outgoing: ServerResponse
-}
-
-type Http2Bindings = {
-  incoming: Http2ServerRequest
-  outgoing: Http2ServerResponse
-}
-```
-
-## Direct response from Node.js API
-
-You can directly respond to the client from the Node.js API.
-In that case, the response from Hono should be ignored, so return `RESPONSE_ALREADY_SENT`.
-
-> [!NOTE]
-> This feature can be used when migrating existing Node.js applications to Hono, but we recommend using Hono's API for new applications.
-
-```ts
-import { serve } from '@hono/node-server'
-import type { HttpBindings } from '@hono/node-server'
-import { RESPONSE_ALREADY_SENT } from '@hono/node-server/utils/response'
-import { Hono } from 'hono'
-
-const app = new Hono<{ Bindings: HttpBindings }>()
-
-app.get('/', (c) => {
-  const { outgoing } = c.env
-  outgoing.writeHead(200, { 'Content-Type': 'text/plain' })
-  outgoing.end('Hello World\n')
-
-  return RESPONSE_ALREADY_SENT
-})
-
-serve(app)
-```
-
-## Listen to a UNIX domain socket
-
-You can configure the HTTP server to listen to a UNIX domain socket instead of a TCP port.
-
-```ts
-import { createAdaptorServer } from '@hono/node-server'
-
-// ...
-
-const socketPath ='/tmp/example.sock'
-
-const server = createAdaptorServer(app)
-server.listen(socketPath, () => {
-  console.log(`Listening on ${socketPath}`)
-})
-```
-
-## Related projects
-
-- Hono - <https://hono.dev>
-- Hono GitHub repository - <https://github.com/honojs/hono>
-
-## Author
-
-Yusuke Wada <https://github.com/yusukebe>
-
-## License
-
-MIT

package/plugin/node_modules/@hono/node-server/package.json

@@ -1,103 +0,0 @@
-{
-  "name": "@hono/node-server",
-  "version": "1.19.9",
-  "description": "Node.js Adapter for Hono",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
-    },
-    "./serve-static": {
-      "types": "./dist/serve-static.d.ts",
-      "require": "./dist/serve-static.js",
-      "import": "./dist/serve-static.mjs"
-    },
-    "./vercel": {
-      "types": "./dist/vercel.d.ts",
-      "require": "./dist/vercel.js",
-      "import": "./dist/vercel.mjs"
-    },
-    "./utils/*": {
-      "types": "./dist/utils/*.d.ts",
-      "require": "./dist/utils/*.js",
-      "import": "./dist/utils/*.mjs"
-    },
-    "./conninfo": {
-      "types": "./dist/conninfo.d.ts",
-      "require": "./dist/conninfo.js",
-      "import": "./dist/conninfo.mjs"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      ".": [
-        "./dist/index.d.ts"
-      ],
-      "serve-static": [
-        "./dist/serve-static.d.ts"
-      ],
-      "vercel": [
-        "./dist/vercel.d.ts"
-      ],
-      "utils/*": [
-        "./dist/utils/*.d.ts"
-      ],
-      "conninfo": [
-        "./dist/conninfo.d.ts"
-      ]
-    }
-  },
-  "scripts": {
-    "test": "node --expose-gc node_modules/jest/bin/jest.js",
-    "build": "tsup --external hono",
-    "watch": "tsup --watch",
-    "postbuild": "publint",
-    "prerelease": "bun run build && bun run test",
-    "release": "np",
-    "lint": "eslint src test",
-    "lint:fix": "eslint src test --fix",
-    "format": "prettier --check \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\"",
-    "format:fix": "prettier --write \"src/**/*.{js,ts}\" \"test/**/*.{js,ts}\""
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/honojs/node-server.git"
-  },
-  "homepage": "https://github.com/honojs/node-server",
-  "author": "Yusuke Wada <yusuke@kamawada.com> (https://github.com/yusukebe)",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=18.14.1"
-  },
-  "devDependencies": {
-    "@hono/eslint-config": "^1.0.1",
-    "@types/jest": "^29.5.3",
-    "@types/node": "^20.10.0",
-    "@types/supertest": "^2.0.12",
-    "@whatwg-node/fetch": "^0.9.14",
-    "eslint": "^9.10.0",
-    "hono": "^4.4.10",
-    "jest": "^29.6.1",
-    "np": "^7.7.0",
-    "prettier": "^3.2.4",
-    "publint": "^0.1.16",
-    "supertest": "^6.3.3",
-    "ts-jest": "^29.1.1",
-    "tsup": "^7.2.0",
-    "typescript": "^5.3.2"
-  },
-  "peerDependencies": {
-    "hono": "^4"
-  },
-  "packageManager": "bun@1.2.20"
-}

package/plugin/node_modules/@huggingface/jinja/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Hugging Face
-
-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/plugin/node_modules/@huggingface/jinja/README.md

@@ -1,78 +0,0 @@
-# Jinja
-
-A minimalistic JavaScript implementation of the Jinja templating engine, specifically designed for parsing and rendering ML chat templates.
-
-## Usage
-
-### Load template from a model on the Hugging Face Hub
-
-First, install the jinja and hub packages:
-
-```sh
-npm i @huggingface/jinja
-npm i @huggingface/hub
-```
-
-You can then load a tokenizer from the Hugging Face Hub and render a list of chat messages, as follows:
-
-```js
-import { Template } from "@huggingface/jinja";
-import { downloadFile } from "@huggingface/hub";
-
-const config = await (
-	await downloadFile({
-		repo: "mistralai/Mistral-7B-Instruct-v0.1",
-		path: "tokenizer_config.json",
-	})
-).json();
-
-const chat = [
-	{ role: "user", content: "Hello, how are you?" },
-	{ role: "assistant", content: "I'm doing great. How can I help you today?" },
-	{ role: "user", content: "I'd like to show off how chat templating works!" },
-];
-
-const template = new Template(config.chat_template);
-const result = template.render({
-	messages: chat,
-	bos_token: config.bos_token,
-	eos_token: config.eos_token,
-});
-// "<s>[INST] Hello, how are you? [/INST]I'm doing great. How can I help you today?</s> [INST] I'd like to show off how chat templating works! [/INST]"
-```
-
-### Transformers.js
-
-First, install `@huggingface/transformers`:
-
-```sh
-npm i @huggingface/transformers
-```
-
-You can then render a list of chat messages using a tokenizer's `apply_chat_template` method.
-
-```js
-import { AutoTokenizer } from "@huggingface/transformers";
-
-// Load tokenizer from the Hugging Face Hub
-const tokenizer = await AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1");
-
-// Define chat messages
-const chat = [
-	{ role: "user", content: "Hello, how are you?" },
-	{ role: "assistant", content: "I'm doing great. How can I help you today?" },
-	{ role: "user", content: "I'd like to show off how chat templating works!" },
-];
-
-const text = tokenizer.apply_chat_template(chat, { tokenize: false });
-// "<s>[INST] Hello, how are you? [/INST]I'm doing great. How can I help you today?</s> [INST] I'd like to show off how chat templating works! [/INST]"
-```
-
-Notice how the entire chat is condensed into a single string. If you would instead like to return the tokenized version (i.e., a list of token IDs), you can use the following:
-
-```js
-const input_ids = tokenizer.apply_chat_template(chat, { tokenize: true, return_tensor: false });
-// [1, 733, 16289, 28793, 22557, 28725, 910, 460, 368, 28804, 733, 28748, 16289, 28793, 28737, 28742, 28719, 2548, 1598, 28723, 1602, 541, 315, 1316, 368, 3154, 28804, 2, 28705, 733, 16289, 28793, 315, 28742, 28715, 737, 298, 1347, 805, 910, 10706, 5752, 1077, 3791, 28808, 733, 28748, 16289, 28793]
-```
-
-For more information about chat templates, check out the transformers [documentation](https://huggingface.co/docs/transformers/main/en/chat_templating).

package/plugin/node_modules/@huggingface/jinja/package.json

@@ -1,54 +0,0 @@
-{
-  "name": "@huggingface/jinja",
-  "version": "0.5.5",
-  "description": "A minimalistic JavaScript implementation of the Jinja templating engine, specifically designed for parsing and rendering ML chat templates.",
-  "keywords": [
-    "face",
-    "hugging",
-    "huggingface",
-    "jinja",
-    "templates"
-  ],
-  "license": "MIT",
-  "author": "Hugging Face",
-  "repository": "https://github.com/huggingface/huggingface.js.git",
-  "source": "src/index.ts",
-  "files": [
-    "dist",
-    "README.md",
-    "src",
-    "tsconfig.json"
-  ],
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.js"
-    }
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "devDependencies": {
-    "@huggingface/transformers": "^3.0.0",
-    "typescript": "^5.3.2",
-    "@huggingface/hub": "^2.8.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "lint": "eslint --quiet --fix --ext .cjs,.ts .",
-    "lint:check": "eslint --ext .cjs,.ts .",
-    "format": "oxfmt .",
-    "format:check": "oxfmt --check .",
-    "build": "tsup src/index.ts --format cjs,esm --clean && tsc --emitDeclarationOnly --declaration",
-    "test": "vitest run",
-    "test:browser": "vitest run --browser.name=chrome --browser.headless",
-    "check": "tsc"
-  }
-}

package/plugin/node_modules/@huggingface/jinja/tsconfig.json

@@ -1,20 +0,0 @@
-{
-	"compilerOptions": {
-		"allowSyntheticDefaultImports": true,
-		"lib": ["ES2022", "DOM"],
-		"module": "ESNext",
-		"moduleResolution": "node",
-		"target": "ESNext",
-		"forceConsistentCasingInFileNames": true,
-		"strict": true,
-		"noImplicitAny": true,
-		"strictNullChecks": true,
-		"skipLibCheck": true,
-		"noImplicitOverride": true,
-		"outDir": "./dist",
-		"declaration": true,
-		"declarationMap": true
-	},
-	"include": ["src", "index.ts"],
-	"exclude": ["dist"]
-}