@automattic/vip 4.1.5 → 4.1.6

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.2",
   "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",

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/{lando/node_modules/js-yaml → unicode-segmenter}/LICENSE

@@ -1,6 +1,6 @@
-(The MIT License)
+MIT License
 
-Copyright (C) 2011-2015 by Vitaly Puzrin
+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
@@ -9,13 +9,13 @@ 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 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.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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;

package/node_modules/unicode-segmenter/_emoji_data.js

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