@wener/utils 1.1.51 → 1.1.53

package/lib/io/ByteBuffer.test.js

@@ -0,0 +1,184 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { assert, describe, test } from "vitest";
+import { ByteBuffer } from "./ByteBuffer.js";
+describe("ByteBuffer", function () {
+    return _async_to_generator(function () {
+        return _ts_generator(this, function (_state) {
+            test("base", function () {
+                var buf = new ByteBuffer();
+                buf.writeString("Hello");
+                buf.writeString("World");
+                assert.equal(buf.length, 10);
+                assert.equal(buf.position, 10);
+                buf.length = 5;
+                assert.equal(buf.length, 5);
+                buf.position = 0;
+                assert.equal(buf.readString(5), "Hello");
+            });
+            test("overflow max length", function () {
+                var buf = new ByteBuffer();
+                buf.writeBytes(new Uint8Array(1025));
+                assert.equal(buf.length, 1025);
+            });
+            test("overflow max length tow step", function () {
+                var buf = new ByteBuffer();
+                buf.writeBytes(new Uint8Array(1023));
+                buf.writeBytes(new Uint8Array(2));
+                assert.equal(buf.length, 1025);
+                console.log("Max", buf.buffer.maxByteLength);
+            });
+            test("writeBytes fill zero", function () {
+                var buf = new ByteBuffer();
+                buf.writeBytes(new Uint8Array([
+                    1,
+                    2
+                ]));
+                buf.position = 0;
+                // console.log('->', buf.position, buf.length, buf.remaining());
+                // console.log(toHexDump(buf.buffer));
+                // truncate to size fill zero
+                buf.writeBytes(new Uint8Array([
+                    1
+                ]), 10);
+                // console.log('->', buf.position, buf.length, buf.remaining());
+                // console.log(toHexDump(buf.buffer));
+                assert.equal(buf.view.getInt8(0), 1);
+                assert.equal(buf.view.getInt8(1), 0);
+                assert.equal(buf.length, 10);
+            });
+            return [
+                2
+            ];
+        });
+    })();
+});

package/lib/io/base64.js

