@kaeawc/auto-mobile 0.0.87 → 0.0.89

package/node_modules/strtok3/README.md

@@ -5,6 +5,7 @@
 [![DeepScan grade](https://deepscan.io/api/teams/5165/projects/8526/branches/103329/badge/grade.svg)](https://deepscan.io/dashboard#view=project&tid=5165&pid=8526&bid=103329)
 [![Known Vulnerabilities](https://snyk.io/test/github/Borewit/strtok3/badge.svg?targetFile=package.json)](https://snyk.io/test/github/Borewit/strtok3?targetFile=package.json)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/59dd6795e61949fb97066ca52e6097ef)](https://www.codacy.com/app/Borewit/strtok3?utm_source=github.com&utm_medium=referral&utm_content=Borewit/strtok3&utm_campaign=Badge_Grade)
+[![Codecov](https://codecov.io/gh/Borewit/strtok3/branch/master/graph/badge.svg)](https://codecov.io/gh/Borewit/strtok3)
 # strtok3
 
 A promise-based streaming [*tokenizer*](#tokenizer-object) for [Node.js](https://nodejs.org) and browsers.
@@ -45,7 +46,7 @@ For TypeScript CommonJS backward compatibility, you can use [load-esm](https://g
 Use Node.js 24 LTS to build the project and install development dependencies.
 This build requirement is separate from the Node.js ≥ 18 runtime requirement in `package.json`.
 CI builds once with Node.js 24, then runs the compiled JavaScript unit tests across the Node.js compatibility matrix and Bun 1.2.x, 1.3.x, and 1.4.x.
-Coverage is collected in a separate Node.js 24 job.
+Coverage is collected in a separate Node.js 24 job and uploaded to Codecov.
 
 For local development, running the TypeScript tests with `tsx` requires Node.js 18.19+ (18.x) or Node.js ≥ 20.6.0.
 
@@ -65,15 +66,18 @@ If you find this project useful and would like to support its development, consi
 Use one of the methods to instantiate an [*abstract tokenizer*](#tokenizer-object):
 - [fromBlob](#fromblob-function)
 - [fromBuffer](#frombuffer-function)
-- [fromFile](#fromfile-function)*
-- [fromStream](#fromstream-function)*
+- [fromFile](#fromfile-function)
+- [fromStream](#fromstream-function)
 - [fromWebStream](#fromwebstream-function)
+- [createTokenizerView](#createtokenizerview-function)
 
 > [!NOTE]
 > `fromFile` requires Node.js file-system APIs, and `fromStream` requires a Node.js readable stream.
 > In browsers, use `fromBlob`, `fromBuffer`, or `fromWebStream`.
 
 All methods return a [`Tokenizer`](#tokenizer-object), either directly or via a promise.
+The `strtok3/core` entry point exports all factories except `fromFile` and can be used
+without Node.js file-system APIs. In browsers, `strtok3` resolves to this core entry point.
 
 #### `fromBlob()` function
 
@@ -141,13 +145,13 @@ parse();
 Creates a [*tokenizer*](#tokenizer-object) from a local file.
 
 ```ts
-function fromFile(sourceFilePath: string, options?: ITokenizerOptions): Promise<FileTokenizer>
+function fromFile(sourceFilePath: string, options?: IFromFileOptions): Promise<FileTokenizer>
 ```  
 
 | Parameter      | Type     | Description                |
 |----------------|----------|----------------------------|
 | sourceFilePath | `string` | Path to file to read from  |
-| options | [ITokenizerOptions](#itokenizeroptions-interface) | Optional tokenizer options |
+| options | [IFromFileOptions](#ifromfileoptions-interface) | Optional file tokenizer options |
 
 > [!NOTE]
 > - Only available for Node.js engines
@@ -248,6 +252,83 @@ async function parse() {
 parse();
 ```
 
+#### `createTokenizerView()` function
+
+Borrow a finite range of an existing tokenizer without buffering it or taking
+ownership of its input. Available from both `strtok3` and `strtok3/core`.
+
+```ts
+function createTokenizerView(source: ITokenizer, length: number): ITokenizerView
+```
+
+The view starts at `source.position`, with local `position` zero and
+`fileInfo.size` equal to `length`. Creation does not read or skip bytes. The size
+is the declared range, so it can exceed the actual remaining input. The outer
+file's MIME type, path, and URL are not copied to the view.
+
+```js
+import { createTokenizerView, fromBuffer } from 'strtok3';
+import { UINT8 } from 'token-types';
+
+const source = fromBuffer(new Uint8Array([10, 20, 30, 40, 50]));
+await source.ignore(1);
+const chunk = createTokenizerView(source, 3); // source bytes [20, 30, 40]
+
+console.log(await chunk.readToken(UINT8)); // 20; chunk.position = 1
+const child = chunk.createView(1);         // same as createTokenizerView(chunk, 1)
+console.log(await child.readToken(UINT8)); // 30; chunk.position = 2
+await child.close();                      // source stays open, at position 3
+
+console.log(chunk.remaining);             // 1
+await chunk.consumeRemainder();           // exactly consume 40, or throw on truncation
+await chunk.close();
+console.log(await source.readToken(UINT8)); // 50
+await source.close();
+```
+
+All read and peek positions, including explicit offsets and `setPosition()`, are
+relative to the view's start. Nested views must fit inside their parent's
+remaining range. A view exposes `setPosition()` and reports random access only
+when its source supports it; a stream with a known size remains forward-only.
+The overload for an `IRandomAccessTokenizer` returns an
+`IRandomAccessTokenizerView`, including for nested `createView()` calls.
+
+A request crossing the declared boundary rejects with `TokenizerBoundaryError`,
+a `RangeError` with `position`, `length`, and `size` properties. This applies to
+reads, peeks, tokens, and skips, even with `mayBeLess: true`. Invalid lengths,
+offsets, and unsafe offset arithmetic reject before allocating token buffers or
+consuming input. The source's token allocation and stream lookahead limits still
+apply through nested views.
+
+A request inside the view that encounters truncated underlying input rejects
+with `EndOfStreamError`. Buffer reads and peeks with `mayBeLess: true` may return
+fewer bytes within the requested range; token reads and peeks always require a
+complete token. A failed exact read may have consumed part of the input; the
+shared cursor reflects the bytes consumed. Peeks do not advance that cursor.
+
+`ignore()` preserves the source's skip behavior, which may return a shorter
+count or reject at EOF. Use `consumeRemainder()` when the entire declared
+remainder must exist: it returns the number consumed, or rejects with
+`EndOfStreamError`. On random-access sources it verifies the final byte and
+advances the cursor without reading the whole remainder. On streams it drains
+the remainder using the source's bounded skip buffers.
+
+The source, parent, child, and sibling views share one cursor. Use them
+sequentially, and close a child before resuming its parent. `close()` is
+idempotent, does not drain the remainder, and never closes or aborts the source.
+After a partially consumed child closes, the parent resumes at that same byte,
+not at the child's declared end. Call `child.consumeRemainder()` before closing
+when the parent should resume after the entire child range. Closed views reject
+further operations and keep their last local position; closing a parent view
+also prevents its children from being used.
+
+Overlapping operations through a view or its parent/child chain are rejected;
+`close()` also rejects while that view has an active operation. Direct operations
+on the original source, or separate views created from it, cannot be coordinated
+by a view, so callers must keep those sequential too. Explicit `abort()`
+propagates to the shared source to cancel pending input and affects its other
+users; it also closes the view.
+
 ### `Tokenizer` object
 The *tokenizer* is an abstraction of a [stream](https://nodejs.org/api/stream.html), file or [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), allowing _reading_ or _peeking_ from the stream.
 It can also be translated in chunked reads, as done in [@tokenizer/http](https://github.com/Borewit/tokenizer-http);
@@ -264,9 +345,18 @@ It can also be translated in chunked reads, as done in [@tokenizer/http](https:/
 _Read_ methods advance the stream pointer, while _peek_ methods do not.
 
 There are two kinds of functions:
-1. *read* methods: used to read a *token* or bytes into a buffer from the [*tokenizer*](#tokenizer-object). The position of the *tokenizer-stream* will advance with the number of bytes read.
+1. *read* methods: used to read a *token* or bytes into a buffer from the [*tokenizer*](#tokenizer-object). After a successful read, `tokenizer.position` is the starting position of the read plus the number of bytes read. An explicit position can skip ahead or, for random-access tokenizers, move backwards.
 2. *peek* methods: same as the read, but it will *not* advance the pointer. It allows to read (peek) ahead.
 
+Reads and peeks require the full requested length unless `mayBeLess: true` is passed to
+`readBuffer` or `peekBuffer`. Otherwise, insufficient input rejects with the exported
+`EndOfStreamError`. Token methods always require the full token.
+
+A failed exact stream read can consume partial input and advance `tokenizer.position`
+by the number of bytes consumed. A failed exact stream peek leaves `tokenizer.position`
+unchanged and retains the partial bytes for subsequent reads. Caller-provided buffers
+may contain partial data even when the operation rejects.
+
 #### `readBuffer` function
 
 Read data from the _tokenizer_ into provided "buffer" (`Uint8Array`).
@@ -299,6 +389,12 @@ peekBuffer(uint8Array: Uint8Array, options?: IReadChunkOptions): Promise<number>
 
 Return value `Promise<number>` Promise with number of bytes read. The number of bytes read may be less if the `mayBeLess` flag was set.
 
+For streams with a known size, a nonempty peek starting at or beyond that size
+rejects with `EndOfStreamError`, or returns zero with `mayBeLess: true`, before
+allocating lookahead or reading input. This also applies through tokenizer views.
+Peeks starting inside the advertised input retain their partial-read behavior
+when they cross EOF. Zero-length peeks remain no-ops.
+
 #### `readToken` function
 
 Read a *token* from the tokenizer-stream.
@@ -342,6 +438,8 @@ readNumber(token: IToken<number>): Promise<number>
 | token      | [IToken<number>](#token-object) | Numeric token to read from the tokenizer-stream.   |
 
 A promise resolving to a numeric value read and decoded from the *tokenizer-stream*.
+Uses a reusable 8-byte buffer, so `token.len` must be at most 8 bytes.
+For larger tokens or values such as `bigint`, use `readToken` instead.
 
 #### `peekNumber` function
 
@@ -353,10 +451,11 @@ peekNumber(token: IToken<number>): Promise<number>
 
 Returns a promise resolving to the decoded numeric value.
 Like `readNumber`, rejects with `EndOfStreamError` if the token cannot be read in full.
+The same 8-byte token limit applies; use `peekToken` for larger tokens or values such as `bigint`.
 
 #### `ignore` function
 
-Advance the offset pointer with the token number of bytes provided.
+Advance the offset pointer by the given number of bytes.
 
 ```ts
 ignore(length: number): Promise<number>
@@ -364,10 +463,14 @@ ignore(length: number): Promise<number>
 
 | Parameter  | Type   | Description                                                      |
 |------------|--------|------------------------------------------------------------------|
-| length     | number | Non-negative number of bytes to ignore. Advances `tokenizer.position`. |
+| length     | number | Non-negative safe integer number of bytes to ignore. Advances `tokenizer.position`. |
 
 Returns a promise resolving to the number of bytes ignored.
 Buffer, blob, and file tokenizers stop at the known file size. Stream tokenizers reject with `EndOfStreamError` if the requested bytes are unavailable.
+When a stream has a known size, skips beyond that size reject before allocating
+a skip buffer or consuming input, including skips through tokenizer views.
+If the size is unknown, or the stream ends before its advertised size, a failed
+skip may consume available bytes before rejecting; `position` reflects those bytes.
 
 #### `close` function
 Clean up resources, such as closing a file pointer if applicable.
@@ -378,6 +481,17 @@ close(): Promise<void>
 
 Await this method when finished with a tokenizer. For Node.js streams, it does not destroy the underlying stream; the caller remains responsible for its lifecycle.
 
+For buffer, blob, and file tokenizers, repeated or concurrent `close()` calls
+share one cleanup operation and invoke `onClose` at most once. If cleanup or the
+callback fails, subsequent calls reject with the same error. Calling `abort()`
+before `close()` does not suppress cleanup or the callback.
+
+Closing or aborting a Node.js stream tokenizer removes its reader-retaining
+stream listeners. After the source ends, shared error and close guards may remain
+until the source emits either event, including after tokenizer closure; these
+guards do not retain the tokenizer. The caller remains responsible for handling
+subsequent source errors.
+
 For Web streams, `close()` releases the reader lock. A BYOB reader leaves the source uncancelled, allowing another reader to continue reading it. A default reader cancels the source before releasing the lock, discarding remaining data. Bytes already read into tokenizer buffers, including peeked bytes, are not returned to the source.
 
 #### `abort` function
@@ -390,6 +504,10 @@ abort(): Promise<void>
 
 This is a no-op for buffer, blob, and file tokenizers.
 
+For Node.js streams, pending reads reject with the exported `AbortError`, and buffered
+peek data is discarded. The underlying stream is not destroyed. Calling `close()` or
+aborting the configured `AbortSignal` has the same effect on pending Node.js stream reads.
+
 For Web streams, `abort()` releases a BYOB reader's lock without cancelling the source. A default reader cancels the source but keeps its lock until `close()` is called. An `AbortSignal` invokes the same abort behavior.
 
 #### `supportsRandomAccess` function
@@ -401,6 +519,25 @@ supportsRandomAccess(): boolean
 Returns `true` for buffer, blob, and file tokenizers, and `false` for stream tokenizers.
 When random access is supported, read and peek methods can use positions before `tokenizer.position`.
 
+#### `isRandomAccessTokenizer` helper
+
+Exported from both `strtok3` and `strtok3/core`:
+
+```ts
+import { isRandomAccessTokenizer, type ITokenizer } from 'strtok3';
+
+function skipToEnd(tokenizer: ITokenizer): void {
+  if (isRandomAccessTokenizer(tokenizer)) {
+    tokenizer.setPosition(tokenizer.fileInfo.size);
+  }
+}
+```
+
+Narrows `ITokenizer` to `IRandomAccessTokenizer` by checking `supportsRandomAccess()`,
+a callable `setPosition`, and a numeric file size. A known size alone does not imply
+random access. Existing third-party implementations can keep returning a boolean
+from `supportsRandomAccess()` without changing their interface.
+
 #### `setPosition` function
 
 Available on buffer, blob, and file tokenizers (`IRandomAccessTokenizer`).
@@ -409,7 +546,10 @@ Available on buffer, blob, and file tokenizers (`IRandomAccessTokenizer`).
 setPosition(position: number): void
 ```
 
-Sets the current byte offset without reading data.
+Sets the current byte offset without reading data. The position must be a
+non-negative safe integer; invalid positions throw `RangeError` without changing
+the cursor. Seeking past EOF is allowed. At or past EOF, `ignore()` returns zero
+without moving the cursor backward, subject to safe end-position arithmetic.
 
 #### `Tokenizer` attributes
 
@@ -471,16 +611,51 @@ try {
 }
 ```
 
+### `IFromFileOptions` interface
+
+Extends [ITokenizerOptions](#itokenizeroptions-interface) for `fromFile()`.
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| regularFileOnly | `boolean` | When `true`, opens with `O_RDONLY \| O_NONBLOCK` and checks that the opened handle refers to a regular file. Defaults to `false`, preserving existing behavior. |
+
+Use this option when non-regular inputs, such as FIFOs, should be rejected without waiting for a writer. Validation uses the opened handle, so replacing the pathname before opening does not bypass the check. Symbolic links to regular files are accepted.
+
+If an opened handle is not a regular file, `fromFile()` closes it and rejects with the exported `NotRegularFileError`. Its `path` property identifies the requested path. Opening errors, stat errors, and abort errors continue to propagate; any handle acquired by the factory is closed if setup fails. After success, the caller must close the tokenizer.
+
+```js
+import { fromFile, NotRegularFileError } from 'strtok3';
+
+try {
+  const tokenizer = await fromFile('somefile.bin', { regularFileOnly: true });
+  try {
+    // Parse the regular file.
+  } finally {
+    await tokenizer.close();
+  }
+} catch (error) {
+  if (!(error instanceof NotRegularFileError)) {
+    throw error;
+  }
+  // Handle an input that is not a regular file.
+}
+```
+
 ### `IReadChunkOptions` interface
 
 Each attribute is optional:
 
 | Attribute | Type    | Description                                                                                                                                                                                                                   |
 |-----------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| length    | number  | Requested number of bytes to read or peek. Defaults to the target buffer length. |
-| position  | number  | Byte offset to read or peek from. Defaults to [tokenizer.position](#tokenizer-attributes) when omitted. Earlier positions require random access. |
+| length    | number  | Requested number of bytes to read or peek. Must be a non-negative safe integer no larger than the target buffer length. Defaults to the target buffer length. |
+| position  | number  | Byte offset to read or peek from. Must be a non-negative safe integer. Defaults to [tokenizer.position](#tokenizer-attributes) when omitted. Earlier positions require random access. |
 | mayBeLess | boolean | If `true`, allows fewer than the requested number of bytes to be read or peeked instead of throwing `EndOfStreamError`. Defaults to `false`. |
 
+Invalid lengths or positions, including a `position + length` that exceeds the safe
+integer range, reject with `RangeError`. Requesting an earlier position on a tokenizer
+without random access rejects with `Error`. Data is written starting at index 0 of the
+target buffer. To write at an offset, pass `buffer.subarray(offset)` as the target buffer.
+
 Example usage:
 ```js
   const bytesPeeked = await tokenizer.peekBuffer(buffer, {mayBeLess: true});

package/node_modules/strtok3/lib/AbstractTokenizer.js

@@ -11,7 +11,7 @@ export class AbstractTokenizer {
      * @protected
      */
     constructor(options) {
-        this.numBuffer = new Uint8Array(8);
+        this.numBuffer = new Uint8Array(10); // Includes the 80-bit floating-point tokens.
         /**
          * Tokenizer-stream position
          */
@@ -106,7 +106,7 @@ export class AbstractTokenizer {
         this.validateLength(length, 'ignore length');
         this.validateLength(this.position + length, 'end position');
         if (this.fileInfo.size !== undefined) {
-            const bytesLeft = this.fileInfo.size - this.position;
+            const bytesLeft = Math.max(0, this.fileInfo.size - this.position);
             if (length > bytesLeft) {
                 this.position += bytesLeft;
                 return bytesLeft;
@@ -115,8 +115,16 @@ export class AbstractTokenizer {
         this.position += length;
         return length;
     }
-    async close() {
-        this.removeAbortListener();
+    close() {
+        if (!this.closePromise) {
+            this.removeAbortListener();
+            // Cache completion before invoking cleanup hooks or caller callbacks.
+            this.closePromise = Promise.resolve().then(() => this.closeOnce());
+        }
+        return this.closePromise;
+    }
+    /** Perform cleanup once, sharing completion and the first error across close calls. */
+    async closeOnce() {
         await this.abort();
         await this.onClose?.();
     }

package/node_modules/strtok3/lib/BlobTokenizer.js

@@ -51,6 +51,7 @@ export class BlobTokenizer extends AbstractTokenizer {
         return true;
     }
     setPosition(position) {
+        this.validateLength(position, 'position');
         this.position = position;
     }
 }

package/node_modules/strtok3/lib/BufferTokenizer.js

@@ -31,7 +31,7 @@ export class BufferTokenizer extends AbstractTokenizer {
      */
     async peekBuffer(uint8Array, options) {
         const normOptions = this.normalizeOptions(uint8Array, options);
-        const bytes2read = Math.min(this.uint8Array.length - normOptions.position, normOptions.length);
+        const bytes2read = Math.max(0, Math.min(this.uint8Array.length - normOptions.position, normOptions.length));
         if (!normOptions.mayBeLess && bytes2read < normOptions.length) {
             throw new EndOfStreamError();
         }
@@ -45,6 +45,7 @@ export class BufferTokenizer extends AbstractTokenizer {
         return true;
     }
     setPosition(position) {
+        this.validateLength(position, 'position');
         this.position = position;
     }
 }

package/node_modules/strtok3/lib/FileTokenizer.js

@@ -1,7 +1,9 @@
-import { open as fsOpen } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import fs, {} from 'node:fs/promises';
 import { throwIfAborted } from './AbortSignal.js';
 import { AbstractTokenizer } from './AbstractTokenizer.js';
 import { getMaxBufferSize } from './BufferSizeError.js';
+import { NotRegularFileError } from './NotRegularFileError.js';
 import { EndOfStreamError } from './stream/index.js';
 export class FileTokenizer extends AbstractTokenizer {
     /**
@@ -12,9 +14,13 @@ export class FileTokenizer extends AbstractTokenizer {
     static async fromFile(sourceFilePath, options) {
         getMaxBufferSize(options);
         throwIfAborted(options?.abortSignal);
-        const fileHandle = await fsOpen(sourceFilePath, 'r');
+        const flags = options?.regularFileOnly ? constants.O_RDONLY | constants.O_NONBLOCK : 'r';
+        const fileHandle = await fs.open(sourceFilePath, flags);
         try {
             const stat = await fileHandle.stat();
+            if (options?.regularFileOnly && !stat.isFile()) {
+                throw new NotRegularFileError(sourceFilePath);
+            }
             return new FileTokenizer(fileHandle, {
                 ...options,
                 fileInfo: { ...options?.fileInfo, path: sourceFilePath, size: stat.size }
@@ -63,12 +69,12 @@ export class FileTokenizer extends AbstractTokenizer {
         }
         return res.bytesRead;
     }
-    async close() {
-        this.removeAbortListener();
+    async closeOnce() {
         await this.fileHandle.close();
-        return super.close();
+        await super.closeOnce();
     }
     setPosition(position) {
+        this.validateLength(position, 'position');
         this.position = position;
     }
     supportsRandomAccess() {

package/node_modules/strtok3/lib/NotRegularFileError.js

@@ -0,0 +1,8 @@
+/** Thrown when regularFileOnly is enabled and the opened handle is not a regular file. */
+export class NotRegularFileError extends Error {
+    constructor(path) {
+        super(`Not a regular file: ${path}`);
+        this.path = path;
+        this.name = 'NotRegularFileError';
+    }
+}

package/node_modules/strtok3/lib/ReadStreamTokenizer.js

@@ -32,9 +32,10 @@ export class ReadStreamTokenizer extends AbstractTokenizer {
             return 0;
         }
         let bytesRead = 0;
+        // Account for partial input before reporting an exact-read failure.
         while (bytesRead < normOptions.length) {
             const chunkLength = Math.min(this.maxBufferSize, normOptions.length - bytesRead);
-            const count = await this.streamReader.read(uint8Array.subarray(bytesRead, bytesRead + chunkLength), normOptions.mayBeLess);
+            const count = await this.streamReader.read(uint8Array.subarray(bytesRead, bytesRead + chunkLength), true);
             bytesRead += count;
             this.position += count;
             if (count < chunkLength) {
@@ -57,6 +58,13 @@ export class ReadStreamTokenizer extends AbstractTokenizer {
         if (normOptions.length === 0) {
             return 0;
         }
+        // A known-empty range needs neither lookahead allocation nor source I/O.
+        if (this.fileInfo.size !== undefined && normOptions.position >= this.fileInfo.size) {
+            if (normOptions.mayBeLess) {
+                return 0;
+            }
+            throw new EndOfStreamError();
+        }
         const lookaheadSize = normOptions.length + normOptions.position - this.position;
         this.validateBufferSize(lookaheadSize);
         let bytesRead = 0;
@@ -75,7 +83,11 @@ export class ReadStreamTokenizer extends AbstractTokenizer {
         }
         if (normOptions.length > 0) {
             try {
-                bytesRead = await this.streamReader.peek(uint8Array.subarray(0, normOptions.length), normOptions.mayBeLess);
+                // The reader retains this buffer. Keep it independent of caller-owned memory,
+                // including partial bytes retained when an exact peek encounters truncation.
+                const peekBuffer = new Uint8Array(normOptions.length);
+                bytesRead = await this.streamReader.peek(peekBuffer, true);
+                uint8Array.set(peekBuffer.subarray(0, bytesRead));
             }
             catch (err) {
                 if (options?.mayBeLess && err instanceof EndOfStreamError) {
@@ -98,6 +110,9 @@ export class ReadStreamTokenizer extends AbstractTokenizer {
         }
         this.validateLength(length, 'ignore length');
         this.validateLength(this.position + length, 'end position');
+        if (length > 0 && this.fileInfo.size !== undefined && length > this.fileInfo.size - this.position) {
+            throw new EndOfStreamError();
+        }
         const bufSize = Math.min(ignoreChunkSize, this.maxBufferSize, length);
         const buf = new Uint8Array(bufSize);
         let totBytesRead = 0;

package/node_modules/strtok3/lib/TokenizerBoundaryError.js

@@ -0,0 +1,10 @@
+/** A request exceeds a tokenizer view, rather than encountering truncated input. */
+export class TokenizerBoundaryError extends RangeError {
+    constructor(position, length, size) {
+        super(`Range at position ${position} with length ${length} exceeds tokenizer view size ${size}`);
+        this.position = position;
+        this.length = length;
+        this.size = size;
+        this.name = 'TokenizerBoundaryError';
+    }
+}