@automattic/vip 4.1.5 → 4.1.8

package/node_modules/undici/lib/web/websocket/receiver.js

@@ -16,6 +16,7 @@ const { failWebsocketConnection } = require('./connection')
 const { WebsocketFrameSend } = require('./frame')
 const { PerMessageDeflate } = require('./permessage-deflate')
 const { MessageSizeExceededError } = require('../../core/errors')
+const { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require('../../core/constants')
 
 // This code was influenced by ws released under the MIT license.
 // Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
@@ -48,18 +49,25 @@ class ByteParser extends Writable {
   /**
    * @param {import('./websocket').Handler} handler
    * @param {Map<string, string>|null} extensions
-   * @param {{ maxPayloadSize?: number }} [options]
+   * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
+   *   A missing value uses the default limit; `0` disables the limit.
    */
   constructor (handler, extensions, options = {}) {
     super()
 
     this.#handler = handler
     this.#extensions = extensions == null ? new Map() : extensions
-    this.#maxFragments = options.maxFragments ?? 0
-    this.#maxPayloadSize = options.maxPayloadSize ?? 0
+    // Options come from the dispatcher's `webSocketOptions`, which only
+    // DispatcherBase provides. Fall back to the defaults rather than to no
+    // limit, so RetryAgent, MockAgent or a custom dispatcher can't turn off
+    // the payload and decompression limits by accident.
+    this.#maxFragments = options.maxFragments ?? defaultWebSocketMaxFragments
+    this.#maxPayloadSize = options.maxPayloadSize ?? defaultWebSocketMaxPayloadSize
 
     if (this.#extensions.has('permessage-deflate')) {
-      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, options))
+      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, {
+        maxPayloadSize: this.#maxPayloadSize
+      }))
     }
   }
 
