@nxtedition/lib 28.0.2 → 28.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "28.0.2",
+  "version": "28.0.3",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -37,6 +37,7 @@
     "errors.js",
     "errors.d.ts",
     "worker.js",
+    "slice.js",
     "stream.js",
     "transcript.js",
     "docker-secrets.js",
@@ -91,5 +92,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "10cdafd06260ca5abfabbf08f503ccd78819c3e2"
+  "gitHead": "15f4fd00f86a558ae56672b1efa3e909b23feb3f"
 }

package/slice.js

@@ -0,0 +1,278 @@
+import util from 'node:util'
+
+const EMPTY_BUF = Buffer.alloc(0)
+const POOL = []
+
+export class Slice {
+  buffer
+  byteOffset = 0
+  byteLength = 0
+  maxByteLength = 0
+
+  static EMPTY_BUF = EMPTY_BUF
+
+  /**
+   *
+   * @param {Buffer} [buffer]
+   * @param {number} [byteOffset]
+   * @param {number} [byteLength]
+   * @param {number} [maxByteLength]
+   */
+  constructor(
+    buffer = Slice.EMPTY_BUF,
+    byteOffset = 0,
+    byteLength = buffer.byteLength,
+    maxByteLength = byteLength,
+  ) {
+    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 (
+      maxByteLength < byteLength ||
+      maxByteLength > buffer.byteLength ||
+      !Number.isInteger(maxByteLength)
+    ) {
+      throw new RangeError(`Invalid maxByteLength: ${maxByteLength}`)
+    }
+
+    this.buffer = buffer
+    this.byteOffset = byteOffset
+    this.byteLength = byteLength
+    this.maxByteLength = maxByteLength
+  }
+
+  static create(buffer, byteOffset, byteLength, maxByteLength) {
+    if (buffer === undefined) {
+      buffer = Slice.EMPTY_BUF
+    }
+    if (byteOffset === undefined) {
+      byteOffset = 0
+    }
+    if (byteLength === undefined) {
+      byteLength = buffer.byteLength
+    }
+    if (maxByteLength === undefined) {
+      maxByteLength = byteLength
+    }
+
+    const slice = POOL.pop()
+
+    if (slice) {
+      slice.buffer = buffer
+      slice.byteOffset = byteOffset
+      slice.byteLength = byteLength
+      slice.maxByteLength = maxByteLength
+      return slice
+    }
+
+    return new Slice(buffer, byteOffset, byteLength, maxByteLength)
+  }
+
+  static free(slice) {
+    if (slice == null) {
+      return
+    }
+
+    slice.reset()
+
+    if (POOL.length < 16 * 1024) {
+      POOL.push(slice)
+    }
+  }
+
+  reset() {
+    this.buffer = Slice.EMPTY_BUF
+    this.byteOffset = 0
+    this.byteLength = 0
+    this.maxByteLength = 0
+  }
+
+  get length() {
+    return this.byteLength
+  }
+
+  /**
+   * @param {Buffer|Slice} target
+   * @param {number} [targetStart = 0]
+   * @param {number} [sourceStart = 0]
+   * @param {number} [sourceEnd = this.byteOffset]
+   * @returns {number} Number of bytes written.
+   */
+  copy(target, targetStart, sourceStart, sourceEnd) {
+    if (target instanceof Slice) {
+      if (targetStart === undefined) {
+        targetStart = target.byteOffset
+      } else {
+        targetStart += target.byteOffset
+      }
+
+      target = target.buffer
+    }
+
+    if (sourceStart === undefined) {
+      sourceStart = this.byteOffset
+    } else {
+      sourceStart += this.byteOffset
+    }
+
+    if (sourceEnd === undefined) {
+      sourceEnd = this.byteLength + this.byteOffset
+    } else {
+      sourceEnd += this.byteOffset
+    }
+
+    return this.buffer.copy(target, targetStart, sourceStart, sourceEnd)
+  }
+
+  /**
+   * @param {Buffer|Slice} target
+   * @param {number} [targetStart = 0]
+   * @param {number} [targetEnd = target.byteOffset]
+   * @param {number} [sourceStart = 0]
+   * @param {number} [sourceEnd = this.byteOffset]
+   * @returns
+   */
+  compare(target, targetStart, targetEnd, sourceStart, sourceEnd) {
+    if (target instanceof Slice) {
+      if (targetStart === undefined) {
+        targetStart = target.byteOffset
+      } else {
+        targetStart += target.byteOffset
+      }
+
+      if (targetEnd === undefined) {
+        targetEnd = target.byteLength + target.byteOffset
+      } else {
+        targetEnd += target.byteOffset
+      }
+
+      target = target.buffer
+    }
+
+    if (sourceStart === undefined) {
+      sourceStart = this.byteOffset
+    } else {
+      sourceStart += this.byteOffset
+    }
+
+    if (sourceEnd === undefined) {
+      sourceEnd = this.byteLength + this.byteOffset
+    } else {
+      sourceEnd += this.byteOffset
+    }
+
+    return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd)
+  }
+
+  /**
+   *
+   * @param {string} string
+   * @param {number} [offset=0]
+   * @param {number} [length=this.byteLength - offset]
+   * @param {NodeJS.BufferEncoding} [encoding='utf8']
+   * @returns {number} Number of bytes written.
+   */
+  write(string, offset, length, encoding) {
+    if (offset === undefined) {
+      offset = this.byteOffset
+    } else {
+      offset += this.byteOffset
+    }
+
+    if (length === undefined) {
+      length = this.byteLength + this.byteOffset - offset
+    }
+
+    return this.buffer.write(string, offset, length, encoding)
+  }
+
+  set(array, offset) {
+    if (array == null) {
+      return
+    }
+
+    if (offset === undefined) {
+      offset = this.byteOffset
+    } else {
+      offset += this.byteOffset
+    }
+
+    array?.copy(this.buffer, offset)
+  }
+
+  at(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)
+  }
+
+  readBigUInt64BE(offset = 0) {
+    if (offset === undefined) {
+      offset = this.byteOffset
+    } else {
+      offset += this.byteOffset
+    }
+
+    return this.buffer.readBigUInt64BE(offset)
+  }
+
+  /**
+   *
+   * @param {BufferEncoding} [encoding='utf8']
+   * @param {number} [start=0]
+   * @param {number} [end=this.byteLength]
+   * @returns {string}
+   */
+  toString(encoding, start, end) {
+    if (start === undefined) {
+      start = this.byteOffset
+    } else {
+      start += this.byteOffset
+    }
+
+    if (end === undefined) {
+      end = this.byteLength + this.byteOffset
+    } else {
+      end += this.byteOffset
+    }
+
+    return this.buffer.toString(encoding, start, end)
+  }
+
+  toBuffer(start, end) {
+    if (start === undefined) {
+      start = this.byteOffset
+    } else {
+      start += this.byteOffset
+    }
+
+    if (end === undefined) {
+      end = this.byteLength + this.byteOffset
+    } else {
+      end += this.byteOffset
+    }
+
+    return this.buffer.subarray(start, end)
+  }
+
+  [Symbol.toStringTag]() {
+    return this.toString()
+  }
+
+  [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'))
+    }
+    return `Slice: "${this.toString()}" <${bytes.join(' ')}>`
+  }
+}