@silver886/mcp-proxy 0.2.0 → 0.2.2

package/node_modules/cloudflared/lib/service.js

@@ -0,0 +1,229 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var service_exports = {};
+__export(service_exports, {
+  AlreadyInstalledError: () => AlreadyInstalledError,
+  LINUX_SERVICE_PATH: () => LINUX_SERVICE_PATH,
+  MACOS_SERVICE_PATH: () => MACOS_SERVICE_PATH,
+  NotInstalledError: () => NotInstalledError,
+  clean: () => clean,
+  current: () => current,
+  err: () => err,
+  exists: () => exists,
+  identifier: () => identifier,
+  install: () => install,
+  journal: () => journal,
+  log: () => log,
+  service: () => service,
+  service_name: () => service_name,
+  uninstall: () => uninstall
+});
+module.exports = __toCommonJS(service_exports);
+var import_node_os = __toESM(require("node:os"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_child_process = require("node:child_process");
+var import_constants = require("./constants.js");
+var import_regex = require("./regex.js");
+const identifier = "com.cloudflare.cloudflared";
+const service_name = "cloudflared.service";
+const MACOS_SERVICE_PATH = {
+  PLIST: is_root() ? `/Library/LaunchDaemons/${identifier}.plist` : `${import_node_os.default.homedir()}/Library/LaunchAgents/${identifier}.plist`,
+  OUT: is_root() ? `/Library/Logs/${identifier}.out.log` : `${import_node_os.default.homedir()}/Library/Logs/${identifier}.out.log`,
+  ERR: is_root() ? `/Library/Logs/${identifier}.err.log` : `${import_node_os.default.homedir()}/Library/Logs/${identifier}.err.log`
+};
+const LINUX_SERVICE_PATH = {
+  SYSTEMD: `/etc/systemd/system/${service_name}`,
+  SERVICE: "/etc/init.d/cloudflared",
+  SERVICE_OUT: "/var/log/cloudflared.log",
+  SERVICE_ERR: "/var/log/cloudflared.err"
+};
+const service = { install, uninstall, exists, log, err, current, clean, journal };
+class AlreadyInstalledError extends Error {
+  constructor() {
+    super("service is already installed");
+  }
+}
+class NotInstalledError extends Error {
+  constructor() {
+    super("service is not installed");
+  }
+}
+function install(token) {
+  if (!["darwin", "linux"].includes(process.platform)) {
+    throw new Error(`Not Implemented on platform ${process.platform}`);
+  }
+  if (exists()) {
+    throw new AlreadyInstalledError();
+  }
+  const args = ["service", "install"];
+  if (token) {
+    args.push(token);
+  }
+  const result = (0, import_node_child_process.spawnSync)(import_constants.bin, args);
+  if (result.status !== 0) {
+    throw new Error(`service install failed: ${result.stderr.toString()}`);
+  }
+}
+function uninstall() {
+  if (!["darwin", "linux"].includes(process.platform)) {
+    throw new Error(`Not Implemented on platform ${process.platform}`);
+  }
+  if (!exists()) {
+    throw new NotInstalledError();
+  }
+  const result = (0, import_node_child_process.spawnSync)(import_constants.bin, ["service", "uninstall"]);
+  if (result.status !== 0) {
+    throw new Error(`service uninstall failed: ${result.stderr.toString()}`);
+  }
+  if (process.platform === "darwin") {
+    import_node_fs.default.rmSync(MACOS_SERVICE_PATH.OUT);
+    import_node_fs.default.rmSync(MACOS_SERVICE_PATH.ERR);
+  } else if (process.platform === "linux" && !is_systemd()) {
+    import_node_fs.default.rmSync(LINUX_SERVICE_PATH.SERVICE_OUT);
+    import_node_fs.default.rmSync(LINUX_SERVICE_PATH.SERVICE_ERR);
+  }
+}
+function log() {
+  if (!exists()) {
+    throw new NotInstalledError();
+  }
+  if (process.platform === "darwin") {
+    return import_node_fs.default.readFileSync(MACOS_SERVICE_PATH.OUT, "utf8");
+  }
+  if (process.platform === "linux" && !is_systemd()) {
+    return import_node_fs.default.readFileSync(LINUX_SERVICE_PATH.SERVICE_OUT, "utf8");
+  }
+  throw new Error(`Not Implemented on platform ${process.platform}`);
+}
+function err() {
+  if (!exists()) {
+    throw new NotInstalledError();
+  }
+  if (process.platform === "darwin") {
+    return import_node_fs.default.readFileSync(MACOS_SERVICE_PATH.ERR, "utf8");
+  }
+  if (process.platform === "linux" && !is_systemd()) {
+    return import_node_fs.default.readFileSync(LINUX_SERVICE_PATH.SERVICE_ERR, "utf8");
+  }
+  throw new Error(`Not Implemented on platform ${process.platform}`);
+}
+function journal(n = 300) {
+  if (process.platform === "linux" && is_systemd()) {
+    const args = ["-u", service_name, "-o", "cat", "-n", n.toString()];
+    return (0, import_node_child_process.spawnSync)("journalctl", args).stdout.toString();
+  }
+  throw new Error(`Not Implemented on platform ${process.platform}`);
+}
+function current() {
+  var _a, _b, _c, _d;
+  if (!["darwin", "linux"].includes(process.platform)) {
+    throw new Error(`Not Implemented on platform ${process.platform}`);
+  }
+  if (!exists()) {
+    throw new NotInstalledError();
+  }
+  const log2 = is_systemd() ? journal() : err();
+  let tunnelID = "";
+  let connectorID = "";
+  const connections = [];
+  let metrics = "";
+  let config = {};
+  for (const line of log2.split("\n")) {
+    try {
+      if (line.match(import_regex.tunnelID_regex)) {
+        tunnelID = ((_a = line.match(import_regex.tunnelID_regex)) == null ? void 0 : _a[1]) ?? "";
+      } else if (line.match(import_regex.connectorID_regex)) {
+        connectorID = ((_b = line.match(import_regex.connectorID_regex)) == null ? void 0 : _b[1]) ?? "";
+      } else if (line.match(import_regex.conn_regex) && line.match(import_regex.location_regex) && line.match(import_regex.ip_regex) && line.match(import_regex.index_regex)) {
+        const [, id] = line.match(import_regex.conn_regex) ?? [];
+        const [, location] = line.match(import_regex.location_regex) ?? [];
+        const [, ip] = line.match(import_regex.ip_regex) ?? [];
+        const [, idx] = line.match(import_regex.index_regex) ?? [];
+        connections[parseInt(idx)] = { id, ip, location };
+      } else if (line.match(import_regex.disconnect_regex)) {
+        const [, idx] = line.match(import_regex.disconnect_regex) ?? [];
+        if (parseInt(idx) in connections) {
+          connections[parseInt(idx)] = { id: "", ip: "", location: "" };
+        }
+      } else if (line.match(import_regex.metrics_regex)) {
+        metrics = ((_c = line.match(import_regex.metrics_regex)) == null ? void 0 : _c[1]) ?? "";
+      } else if (line.match(import_regex.config_regex)) {
+        config = JSON.parse(((_d = line.match(import_regex.config_regex)) == null ? void 0 : _d[1].replace(/\\/g, "")) ?? "{}");
+      }
+    } catch (err2) {
+      if (process.env.VERBOSE) {
+        console.error("log parsing failed", err2);
+      }
+    }
+  }
+  return { tunnelID, connectorID, connections, metrics, config };
+}
+function clean() {
+  if (process.platform !== "darwin") {
+    throw new Error(`Not Implemented on platform ${process.platform}`);
+  }
+  if (exists()) {
+    throw new AlreadyInstalledError();
+  }
+  import_node_fs.default.rmSync(MACOS_SERVICE_PATH.OUT, { force: true });
+  import_node_fs.default.rmSync(MACOS_SERVICE_PATH.ERR, { force: true });
+}
+function exists() {
+  if (process.platform === "darwin") {
+    return import_node_fs.default.existsSync(MACOS_SERVICE_PATH.PLIST);
+  } else if (process.platform === "linux") {
+    return is_systemd() ? import_node_fs.default.existsSync(LINUX_SERVICE_PATH.SYSTEMD) : import_node_fs.default.existsSync(LINUX_SERVICE_PATH.SERVICE);
+  }
+  throw new Error(`Not Implemented on platform ${process.platform}`);
+}
+function is_root() {
+  var _a;
+  return ((_a = process.getuid) == null ? void 0 : _a.call(process)) === 0;
+}
+function is_systemd() {
+  return process.platform === "linux" && import_node_fs.default.existsSync("/run/systemd/system");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlreadyInstalledError,
+  LINUX_SERVICE_PATH,
+  MACOS_SERVICE_PATH,
+  NotInstalledError,
+  clean,
+  current,
+  err,
+  exists,
+  identifier,
+  install,
+  journal,
+  log,
+  service,
+  service_name,
+  uninstall
+});

package/node_modules/cloudflared/lib/tunnel.js

@@ -0,0 +1,164 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tunnel_exports = {};
+__export(tunnel_exports, {
+  Tunnel: () => Tunnel,
+  build_args: () => build_args,
+  build_options: () => build_options,
+  tunnel: () => tunnel
+});
+module.exports = __toCommonJS(tunnel_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_events = require("node:events");
+var import_constants = require("./constants.js");
+var import_handler = require("./handler.js");
+class Tunnel extends import_node_events.EventEmitter {
+  constructor(options = ["tunnel", "--hello-world"]) {
+    super();
+    this.outputHandlers = [];
+    this.stop = this._stop.bind(this);
+    this.setupDefaultHandlers();
+    const args = Array.isArray(options) ? options : build_args(options);
+    this._process = this.createProcess(args);
+    this.setupEventHandlers();
+  }
+  get process() {
+    return this._process;
+  }
+  setupDefaultHandlers() {
+    new import_handler.ConnectionHandler(this);
+    new import_handler.TryCloudflareHandler(this);
+  }
+  /**
+   * Add a custom output handler
+   * @param handler Function to handle cloudflared output
+   */
+  addHandler(handler) {
+    this.outputHandlers.push(handler);
+  }
+  /**
+   * Remove a previously added output handler
+   * @param handler The handler to remove
+   */
+  removeHandler(handler) {
+    const index = this.outputHandlers.indexOf(handler);
+    if (index !== -1) {
+      this.outputHandlers.splice(index, 1);
+    }
+  }
+  processOutput(output) {
+    for (const handler of this.outputHandlers) {
+      try {
+        handler(output, this);
+      } catch (error) {
+        this.emit("error", error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+  setupEventHandlers() {
+    this.on("stdout", (output) => {
+      this.processOutput(output);
+    });
+    this.on("stderr", (output) => {
+      this.processOutput(output);
+    });
+  }
+  createProcess(args) {
+    var _a, _b;
+    const child = (0, import_node_child_process.spawn)(import_constants.bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    child.on("error", (error) => this.emit("error", error));
+    child.on("exit", (code, signal) => this.emit("exit", code, signal));
+    if (process.env.VERBOSE) {
+      child.stdout.pipe(process.stdout);
+      child.stderr.pipe(process.stderr);
+    }
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (data) => this.emit("stdout", data.toString()));
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (data) => this.emit("stderr", data.toString()));
+    return child;
+  }
+  _stop() {
+    return this.process.kill("SIGINT");
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  /**
+   * Create a quick tunnel without a Cloudflare account.
+   * @param url The local service URL to connect to. If not provided, the hello world mode will be used.
+   * @param options The options to pass to cloudflared.
+   */
+  static quick(url, options = {}) {
+    const args = ["tunnel"];
+    if (url) {
+      args.push("--url", url);
+    } else {
+      args.push("--hello-world");
+    }
+    args.push(...build_options(options));
+    return new Tunnel(args);
+  }
+  /**
+   * Create a tunnel with a Cloudflare account.
+   * @param token The Cloudflare Tunnel token.
+   * @param options The options to pass to cloudflared.
+   */
+  static withToken(token, options = {}) {
+    options["--token"] = token;
+    return new Tunnel(build_args(options));
+  }
+}
+function tunnel(options = {}) {
+  return new Tunnel(options);
+}
+function build_args(options) {
+  const args = "--hello-world" in options ? ["tunnel"] : ["tunnel", "run"];
+  args.push(...build_options(options));
+  return args;
+}
+function build_options(options) {
+  const opts = [];
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === "string") {
+      opts.push(`${key}`, value);
+    } else if (typeof value === "number") {
+      opts.push(`${key}`, value.toString());
+    } else if (typeof value === "boolean") {
+      if (value === true) {
+        opts.push(`${key}`);
+      }
+    }
+  }
+  return opts;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tunnel,
+  build_args,
+  build_options,
+  tunnel
+});

package/node_modules/cloudflared/lib/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/node_modules/cloudflared/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "cloudflared",
+  "version": "0.7.1",
+  "description": "Cloudflared in Node. Which allows you to easily create HTTPS tunnels using Cloudflare's cloudflared. It provides a typed API for creating tunnels and managing the cloudflared binary installation.",
+  "main": "./lib/lib.js",
+  "types": "./lib/lib.d.ts",
+  "bin": "./lib/cloudflared.js",
+  "keywords": [
+    "cloudflared",
+    "tunnel",
+    "macos",
+    "windows",
+    "linux",
+    "cli",
+    "lib"
+  ],
+  "author": "JacobLinCool <jacoblincool@gmail.com> (https://github.com/JacobLinCool)",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "scripts"
+  ],
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.0",
+    "@changesets/cli": "^2.27.7",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.8.0",
+    "@types/node": "^22.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.1",
+    "@typescript-eslint/parser": "^8.0.1",
+    "changeset": "^0.2.6",
+    "eslint": "^9.8.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.3",
+    "tsup": "^8.2.4",
+    "typedoc": "^0.26.5",
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5",
+    "cloudflared": "0.7.1"
+  },
+  "homepage": "https://github.com/JacobLinCool/node-cloudflared#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JacobLinCool/node-cloudflared.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JacobLinCool/node-cloudflared/issues"
+  },
+  "scripts": {
+    "test": "vitest",
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "docs": "typedoc ./src/lib.ts",
+    "format": "prettier --write '**/*.{js,ts,jsx,tsx,json,yml,yaml,md,html}' --ignore-path .gitignore",
+    "lint": "eslint .",
+    "postinstall": "node scripts/postinstall.mjs && node lib/cloudflared.js bin install latest",
+    "changeset": "changeset"
+  }
+}

