@wener/utils 1.1.50 → 1.1.53

package/lib/io/Buffer.js

@@ -1,25 +1,195 @@
-import { ArrayBuffers } from './ArrayBuffers.js';
-import { isBuffer } from './isBuffer.js';
-/**
- * Buffer is a polyfill version of NodeJS Buffer
- */ export class Buffer extends Uint8Array {
-    // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {
-    //   super(buffer, byteOffset, length);
-    // }
-    static get isPolyfill() {
-        return true;
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    }
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class)
+                _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor)
+            descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps)
+        _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps)
+        _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
     }
-    static isBuffer(v) {
-        return v instanceof Buffer || isBuffer(v);
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass)
+        _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
     }
-    static from(array, arg2) {
-        // todo mapfn
-        return new Buffer(ArrayBuffers.from(array, arg2));
+    else {
+        return left instanceof right;
+    }
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
     }
-    static isEncoding = ArrayBuffers.isEncoding;
-    toString(encoding) {
-        return ArrayBuffers.toString(this, encoding);
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class))
+            return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class))
+                return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () { }));
     }
+    catch (_) { }
+    return (_is_native_reflect_construct = function () {
+        return !!result;
+    })();
 }
-
-//# sourceMappingURL=Buffer.js.map
+import { ArrayBuffers } from "./ArrayBuffers.js";
+import { isBuffer } from "./isBuffer.js";
+/**
+ * Buffer is a polyfill version of NodeJS Buffer
+ */ export var Buffer = /*#__PURE__*/ function (Uint8Array1) {
+    "use strict";
+    _inherits(Buffer, Uint8Array1);
+    function Buffer() {
+        _class_call_check(this, Buffer);
+        return _call_super(this, Buffer, arguments);
+    }
+    _create_class(Buffer, [
+        {
+            key: "toString",
+            value: function toString(encoding) {
+                return ArrayBuffers.toString(this, encoding);
+            }
+        }
+    ], [
+        {
+            key: "isPolyfill",
+            get: // constructor(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {
+            //   super(buffer, byteOffset, length);
+            // }
+            function get() {
+                return true;
+            }
+        },
+        {
+            key: "isBuffer",
+            value: function isBuffer1(v) {
+                return _instanceof(v, Buffer) || isBuffer(v);
+            }
+        },
+        {
+            key: "from",
+            value: function from(array, arg2) {
+                // todo mapfn
+                return new Buffer(ArrayBuffers.from(array, arg2));
+            }
+        }
+    ]);
+    return Buffer;
+}(_wrap_native_super(Uint8Array));
+_define_property(Buffer, "isEncoding", ArrayBuffers.isEncoding);

package/lib/io/Buffer.test.js

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { Buffer } from "./Buffer.js";
+import { isBuffer } from "./isBuffer.js";
+test("basic", function () {
+    {
+        var buf = new Buffer(0);
+        expect(Buffer.isBuffer(buf)).toBeTruthy();
+        expect(isBuffer(buf)).toBeTruthy();
+    }
+    // const b = new Buffer(10)
+    // t.is(b.length,10)
+    // t.is(b.byteLength,10)
+    // t.is(b.byteOffset,0)
+    // t.is(b.buffer.byteLength,10)
+    // t.is(b.buffer.byteOffset,0)
+    // t.is(b.buffer.length,1)
+    // t.is(b.buffer[0].byteLength,10)
+    // t.is(b.buffer[0].byteOffset,0)
+    // t.is(b.buffer[0].length,10)
+    // t.is(b.buffer[0][0],0)
+    // t.is(b.buffer[0][9],0)
+});