@nxtedition/slice 1.1.10 → 1.1.11

package/README.md

@@ -89,19 +89,23 @@ A lightweight view over a `Buffer` with explicit offset and length tracking.
 
 #### `new Slice(buffer?: Buffer, byteOffset?: number, byteLength?: number, maxByteLength?: number)`
 
-Creates a new slice. All parameters are optional — defaults to an empty slice.
+Creates a new slice. All parameters are optional — defaults to an empty slice. The constructor does **no** validation; pass only consistent values, or use `Slice.from` for a checked construction.
+
+#### `Slice.from(buffer: Buffer, byteOffset?: number, byteLength?: number): Slice`
+
+Validated factory for wrapping an existing `Buffer`. `byteOffset` defaults to `0` and `byteLength` to the remaining bytes (`buffer.byteLength - byteOffset`). Throws `TypeError` if `buffer` is not a `Buffer`, and `RangeError` if `byteOffset`/`byteLength` are negative, non-integer, or `byteOffset + byteLength` exceeds the buffer. Prefer this over the bare constructor when the inputs are untrusted.
 
 #### Properties
 
 - `buffer: Buffer` — The underlying `Buffer`
 - `byteOffset: number` — Start offset into the buffer
 - `byteLength: number` — Current length in bytes
-- `maxByteLength: number` — Maximum capacity in bytes
+- `maxByteLength: number` — For a pool-allocated slice, the power-of-2 bucket capacity (always `>= byteLength`). For a manually-constructed slice it defaults to `byteLength` and is purely informational: no method bounds writes against it — reads and writes are validated/clamped against `byteLength`.
 - `length: number` — Alias for `byteLength`
 
 #### Methods
 
-- `reset(): void` — Clear the slice back to empty state. **Note:** this does not return the slot to the `PoolAllocator` — you must call `realloc(slice, 0)` to free pool memory.
+- `reset(): void` — Clear the slice back to empty state. **Note:** this does not return the slot to the `PoolAllocator`. To free pool memory call `realloc(slice, 0)` — and do **not** `reset()` first: `reset()` detaches the slice from the pool buffer, so a subsequent `realloc(slice, 0)` can no longer locate the slot and the slot leaks.
 - `copy(target: Uint8Array | Slice, targetStart?: number, sourceStart?: number, sourceEnd?: number): number` — Copy data to a `Uint8Array`/`Buffer` or `Slice`. Returns bytes copied.
 - `compare(target: Uint8Array | Slice, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): -1 | 0 | 1` — Compare with a `Uint8Array`/`Buffer` or `Slice`
 - `write(string: string, offset?: number, length?: number, encoding?: BufferEncoding): number` — Write a string into the slice. Returns bytes written.
