@nxtedition/lib 28.0.2 → 28.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "28.0.2",
+  "version": "28.0.5",
   "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": "f778b4c525a240411f681137d8dd0fe19031c7b0"
 }

package/sequence.js

@@ -1,4 +1,5 @@
 import assert from 'node:assert'
+import util from 'node:util'
 
 export const ID_SEP = '~'
 
@@ -46,12 +47,12 @@ export class Sequence {
       return -1
     }
 
-    if (a && typeof a === 'string') {
-      a = new Sequence(a)
+    if (a === b) {
+      return 0
     }
 
-    if (typeof b === 'string') {
-      b = new Sequence(b)
+    if (typeof a === 'string') {
+      a = new Sequence(a)
     }
 
     return a.compare(b, strict)
@@ -205,13 +206,29 @@ export class Sequence {
   }
 
   at(index) {
-    assert(Number.isFinite(index) && index >= 0 && index * 2 < this.#parts.length)
+    if (!Number.isInteger(index)) {
+      throw new TypeError('index must be an integer')
+    }
+    if (index < 0 || index >= this.#parts.length / 2) {
+      throw new RangeError('index out of range')
+    }
+
     return this.#parts[index * 2 + 1]
   }
 
   set(index, sequence) {
-    assert(Number.isFinite(index) && index >= 0 && index < this.#parts.length)
-    assert(Number.isFinite(sequence) && sequence >= 0)
+    if (!Number.isInteger(index)) {
+      throw new TypeError('index must be an integer')
+    }
+    if (index < 0 || index >= this.#parts.length / 2) {
+      throw new RangeError('index out of range')
+    }
+    if (!Number.isInteger(sequence)) {
+      throw new TypeError('sequence must be an integer')
+    }
+    if (sequence < 0) {
+      throw new RangeError('sequence must be non-negative')
+    }
     if (this.#parts[index * 2 + 1] !== sequence) {
       this.#parts[index * 2 + 1] = sequence
       this.#value = ''
@@ -224,11 +241,23 @@ export class Sequence {
       strict = true
     }
 
-    assert(other instanceof Sequence)
-    assert(typeof strict === 'boolean')
+    if (typeof other === 'string') {
+      if (this.#value && this.#value === other) {
+        return 0
+      }
+      other = new Sequence(other)
+    }
+
+    if (!(other instanceof Sequence)) {
+      throw new TypeError('Can only compare with another Sequence')
+    }
+
+    if (typeof strict !== 'boolean') {
+      throw new TypeError('strict must be a boolean')
+    }
 
-    if (strict && other.identity && this.identity) {
-      assert.strictEqual(other.identity, this.identity)
+    if (strict && other.identity && this.identity && other.identity !== this.identity) {
+      throw new Error('Cannot compare sequences with different identities')
     }
 
     if (this.#parts.length !== other.#parts.length) {
@@ -256,4 +285,12 @@ export class Sequence {
     }
     return this.#value
   }
+
+  [Symbol.toStringTag]() {
+    return this.toString()
+  }
+
+  [util.inspect.custom](depth, options, inspect) {
+    return `Sequence: "${this.toString()}"`
+  }
 }

package/slice.js

@@ -0,0 +1,294 @@
+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
+    }
+
+    if (byteOffset < 0) {
+      throw new RangeError('byteOffset must be non-negative')
+    }
+
+    if (byteLength < 0) {
+      throw new RangeError('byteLength must be non-negative')
+    }
+
+    if (byteLength > maxByteLength) {
+      throw new RangeError('byteLength cannot be greater than maxByteLength')
+    }
+
+    if (byteOffset + maxByteLength > buffer.byteLength) {
+      throw new RangeError('Slice exceeds buffer length')
+    }
+
+    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(' ')}>`
+  }
+}