package/node_modules/cloudflared/scripts/postinstall.mjs

@@ -0,0 +1,10 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+if (!fs.existsSync(path.resolve(__dirname, "..", "lib"))) {
+    execSync("npm run build");
+}

package/node_modules/eventsource-parser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Espen Hovlandsdal <espen@hovlandsdal.com>
+
+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/node_modules/eventsource-parser/README.md

@@ -0,0 +1,126 @@
+# eventsource-parser
+
+[![npm version](https://img.shields.io/npm/v/eventsource-parser.svg?style=flat-square)](https://www.npmjs.com/package/eventsource-parser)[![npm bundle size](https://img.shields.io/bundlephobia/minzip/eventsource-parser?style=flat-square)](https://bundlephobia.com/result?p=eventsource-parser)[![npm weekly downloads](https://img.shields.io/npm/dw/eventsource-parser.svg?style=flat-square)](https://www.npmjs.com/package/eventsource-parser)
+
+A streaming parser for [server-sent events/eventsource](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events), without any assumptions about how the actual stream of data is retrieved. It is intended to be a building block for [clients](https://github.com/rexxars/eventsource-client) and polyfills in javascript environments such as browsers, node.js and deno.
+
+If you are looking for a modern client implementation, see [eventsource-client](https://github.com/rexxars/eventsource-client).
+
+You create an instance of the parser, and _feed_ it chunks of data - partial or complete, and the parse emits parsed messages once it receives a complete message. A [TransformStream variant](#stream-usage) is also available for environments that support it (modern browsers, Node 18 and higher).
+
+Other modules in the EventSource family:
+
+- [eventsource-client](https://github.com/rexxars/eventsource-client): modern, feature rich eventsource client for browsers, node.js, bun, deno and other modern JavaScript environments.
+- [eventsource-encoder](https://github.com/rexxars/eventsource-encoder): encodes messages in the EventSource/Server-Sent Events format.
+- [eventsource](https://github.com/eventsource/eventsource): Node.js polyfill for the WhatWG EventSource API.
+
+> [!NOTE]
+> Migrating from eventsource-parser 1.x/2.x? See the [migration guide](./MIGRATE-v3.md).
+
+## Installation
+
+```bash
+npm install --save eventsource-parser
+```
+
+## Usage
+
+```ts
+import {createParser, type EventSourceMessage} from 'eventsource-parser'
+
+function onEvent(event: EventSourceMessage) {
+  console.log('Received event!')
+  console.log('id: %s', event.id || '<none>')
+  console.log('event: %s', event.event || '<none>')
+  console.log('data: %s', event.data)
+}
+
+const parser = createParser({onEvent})
+const sseStream = getSomeReadableStream()
+
+for await (const chunk of sseStream) {
+  parser.feed(chunk)
+}
+
+// If you want to re-use the parser for a new stream of events, make sure to reset it!
+parser.reset()
+console.log('Done!')
+```
+
+### Retry intervals
+
+If the server sends a `retry` field in the event stream, the parser will call any `onRetry` callback specified to the `createParser` function:
+
+```ts
+const parser = createParser({
+  onRetry(retryInterval) {
+    console.log('Server requested retry interval of %dms', retryInterval)
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+### Parse errors
+
+If the parser encounters an error while parsing, it will call any `onError` callback provided to the `createParser` function:
+
+```ts
+import {type ParseError} from 'eventsource-parser'
+
+const parser = createParser({
+  onError(error: ParseError) {
+    console.error('Error parsing event:', error)
+    if (error.type === 'invalid-field') {
+      console.error('Field name:', error.field)
+      console.error('Field value:', error.value)
+      console.error('Line:', error.line)
+    } else if (error.type === 'invalid-retry') {
+      console.error('Invalid retry interval:', error.value)
+    }
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+Note that `invalid-field` errors will usually be called for any invalid data - not only data shaped as `field: value`. This is because the EventSource specification says to treat anything prior to a `:` as the field name. Use the `error.line` property to get the full line that caused the error.
+
+> [!NOTE]
+> When encountering the end of a stream, calling `.reset({consume: true})` on the parser to flush any remaining data and reset the parser state. This will trigger the `onError` callback if the pending data is not a valid event.
+
+### Comments
+
+The parser will ignore comments (lines starting with `:`) by default. If you want to handle comments, you can provide an `onComment` callback to the `createParser` function:
+
+```ts
+const parser = createParser({
+  onComment(comment) {
+    console.log('Received comment:', comment)
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+> [!NOTE]
+> Leading whitespace is not stripped from comments, eg `: comment` will give ` comment` as the comment value, not `comment` (note the leading space).
+
+## Stream usage
+
+```ts
+import {EventSourceParserStream} from 'eventsource-parser/stream'
+
+const eventStream = response.body
+  .pipeThrough(new TextDecoderStream())
+  .pipeThrough(new EventSourceParserStream())
+```
+
+Note that the TransformStream is exposed under a separate export (`eventsource-parser/stream`), in order to maximize compatibility with environments that do not have the `TransformStream` constructor available.
+
+## License
+
+MIT © [Espen Hovlandsdal](https://espen.codes/)