@nxtedition/slice 1.1.4 → 1.1.5

package/lib/index.d.ts

@@ -9,7 +9,7 @@ export declare class Slice {
     byteOffset: number;
     byteLength: number;
     maxByteLength: number;
-    static EMPTY_BUF: Buffer;
+    static get EMPTY_BUF(): Buffer;
     constructor(buffer?: Buffer<ArrayBufferLike>, byteOffset?: number, byteLength?: number, maxByteLength?: number);
     reset(): void;
     get length(): number;
@@ -24,11 +24,11 @@ export declare class Slice {
     toString(encoding?: BufferEncoding, start?: number, end?: number): string;
     toBuffer(start?: number, end?: number): Buffer;
     get [Symbol.toStringTag](): string;
-    [util.inspect.custom](depth: number, options: util.InspectOptionsStylized, inspect: typeof util.inspect): string;
+    [util.inspect.custom](): string;
 }
 export declare class PoolAllocator {
     #private;
-    constructor(poolTotal?: number);
+    constructor(poolTotalOrBuffer?: Buffer | ArrayBufferView | ArrayBuffer | SharedArrayBuffer | number);
     get size(): number;
     isFromPool(slice: Slice | null | undefined): boolean;
     realloc(byteLength: number): Slice;

package/lib/index.js

@@ -14,7 +14,9 @@ export class Slice {
   byteLength         = 0
   maxByteLength         = 0
 
-  static EMPTY_BUF         = EMPTY_BUF
+  static get EMPTY_BUF()         {
+    return EMPTY_BUF
+  }
 
   constructor(
     buffer = Slice.EMPTY_BUF,
@@ -71,6 +73,8 @@ export class Slice {
     sourceStart         ,
     sourceEnd         ,
   )         {
+    const sliceEnd = this.byteOffset + this.byteLength
+
     if (sourceStart === undefined) {
       sourceStart = this.byteOffset
     } else {
@@ -78,15 +82,19 @@ export class Slice {
     }
 
     if (sourceEnd === undefined) {
-      sourceEnd = this.byteLength + this.byteOffset
+      sourceEnd = sliceEnd
     } else {
       sourceEnd += this.byteOffset
     }
 
-    let targetEnd                    
+    // Clamp 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 (target instanceof Slice) {
-      targetEnd = target.byteOffset + target.byteLength
+      const targetEnd = target.byteOffset + target.byteLength
       if (targetStart === undefined) {
         targetStart = target.byteOffset
       } else {
@@ -94,7 +102,9 @@ export class Slice {
       }
 
       target = target.buffer
-      sourceEnd = Math.min(sourceEnd, sourceStart + (targetEnd - targetStart))
+      if (sourceEnd - sourceStart > targetEnd - targetStart) {
+        sourceEnd = sourceStart + (targetEnd - targetStart)
+      }
     }
 
     if (
@@ -115,7 +125,20 @@ export class Slice {
     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 {
@@ -123,11 +146,14 @@ export class Slice {
       }
 
       if (targetEnd === undefined) {
-        targetEnd = target.byteLength + target.byteOffset
+        targetEnd = targetSliceEnd
       } else {
         targetEnd += target.byteOffset
       }
 
+      if (targetEnd > targetSliceEnd) {
+        targetEnd = targetSliceEnd
+      }
       target = target.buffer
     }
 
@@ -138,23 +164,35 @@ export class Slice {
     }
 
     if (sourceEnd === undefined) {
-      sourceEnd = this.byteLength + this.byteOffset
+      sourceEnd = sliceEnd
     } else {
       sourceEnd += this.byteOffset
     }
 
+    if (sourceEnd > sliceEnd) {
+      sourceEnd = sliceEnd
+    }
+
     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) {
+        throw new RangeError(`Invalid offset: ${offset}`)
+      }
       offset += this.byteOffset
     }
 
+    const available = sliceEnd - offset
     if (length === undefined) {
-      length = this.byteLength + this.byteOffset - offset
+      length = available
+    } else if (length > available) {
+      length = available
     }
 
     return this.buffer.write(string, offset, length, encoding)
@@ -190,6 +228,8 @@ export class Slice {
   }
 
   toString(encoding                 , start         , end         )         {
+    const sliceEnd = this.byteOffset + this.byteLength
+
     if (start === undefined) {
       start = this.byteOffset
     } else {
@@ -197,15 +237,21 @@ export class Slice {
     }
 
     if (end === undefined) {
-      end = this.byteLength + this.byteOffset
+      end = sliceEnd
     } else {
       end += this.byteOffset
     }
 
+    if (end > sliceEnd) {
+      end = sliceEnd
+    }
+
     return this.buffer.toString(encoding, start, end)
   }
 
   toBuffer(start         , end         )         {
+    const sliceEnd = this.byteOffset + this.byteLength
+
     if (start === undefined) {
       start = this.byteOffset
     } else {
@@ -213,30 +259,45 @@ export class Slice {
     }
 
     if (end === undefined) {
-      end = this.byteLength + this.byteOffset
+      end = sliceEnd
     } else {
       end += this.byteOffset
     }
 
+    if (end > sliceEnd) {
+      end = sliceEnd
+    }
+
     return start === 0 && end === this.buffer.byteLength
       ? this.buffer
       : this.buffer.subarray(start, end)
   }
 
   get [Symbol.toStringTag]()         {
-    return this.toString()
+    return 'Slice'
   }
 
-  [util.inspect.custom](
-    depth        ,
-    options                             ,
-    inspect                     ,
-  )         {
-    const bytes = []
-    for (let i = 0; i < this.byteLength; i++) {
-      bytes.push(this.buffer[this.byteOffset + i].toString(16).padStart(2, '0'))
+  [util.inspect.custom]()         {
+    const MAX_BYTES = 32
+    const len = this.byteLength
+    const shown = len < MAX_BYTES ? len : 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')
+    }
+    if (shown < len) {
+      hex += ` ... (${len - shown} more)`
     }
-    return `Slice: "${this.toString()}" <${bytes.join(' ')}>`
+
+    const strEnd = shown < len ? this.byteOffset + shown : this.byteOffset + len
+    const str = this.buffer.toString('utf8', this.byteOffset, strEnd)
+    const truncated = shown < len ? '…' : ''
+
+    return `Slice(${len}): "${str}${truncated}" <${hex}>`
   }
 }
 
@@ -251,8 +312,32 @@ export class PoolAllocator {
   #poolSize = 0
   #poolCount = 0
 
-  constructor(poolTotal = 128 * 1024 * 1024) {
-    this.#poolBuffer = Buffer.allocUnsafe(Number.isFinite(poolTotal) ? poolTotal : 0)
+  constructor(
+    poolTotalOrBuffer                                                                      = 128 *
+      1024 *
+      1024,
+  ) {
+    if (typeof poolTotalOrBuffer === 'number') {
+      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)
@@ -279,9 +364,13 @@ export class PoolAllocator {
       throw new TypeError(`Invalid byteLength: ${byteLength}`)
     }
 
-    if (slice == null) {
-      slice = new Slice()
-    } else if (slice.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
     }
 
@@ -317,15 +406,8 @@ export class PoolAllocator {
     }
 
     const maxByteLength = 1 << dstIdx
-    if (
-      this.#poolsBucket.length > 32 ||
-      maxByteLength < byteLength ||
-      (maxByteLength & 0x7) !== 0
-    ) {
-      throw new Error(`Invalid pool state`)
-    }
 
-    if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx]?.length) {
+    if (dstIdx < this.#poolsBucket.length && this.#poolsBucket[dstIdx].length) {
       slice.buffer = this.#poolBuffer
       slice.byteOffset = this.#poolsBucket[dstIdx].pop() 
       slice.byteLength = byteLength

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/slice",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -30,5 +30,5 @@
     "tsd": "^0.33.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "a29e479679bd053fa37ff8868d47918a8983ee48"
+  "gitHead": "b3ff34d7bea69e295919bdfdae8bc2e6ff9ab0ff"
 }