@@ -244,6 +252,19 @@ class ByteParser extends Writable {
         if (isControlFrame(this.#info.opcode)) {
           this.#loop = this.parseControlFrame(body)
           this.#state = parserStates.INFO
+
+          // If the automatic PONG/CLOSE reply filled the socket's write buffer,
+          // stop parsing and resume on drain so a PING flood cannot grow the
+          // outbound queue without bound.
+          if (this.#loop && this.#handler.socket.writableNeedDrain) {
+            this.#loop = false
+            this.#handler.socket.once('drain', () => {
+              if (this.destroyed) return
+              this.#loop = true
+              this.run(callback)
+            })
+            return
+          }
         } else {
           if (!this.#info.compressed) {
             if (!this.writeFragments(body)) {

package/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.11.2",
+  "version": "8.12.3",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -63,13 +63,15 @@
   "types": "index.d.ts",
   "scripts": {
     "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
-    "build:wasm": "node build/wasm.js --docker",
+    "build:milo": "node build/milo.js",
+    "build:llhttp": "node build/llhttp.js --docker",
+    "build:wasm": "node build/llhttp.js --docker",
     "generate-pem": "node scripts/generate-pem.js",
     "lint": "eslint --cache",
     "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE= npm run test:typescript",
     "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp --timeout 180000 -p \"test/busboy/*.js\"",
     "test:cache": "borp --timeout 180000 -p \"test/cache/*.js\"",
@@ -97,7 +99,7 @@
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt:setup": "node test/web-platform-tests/wpt-runner.mjs setup",
-    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource",
+    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource /service-workers",
     "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
@@ -109,7 +111,7 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.2.2",
+    "@fastify/busboy": "3.2.3",
     "@matteo.collina/tspl": "^0.2.0",
     "@metcoder95/https-pem": "^1.0.0",
     "@sinonjs/fake-timers": "^12.0.0",
@@ -120,12 +122,12 @@
     "cross-env": "^10.0.0",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.28.0",
-    "eslint": "^9.9.0",
+    "eslint": "^10.12.0",
     "fast-check": "^4.1.1",
     "husky": "^9.0.7",
     "jest": "^30.0.5",
     "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.13.0",
+    "neostandard": "^0.14.0",
     "node-forge": "^1.3.1",
     "proxy": "^4.0.0",
     "tsd": "^0.33.0",

package/node_modules/undici/types/api.d.ts

@@ -5,7 +5,7 @@ import Dispatcher from './dispatcher'
 /** Performs an HTTP request. */
 declare function request<TOpaque = null> (
   url: string | URL | UrlObject,
-  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>
 ): Promise<Dispatcher.ResponseData<TOpaque>>
 
 /** A faster version of `request`. */

package/node_modules/undici/types/cache-interceptor.d.ts

@@ -160,6 +160,16 @@ declare namespace CacheHandler {
      * @default Infinity
      */
     maxEntrySize?: number
+
+    /**
+     * Responses whose body size, in bytes, is greater than this value are
+     * stored compressed with zstd. Responses with an easily compressible
+     * Content-Type (e.g. json, xml, plain text) are compressed regardless of
+     * size. Requires Node with zstd support
+     * (22.19+).
+     * @default 1048576 (1 MiB)
+     */
+    compressThreshold?: number
   }
 
   export class SqliteCacheStore implements CacheStore {

package/node_modules/undici/types/client.d.ts

@@ -92,7 +92,7 @@ export declare namespace Client {
      */
     allowH2?: boolean;
     /**
-     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but not raise it.
      * @default 100
      * @deprecated Use h2Options.maxConcurrentStreams instead
      */
@@ -119,6 +119,8 @@ export declare namespace Client {
      * @description HTTP/2 configuration options
      */
     h2Options?: Client.H2Options;
+    /** @experimental Enables the experimental Milo HTTP/1 parser for this client. Defaults to the `UNDICI_USE_MILO` environment variable. */
+    useMilo?: boolean;
   }
   export interface SocketInfo {
     localAddress?: string
@@ -157,7 +159,7 @@ export declare namespace Client {
      */
     pingInterval?: number;
     /**
-     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but not raise it.
      * @default 100
     */
     maxConcurrentStreams?: number;
@@ -173,8 +175,12 @@ export declare namespace Client {
   }
   export interface EventSourceOptions {
     /**
-     * Maximum allowed event size in bytes for EventSource messages.
-     * Set to 0 to disable the limit.
+     * Maximum total bytes of data and metadata field values retained for a
+     * pending EventSource event. Each unfinished line is separately bounded
+     * to this value plus seven syntax bytes. The number of data lines per
+     * event and buffered input chunks are each limited to
+     * min(131072, max(1024, floor(maxEventSize / 128))).
+     * Set to 0 to disable these limits.
      * @default buffer.kStringMaxLength
      */
     maxEventSize?: number;

package/node_modules/undici/types/errors.d.ts

@@ -39,13 +39,15 @@ declare namespace Errors {
       code: number,
       options: {
         headers?: IncomingHttpHeaders | string[] | null,
-        body?: null | Record<string, any> | string
+        body?: null | Record<string, any> | string,
+        bodyTruncated?: boolean
       }
     )
     name: 'ResponseError'
     code: 'UND_ERR_RESPONSE'
     statusCode: number
     body: null | Record<string, any> | string
+    bodyTruncated: boolean
     headers: IncomingHttpHeaders | string[] | null
   }
 
@@ -121,6 +123,13 @@ declare namespace Errors {
     code: string
   }
 
+  /** WebAssembly is unavailable when initializing the HTTP/1 parser. */
+  export class WebAssemblyNotSupportedError extends Error {
+    constructor (message?: string)
+    name: 'Error'
+    code: 'ERR_WEBASSEMBLY_NOT_SUPPORTED'
+  }
+
   /** The response exceed the length allowed. */
   export class ResponseExceededMaxSizeError extends UndiciError {
     name: 'ResponseExceededMaxSizeError'
@@ -169,6 +178,12 @@ declare namespace Errors {
     code: 'UND_ERR_MAX_ORIGINS_REACHED'
   }
 
+  /** The maximum number of redirects has been reached. */
+  export class MaxRedirectsError extends UndiciError {
+    name: 'MaxRedirectsError'
+    code: 'UND_ERR_REDIRECT_MAX'
+  }
+
   /** SOCKS5 proxy related error. */
   export class Socks5ProxyError extends UndiciError {
     constructor (

package/node_modules/undici/types/h2c-client.d.ts

@@ -63,7 +63,7 @@ export declare namespace H2CClient {
     /** The amount of time in milliseconds to wait for a connection attempt to finish before trying the next address when using the `autoSelectFamily` option. */
     autoSelectFamilyAttemptTimeout?: number;
     /**
-     * @description Dictates the maximum number of concurrent streams for a single H2 session. It can be overridden by a SETTINGS remote frame.
+     * @description Dictates the maximum number of concurrent streams for a single H2 session. The server's SETTINGS_MAX_CONCURRENT_STREAMS can lower it, but not raise it.
      * @default 100
     */
     maxConcurrentStreams?: number

package/node_modules/undici/types/interceptors.d.ts

@@ -16,7 +16,12 @@ declare namespace Interceptors {
     maxSize?: number
   }
 
-  export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
+  export type ResponseErrorInterceptorOpts = {
+    /** @deprecated This option is ignored. The interceptor always throws on error responses. */
+    throwOnError?: boolean
+    /** Maximum number of response body bytes to include in the error. 0 disables the limit. @default 1048576 */
+    maxSize?: number
+  }
   export type CacheInterceptorOpts = CacheHandler.CacheOptions
 
   // DNS interceptor

package/node_modules/undici/types/utility.d.ts

@@ -1,7 +1,7 @@
 type AutocompletePrimitiveBaseType<T> =
-  T extends string ? string :
-    T extends number ? number :
-      T extends boolean ? boolean :
-        never
+  T extends string ? string
+    : T extends number ? number
+      : T extends boolean ? boolean
+        : never
 
 export type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>)

package/node_modules/{fetch-retry → unicode-segmenter}/LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2016 Jon K. Bernhardsen
+Copyright (c) 2024 Hyeseong Kim <hey@hyeseong.kim>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/node_modules/unicode-segmenter/README.md

@@ -0,0 +1,324 @@
+# unicode-segmenter
+[![NPM Package Version](https://img.shields.io/npm/v/unicode-segmenter)](https://npmx.dev/unicode-segmenter)
+[![NPM Downloads](https://img.shields.io/npm/dw/unicode-segmenter)](https://npmx.dev/unicode-segmenter)
+[![Integration](https://github.com/cometkim/unicode-segmenter/actions/workflows/ci.yml/badge.svg)](https://github.com/cometkim/unicode-segmenter/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/cometkim/unicode-segmenter/graph/badge.svg?token=3rA29JEH4J)](https://codecov.io/gh/cometkim/unicode-segmenter)
+[![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/cometkim/unicode-segmenter?utm_source=badge)
+[![LICENSE - MIT](https://img.shields.io/github/license/cometkim/unicode-segmenter)](#license)
+
+A lightweight implementation of the [Unicode Text Segmentation (UAX \#29)](https://www.unicode.org/reports/tr29)
+
+- **Spec compliant**: Up-to-date Unicode data, verified by the official Unicode test suites and fuzzed with the native `Intl.Segmenter`, and maintaining 100% test coverage.
+
+- **Excellent compatibility**: It works well on older browsers, edge runtimes, React Native (Hermes) and QuickJS.
+
+- **Zero-dependencies**: It doesn't bloat `node_modules` or the network bandwidth. Like a small minimal snippet.
+
+- **Small bundle size**: It effectively compresses the Unicode data and provides a bundler-friendly format.
+
+- **Extremely efficient**: It's carefully optimized for runtime performance, making it the fastest one in the ecosystem—outperforming even the built-in `Intl.Segmenter`. Its flat lookup tables also keep the memory footprint far smaller than other libraries.
+
+- **TypeScript**: It's fully type-checked, and provides type definitions and JSDoc.
+
+- **ESM-first**: It primarily supports ES modules, and still supports CommonJS.
+
+> [!NOTE]
+> unicode-segmenter is now **[e18e] recommendation!**
+
+## Unicode® Version
+
+Unicode® 17.0.0
+
+Unicode® Standard Annex \#29 - [Revision 47](https://www.unicode.org/reports/tr29/tr29-47.html) (2025-08-17)
+
+## APIs
+
+Entries for Unicode text segmentation.
+
+- [`unicode-segmenter/grapheme`](#export-unicode-segmentergrapheme): Segments and counts **extended grapheme clusters**
+- [`unicode-segmenter/intl-adapter`](#export-unicode-segmenterintl-adapter): [`Intl.Segmenter`] adapter
+- [`unicode-segmenter/intl-polyfill`](#export-unicode-segmenterintl-polyfill): [`Intl.Segmenter`] polyfill
+
+And matchers for extra use cases.
+
+- [`unicode-segmenter/emoji`](#export-unicode-segmenteremoji): Matches single codepoint emojis
+- [`unicode-segmenter/general`](#export-unicode-segmentergeneral): Matches single codepoint alphanumerics
+
+### Export `unicode-segmenter/grapheme`
+
+Utilities for text segmentation by extended grapheme cluster rules.
+
+#### Example: Split graphemes
+
+You can split a string into graphemes by simply consuming the `splitGraphemes()` generator.
+
+It yields substrings directly, so it allocates less than `graphemeSegments()`.
+
+```js
+import { splitGraphemes } from 'unicode-segmenter/grapheme';
+
+[...splitGraphemes('#️⃣*️⃣0️⃣1️⃣2️⃣')];
+// 0: #️⃣
+// 1: *️⃣
+// 2: 0️⃣
+// 3: 1️⃣
+// 4: 2️⃣
+```
+
+#### Example: Collect graphemes into an array
+
+If you need the result as an array, use `collectGraphemes()` for convenience.
+
+This is a fast version of `[...splitGraphemes(str)]`, 1.5-2.5x faster.
+
+```js
+import { collectGraphemes } from 'unicode-segmenter/grapheme';
+
+collectGraphemes('#️⃣*️⃣0️⃣1️⃣2️⃣'); // => ["#️⃣", "*️⃣", "0️⃣", "1️⃣", "2️⃣"]
+```
+
+However, it collects all grapheme clusters at once, so it's not good for large text or streamed input.
+
+#### Example: Count graphemes
+
+If you need only the count, use `countGraphemes()`, which is optimized to avoid allocations for segments.
+
+Mostly 2-4x faster than the full segmenter and more GC friendly, so you can call it in a hot path.
+
+```js
+import { countGraphemes } from 'unicode-segmenter/grapheme';
+
+'👋 안녕!'.length;
+// => 6
+countGraphemes('👋 안녕!');
+// => 5
+
+'a̐éö̲'.length;
+// => 7
+countGraphemes('a̐éö̲');
+// => 3
+```
+
+#### Example: Get full segment info
+
+You can retrieve all grapheme segments using the `graphemeSegments()` generator.
+
+Each segment is returned as a `GraphemeSegmentOutput` object containing the `segment` (the substring), the starting `index`, and the full `input` string. This pattern is similar to the [`Intl.Segmenter`] API, so it can be a drop-in replacement.
+
+```js
+import { graphemeSegments } from 'unicode-segmenter/grapheme';
+
+[...graphemeSegments('a̐éö̲\r\n')];
+// 0: { segment: 'a̐', index: 0, input: 'a̐éö̲\r\n' }
+// 1: { segment: 'é', index: 2, input: 'a̐éö̲\r\n' }
+// 2: { segment: 'ö̲', index: 4, input: 'a̐éö̲\r\n' }
+// 3: { segment: '\r\n', index: 7, input: 'a̐éö̲\r\n' }
+```
+
+#### Example: Build an advanced grapheme matcher
+
+`graphemeSegments()` exposes some knowledge identified in the middle of the process to support some useful cases.
+
+For example, knowing the [Grapheme_Cluster_Break](https://www.unicode.org/reports/tr29/tr29-43.html#Default_Grapheme_Cluster_Table) category at the beginning and end of a segment can help approximately infer the applied boundary rule.
+
+```js
+import { graphemeSegments, GraphemeCategory } from 'unicode-segmenter/grapheme';
+
+function* matchEmoji(str) {
+  for (const { segment, _catBegin } of graphemeSegments(input)) {
+    // `_catBegin` identified as Extended_Pictographic means the segment is emoji
+    if (_catBegin === GraphemeCategory.Extended_Pictographic) {
+      yield segment;
+    }
+  }
+}
+
+[...matchEmoji('1🌷2🎁3💩4😜5👍')]
+// 0: 🌷
+// 1: 🎁
+// 2: 💩
+// 3: 😜
+// 4: 👍
+```
+
+Or build even more advanced one like an Unicode-aware [TTY string width](https://github.com/cometkim/unicode-string-width) utility.
+
+### Export `unicode-segmenter/intl-adapter`
+
+[`Intl.Segmenter`] API adapter (only `granularity: "grapheme"` available yet)
+
+```js
+import { Segmenter } from 'unicode-segmenter/intl-adapter';
+
+// Same API with the `Intl.Segmenter`
+const segmenter = new Segmenter();
+```
+
+### Export `unicode-segmenter/intl-polyfill`
+
+[`Intl.Segmenter`] API polyfill (only `granularity: "grapheme"` available yet)
+
+```js
+// Apply polyfill to the `globalThis.Intl` object.
+import 'unicode-segmenter/intl-polyfill';
+
+const segmenter = new Intl.Segmenter();
+```
+
+### Export `unicode-segmenter/emoji`
+
+Utilities for matching emoji-like characters.
+
+#### Example: Use Unicode emoji property matches
+
+```js
+import {
+  isEmojiPresentation,    // match \p{Emoji_Presentation}
+  isExtendedPictographic, // match \p{Extended_Pictographic}
+} from 'unicode-segmenter/emoji';
+
+isEmojiPresentation('😍'.codePointAt(0));
+// => true
+isEmojiPresentation('♡'.codePointAt(0));
+// => false
+
+isExtendedPictographic('😍'.codePointAt(0));
+// => true
+isExtendedPictographic('♡'.codePointAt(0));
+// => true
+```
+
+### Export `unicode-segmenter/general`
+
+Utilities for matching alphanumeric characters.
+
+#### Example: Use Unicode general property matchers
+
+```js
+import {
+  isLetter,       // match \p{L}
+  isNumeric,      // match \p{N}
+  isAlphabetic,   // match \p{Alphabetic}
+  isAlphanumeric, // match [\p{N}\p{Alphabetic}]
+} from 'unicode-segmenter/general';
+```
+
+## Runtime Compatibility
+
+`unicode-segmenter` uses only fundamental features of ES2015, making it compatible with most browsers.
+
+To ensure compatibility, the runtime should support:
+- [`String.prototype.codePointAt()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt)
+- [Typed arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Typed_arrays)
+- [Generators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator)
+- [Modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)
+
+If the runtime doesn't support these features, it can easily be fulfilled with tools like Babel.
+
+## React Native Support
+
+Since [Hermes doesn't support the `Intl.Segmenter` API](https://github.com/facebook/hermes/blob/main/doc/IntlAPIs.md) yet, `unicode-segmenter` is a good alternative.
+
+`unicode-segmenter` is compiled into small & efficient Hermes bytecode than other JavaScript libraries. See the [benchmark](#hermes-bytecode-stats) for details.
+
+## Comparison
+
+`unicode-segmenter` aims to be lighter and faster than alternatives in the ecosystem while fully spec compliant. So the benchmark is tracking several libraries' performance, bundle size, and Unicode version compliance.
+
+### `unicode-segmenter/grapheme` vs
+
+- [graphemer]@1.4.0
+- [grapheme-splitter]@1.0.4
+- [@formatjs/intl-segmenter]@12.1.0
+- WebAssembly build of [unicode-segmentation]@1.12.0 with minimum bindings
+- Built-in [`Intl.Segmenter`] API
+
+#### JS Bundle Stats
+
+| Name                                 | Unicode® | ESM? |    Size | Size (min) | Size (min+gzip) | Size (min+br) | Size (min+zstd) |
+|--------------------------------------|----------|------|--------:|-----------:|----------------:|--------------:|----------------:|
+| `unicode-segmenter/grapheme`         | 17.0.0   | ✔️   |   7,767 |      4,876 |           2,325 |         2,104 |           2,374 |
+| `unicode-segmenter/grapheme` (full*) | 17.0.0   | ✔️   |  10,173 |      5,725 |           2,607 |         2,322 |           2,668 |
+| `graphemer`                          | 15.0.0   | ✖️   | 410,435 |     95,104 |          15,752 |        10,660 |          15,911 |
+| `grapheme-splitter`                  | 10.0.0   | ✖️   | 122,254 |     23,682 |           7,852 |         4,802 |           6,753 |
+| `@formatjs/intl-segmenter`*          | 17.0.0   | ✖️   | 268,301 |    176,759 |          45,988 |        31,701 |          45,370 |
+| `unicode-segmentation`*              | 15.1.0   | -    |  56,529 |     52,439 |          24,108 |        17,343 |          24,375 |
+| `Intl.Segmenter`*                    | -        | -    |       0 |          0 |               0 |             0 |               0 |
+
+* `unicode-segmenter/grapheme` provides count/split-only API which has much less overhead than full `Segmenter` implementation, which includes some redundant codes but tree-shakable.
+* `@formatjs/intl-segmenter` handles grapheme, word, and sentence, but it's not tree-shakable.
+* `unicode-segmentation` size contains only minimum WASM binary and its bindings to execute benchmarking. It will increases to expose more features.
+* `Intl.Segmenter`'s Unicode data depends on the host, and may not be up-to-date.
+* `Intl.Segmenter` may not be available in [some old browsers](https://caniuse.com/mdn-javascript_builtins_intl_segmenter), edge runtimes, or embedded environments.
+
+#### Hermes Bytecode Stats
+
+| Name                                | Bytecode size | Bytecode size (gzip)* |
+|-------------------------------------|--------------:|----------------------:|
+| `unicode-segmenter/grapheme`        |        15,794 |                 8,916 |
+| `unicode-segmenter/grapheme` (full) |        16,003 |                 9,073 |
+| `graphemer`                         |       134,085 |                31,770 |
+| `grapheme-splitter`                 |        63,942 |                19,165 |
+| `@formatjs/intl-segmenter`          |       329,547 |               136,751 |
+
+* The installation size contains _compressed_ assets.
+
+#### Memory Stats
+
+Retained memory per library after segmenting the benchmark corpus, measured by `yarn memory-stats:grapheme` in isolated Node.js processes (median of 5, GC-stabilized deltas).
+
+
+| Name                         | JS heap | ArrayBuffers* |
+|------------------------------|--------:|--------------:|
+| `unicode-segmenter/grapheme` | 217 kB  |       19.1 kB |
+| `graphemer`                  | 2.32 MB |           0 B |
+| `grapheme-splitter`          | 570 kB  |           0 B |
+| `@formatjs/intl-segmenter`   | 1.95 MB |           0 B |
+| `unicode-segmentation`*      | 214 kB  |             - |
+| `Intl.Segmenter`*            | 86.1 kB |             - |
+
+* "ArrayBuffers" is `process.memoryUsage().arrayBuffers`: `unicode-segmenter` keeps its lookup tables in typed arrays, so they live there instead of the JS heap. No other JavaScript library here allocates any.
+* `unicode-segmentation`'s WASM linear memory and `Intl.Segmenter`'s ICU data are allocated by native code and invisible to both columns.
+
+#### Runtime Performance
+
+Here is a brief explanation, and you can see [archived benchmark results](benchmark/grapheme/_records).
+
+**Performance in Node.js/Bun/Deno**: `unicode-segmenter/grapheme` has best-in-class performance.
+- 5\~48x faster than other JavaScript libraries.
+- 3.5\~8x faster than WASM binding of the Rust's [unicode-segmentation].
+- 1.3\~2.5x faster than built-in [`Intl.Segmenter`].
+
+**Performance in Browsers**: The performance in browser environments varies greatly due to differences in browser engines, which makes benchmarking inconsistent, but:
+- Still significantly faster than other JavaScript libraries.
+- Generally outperforms the built-in in the most browser environments, except the Firefox.
+
+**Performance in React Native**: `unicode-segmenter/grapheme` is still faster than alternatives when compiled to Hermes bytecode. It's \~4x faster than `graphemer` and \~34x faster than `grapheme-splitter`.
+
+**Performance in QuickJS**: `unicode-segmenter/grapheme` is the only usable library in terms of performance.
+
+Instead of trusting these claims, you can try `yarn perf:grapheme` directly in your environment or build your own benchmark.
+
+## Acknowledgments
+
+- **The Rust Unicode team ([@unicode-rs](https://github.com/unicode-rs))**:\
+   The initial implementation was ported manually from [unicode-segmentation] library.
+
+- **Marijn Haverbeke ([@marijnh](https://github.com/marijnh))**:\
+   Inspired a technique that can greatly compress Unicode data table from [his library](https://github.com/marijnh/find-cluster-break).
+
+## LICENSE
+
+[MIT](LICENSE)
+
+[e18e]: https://e18e.dev/
+[Hermes]: https://hermesengine.dev/
+[QuickJS]: https://bellard.org/quickjs/
+[unicode-segmentation]: https://github.com/unicode-rs/unicode-segmentation
+[`Intl.Segmenter`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter
+[graphemer]: https://github.com/flmnt/graphemer
+[grapheme-splitter]: https://github.com/orling/grapheme-splitter
+[emoji-regex]: https://github.com/mathiasbynens/emoji-regex
+[emojibase-regex]: https://emojibase.dev/docs/regex
+[XRegExp]: https://xregexp.com/
+[@formatjs/intl-segmenter]: https://formatjs.github.io/docs/polyfills/intl-segmenter/

package/node_modules/unicode-segmenter/_emoji_data.cjs

@@ -0,0 +1,24 @@
+"use strict";
+
+exports.extended_pictographic_table = exports.emoji_presentation_table = void 0;
+var _core = require("./core.cjs");
+// The following code was generated by "scripts/unicode.js",
+// DO NOT EDIT DIRECTLY.
+//
+// @ts-check
+
+/**
+ * @typedef {import('./core.js').UnicodeDataEncoding} UnicodeDataEncoding
+ */
+
+/**
+ * The Unicode `Emoji_Presentation` properties table
+ */
+const emoji_presentation_table = exports.emoji_presentation_table = (0, _core.decodeUnicodeFlatData)(/** @type {UnicodeDataEncoding} */
+'qhj21tc33020pg21l11i3br20j10d081h11518050l10711040207041s10j20104210t32o10e0rl31j3040uqks10qc0ub029r4p110o10k102412l11uag2c81l41l1cq244cg1303m4101qb2u3d31n1i10q11d0m5k5g3l460322333b178jeb40rh1u2191obg7c3a3o3104f2b49');
+
+/**
+ * The Unicode `Extended_Pictographic` properties table
+ */
+const extended_pictographic_table = exports.extended_pictographic_table = (0, _core.decodeUnicodeFlatData)(/** @type {UnicodeDataEncoding} */
+'pa040tov10c0od0m10q55f1vm11c0ma0p1a42nc0ne1a090q3314902021204020112030318250105bb1201110i1021i15101131502141b15120511011k1155132040202510201010603060a1f02040104210b1g3290e0e0kn11vs12j11j3040qt40c0pl2010qmtr10n23k6bf1f0e1l29g71c1e029j1n3r1ea0k1028139m16rb2v621122i522135tf1u3b51n17127c0232041d120819052c28220104060306l5g3l4572g130152cqdl2c3o37a5o27u11c32d9m2cu2191obo57eh9gg1tv3');

package/node_modules/unicode-segmenter/_emoji_data.d.cts

@@ -0,0 +1 @@
+export * from "./_emoji_data.js";

package/node_modules/unicode-segmenter/_emoji_data.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @typedef {import('./core.js').UnicodeDataEncoding} UnicodeDataEncoding
+ */
+/**
+ * The Unicode `Emoji_Presentation` properties table
+ */
+export const emoji_presentation_table: import("./core.js").UnicodeRangeTable;
+/**
+ * The Unicode `Extended_Pictographic` properties table
+ */
+export const extended_pictographic_table: import("./core.js").UnicodeRangeTable;
+export type UnicodeDataEncoding = import("./core.js").UnicodeDataEncoding;