@k3000/store 0.1.0

package/architect.mjs

@@ -0,0 +1,1400 @@
+import {dirname, resolve} from "node:path"
+import {openSync, closeSync, readFileSync, writeFileSync, readSync, writeSync, unlinkSync} from "node:fs"
+import {createCipheriv, createDecipheriv, createHash, scryptSync} from "node:crypto"
+
+/**
+ *
+ * @param {Array} array
+ * @param {Function | String} predicate
+ * @return {Array}
+ */
+Array.prototype.eachFlat = function (array, predicate) {
+
+    if (typeof predicate === "string") {
+
+        const key = predicate
+
+        predicate = (a, b) => a[key] === b[key]
+    }
+
+    return this.map(item => {
+
+        const result = array.filter(entry => predicate(item, entry))
+
+        if (result.length === 0) return item
+
+        return result.map(entry => ({...entry, ...item}))
+
+    }).flat()
+}
+
+/**
+ *
+ * @param {Array} array
+ * @param {Function | String} predicate
+ * @return {Array}
+ */
+Array.prototype.filterFlat = function (array, predicate) {
+
+    if (typeof predicate === "string") {
+
+        const key = predicate
+
+        predicate = (a, b) => a[key] === b[key]
+    }
+
+    return this.map(item => array
+        .filter(entry => predicate(item, entry))
+        .map(entry => ({...entry, ...item}))
+    ).flat()
+}
+
+/**
+ * 时间筛选的最大值
+ * @type {number}
+ */
+export const MaxTime = 99999999999999
+/**
+ * 用于获取存储的位置
+ * @type {symbol}
+ */
+export const position = Symbol('position')
+
+export const TypeLen = {
+
+    id: 4,
+    int: 4,
+    text: 1,
+    time: 6,
+    uint: 4,
+    float: 8,
+    bigint: 8,
+    bigUint: 8,
+    buffer: 1,
+    string: 12
+}
+
+/**
+ * 加解密的类
+ */
+class Cipher {
+    /**
+     * 加密的键
+     * @type {string}
+     */
+    #key
+    /**
+     * 加密方式
+     * @type {string}
+     */
+    #algorithm = 'aes-192-cbc'
+    /**
+     * 加密向量
+     * @type {Int8Array}
+     */
+    #iv
+
+    constructor(key) {
+
+        if (!key) return
+
+        this.update(key)
+    }
+
+    /**
+     * 计算md5值
+     * @param {string} data
+     * @returns {Promise<ArrayBuffer>}
+     */
+    md5(data) {
+
+        const hash = createHash('md5')
+
+        hash.update(data)
+
+        return hash.digest('hex')
+    }
+
+    /**
+     * 加密
+     * @param {buffer} buffer
+     * @returns {buffer}
+     */
+    encrypt(buffer) {
+
+        if (!this.#key) return buffer
+
+        const cipher = createCipheriv(this.#algorithm, this.#key, this.#iv)
+
+        return Buffer.concat([cipher.update(buffer), cipher.final()])
+    }
+
+    /**
+     * 解密
+     * @param {buffer} buffer
+     * @returns {buffer}
+     */
+    decrypt(buffer) {
+
+        if (!this.#key) return buffer
+
+        const decipher = createDecipheriv(this.#algorithm, this.#key, this.#iv)
+
+        return Buffer.concat([decipher.update(buffer), decipher.final()])
+    }
+
+    /**
+     * 更新键
+     * @param {string} key
+     */
+    update(key) {
+
+        if (!key) return this.#key = undefined
+
+        this.#key = this.md5(key)
+        this.#iv = Buffer.from(this.#key).subarray(8, 24)
+        this.#key = scryptSync(this.#key, 'salt', 24)
+    }
+}
+
+export class Entity {
+
+    #storage
+    #position
+
+    #indexSet
+    #lengthSet
+    #positionSet
+
+    constructor(storage, position, indexSet, lengthSet, positionSet) {
+
+        this.#storage = storage
+        this.#position = position
+        this.#indexSet = indexSet
+        this.#lengthSet = lengthSet
+        this.#positionSet = positionSet
+    }
+
+    get [position]() {
+
+        return this.#position
+    }
+
+    get(name) {
+
+        return this.#storage.getValue(this.#position + this.#positionSet[name], this.#lengthSet[name])
+    }
+
+    set(name, buffer) {
+
+        this.#storage.setValue(this.#position + this.#positionSet[name], this.#lengthSet[name], buffer)
+    }
+
+    #indexPosition(index, buffer, length, s, e) {
+
+        if (e < s) return s
+        if (s === e) return buffer < this.#storage.getValue(index[s], length) ? s : s + 1
+        if (buffer <= this.#storage.getValue(index[s], length)) return s
+        if (buffer >= this.#storage.getValue(index[e], length)) return e + 1
+
+        let m = Math.floor((s + e) / 2), buf = this.#storage.getValue(index[m], length)
+
+        if (buffer < buf) return this.#indexPosition(index, buffer, length, s + 1, m - 1)
+        if (buffer > buf) return this.#indexPosition(index, buffer, length, m + 1, e - 1)
+
+        return m
+    }
+
+    set2(name, buffer) {
+
+        const position = this.#position + this.#positionSet[name]
+        const index = this.#indexSet[name]
+        const length = this.#lengthSet[name]
+        const buf = this.#storage.getValue(position, length)
+        const changed = !buf.equals(buffer)
+
+        if (changed) {
+
+            this.#storage.setValue(position, length, buffer)
+        }
+
+        let i = index.indexOf(position)
+
+        if (changed || i === -1) {
+
+            let s = 0, e = index.length - 1
+
+            if (i >= 0) {
+
+                index.splice(i, 1)
+
+                if (buf > buffer) {
+
+                    e = i - 1
+
+                } else {
+
+                    e--
+
+                    s = i
+                }
+            }
+
+            i = index.length === 0 ? 0 : this.#indexPosition(index, buffer, length, s, e)
+
+            index.splice(i, 0, position)
+        }
+    }
+
+    readFileSync(name) {
+
+        return readFileSync(this.#storage.bufferDir + (this.#position + this.#positionSet[name]))
+    }
+
+    buffer(value, name) {
+
+        const buffer = Buffer.alloc(TypeLen.buffer)
+
+        if (value instanceof Buffer) {
+
+            writeFileSync(this.#storage.bufferDir + (this.#position + this.#positionSet[name]), value)
+
+            buffer[0] = 1
+        }
+
+        return buffer
+    }
+
+    intToBuffer(value, name) {
+
+        const size = this.#lengthSet[name]
+
+        const buffer = Buffer.alloc(size)
+
+        switch (size) {
+
+            case 1:
+                buffer.writeInt8(value)
+                break
+            case 2:
+                buffer.writeInt16BE(value)
+                break
+            case 3:
+                writeInt24BE(buffer, value)
+                break
+            case 4:
+                buffer.writeInt32BE(value)
+                break
+        }
+
+        return buffer
+    }
+
+    uintToBuffer(value, name) {
+
+        const size = this.#lengthSet[name]
+
+        const buffer = Buffer.alloc(size)
+
+        switch (size) {
+
+            case 1:
+                buffer.writeUint8(value)
+                break
+            case 2:
+                buffer.writeUint16BE(value)
+                break
+            case 3:
+                writeUint24BE(buffer, value)
+                break
+            case 4:
+                buffer.writeUint32BE(value)
+                break
+        }
+
+        return buffer
+    }
+
+    textToBuffer(value = '', name) {
+
+        const buffer = Buffer.alloc(TypeLen.text)
+
+        writeFileSync(this.#storage.bufferDir + (this.#position + this.#positionSet[name]),
+            typeof value === "string" ? value : String(value))
+
+        buffer[0] = 1
+
+        return buffer
+    }
+
+    s2b(value = '', name) {
+
+        return s2b(value, this.#lengthSet[name])
+    }
+}
+
+export class Entities extends Array {
+
+    #idle
+    #name
+    #index
+    #value
+    #length
+    #record
+    #bufferSet = {}
+    #lengthSet = {}
+    #positionSet = {}
+    #storage
+    #classify
+
+    constructor(storage, classify) {
+
+        const name = classify.name
+        const record = storage.record.record[name]
+
+        super()
+
+        this.#name = name
+        this.#storage = storage
+        this.#classify = classify
+        this.#idle = storage.record.idle[name]
+        this.#index = storage.record.index[name]
+        this.#value = storage.record.value[name]
+        this.#length = storage.struct.extra[name].length
+        this.#record = record
+
+        for (const [key, value] of Object.entries(storage.struct.base[name])) {
+
+            this.#lengthSet[key] = value.length
+            this.#positionSet[key] = value.position
+        }
+
+        const methods = {
+            push: this.push.bind(this),
+            pop: this.pop.bind(this),
+            unshift: this.unshift.bind(this),
+            shift: this.shift.bind(this),
+            splice: this.splice.bind(this),
+            page: this.page.bind(this),
+            remove: this.remove.bind(this),
+            s2b: this.s2b.bind(this),
+            findByValue: this.findByValue.bind(this),
+            findByTime: this.findByTime.bind(this),
+        }
+
+        for (const [key, value] of Object.entries(storage.struct.base[name])) {
+
+            if (Reflect.has(value, 'index')) {
+
+                const name = `indexBy${key[0].toUpperCase()}${key.substring(1)}`
+
+                methods[name] = this[name].bind(this)
+            }
+        }
+
+        return (target, p) => {
+
+            const index = Number.parseInt(String(p))
+
+            if (Number.isInteger(index)) {
+
+                if (index >= record.length || index < 0) return null
+
+                return storage.getEntity(record[p], classify, this.#index, this.#lengthSet, this.#positionSet)
+            }
+
+            if (Reflect.has(methods, p)) return methods[p]
+
+            const result = record[p]
+
+            if (typeof result !== "function") return result
+
+            return (...arg) => result.call(record.map(position => storage.getEntity(position, classify,
+                this.#index, this.#lengthSet, this.#positionSet)), ...arg)
+        }
+    }
+
+    #recycle(index) {
+
+        let i
+
+        for (const value of Object.values(this.#index)) {
+
+            i = value.indexOf(index)
+
+            if (i >= 0) {
+
+                value.splice(i, 1)
+            }
+        }
+
+        for (const value of Object.values(this.#bufferSet)) {
+
+            unlinkSync(`${this.#storage.bufferDir}/${index + value}`)
+        }
+    }
+
+    #getEntity(position) {
+
+        return this.#storage.getEntity(position, this.#classify, this.#index, this.#lengthSet, this.#positionSet)
+    }
+
+    #assign(position, item) {
+
+        Object.assign(new this.#classify(position, this.#index, this.#lengthSet, this.#positionSet),
+            this.#classify.create(item))
+    }
+
+    push(...items) {
+
+        if (this.#storage.needSave === false) {
+
+            this.#storage.needSave = true
+        }
+
+        for (const item of items) {
+
+            let position
+
+            if (this.#idle.length) {
+
+                position = this.#idle.pop()
+
+            } else {
+
+                position = this.#storage.pointer
+
+                this.#storage.pointer += this.#length
+            }
+
+            this.#record.push(position)
+
+            this.#assign(position, item)
+        }
+
+        return items.length
+    }
+
+    pop() {
+
+        if (this.#storage.needSave === false) {
+
+            this.#storage.needSave = true
+        }
+
+        const index = this.#record.pop()
+
+        this.#recycle(index)
+
+        this.#idle.push(index)
+
+        return this.#getEntity(index)
+    }
+
+    unshift(...items) {
+
+        if (this.#storage.needSave === false) {
+
+            this.#storage.needSave = true
+        }
+
+        for (const item of items) {
+
+            let position
+
+            if (this.#idle.length) {
+
+                position = this.#idle.pop()
+
+            } else {
+
+                position = this.#storage.pointer
+
+                this.#storage.pointer += this.#length
+            }
+
+            this.#record.unshift(position)
+
+            this.#assign(position, item)
+        }
+
+        return items.length
+    }
+
+    shift() {
+
+        if (this.#storage.needSave === false) {
+
+            this.#storage.needSave = true
+        }
+
+        const index = this.#record.shift()
+
+        this.#recycle(index)
+        this.#idle.push(index)
+
+        return this.#getEntity(index)
+    }
+
+    splice(start, deleteCount, ...items) {
+
+        if (this.#storage.needSave === false) {
+
+            this.#storage.needSave = true
+        }
+
+        const record = items.map(item => {
+
+            let position
+
+            if (this.#idle.length) {
+
+                position = this.#idle.pop()
+
+            } else {
+
+                position = this.#storage.pointer
+
+                this.#storage.pointer += this.#length
+            }
+
+            this.#assign(position, item)
+
+            return position
+        })
+
+        const idle = this.#record.splice(start, deleteCount, ...record)
+
+        for (let index of idle) {
+
+            this.#recycle(index)
+        }
+
+        this.#idle.push(...idle)
+
+        return idle
+    }
+
+    #page(predicate, page, size, params) {
+
+        const result = this.#storage.getCache(params,
+            () => this.#record.filter(position => predicate(this.#getEntity(position))))
+
+        const list = result.slice((page - 1) * size, page * size).map(position => this.#getEntity(position))
+
+        list.total = result.length
+
+        return list
+    }
+
+    /**
+     * 分页
+     * @param {Function} predicate
+     * @param index
+     * @param size
+     * @param params
+     * @return {*[]|*|*[]}
+     */
+    page(predicate, page, size, params) {
+
+        if (typeof page === "string" && typeof size === "string" && typeof params === "object") {
+
+            return this.#page(predicate, params[page], params[size], this.#name + ' ' +
+                JSON.stringify(params, (replacer, target) => replacer === page || replacer === size ? undefined : target)
+            )
+        }
+
+        if (size <= 0) {
+
+            return []
+        }
+
+        if (page < 1) {
+
+            page = 1
+        }
+
+        const total = size * page
+
+        const result = []
+
+        for (let i = 0; i < this.#record.length; i++) {
+
+            if (predicate(this.#record[i], i, this.#record)) {
+
+                result.push(this.#record[i])
+
+                if (result.length >= total) {
+
+                    return result.slice((page - 1) * size).map(index => this.#getEntity(index))
+                }
+            }
+        }
+
+        return result.slice((page - 1) * size).map(index => this.#getEntity(index))
+    }
+
+    remove(...items) {
+
+        let index
+
+        if (Array.isArray(items[0])) {
+
+            items = items[0]
+        }
+
+        for (const item of items) {
+
+            if (item === undefined) continue
+
+            index = this.#record.findIndex(pos => item[position] === pos)
+
+            if (index >= 0) {
+
+                this.splice(index, 1)
+            }
+        }
+    }
+
+    #findByValue(index, buffer, length, s, e) {
+
+        if (e < s) return []
+
+        let m = Math.floor((s + e) / 2), buf = this.#storage.getValue(index[m], length)
+
+        if (buffer < buf) return this.#findByValue(index, buffer, length, s, m - 1)
+        if (buffer > buf) return this.#findByValue(index, buffer, length, m + 1, e)
+
+        let result = [index[m]], i
+
+        for (i = m - 1; i >= 0; i--) {
+
+            if (!this.#storage.getValue(index[i], length).equals(buffer)) break
+
+            result.unshift(index[i])
+        }
+
+        for (i = m + 1; i < index.length; i++) {
+
+            if (!this.#storage.getValue(index[i], length).equals(buffer)) break
+
+            result.push(index[i])
+        }
+
+        return result
+    }
+
+    findByValue(name, value) {
+
+        const index = this.#index[name]
+        const position = this.#positionSet[name]
+
+        return this.#findByValue(index, value, this.#lengthSet[name], 0, index.length - 1)
+            .map(index => this.#getEntity(index - position))
+    }
+
+    #findByTime(index, after, before, length, s, e) {
+
+        if (e < s) return []
+
+        let m = Math.floor((s + e) / 2), buffer = this.#storage.getValue(index[m], length)
+
+        if (before < buffer) return this.#findByTime(index, after, before, length, s, m - 1)
+        if (after > buffer) return this.#findByTime(index, after, before, length, m + 1, e)
+
+        let result = [index[m]], i
+
+        for (i = m - 1; i >= 0; i--) {
+
+            if (this.#storage.getValue(index[i], length) < after) break
+
+            result.unshift(index[i])
+        }
+
+        for (i = m + 1; i < index.length; i++) {
+
+            if (this.#storage.getValue(index[i], length) > before) break
+
+            result.push(index[i])
+        }
+
+        return result
+    }
+
+    findByTime(name, {after = 0, before = MaxTime}) {
+
+        const index = this.#index[name]
+        const position = this.#positionSet[name]
+
+        if (after > before) {
+
+            [after, before] = [before, after]
+        }
+
+        if (after < 0 || after > MaxTime) {
+
+            after = 0
+        }
+
+        if (before < 0 || before > MaxTime) {
+
+            before = MaxTime
+        }
+
+        return this.#findByTime(index, d2b(after), d2b(before), TypeLen.time, 0, index.length - 1)
+            .map(index => this.#getEntity(index - position))
+    }
+
+    s2b(value = '', name) {
+
+        return s2b(value, this.#lengthSet[name])
+    }
+}
+
+const u2o = (url = '') => {
+
+    const obj = {}
+
+    let index = url.indexOf('?')
+
+    if (index >= 0) {
+
+        for (const params of url.substring(index + 1).split('&')) {
+
+            index = params.indexOf('=')
+
+            if (index === -1) {
+
+                obj[decodeURI(params)] = decodeURI(params)
+
+            } else {
+
+                obj[decodeURI(params.substring(0, index))] = decodeURI(params.substring(index + 1))
+            }
+        }
+    }
+
+    return obj
+}
+
+export class Storage {
+
+    needSave = false
+
+    #cipher
+    #buffer
+    #struct
+    #record
+    #fd_data
+    #fd_index
+    #caches = new Map
+    #values = new Map
+    #entities = new Map
+    #interval
+
+    constructor(url, password, newPwd) {
+
+        url = decodeURI(url)
+
+        let dir = url.endsWith('/') ? url : dirname(url) + '/'
+
+        const root = resolve('/')
+
+        if (dir.startsWith('file:///')) {
+
+            dir = root.length > 1 ? dir.substring(7 + root.length) : dir.substring(7)
+        }
+
+        this.#fd_data = openSync(dir + 'data', 'r+')
+        this.#fd_index = openSync(dir + 'index', 'r+')
+
+        const params = u2o(url)
+
+        this.#cipher = new Cipher(params.password || password || '')
+
+        newPwd = newPwd || params.newPwd
+
+        try {
+
+            this.#struct = this.#getStruct()
+            this.#record = this.#getRecord()
+
+            if (newPwd !== undefined) {
+
+                this.#cipher.update(newPwd)
+
+                this.updateStruct(this.#struct)
+                this.updateRecord(this.#record)
+            }
+
+        } catch (e) {
+
+            throw new Error('密码不匹配或者存储文件不正确')
+        }
+
+        this.#buffer = dir + '/buffer/'
+
+        const id = this.#getId() + 1
+
+        this.#updateId(id)
+
+        this.#interval = setInterval(() => {
+
+            this.#save()
+
+            this.#check(this.#caches, this.#values, this.#entities)
+
+            if (id !== this.#getId()) {
+
+                throw new Error(dir + '已在其他地方打开')
+            }
+
+        }, 3000)
+    }
+
+    #save() {
+
+        for (const [position, item] of this.#values.entries()) {
+
+            if (item.needsSave) {
+
+                item.needsSave = false
+
+                writeSync(this.#fd_data, item.value, 0, item.value.length, position)
+            }
+        }
+
+        if (this.needSave) {
+
+            this.updateRecord(this.#record)
+        }
+    }
+
+    #check(...arg) {
+
+        for (const map of arg) {
+
+            for (const [key, value] of map) {
+
+                if (value.expired === false) {
+
+                    value.expired = true
+
+                } else {
+
+                    map.delete(key)
+                }
+            }
+        }
+    }
+
+    #writeNumber(number, position) {
+
+        const buffer = Buffer.alloc(4)
+
+        buffer.writeUint32BE(number, 0)
+
+        writeSync(this.#fd_index, buffer, 0, 4, position)
+    }
+
+    #updateId(id = 0) {
+
+        this.#writeNumber(id, 0)
+    }
+
+    updateStruct(struct = {
+        base: {},
+        extra: {},
+    }) {
+
+        this.#struct = struct
+
+        this.#update(struct)
+    }
+
+    updateRecord(record = {
+        idle: {},
+        index: {},
+        value: {},
+        record: {},
+        pointer: 0,
+    }, length = 4 + this.#getLength()) {
+
+        this.#record = record
+
+        this.#update(record, length)
+    }
+
+    #update(object = {}, position = 0) {
+
+        object = Buffer.from(JSON.stringify(object))
+        object = this.#cipher.encrypt(object)
+
+        this.#writeNumber(object.length, 4 + position)
+
+        writeSync(this.#fd_index, object, 0, object.length, 8 + position)
+    }
+
+    #getId() {
+
+        const buffer = Buffer.alloc(4)
+
+        readSync(this.#fd_index, buffer, {
+            offset: 0,
+            length: 4,
+            position: 0,
+        })
+
+        return buffer.readUInt32BE(0)
+    }
+
+    #getLength(position = 0) {
+
+        const buffer = Buffer.alloc(4)
+
+        readSync(this.#fd_index, buffer, 0, 4, 4 + position)
+
+        return buffer.readUInt32BE(0)
+    }
+
+    #getJson(length, position = 0) {
+
+        const buffer = Buffer.alloc(length)
+
+        readSync(this.#fd_index, buffer, 0, length, 8 + position)
+
+        return JSON.parse(this.#cipher.decrypt(buffer).toString() || '{}')
+    }
+
+    #getStruct() {
+
+        return this.#getJson(this.#getLength())
+    }
+
+    #getRecord() {
+
+        const position = this.#getLength() + 4
+
+        return this.#getJson(this.#getLength(position), position)
+    }
+
+    init() {
+
+        this.#updateId(1)
+        this.updateStruct()
+        this.updateRecord()
+    }
+
+    getCache(params, predicate) {
+
+        if (this.#caches.has(params)) {
+
+            const item = this.#caches.get(params)
+
+            if (item.expired === false) {
+
+                item.expired = true
+            }
+
+            return item.cache
+
+        } else {
+
+            const cache = predicate()
+
+            this.#caches.set(params, {
+                expired: false,
+                cache,
+            })
+
+            return cache
+        }
+    }
+
+    getValue(position, length) {
+
+        if (this.#values.has(position)) {
+
+            const item = this.#values.get(position)
+
+            if (item.expired === true) {
+
+                item.expired = false
+            }
+
+            return item.value
+
+        } else {
+
+            const value = Buffer.alloc(length)
+
+            readSync(this.#fd_data, value, 0, length, position)
+
+            this.#values.set(position, {
+                value,
+                expired: false,
+                needsSave: true,
+            })
+
+            return value
+        }
+    }
+
+    setValue(position, length, value) {
+
+        if (this.#values.has(position)) {
+
+            const item = this.#values.get(position)
+
+            if (!item.value.equals(value)) {
+
+                if (item.needsSave === false) {
+
+                    item.needsSave = true
+                }
+
+                item.value = value
+            }
+
+        } else {
+
+            const val = Buffer.alloc(length)
+
+            readSync(this.#fd_data, val, 0, length, position)
+
+            this.#values.set(position, {
+                value,
+                expired: true,
+                needsSave: value !== val,
+            })
+        }
+    }
+
+    getEntity(position, classify, ...arg) {
+
+        if (this.#entities.has(position)) {
+
+            const item = this.#entities.get(position)
+
+            if (item.expired === false) {
+
+                item.expired = true
+            }
+
+            return item.entity
+
+        } else {
+
+            const entity = new classify(position, ...arg)
+
+            this.#entities.set(position, {
+                entity,
+                expired: false
+            })
+
+            return entity
+        }
+    }
+
+    get struct() {
+
+        return this.#struct
+    }
+
+    get record() {
+
+        return this.#record
+    }
+
+    get bufferDir() {
+
+        return this.#buffer
+    }
+
+    get pointer() {
+
+        return this.#record.pointer
+    }
+
+    set pointer(pointer) {
+
+        this.#record.pointer = pointer
+    }
+
+    close() {
+
+        this.#save()
+
+        clearInterval(this.#interval)
+
+        closeSync(this.#fd_data)
+        closeSync(this.#fd_index)
+    }
+
+    updateValue(value, name, key) {
+
+        if (!value) return this.#record.value[name][key] += this.#struct.base[name][key].step
+
+        value = Number.parseFloat(value) || 1
+
+        if (value > this.#record.value[name][key]) this.#record.value[name][key] = value
+
+        return value
+    }
+}
+
+export class Store {
+}
+
+export const buffer = Buffer
+export const string = String
+
+const now = Date.now().toString(16)
+
+const length = now.length % 2 === 0 ? now.length : now.length + 1
+
+/**
+ * @param {Buffer} buffer
+ * @param {Number} value
+ */
+const writeInt24BE = (buffer, value) => {
+
+    if (value > 8388607 || value < -8388608) throw new RangeError(
+        'RangeError [ERR_OUT_OF_RANGE]: The value of "value" is out of range. It must be >= -8388608 and <= 8388607. Received ' + value)
+
+    if (value > 65535) {
+
+        buffer.writeUInt8(value >> 16)
+        buffer.writeUint16BE(value % 65536, 1)
+
+    } else if (value > 0) {
+
+        buffer.writeUInt8(0)
+        buffer.writeUint16BE(value, 1)
+
+    } else if (value === -8388608) {
+
+        buffer.writeUInt8(128)
+        buffer.writeUint16BE(0, 1)
+
+    } else if (value < -65535) {
+
+        value = -value
+        buffer.writeUInt8((value >> 16) + 128)
+        buffer.writeUint16BE(value % 65536, 1)
+
+    } else if (value < 0) {
+
+        value = -value
+        buffer.writeUInt8(128)
+        buffer.writeUint16BE(value, 1)
+    }
+}
+
+/**
+ * @param {Buffer} buffer
+ * @param {Number} value
+ */
+const writeUint24BE = (buffer, value) => {
+
+    if (value > 16777215 || value < 0) throw new RangeError(
+        'RangeError [ERR_OUT_OF_RANGE]: The value of "value" is out of range. It must be >= -8388608 and <= 8388607. Received ' + value)
+
+    if (value > 65535) {
+
+        buffer.writeUInt8(value >> 16)
+        buffer.writeUint16BE(value % 65536, 1)
+
+    } else if (value >= 0) {
+
+        buffer.writeUInt8(0)
+        buffer.writeUint16BE(value, 1)
+    }
+}
+
+/**
+ * @param {Buffer} buffer
+ * @return {Number}
+ */
+export const readInt24BE = buffer => {
+
+    let n1 = buffer.readUint8()
+    const n2 = buffer.readUInt16BE(1)
+
+    if (n1 === 0) return n2
+
+    if (n1 === 128 && n2 === 0) return -8388608
+
+    if (n1 >= 128) {
+
+        n1 -= 128
+
+        return -(n1 * 65536 + n2)
+    }
+
+    return n1 * 65536 + n2
+}
+
+/**
+ * @param {Buffer} buffer
+ * @return {Number}
+ */
+export const readUint24BE = buffer => {
+
+    let n1 = buffer.readUint8()
+    const n2 = buffer.readUInt16BE(1)
+
+    if (n1 === 0) return n2
+
+    return n1 * 65536 + n2
+}
+
+export const b2d = buffer => {
+
+    let n = 0
+
+    for (let i = 0; i < buffer.length; i++) {
+
+        n = n * 256 + buffer[i]
+    }
+
+    return n
+}
+
+export const d2b = tick => {
+
+    tick = tick || 0
+
+    if (tick instanceof Date) {
+
+        tick = tick.getTime()
+    }
+
+    tick = tick.toString(16).padStart(length, '0')
+
+    const buffer = Buffer.alloc(length / 2)
+
+    for (let i = 0; i < length; i += 2) {
+
+        buffer[i / 2] = Number.parseInt(tick.substring(i, i + 2), 16)
+    }
+
+    return buffer
+}
+
+const s2b = (value, length) => {
+
+    value = typeof value === "string" ? value : String(value)
+
+    let buffer = Buffer.from(value)
+
+    if (buffer.length > length) {
+
+        let len = 0
+
+        for (let i = value.length - 1; i >= 0; i--) {
+
+            const byteLength = Buffer.byteLength(value[i])
+
+            if (len + byteLength > length) break
+
+            len += byteLength
+        }
+
+        buffer = buffer.subarray(buffer.length - len)
+    }
+
+    return Buffer.concat([Buffer.alloc(length - buffer.length), buffer])
+}
+
+export const b2s = buffer => {
+
+    for (let i = 0; i < buffer.length; i++) {
+
+        if (buffer[i] !== 0) {
+
+            return buffer.subarray(i).toString()
+        }
+    }
+}
+
+export const bufferToInt = buffer => {
+
+    switch (buffer.length) {
+
+        case 1: return buffer.readInt8()
+        case 2: return buffer.readInt16BE()
+        case 3: return readInt24BE(buffer)
+        case 4: return buffer.readInt32BE()
+    }
+}
+
+export const bufferToUint = buffer => {
+
+    switch (buffer.length) {
+
+        case 1: return buffer.readUint8()
+        case 2: return buffer.readUint16BE()
+        case 3: return readUint24BE(buffer)
+        case 4: return buffer.readUint32BE()
+    }
+}
+
+export const uInt32BEToBuffer = value => {
+
+    const buffer = Buffer.alloc(TypeLen.uint)
+
+    buffer.writeUInt32BE(value, 0)
+
+    return buffer
+}
+
+export const int32BEToBuffer = value => {
+
+    const buffer = Buffer.alloc(TypeLen.int)
+
+    buffer.writeInt32BE(value, 0)
+
+    return buffer
+}
+
+export const bigUint32BEToBuffer = value => {
+
+    const buffer = Buffer.alloc(TypeLen.bigUint)
+
+    buffer.writeBigUint64BE(value, 0)
+
+    return buffer
+}
+
+export const bigint32BEToBuffer = value => {
+
+    const buffer = Buffer.alloc(TypeLen.bigint)
+
+    buffer.writeBigInt64BE(value, 0)
+
+    return buffer
+}
+
+export const doubleBEToBuffer = value => {
+
+    const buffer = Buffer.alloc(TypeLen.float)
+
+    buffer.writeDoubleBE(value, 0)
+
+    return buffer
+}
+
+export const cloneObjByKey = (obj, ...keys) => {
+
+    if (!obj) return obj
+
+    const result = {}
+
+    for (const key of keys) {
+
+        result[key] = obj[key]
+    }
+
+    return result
+}