@@ -1,15 +1,15 @@
 // https://github.com/niklasvh/base64-arraybuffer/blob/master/src/index.ts
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 // Use a lookup table to find the index.
-const lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
-for(let i = 0; i < chars.length; i++){
+var lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+for(var i = 0; i < chars.length; i++){
     lookup[chars.charCodeAt(i)] = i;
 }
 export function encodeArrayBufferToBase64(arraybuffer) {
-    const bytes = new Uint8Array(arraybuffer);
-    const len = bytes.length;
-    let base64 = '';
-    for(let i = 0; i < len; i += 3){
+    var bytes = new Uint8Array(arraybuffer);
+    var len = bytes.length;
+    var base64 = '';
+    for(var i = 0; i < len; i += 3){
         base64 += chars[bytes[i] >> 2];
         base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
         base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
@@ -23,22 +23,22 @@ export function encodeArrayBufferToBase64(arraybuffer) {
     return base64;
 }
 export function decodeBase64ToUint8Array(base64) {
-    const len = base64.length;
-    let bufferLength = base64.length * 0.75;
-    let i;
-    let p = 0;
-    let encoded1;
-    let encoded2;
-    let encoded3;
-    let encoded4;
+    var len = base64.length;
+    var bufferLength = base64.length * 0.75;
+    var i;
+    var p = 0;
+    var encoded1;
+    var encoded2;
+    var encoded3;
+    var encoded4;
     if (base64[base64.length - 1] === '=') {
         bufferLength--;
         if (base64[base64.length - 2] === '=') {
             bufferLength--;
         }
     }
-    const arraybuffer = new ArrayBuffer(bufferLength);
-    const bytes = new Uint8Array(arraybuffer);
+    var arraybuffer = new ArrayBuffer(bufferLength);
+    var bytes = new Uint8Array(arraybuffer);
     for(i = 0; i < len; i += 4){
         encoded1 = lookup[base64.charCodeAt(i)];
         encoded2 = lookup[base64.charCodeAt(i + 1)];
@@ -50,5 +50,3 @@ export function decodeBase64ToUint8Array(base64) {
     }
     return bytes;
 }
-
-//# sourceMappingURL=base64.js.map

package/lib/io/dump.js

@@ -1,21 +1,23 @@
-import { ArrayBuffers } from './ArrayBuffers.js';
+import { ArrayBuffers } from "./ArrayBuffers.js";
 export function toHexDump(data) {
-    return Array.from(ArrayBuffers.toHex(data).match(/.{1,32}/g) ?? []).map((v, i)=>{
-        let idxPrefix = `${i.toString(16).padStart(8, '0')}:`;
-        let content = Array.from(v.match(/.{4}/g) ?? []).join(' ');
-        let chars = Array.from(new Uint8Array(ArrayBuffers.fromHex(v).buffer)).map((v)=>{
-            let c = String.fromCharCode(v);
+    var _ArrayBuffers_toHex_match;
+    return Array.from((_ArrayBuffers_toHex_match = ArrayBuffers.toHex(data).match(/.{1,32}/g)) !== null && _ArrayBuffers_toHex_match !== void 0 ? _ArrayBuffers_toHex_match : []).map(function (v, i) {
+        var idxPrefix = "".concat(i.toString(16).padStart(8, "0"), ":");
+        var _v_match;
+        var content = Array.from((_v_match = v.match(/.{4}/g)) !== null && _v_match !== void 0 ? _v_match : []).join(" ");
+        var chars = Array.from(new Uint8Array(ArrayBuffers.fromHex(v).buffer)).map(function (v) {
+            var c = String.fromCharCode(v);
             if (v < 32 || v > 126) {
-                c = '.';
+                c = ".";
             }
             return c;
         });
         return [
             idxPrefix,
-            content.padEnd(40, ' '),
-            chars.join('')
-        ].join(' ');
-    }).join('\n');
+            content.padEnd(40, " "),
+            chars.join("")
+        ].join(" ");
+    }).join("\n");
 }
 /**
  * Chrome Websocket Binary format
@@ -23,9 +25,7 @@ export function toHexDump(data) {
  * 00000000: 0000 0000 0000 0000 0000 0000 0000 0000  ................
  * ```
  */ export function fromHexDump(dump) {
-    return ArrayBuffers.fromHex(dump.split('\n').map((v)=>{
-        return v.substring(10, 10 + 41).replaceAll(' ', '');
-    }).join(''));
+    return ArrayBuffers.fromHex(dump.split("\n").map(function (v) {
+        return v.substring(10, 10 + 41).replaceAll(" ", "");
+    }).join(""));
 }
-
-//# sourceMappingURL=dump.js.map

package/lib/io/isBuffer.js

@@ -3,7 +3,6 @@
  *
  * @see {@link https://github.com/feross/is-buffer feross/is-buffer}
  */ export function isBuffer(obj) {
-    return obj?.constructor?.isBuffer?.(obj);
+    var _obj_constructor_isBuffer, _obj_constructor;
+    return obj === null || obj === void 0 ? void 0 : (_obj_constructor = obj.constructor) === null || _obj_constructor === void 0 ? void 0 : (_obj_constructor_isBuffer = _obj_constructor.isBuffer) === null || _obj_constructor_isBuffer === void 0 ? void 0 : _obj_constructor_isBuffer.call(_obj_constructor, obj);
 }
-
-//# sourceMappingURL=isBuffer.js.map

package/lib/io/isBuffer.test.js

@@ -0,0 +1,8 @@
+import { Buffer } from "node:buffer";
+import { expect, test } from "vitest";
+import { classOf } from "../langs/classOf.js";
+import { isBuffer } from "./isBuffer.js";
+test("isBuffer", function () {
+    expect(isBuffer(Buffer.from(""))).toBeTruthy();
+    expect(classOf(Buffer)).toBe("Function");
+});

package/lib/io/isTransferable.js

@@ -1,5 +1,13 @@
-import { getGlobalThis } from '../web/getGlobalThis.js';
-const globalThis = getGlobalThis();
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+import { getGlobalThis } from "../web/getGlobalThis.js";
+var globalThis = getGlobalThis();
 /**
  * transferable object pass between workers, can work with structuredClone
  *
@@ -7,12 +15,14 @@ const globalThis = getGlobalThis();
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects | Transferable objects}
  */ export function isTransferable(v) {
-    _ctors ||= ctors();
-    return _ctors.some((ctor)=>v instanceof ctor);
+    _ctors || (_ctors = ctors());
+    return _ctors.some(function (ctor) {
+        return _instanceof(v, ctor);
+    });
 }
-let _ctors;
+var _ctors;
 function ctors() {
-    const o = globalThis.window || globalThis || global;
+    var o = globalThis.window || globalThis || global;
     return [
         o.ArrayBuffer,
         o.MessagePort,
@@ -26,5 +36,3 @@ function ctors() {
         o.RTCDataChannel
     ].filter(Boolean);
 }
-
-//# sourceMappingURL=isTransferable.js.map

package/lib/io/isTransferable.test.js

@@ -0,0 +1,17 @@
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+import { Buffer } from "node:buffer";
+import { expect, test } from "vitest";
+import { isTransferable } from "./isTransferable.js";
+test("isTransferable", function () {
+    expect(isTransferable(0)).toBeFalsy();
+    expect(isTransferable(Buffer.from(""))).toBeFalsy();
+    expect(_instanceof(new ArrayBuffer(0), ArrayBuffer)).toBeTruthy();
+    expect(isTransferable(new ArrayBuffer(0))).toBeTruthy();
+});