@@ -117,8 +121,10 @@ All offsets are **relative to the slice** (i.e. `0` is `byteOffset`). For a `Sli
 
 The rule is consistent across the API:
 
-- **Start/offset arguments are validated** — `set`'s `offset`, `copy`/`compare`'s `sourceStart`/`targetStart`, `toString`/`toBuffer`'s `start`, `write`'s `offset`/`length`, and `at`'s `index` must be in-range integers. Out-of-range or non-integer values throw `RangeError`. This prevents a negative offset from resolving to a position **before** the slice and reading/writing adjacent (pool) memory.
+- **Start/offset arguments are validated** — `set`'s `offset`, `copy`/`compare`'s `sourceStart`/`targetStart`, `toString`/`toBuffer`'s `start`, `write`'s `offset`, and `at`'s `index` must be in-range integers. Out-of-range or non-integer values throw `RangeError`. This prevents a negative offset from resolving to a position **before** the slice and reading/writing adjacent (pool) memory.
 - **End arguments are clamped** — `sourceEnd`/`targetEnd`/`end` are clamped to the slice's logical length (matching `Buffer`'s lenient end-of-range behavior), so over-long ranges never read past the slice's end.
+- **`write`'s `length` is hybrid** — a negative or non-integer `length` throws `RangeError`, but a too-large `length` is clamped to the bytes available in the slice (it behaves like an end argument, not a strict start argument).
+- For a raw `Buffer`/`Uint8Array` target, `targetStart`/`targetEnd` (and a non-`Slice` `compare` target's range) are passed straight through to the underlying `Buffer` method, so they follow `Buffer`'s own coercion/validation rather than the rules above.
 
 #### Static
 
@@ -137,7 +143,7 @@ Creates a pool allocator. Pass a byte size to allocate a fresh backing buffer (d
 #### Methods
 
 - `realloc(byteLength: number): Slice` — Allocate a fresh slice.
-- `realloc(slice: Slice, byteLength: number): Slice` — Resize a slice, or free it by passing `0`. **Contents are not preserved** — `realloc` has `malloc` semantics, not C `realloc` semantics; after a resize the bytes are undefined (a same-bucket resize happens to keep them in place, but do not rely on it). Only call `realloc` with a slice that belongs to this allocator (or a fresh/empty `Slice`); passing a slice from another pool, or freeing the same slice twice, corrupts the allocator's accounting.
+- `realloc(slice: Slice, byteLength: number): Slice` — Resize a slice, or free it by passing `0`. **Contents are not preserved** — `realloc` has `malloc` semantics, not C `realloc` semantics; after a resize the bytes are undefined (a same-bucket resize happens to keep them in place, but do not rely on it). Only call `realloc` with a slice that belongs to this allocator (or a fresh/empty `Slice`); passing a slice from another pool, or freeing the same pool slot through two aliasing `Slice` objects, corrupts the allocator's accounting. (Calling `realloc(slice, 0)` twice on the _same_ object is a harmless no-op — the first free empties the slice, so the second returns immediately.)
 - `isFromPool(slice: Slice | null | undefined): boolean` — Check if a slice's buffer is this pool's backing buffer. Note this is an identity check; it returns `true` for any slice over the same buffer, not only ones this allocator handed out.
 
 Allocations larger than 256 KB (the largest bucket), or made when the contiguous pool is exhausted, fall back to a fresh standalone `Buffer` (`isFromPool` returns `false`) and are excluded from `size`/`stats`.

package/lib/index.d.ts

@@ -49,3 +49,4 @@ export declare class PoolAllocator {
         }[];
     };
 }
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAI5B,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,qBAAa,KAAM,YAAW,SAAS;IACrC,MAAM,EAAE,MAAM,CAAY;IAC1B,UAAU,EAAE,MAAM,CAAI;IACtB,UAAU,EAAE,MAAM,CAAI;IACtB,aAAa,EAAE,MAAM,CAAI;IAEzB,MAAM,KAAK,SAAS,IAAI,MAAM,CAE7B;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,SAAI,EAAE,UAAU,SAAiC,GAAG,KAAK;gBAuB7F,MAAM,0BAAkB,EACxB,UAAU,SAAI,EACd,UAAU,SAAoB,EAC9B,aAAa,SAAa;IAQ5B,KAAK,IAAI,IAAI;IAOb,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,CACF,MAAM,EAAE,UAAU,GAAG,KAAK,EAC1B,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM;IA0DT,OAAO,CACL,MAAM,EAAE,UAAU,GAAG,KAAK,EAC1B,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IAgEb,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,MAAM;IA2B1F,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAyBrE,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IASzB,IAAI,CAAC,IAAI,EAAE;QACT,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAA;KAC1E,GAAG,OAAO;IAIX,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IA4BzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IA8B9C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;CAkChC;AAED,qBAAa,aAAa;;gBAYtB,iBAAiB,GAAE,MAAM,GAAG,eAAe,GAAG,WAAW,GAAG,iBAAiB,GAAG,MAE1E;IAgCR,IAAI,IAAI,WAEP;IAED,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAIpD,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK;IAClC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,GAAG,KAAK;IAuGhD,IAAI,KAAK;;;;;;;;;;;;;MAeR;CACF"}

package/lib/index.js

@@ -1,517 +1,438 @@
-import util from 'node:util'
-
-const EMPTY_BUF = Buffer.alloc(0)
-
-                         
-                
-                    
-                    
- 
-
-export class Slice                      {
-  buffer         = EMPTY_BUF
-  byteOffset         = 0
-  byteLength         = 0
-  maxByteLength         = 0
-
-  static get EMPTY_BUF()         {
-    return EMPTY_BUF
-  }
-
-  static from(buffer        , byteOffset = 0, byteLength = buffer.byteLength - byteOffset)        {
-    if (!(buffer instanceof Buffer)) {
-      throw new TypeError('buffer must be a Buffer')
-    }
-
-    if (byteOffset < 0 || !Number.isInteger(byteOffset)) {
-      throw new RangeError(`Invalid byteOffset: ${byteOffset}`)
-    }
-
-    if (byteLength < 0 || !Number.isInteger(byteLength)) {
-      throw new RangeError(`Invalid byteLength: ${byteLength}`)
-    }
-
-    if (byteOffset + byteLength > buffer.byteLength) {
-      throw new RangeError(
-        `byteOffset + byteLength (${byteOffset + byteLength}) exceeds buffer size (${buffer.byteLength})`,
-      )
-    }
-
-    return new Slice(buffer, byteOffset, byteLength)
-  }
-
-  constructor(
-    buffer = Slice.EMPTY_BUF,
-    byteOffset = 0,
-    byteLength = buffer.byteLength,
-    maxByteLength = byteLength,
-  ) {
-    this.buffer = buffer
-    this.byteOffset = byteOffset
-    this.byteLength = byteLength
-    this.maxByteLength = maxByteLength
-  }
-
-  reset()       {
-    this.buffer = Slice.EMPTY_BUF
-    this.byteOffset = 0
-    this.byteLength = 0
-    this.maxByteLength = 0
-  }
-
-  get length()         {
-    return this.byteLength
-  }
-
-  copy(
-    target                    ,
-    targetStart         ,
-    sourceStart         ,
-    sourceEnd         ,
-  )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (sourceStart === undefined) {
-      sourceStart = this.byteOffset
-    } else {
-      // Start offsets are validated (not clamped) so a negative offset can
-      // never resolve to a position before the slice and read adjacent
-      // (pool) memory.
-      if (sourceStart < 0 || sourceStart > this.byteLength || !Number.isInteger(sourceStart)) {
-        throw new RangeError(`Invalid sourceStart: ${sourceStart}`)
-      }
-      sourceStart += this.byteOffset
-    }
-
-    if (sourceEnd === undefined) {
-      sourceEnd = sliceEnd
-    } else {
-      sourceEnd += this.byteOffset
-    }
-
-    // Clamp the end against the logical slice length so copy() cannot read
-    // past the slice's own end and leak adjacent (pool) memory.
-    if (sourceEnd > sliceEnd) {
-      sourceEnd = sliceEnd
-    }
-    if (sourceEnd < sourceStart) {
-      sourceEnd = sourceStart
-    }
-
-    if (target instanceof Slice) {
-      const targetEnd = target.byteOffset + target.byteLength
-      if (targetStart === undefined) {
-        targetStart = target.byteOffset
-      } else {
-        if (targetStart < 0 || targetStart > target.byteLength || !Number.isInteger(targetStart)) {
-          throw new RangeError(`Invalid targetStart: ${targetStart}`)
-        }
-        targetStart += target.byteOffset
-      }
-
-      target = target.buffer
-      if (sourceEnd - sourceStart > targetEnd - targetStart) {
-        sourceEnd = sourceStart + (targetEnd - targetStart)
-      }
-    }
-
-    if (
-      sourceStart === targetStart &&
-      this.buffer.buffer === target.buffer &&
-      this.buffer.byteOffset === target.byteOffset
-    ) {
-      return sourceEnd - sourceStart
-    }
-
-    return this.buffer.copy(target, targetStart, sourceStart, sourceEnd)
-  }
-
-  compare(
-    target                    ,
-    targetStart         ,
-    targetEnd         ,
-    sourceStart         ,
-    sourceEnd         ,
-  )             {
-    if (
-      target === this &&
-      targetStart === undefined &&
-      targetEnd === undefined &&
-      sourceStart === undefined &&
-      sourceEnd === undefined
-    ) {
-      return 0
-    }
-
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (target instanceof Slice) {
-      const targetSliceEnd = target.byteOffset + target.byteLength
-      if (targetStart === undefined) {
-        targetStart = target.byteOffset
-      } else {
-        if (targetStart < 0 || targetStart > target.byteLength || !Number.isInteger(targetStart)) {
-          throw new RangeError(`Invalid targetStart: ${targetStart}`)
-        }
-        targetStart += target.byteOffset
-      }
-
-      if (targetEnd === undefined) {
-        targetEnd = targetSliceEnd
-      } else {
-        targetEnd += target.byteOffset
-      }
-
-      if (targetEnd > targetSliceEnd) {
-        targetEnd = targetSliceEnd
-      }
-      if (targetEnd < targetStart) {
-        targetEnd = targetStart
-      }
-      target = target.buffer
-    }
-
-    if (sourceStart === undefined) {
-      sourceStart = this.byteOffset
-    } else {
-      if (sourceStart < 0 || sourceStart > this.byteLength || !Number.isInteger(sourceStart)) {
-        throw new RangeError(`Invalid sourceStart: ${sourceStart}`)
-      }
-      sourceStart += this.byteOffset
-    }
-
-    if (sourceEnd === undefined) {
-      sourceEnd = sliceEnd
-    } else {
-      sourceEnd += this.byteOffset
-    }
-
-    if (sourceEnd > sliceEnd) {
-      sourceEnd = sliceEnd
-    }
-    if (sourceEnd < sourceStart) {
-      sourceEnd = sourceStart
-    }
-
-    return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd)
-  }
-
-  write(string        , offset         , length         , encoding                 )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (offset === undefined) {
-      offset = this.byteOffset
-    } else {
-      if (offset < 0 || offset > this.byteLength || !Number.isInteger(offset)) {
-        throw new RangeError(`Invalid offset: ${offset}`)
-      }
-      offset += this.byteOffset
-    }
-
-    const available = sliceEnd - offset
-    if (length === undefined) {
-      length = available
-    } else {
-      if (length < 0 || !Number.isInteger(length)) {
-        throw new RangeError(`Invalid length: ${length}`)
-      }
-      if (length > available) {
-        length = available
-      }
-    }
-
-    return this.buffer.write(string, offset, length, encoding)
-  }
-
-  set(source                                   , offset         )       {
-    if (source == null) {
-      return
-    }
-
-    if (offset === undefined) {
-      offset = this.byteOffset
-    } else {
-      // Validate (not clamp): a negative offset would resolve to a position
-      // before the slice and corrupt adjacent (pool) memory.
-      if (offset < 0 || offset > this.byteLength || !Number.isInteger(offset)) {
-        throw new RangeError(`Invalid offset: ${offset}`)
-      }
-      offset += this.byteOffset
-    }
-
-    const available = this.byteOffset + this.byteLength - offset
-    if (available <= 0) {
-      return
-    }
-
-    const end = source.byteLength < available ? source.byteLength : available
-    source.copy(this.buffer, offset, 0, end)
-  }
-
-  at(index        )         {
-    if (!Number.isInteger(index) || index >= this.byteLength || index < -this.byteLength) {
-      throw new RangeError(`Index out of range: ${index}`)
-    }
-    return index >= 0
-      ? this.buffer[this.byteOffset + index]
-      : this.buffer[this.byteOffset + this.byteLength + index]
-  }
-
-  test(expr   
-                                                                             
-   )          {
-    return expr.test(this.buffer, this.byteOffset, this.byteLength)
-  }
-
-  toString(encoding                 , start         , end         )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (start === undefined) {
-      start = this.byteOffset
-    } else {
-      if (start < 0 || start > this.byteLength || !Number.isInteger(start)) {
-        throw new RangeError(`Invalid start: ${start}`)
-      }
-      start += this.byteOffset
-    }
-
-    if (end === undefined) {
-      end = sliceEnd
-    } else {
-      end += this.byteOffset
-    }
-
-    if (end > sliceEnd) {
-      end = sliceEnd
-    }
-    if (end < start) {
-      end = start
+import util from 'node:util';
+const EMPTY_BUF = Buffer.alloc(0);
+export class Slice {
+    buffer = EMPTY_BUF;
+    byteOffset = 0;
+    byteLength = 0;
+    maxByteLength = 0;
+    static get EMPTY_BUF() {
+        return EMPTY_BUF;
+    }
+    static from(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+        if (!(buffer instanceof Buffer)) {
+            throw new TypeError('buffer must be a Buffer');
+        }
+        if (byteOffset < 0 || !Number.isInteger(byteOffset)) {
+            throw new RangeError(`Invalid byteOffset: ${byteOffset}`);
+        }
+        if (byteLength < 0 || !Number.isInteger(byteLength)) {
+            throw new RangeError(`Invalid byteLength: ${byteLength}`);
+        }
+        if (byteOffset + byteLength > buffer.byteLength) {
+            throw new RangeError(`byteOffset + byteLength (${byteOffset + byteLength}) exceeds buffer size (${buffer.byteLength})`);
+        }
+        return new Slice(buffer, byteOffset, byteLength);
+    }
+    constructor(buffer = Slice.EMPTY_BUF, byteOffset = 0, byteLength = buffer.byteLength, maxByteLength = byteLength) {
+        this.buffer = buffer;
+        this.byteOffset = byteOffset;
+        this.byteLength = byteLength;
+        this.maxByteLength = maxByteLength;
+    }
+    reset() {
+        this.buffer = Slice.EMPTY_BUF;
+        this.byteOffset = 0;
+        this.byteLength = 0;
+        this.maxByteLength = 0;
+    }
+    get length() {
+        return this.byteLength;
+    }
+    copy(target, targetStart, sourceStart, sourceEnd) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (sourceStart === undefined) {
+            sourceStart = this.byteOffset;
+        }
+        else {
+            // Start offsets are validated (not clamped) so a negative offset can
+            // never resolve to a position before the slice and read adjacent
+            // (pool) memory.
+            if (sourceStart < 0 || sourceStart > this.byteLength || !Number.isInteger(sourceStart)) {
+                throw new RangeError(`Invalid sourceStart: ${sourceStart}`);
+            }
+            sourceStart += this.byteOffset;
+        }
+        if (sourceEnd === undefined) {
+            sourceEnd = sliceEnd;
+        }
+        else {
+            sourceEnd += this.byteOffset;
+        }
+        // Clamp the end against the logical slice length so copy() cannot read
+        // past the slice's own end and leak adjacent (pool) memory.
+        if (sourceEnd > sliceEnd) {
+            sourceEnd = sliceEnd;
+        }
+        if (sourceEnd < sourceStart) {
+            sourceEnd = sourceStart;
+        }
+        if (target instanceof Slice) {
+            const targetEnd = target.byteOffset + target.byteLength;
+            if (targetStart === undefined) {
+                targetStart = target.byteOffset;
+            }
+            else {
+                if (targetStart < 0 || targetStart > target.byteLength || !Number.isInteger(targetStart)) {
+                    throw new RangeError(`Invalid targetStart: ${targetStart}`);
+                }
+                targetStart += target.byteOffset;
+            }
+            target = target.buffer;
+            if (sourceEnd - sourceStart > targetEnd - targetStart) {
+                sourceEnd = sourceStart + (targetEnd - targetStart);
+            }
+        }
+        if (sourceStart === targetStart &&
+            this.buffer.buffer === target.buffer &&
+            this.buffer.byteOffset === target.byteOffset) {
+            return sourceEnd - sourceStart;
+        }
+        return this.buffer.copy(target, targetStart, sourceStart, sourceEnd);
+    }
+    compare(target, targetStart, targetEnd, sourceStart, sourceEnd) {
+        if (target === this &&
+            targetStart === undefined &&
+            targetEnd === undefined &&
+            sourceStart === undefined &&
+            sourceEnd === undefined) {
+            return 0;
+        }
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (target instanceof Slice) {
+            const targetSliceEnd = target.byteOffset + target.byteLength;
+            if (targetStart === undefined) {
+                targetStart = target.byteOffset;
+            }
+            else {
+                if (targetStart < 0 || targetStart > target.byteLength || !Number.isInteger(targetStart)) {
+                    throw new RangeError(`Invalid targetStart: ${targetStart}`);
+                }
+                targetStart += target.byteOffset;
+            }
+            if (targetEnd === undefined) {
+                targetEnd = targetSliceEnd;
+            }
+            else {
+                targetEnd += target.byteOffset;
+            }
+            if (targetEnd > targetSliceEnd) {
+                targetEnd = targetSliceEnd;
+            }
+            if (targetEnd < targetStart) {
+                targetEnd = targetStart;
+            }
+            target = target.buffer;
+        }
+        if (sourceStart === undefined) {
+            sourceStart = this.byteOffset;
+        }
+        else {
+            if (sourceStart < 0 || sourceStart > this.byteLength || !Number.isInteger(sourceStart)) {
+                throw new RangeError(`Invalid sourceStart: ${sourceStart}`);
+            }
+            sourceStart += this.byteOffset;
+        }
+        if (sourceEnd === undefined) {
+            sourceEnd = sliceEnd;
+        }
+        else {
+            sourceEnd += this.byteOffset;
+        }
+        if (sourceEnd > sliceEnd) {
+            sourceEnd = sliceEnd;
+        }
+        if (sourceEnd < sourceStart) {
+            sourceEnd = sourceStart;
+        }
+        return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
     }
-
-    return this.buffer.toString(encoding, start, end)
-  }
-
-  toBuffer(start         , end         )         {
-    const sliceEnd = this.byteOffset + this.byteLength
-
-    if (start === undefined) {
-      start = this.byteOffset
-    } else {
-      if (start < 0 || start > this.byteLength || !Number.isInteger(start)) {
-        throw new RangeError(`Invalid start: ${start}`)
-      }
-      start += this.byteOffset
+    write(string, offset, length, encoding) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (offset === undefined) {
+            offset = this.byteOffset;
+        }
+        else {
+            if (offset < 0 || offset > this.byteLength || !Number.isInteger(offset)) {
+                throw new RangeError(`Invalid offset: ${offset}`);
+            }
+            offset += this.byteOffset;
+        }
+        const available = sliceEnd - offset;
+        if (length === undefined) {
+            length = available;
+        }
+        else {
+            if (length < 0 || !Number.isInteger(length)) {
+                throw new RangeError(`Invalid length: ${length}`);
+            }
+            if (length > available) {
+                length = available;
+            }
+        }
+        return this.buffer.write(string, offset, length, encoding);
     }
-
-    if (end === undefined) {
-      end = sliceEnd
-    } else {
-      end += this.byteOffset
+    set(source, offset) {
+        if (source == null) {
+            return;
+        }
+        if (offset === undefined) {
+            offset = this.byteOffset;
+        }
+        else {
+            // Validate (not clamp): a negative offset would resolve to a position
+            // before the slice and corrupt adjacent (pool) memory.
+            if (offset < 0 || offset > this.byteLength || !Number.isInteger(offset)) {
+                throw new RangeError(`Invalid offset: ${offset}`);
+            }
+            offset += this.byteOffset;
+        }
+        const available = this.byteOffset + this.byteLength - offset;
+        if (available <= 0) {
+            return;
+        }
+        const end = source.byteLength < available ? source.byteLength : available;
+        source.copy(this.buffer, offset, 0, end);
     }
-
-    if (end > sliceEnd) {
-      end = sliceEnd
+    at(index) {
+        if (!Number.isInteger(index) || index >= this.byteLength || index < -this.byteLength) {
+            throw new RangeError(`Index out of range: ${index}`);
+        }
+        return index >= 0
+            ? this.buffer[this.byteOffset + index]
+            : this.buffer[this.byteOffset + this.byteLength + index];
     }
-    if (end < start) {
-      end = start
+    test(expr) {
+        return expr.test(this.buffer, this.byteOffset, this.byteLength);
     }
-
-    return start === 0 && end === this.buffer.byteLength
-      ? this.buffer
-      : this.buffer.subarray(start, end)
-  }
-
-  get [Symbol.toStringTag]()         {
-    return 'Slice'
-  }
-
-  [util.inspect.custom]()         {
-    const MAX_BYTES = 32
-    const len = this.byteLength
-
-    // Never read past the underlying buffer. A malformed slice (byteOffset /
-    // byteLength extending beyond the buffer) is exactly the state a developer
-    // inspects while debugging pool corruption — inspect must not throw on it.
-    const available = this.buffer.byteLength - this.byteOffset
-    const safeLen = available > 0 ? (len < available ? len : available) : 0
-    const shown = safeLen < MAX_BYTES ? safeLen : MAX_BYTES
-
-    let hex = ''
-    for (let i = 0; i < shown; i++) {
-      if (i !== 0) {
-        hex += ' '
-      }
-      hex += this.buffer[this.byteOffset + i].toString(16).padStart(2, '0')
+    toString(encoding, start, end) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (start === undefined) {
+            start = this.byteOffset;
+        }
+        else {
+            if (start < 0 || start > this.byteLength || !Number.isInteger(start)) {
+                throw new RangeError(`Invalid start: ${start}`);
+            }
+            start += this.byteOffset;
+        }
+        if (end === undefined) {
+            end = sliceEnd;
+        }
+        else {
+            end += this.byteOffset;
+        }
+        if (end > sliceEnd) {
+            end = sliceEnd;
+        }
+        if (end < start) {
+            end = start;
+        }
+        return this.buffer.toString(encoding, start, end);
     }
-    if (shown < len) {
-      hex += ` ... (${len - shown} more)`
+    toBuffer(start, end) {
+        const sliceEnd = this.byteOffset + this.byteLength;
+        if (start === undefined) {
+            start = this.byteOffset;
+        }
+        else {
+            if (start < 0 || start > this.byteLength || !Number.isInteger(start)) {
+                throw new RangeError(`Invalid start: ${start}`);
+            }
+            start += this.byteOffset;
+        }
+        if (end === undefined) {
+            end = sliceEnd;
+        }
+        else {
+            end += this.byteOffset;
+        }
+        if (end > sliceEnd) {
+            end = sliceEnd;
+        }
+        if (end < start) {
+            end = start;
+        }
+        return start === 0 && end === this.buffer.byteLength
+            ? this.buffer
+            : this.buffer.subarray(start, end);
+    }
+    get [Symbol.toStringTag]() {
+        return 'Slice';
+    }
+    [util.inspect.custom]() {
+        const MAX_BYTES = 32;
+        const len = this.byteLength;
+        // A malformed slice (a NaN/non-finite/fractional/negative/out-of-bounds
+        // byteOffset or byteLength) is exactly the state a developer inspects while
+        // debugging pool corruption — inspect must never throw on it. Coerce
+        // byteOffset to a safe integer index in [0, buffer.byteLength]: the
+        // `>= 0` test is false for NaN and -Infinity (→ 0), Math.floor truncates a
+        // fractional offset, and Math.min caps Infinity/oversize at the buffer end
+        // (available 0). Every buffer access below is then guaranteed in-bounds and
+        // begin + shown <= buffer.byteLength holds.
+        const bufferLength = this.buffer.byteLength;
+        const begin = this.byteOffset >= 0 ? Math.min(Math.floor(this.byteOffset), bufferLength) : 0;
+        const cap = bufferLength - begin;
+        const safeLen = len > 0 ? (len < cap ? len : cap) : 0;
+        const shown = safeLen < MAX_BYTES ? safeLen : MAX_BYTES;
+        let hex = '';
+        for (let i = 0; i < shown; i++) {
+            if (i !== 0) {
+                hex += ' ';
+            }
+            hex += this.buffer[begin + i].toString(16).padStart(2, '0');
+        }
+        if (shown < len) {
+            hex += ` ... (${len - shown} more)`;
+        }
+        const str = this.buffer.toString('utf8', begin, begin + shown);
+        const truncated = shown < len ? '…' : '';
+        return `Slice(${len}): "${str}${truncated}" <${hex}>`;
     }
-
-    const str = this.buffer.toString('utf8', this.byteOffset, this.byteOffset + shown)
-    const truncated = shown < len ? '…' : ''
-
-    return `Slice(${len}): "${str}${truncated}" <${hex}>`
-  }
 }
-
 export class PoolAllocator {
-  #size = 0
-  #padding = 0
-
-  #poolsBucket             = []
-  #poolsBucketUsed           = []
-  #poolBuffer        
-  #poolOffset = 0
-  #poolSize = 0
-  #poolCount = 0
-
-  constructor(
-    poolTotalOrBuffer                                                                      = 128 *
-      1024 *
-      1024,
-  ) {
-    if (typeof poolTotalOrBuffer === 'number') {
-      if (!Number.isInteger(poolTotalOrBuffer) || poolTotalOrBuffer < 0) {
-        throw new RangeError(`Invalid pool size: ${poolTotalOrBuffer}`)
-      }
-      this.#poolBuffer = Buffer.allocUnsafeSlow(poolTotalOrBuffer)
-    } else if (poolTotalOrBuffer instanceof Buffer) {
-      this.#poolBuffer = poolTotalOrBuffer
-    } else if (ArrayBuffer.isView(poolTotalOrBuffer)) {
-      this.#poolBuffer = Buffer.from(
-        poolTotalOrBuffer.buffer,
-        poolTotalOrBuffer.byteOffset,
-        poolTotalOrBuffer.byteLength,
-      )
-    } else if (
-      poolTotalOrBuffer instanceof ArrayBuffer ||
-      poolTotalOrBuffer instanceof SharedArrayBuffer
-    ) {
-      this.#poolBuffer = Buffer.from(poolTotalOrBuffer)
-    } else {
-      throw new TypeError(
-        'Invalid poolTotalOrBuffer: must be a Buffer, ArrayBufferView, ArrayBuffer, SharedArrayBuffer, or number',
-      )
-    }
-
-    for (let n = 0; 2 ** n <= 256 * 1024; n++) {
-      this.#poolsBucket.push([])
-      this.#poolsBucketUsed.push(0)
-    }
-  }
-
-  get size() {
-    return this.#size
-  }
-
-  isFromPool(slice                          )          {
-    return slice != null && slice.buffer === this.#poolBuffer
-  }
-
-                                    
-                                                  
-  realloc(slice                , byteLength         )        {
-    if (typeof slice === 'number') {
-      byteLength = slice
-      slice = new Slice()
-    }
-
-    if (byteLength == null || !Number.isInteger(byteLength) || byteLength < 0) {
-      throw new TypeError(`Invalid byteLength: ${byteLength}`)
-    }
-
-    // 2^30 is the largest power-of-two that fits a 32-bit signed int; a
-    // larger request overflows `1 << dstIdx` to a negative bucket size.
-    if (byteLength > 1 << 30) {
-      throw new RangeError(`byteLength too large: ${byteLength} (max ${1 << 30})`)
-    }
-
-    if (slice.byteLength === byteLength) {
-      return slice
-    }
-
-    // Ceil to nearest power of two.
-    const dstIdx = byteLength <= 8 ? 3 : 32 - Math.clz32(byteLength - 1)
-
-    if (slice.buffer === this.#poolBuffer) {
-      const srcIdx = 32 - Math.clz32(slice.maxByteLength - 1)
-
-      if (slice.maxByteLength !== 1 << srcIdx) {
-        throw new Error(`Invalid pool state`)
-      }
-
-      this.#size -= slice.maxByteLength
-      this.#padding -= slice.maxByteLength - slice.byteLength
-
-      if (srcIdx === dstIdx) {
-        slice.byteLength = byteLength
-        this.#size += slice.maxByteLength
-        this.#padding += slice.maxByteLength - slice.byteLength
-        return slice
-      }
-
-      this.#poolsBucket[srcIdx].push(slice.byteOffset)
-      this.#poolsBucketUsed[srcIdx] -= 1
-      this.#poolSize -= slice.maxByteLength
+    #size = 0;
+    #padding = 0;
+    #poolsBucket = [];
+    #poolsBucketUsed = [];
+    #poolBuffer;
+    #poolOffset = 0;
+    #poolSize = 0;
+    #poolCount = 0;
+    constructor(poolTotalOrBuffer = 128 *
+        1024 *
+        1024) {
+        if (typeof poolTotalOrBuffer === 'number') {
+            if (!Number.isInteger(poolTotalOrBuffer) || poolTotalOrBuffer < 0) {
+                throw new RangeError(`Invalid pool size: ${poolTotalOrBuffer}`);
+            }
+            this.#poolBuffer = Buffer.allocUnsafeSlow(poolTotalOrBuffer);
+        }
+        else if (poolTotalOrBuffer instanceof Buffer) {
+            this.#poolBuffer = poolTotalOrBuffer;
+        }
+        else if (ArrayBuffer.isView(poolTotalOrBuffer)) {
+            this.#poolBuffer = Buffer.from(poolTotalOrBuffer.buffer, poolTotalOrBuffer.byteOffset, poolTotalOrBuffer.byteLength);
+        }
+        else if (poolTotalOrBuffer instanceof ArrayBuffer ||
+            poolTotalOrBuffer instanceof SharedArrayBuffer) {
+            this.#poolBuffer = Buffer.from(poolTotalOrBuffer);
+        }
+        else {
+            throw new TypeError('Invalid poolTotalOrBuffer: must be a Buffer, ArrayBufferView, ArrayBuffer, SharedArrayBuffer, or number');
+        }
+        for (let n = 0; 2 ** n <= 256 * 1024; n++) {
+            this.#poolsBucket.push([]);
+            this.#poolsBucketUsed.push(0);
+        }
     }
-
-    slice.reset()
-
-    if (byteLength === 0) {
-      return slice
+    get size() {
+        return this.#size;
     }
-
-    const maxByteLength = 1 << dstIdx
-
-    if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx].length) {
-      slice.buffer = this.#poolBuffer
-      slice.byteOffset = this.#poolsBucket[dstIdx].pop() 
-      slice.byteLength = byteLength
-      slice.maxByteLength = maxByteLength
-
-      this.#poolsBucketUsed[dstIdx] += 1
-      this.#poolSize += maxByteLength
-      this.#size += maxByteLength
-      this.#padding += maxByteLength - byteLength
-    } else if (
-      dstIdx < this.#poolsBucket.length &&
-      this.#poolOffset + maxByteLength <= this.#poolBuffer.byteLength
-    ) {
-      slice.buffer = this.#poolBuffer
-      slice.byteOffset = this.#poolOffset
-      slice.byteLength = byteLength
-      slice.maxByteLength = maxByteLength
-
-      this.#poolOffset += maxByteLength
-      this.#poolCount += 1
-      this.#poolsBucketUsed[dstIdx] += 1
-      this.#poolSize += maxByteLength
-      this.#size += maxByteLength
-      this.#padding += maxByteLength - byteLength
-    } else {
-      slice.buffer = Buffer.allocUnsafeSlow(byteLength)
-      slice.byteOffset = 0
-      slice.byteLength = byteLength
-      slice.maxByteLength = byteLength
+    isFromPool(slice) {
+        return slice != null && slice.buffer === this.#poolBuffer;
     }
-
-    return slice
-  }
-
-  get stats() {
-    return {
-      size: this.#size,
-      padding: this.#padding,
-      ratio: this.#size > this.#padding ? this.#size / (this.#size - this.#padding) : 1,
-      poolTotal: this.#poolBuffer.byteLength,
-      poolUsed: this.#poolOffset,
-      poolSize: this.#poolSize,
-      poolCount: this.#poolCount,
-      buckets: this.#poolsBucket.map((pool, i) => ({
-        free: pool.length,
-        used: this.#poolsBucketUsed[i],
-        size: pool.length + this.#poolsBucketUsed[i],
-      })),
+    realloc(slice, byteLength) {
+        if (typeof slice === 'number') {
+            byteLength = slice;
+            slice = new Slice();
+        }
+        if (byteLength == null || !Number.isInteger(byteLength) || byteLength < 0) {
+            throw new TypeError(`Invalid byteLength: ${byteLength}`);
+        }
+        // 2^30 is the largest power-of-two that fits a 32-bit signed int; a
+        // larger request overflows `1 << dstIdx` to a negative bucket size.
+        if (byteLength > 1 << 30) {
+            throw new RangeError(`byteLength too large: ${byteLength} (max ${1 << 30})`);
+        }
+        if (slice.byteLength === byteLength) {
+            return slice;
+        }
+        // Ceil to nearest power of two — the destination bucket and its byte size.
+        const dstIdx = byteLength <= 8 ? 3 : 32 - Math.clz32(byteLength - 1);
+        const maxByteLength = 1 << dstIdx;
+        if (slice.buffer === this.#poolBuffer) {
+            const srcMaxByteLength = slice.maxByteLength;
+            // Same-bucket resize is the hot path: just update the logical length and
+            // adjust padding by the delta — no bucket bookkeeping, no second clz32,
+            // no net change to #size. A free (byteLength === 0) is deliberately
+            // excluded so it always falls through to the free-list path below:
+            // byteLength 0 maps to dstIdx 3 / maxByteLength 8, which would otherwise
+            // match a live bucket-3 slot here and "resize" it to 0 — leaking the slot
+            // (never returned to the free list, still counted in #size/#poolSize).
+            if (byteLength !== 0 && srcMaxByteLength === maxByteLength) {
+                this.#padding += slice.byteLength - byteLength;
+                slice.byteLength = byteLength;
+                return slice;
+            }
+            const srcIdx = 32 - Math.clz32(srcMaxByteLength - 1);
+            // Corruption tripwire for a foreign/double-freed slice. maxByteLength must
+            // be a power of two that maps to a real pool bucket — index in
+            // [3, poolsBucket.length). The pool never hands out a slot below bucket 3
+            // (8 bytes), so a smaller power of two (1/2/4 → srcIdx 0/1/2) is just as
+            // corrupt as an oversized one (e.g. 2^20 → srcIdx 20, out of range):
+            // `=== 1 << srcIdx` alone passes both, after which the bucket bookkeeping
+            // below would drive an always-empty bucket's `used` count negative (or
+            // index a non-existent bucket) and drift #size/#poolSize.
+            if (srcMaxByteLength !== 1 << srcIdx || srcIdx < 3 || srcIdx >= this.#poolsBucket.length) {
+                throw new Error(`Invalid pool state`);
+            }
+            this.#size -= srcMaxByteLength;
+            this.#padding -= srcMaxByteLength - slice.byteLength;
+            this.#poolsBucket[srcIdx].push(slice.byteOffset);
+            this.#poolsBucketUsed[srcIdx] -= 1;
+            this.#poolSize -= srcMaxByteLength;
+        }
+        slice.reset();
+        if (byteLength === 0) {
+            return slice;
+        }
+        if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx].length) {
+            slice.buffer = this.#poolBuffer;
+            slice.byteOffset = this.#poolsBucket[dstIdx].pop();
+            slice.byteLength = byteLength;
+            slice.maxByteLength = maxByteLength;
+            this.#poolsBucketUsed[dstIdx] += 1;
+            this.#poolSize += maxByteLength;
+            this.#size += maxByteLength;
+            this.#padding += maxByteLength - byteLength;
+        }
+        else if (dstIdx < this.#poolsBucket.length &&
+            this.#poolOffset + maxByteLength <= this.#poolBuffer.byteLength) {
+            slice.buffer = this.#poolBuffer;
+            slice.byteOffset = this.#poolOffset;
+            slice.byteLength = byteLength;
+            slice.maxByteLength = maxByteLength;
+            this.#poolOffset += maxByteLength;
+            this.#poolCount += 1;
+            this.#poolsBucketUsed[dstIdx] += 1;
+            this.#poolSize += maxByteLength;
+            this.#size += maxByteLength;
+            this.#padding += maxByteLength - byteLength;
+        }
+        else {
+            slice.buffer = Buffer.allocUnsafeSlow(byteLength);
+            slice.byteOffset = 0;
+            slice.byteLength = byteLength;
+            slice.maxByteLength = byteLength;
+        }
+        return slice;
+    }
+    get stats() {
+        return {
+            size: this.#size,
+            padding: this.#padding,
+            ratio: this.#size > this.#padding ? this.#size / (this.#size - this.#padding) : 1,
+            poolTotal: this.#poolBuffer.byteLength,
+            poolUsed: this.#poolOffset,
+            poolSize: this.#poolSize,
+            poolCount: this.#poolCount,
+            buckets: this.#poolsBucket.map((pool, i) => ({
+                free: pool.length,
+                used: this.#poolsBucketUsed[i],
+                size: pool.length + this.#poolsBucketUsed[i],
+            })),
+        };
     }
-  }
 }
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/slice",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -14,7 +14,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsc -p tsconfig.build.json && amaroc ./src/index.ts && mv src/index.js lib/",
+    "build": "rimraf lib && tsc -p tsconfig.build.json",
     "prepublishOnly": "yarn build",
     "typecheck": "tsc --noEmit",
     "test": "yarn build && node --test",
@@ -24,7 +24,6 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "amaroc": "^1.0.1",
     "oxlint-tsgolint": "^0.17.0",
     "rimraf": "^6.1.3",
     "tsd": "^0.33.0",