wenay-common 1.0.21 → 1.0.22

package/lib/{srcClient/index.js → index.js}

@@ -15,25 +15,25 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = exports.LoadCandles = exports.List = exports.Math = exports.ListNodeAnd = exports.Color = exports.Time = exports.Common = exports.BaseTypes = void 0;
-__exportStar(require("../src/Common/Time"), exports);
-__exportStar(require("../src/Common/Common"), exports);
-__exportStar(require("../src/Common/Color"), exports);
-__exportStar(require("../src/Common/ListNodeAnd"), exports);
-__exportStar(require("../src/Common/Math"), exports);
-__exportStar(require("../src/Exchange/ConnectData/Binance"), exports);
-exports.BaseTypes = require("../src/Common/BaseTypes");
-exports.Common = require("../src/Common/Common");
-exports.Time = require("../src/Common/Time");
-exports.Color = require("../src/Common/Color");
-exports.ListNodeAnd = require("../src/Common/ListNodeAnd");
-exports.Math = require("../src/Common/Math");
-exports.List = require("../src/Common/List");
-exports.LoadCandles = require("../src/Exchange/ConnectData/Binance");
-const ListNodeAnd_1 = require("../src/Common/ListNodeAnd");
+__exportStar(require("./Common/Time"), exports);
+__exportStar(require("./Common/Common"), exports);
+__exportStar(require("./Common/Color"), exports);
+__exportStar(require("./Common/ListNodeAnd"), exports);
+__exportStar(require("./Common/Math"), exports);
+__exportStar(require("./Exchange/ConnectData/Binance"), exports);
+exports.BaseTypes = require("./Common/BaseTypes");
+exports.Common = require("./Common/Common");
+exports.Time = require("./Common/Time");
+exports.Color = require("./Common/Color");
+exports.ListNodeAnd = require("./Common/ListNodeAnd");
+exports.Math = require("./Common/Math");
+exports.List = require("./Common/List");
+exports.LoadCandles = require("./Exchange/ConnectData/Binance");
+const ListNodeAnd_1 = require("./Common/ListNodeAnd");
 function test() {
     const tt = new ListNodeAnd_1.CListNodeAnd();
     console.log("test");
-    console.log("lalalal this is client");
+    console.log("lalalal");
 }
 exports.test = test;
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "wenay-common",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "math math math",
   "strict": true,
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "build:client": "tsc",
+    "build:server": "tsc",
     "test": "",
     "prepare": "npm run build",
     "prepublishOnly": "npm test"

package/lib/src/Common/BaseTypes.d.ts

@@ -1,38 +0,0 @@
-export type Immutable<T> = ReadonlyFull<T> & {
-    readonly Mutable: false;
-};
-export type ReadonlyFull<T> = T extends ((...args: any) => any) ? T : T extends number | string | boolean | symbol ? T : T extends const_Date ? const_Date : {
-    readonly [P in keyof T]: ReadonlyFull<T[P]>;
-};
-export type MutableFull<T> = T extends ((...args: any) => any) ? T : T extends number | string | boolean | symbol ? T : T extends const_Date ? const_Date : {
-    -readonly [P in keyof T]: MutableFull<T[P]>;
-};
-export type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-export type const_Date = Omit<Date, "setTime" | "setFullYear" | "setMonth" | "setDate" | "setHours" | "setMinutes" | "setSeconds" | "setMilliseconds" | "setUTCFullYear" | "setUTCMonth" | "setUTCDate" | "setUTCHours" | "setUTCMinutes" | "setUTCSeconds" | "setUTCMilliseconds">;
-export interface DateConstructor {
-    new (value: number | string | Date | const_Date): Date;
-}
-export declare var Date: DateConstructor;
-export interface ArrayConstructor {
-    isArray<T>(a: unknown): a is readonly unknown[];
-    isArray<T>(a: readonly T[]): a is readonly T[];
-    isArray<T>(a: T[]): a is T[];
-}
-export type ReplaceKeyType<Struct extends object, Key extends keyof Struct, NewType> = {
-    [key in keyof Struct]: key extends Key ? NewType : Struct[key];
-};
-export type KeysByTypeUnchecked<T, PickT> = {
-    [key in keyof T]: T[key] extends PickT ? key : never;
-}[keyof T];
-export type KeysByType<T, PickT extends T[keyof T]> = {
-    [key in keyof T]: T[key] extends PickT ? key : never;
-}[keyof T];
-export type KeysWithoutType<T, ExcludeT> = {
-    [key in keyof T]: T[key] extends ExcludeT ? never : key;
-}[keyof T];
-export type OmitTypes<T, ExcludeT> = Pick<T, KeysWithoutType<T, ExcludeT>>;
-export type PickTypes<T, PickT extends T[keyof T]> = Pick<T, KeysByType<T, PickT>>;
-export type PickTypesUnchecked<T, PickT> = Pick<T, KeysByTypeUnchecked<T, PickT>>;
-export type RequiredExcept<T, E extends keyof T> = Required<Omit<T, E>> & Pick<T, E>;

package/lib/src/Common/BaseTypes.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=BaseTypes.js.map

package/lib/src/Common/BaseTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BaseTypes.js","sourceRoot":"","sources":["../../../src/Common/BaseTypes.ts"],"names":[],"mappings":""}

package/lib/src/Common/ByteStream.d.ts

@@ -1,96 +0,0 @@
-import { const_Date } from "./BaseTypes";
-export type NumericTypes = "int8" | "int16" | "int24" | "int32" | "int48" | "int64" | "float" | "double" | "uint8" | "uint16" | "uint24" | "uint32" | "uint48" | "uint64";
-export declare class Nullable<T extends NumericTypes> {
-    value: T;
-    constructor(type: T);
-}
-export declare function nullable(type: NumericTypes): Nullable<NumericTypes>;
-export type WritableToBytes = {
-    write(stream: ByteStreamW): boolean | void;
-};
-export declare class ByteStreamW {
-    protected _view: DataView;
-    protected _pos: number;
-    protected _isThrowable: boolean;
-    protected _buffer(): ArrayBuffer;
-    protected resize(size: number): void;
-    constructor(view?: DataView);
-    get length(): number;
-    get data(): Readonly<DataView>;
-    noThrow(): ByteStreamW;
-    private _ensureAllocation;
-    private _setInt8;
-    private _setInt16;
-    private _setInt32;
-    protected _push(value: number, bytes: number, isInteger: boolean): this;
-    pushInt8(value: number): this;
-    pushInt16(value: number): this;
-    pushInt24(value: number): this;
-    pushInt32(value: number): this;
-    pushInt48(value: number): this;
-    pushInt64(value: number): this;
-    pushFloat(value: number): this;
-    pushDouble(value: number): this;
-    pushBool(value: boolean): this;
-    pushDate(value: const_Date): this;
-    private _checkResult;
-    push(obj: WritableToBytes): this | null;
-    pushNullable(obj: WritableToBytes | null): this | null;
-    pushNumber(value: number, type: NumericTypes | Nullable<NumericTypes>): boolean;
-    pushNumbers(values: readonly number[], type: NumericTypes | Nullable<NumericTypes>): this | null;
-    pushArrayByFunc<T>(array: Iterable<T>, func: (stream: ByteStreamW, item: T) => boolean | void, maxlength?: number): this | null;
-    protected _getWriteFuncForNumeric(type: NumericTypes | Nullable<NumericTypes>): (stream: ByteStreamW, value: number) => boolean;
-    pushArrayNumeric(array: Iterable<number>, type: NumericTypes | Nullable<NumericTypes>, maxlength?: number): this | null;
-    pushArray<T extends WritableToBytes>(array: Iterable<T> | Int8Array | Uint8Array, maxlength?: number): this | null;
-    pushArrayOfNullable<T extends WritableToBytes | null>(array: Iterable<T>, maxlength?: number): this | null;
-    private _pushNullableString;
-    pushAnsi(text: string | null): this;
-    pushUnicode(text: string | null): this;
-}
-type ReaderFromBytes<T> = {
-    read(stream: ByteStreamR | any): T;
-};
-declare class ByteStreamR_<throwable extends boolean> {
-    protected _wstream?: Readonly<ByteStreamW>;
-    protected _view: Readonly<DataView>;
-    protected _pos: number;
-    private isThrowable;
-    constructor(data: Readonly<ArrayBuffer | DataView>);
-    UpdateFrom(stream: Readonly<ByteStreamW>): void;
-    private __readNumber;
-    _readNumber(bytes: number, isInteger: boolean, isSigned?: boolean): throwable extends true ? number : number | null;
-    noThrow(): ByteStreamR_<false>;
-    readInt8(): throwable extends true ? number : number | null;
-    readInt16(): throwable extends true ? number : number | null;
-    readInt24(): throwable extends true ? number : number | null;
-    readInt32(): throwable extends true ? number : number | null;
-    readInt48(): throwable extends true ? number : number | null;
-    readInt64(): throwable extends true ? number : number | null;
-    readUint8(): throwable extends true ? number : number | null;
-    readUint16(): throwable extends true ? number : number | null;
-    readUint24(): throwable extends true ? number : number | null;
-    readUint32(): throwable extends true ? number : number | null;
-    readUint48(): throwable extends true ? number : number | null;
-    readUint64(): throwable extends true ? number : number | null;
-    readFloat(): throwable extends true ? number : number | null;
-    readDouble(): throwable extends true ? number : number | null;
-    readBool(): throwable extends true ? boolean : boolean | null;
-    readNumber(type: NumericTypes | Nullable<NumericTypes>): throwable extends true ? number : number | null;
-    readDate(): Date;
-    toType<T>(value: T): throwable extends true ? T : T | null;
-    protected _getReadFuncForNumeric<T extends NumericTypes | Nullable<NumericTypes>>(type: T): (stream: ByteStreamR_<throwable>) => throwable extends true ? number : T extends NumericTypes ? number : number | null;
-    readNullable<T>(reader: ReaderFromBytes<NonNullable<T>>): NonNullable<T> | null;
-    readArray<T>(func: (stream: ByteStreamR) => NonNullable<T>): T[];
-    readArray<T extends NumericTypes | Nullable<NumericTypes>>(type: T): T extends NumericTypes ? number[] : (number | null)[];
-    readArray<T>(reader: ReaderFromBytes<NonNullable<T>>): T[];
-    protected _readArrayByFunc<T>(func: (stream: ByteStreamR | any) => T): T[] | null;
-    protected _readArrayOfNumeric(type: NumericTypes): (throwable extends true ? number : number)[] | null;
-    protected _readArrayByReader<T>(reader: ReaderFromBytes<T>): T[] | null;
-    private _readNullableString;
-    readAnsi(): string | null;
-    readUnicode(): string | null;
-}
-export declare class ByteStreamR extends ByteStreamR_<true> {
-    constructor(data: Readonly<ArrayBuffer | DataView>);
-}
-export {};

package/lib/src/Common/ByteStream.js

@@ -1,427 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ByteStreamR = exports.ByteStreamW = exports.nullable = exports.Nullable = void 0;
-function createCopyOfBuffer(src, length = src.byteLength) {
-    let dst = new ArrayBuffer(length);
-    new Uint8Array(dst).set(new Uint8Array(src));
-    return dst;
-}
-class Nullable {
-    value;
-    constructor(type) { this.value = type; }
-}
-exports.Nullable = Nullable;
-function nullable(type) { return new Nullable(type); }
-exports.nullable = nullable;
-function __getNumericTypeInfo(type) {
-    switch (type) {
-        case "int8": return [1];
-        case "uint8": return [1, false];
-        case "int16": return [2];
-        case "uint16": return [2, false];
-        case "int24": return [3];
-        case "uint24": return [3, false];
-        case "int32": return [4];
-        case "uint32": return [4, false];
-        case "int48": return [6];
-        case "uint48": return [6, false];
-        case "int64": return [8];
-        case "uint64": return [8, false];
-        case "float": return [4, true, false];
-        case "double": return [8, true, false];
-        default: throw "wrong type: " + type;
-    }
-}
-;
-function getNumericTypeInfo(type) {
-    let [size, signed = true, integer = true] = __getNumericTypeInfo(type) ?? [0];
-    if (!size)
-        return null;
-    return { size, signed, integer };
-}
-class ByteStreamW {
-    _view = new DataView(new ArrayBuffer(0));
-    _pos = 0;
-    _isThrowable = true;
-    _buffer() { return this._view?.buffer; }
-    resize(size) { let buf = createCopyOfBuffer(this._buffer(), size); this._view = new DataView(buf); }
-    constructor(view) { this.resize(0); }
-    get length() { return this._pos; }
-    get data() { return new DataView(this._buffer(), 0, this._pos); }
-    noThrow() { let other = new ByteStreamW(this._view); other._pos = this._pos; other._isThrowable = false; return other; }
-    _ensureAllocation(bytes) {
-        let minSize = this._pos + bytes;
-        if (minSize > this._view.byteLength)
-            for (let extraSize = Math.max(minSize * 0.5, 32); extraSize >= 0; extraSize /= 2) {
-                try {
-                    this.resize(minSize + extraSize);
-                    break;
-                }
-                catch (e) {
-                    if (extraSize < 1)
-                        throw (e);
-                }
-            }
-    }
-    _setInt8(pos, value) { if ((value & 1 << 7) != 0)
-        this._view.setInt8(pos, value);
-    else
-        this._view.setUint8(pos, value); }
-    _setInt16(pos, value) { if ((value & 1 << 15) != 0)
-        this._view.setInt16(pos, value);
-    else
-        this._view.setUint16(pos, value); }
-    _setInt32(pos, value) { if ((value & 1 << 31) != 0)
-        this._view.setInt32(pos, value);
-    else
-        this._view.setUint32(pos, value); }
-    _push(value, bytes, isInteger) {
-        let pos = this._pos;
-        this._ensureAllocation(bytes);
-        let view = this._view;
-        if (isNaN(value))
-            throw "Failed to save NaN";
-        if (isInteger && !Number.isInteger(value))
-            throw "Failed to save value " + value + " as integer";
-        if (isInteger)
-            switch (bytes) {
-                case 1:
-                    this._setInt8(pos, value);
-                    break;
-                case 2:
-                    this._setInt16(pos, value);
-                    break;
-                case 3:
-                    this._setInt16(pos, value);
-                    this._setInt8(pos + 2, value >> 16);
-                    break;
-                case 4:
-                    this._setInt32(pos, value);
-                    break;
-                case 6:
-                    this._setInt32(pos, value);
-                    this._setInt16(pos + 4, value / 0x10000000);
-                    break;
-                case 8:
-                    this._setInt32(pos, value);
-                    this._setInt32(pos + 4, value / 0x10000000);
-                    break;
-                default: throw ("Wrong byte length: " + bytes);
-            }
-        else
-            switch (bytes) {
-                case 4:
-                    view.setFloat32(pos, value);
-                    break;
-                case 8:
-                    view.setFloat64(pos, value);
-                    break;
-                default: throw ("Wrong byte length: " + bytes);
-            }
-        this._pos += bytes;
-        return this;
-    }
-    pushInt8(value) { return this._push(value, 1, true); }
-    pushInt16(value) { return this._push(value, 2, true); }
-    pushInt24(value) { return this._push(value, 3, true); }
-    pushInt32(value) { return this._push(value, 4, true); }
-    pushInt48(value) { return this._push(value, 6, true); }
-    pushInt64(value) { return this._push(value, 8, true); }
-    pushFloat(value) { return this._push(value, 4, false); }
-    pushDouble(value) { return this._push(value, 8, false); }
-    pushBool(value) { return this.pushInt8(value == true ? 1 : 0); }
-    pushDate(value) { return this.pushInt64(value.valueOf()); }
-    _checkResult(result, msg) { if (result == false && this._isThrowable)
-        throw ("Failed to write " + msg); return result != false; }
-    push(obj) { let ok = obj.write(this); return this._checkResult(ok, () => "object") ? this : null; }
-    pushNullable(obj) { let ok = this.pushBool(obj != null) ? obj?.write(this) : false; return this._checkResult(ok, () => "object") ? this : null; }
-    pushNumber(value, type) { return this._getWriteFuncForNumeric(type)(this, value); }
-    pushNumbers(values, type) { for (let value of values)
-        if (!this.pushNumber(value, type))
-            return null; return this; }
-    pushArrayByFunc(array, func, maxlength) {
-        let oldpos = this._pos;
-        this.pushInt32(0);
-        let i = 0;
-        for (let value of array) {
-            if (func(this, value) == false)
-                if (this._isThrowable)
-                    throw ("Failed to write array item №" + i);
-                else
-                    return null;
-            i++;
-            if (i === maxlength)
-                break;
-        }
-        this._view.setUint32(oldpos, i);
-        return this;
-    }
-    _getWriteFuncForNumeric(type) {
-        let isNullable = false;
-        if (type instanceof Nullable) {
-            type = type.value;
-            isNullable = true;
-        }
-        let typeInfo = getNumericTypeInfo(type);
-        if (!typeInfo)
-            throw ("Wrong type: " + type);
-        return (stream, value) => { return (isNullable ? stream.pushBool(value != null) : stream)?._push(value, typeInfo.size, typeInfo.integer) != null; };
-    }
-    pushArrayNumeric(array, type, maxlength) {
-        return this.pushArrayByFunc(array, this._getWriteFuncForNumeric(type), maxlength);
-    }
-    pushArray(array, maxlength) {
-        if (array instanceof Int8Array || array instanceof Uint8Array) {
-            let length = Math.min(array.length, maxlength ?? array.length);
-            this._ensureAllocation(length + 4);
-            this.pushInt32(length);
-            let arrayClass = (array instanceof Int8Array) ? Int8Array : Uint8Array;
-            if (length != array.length)
-                array = new arrayClass(array, 0, length);
-            new arrayClass(this._buffer()).set(array, this._pos);
-            return this;
-        }
-        let func = (stream, item) => item.write(stream) != false;
-        return this.pushArrayByFunc(array, func, maxlength);
-    }
-    pushArrayOfNullable(array, maxlength) {
-        let func = (stream, item) => stream.pushBool(item != null) && item?.write(stream) != false;
-        return this.pushArrayByFunc(array, func, maxlength);
-    }
-    _pushNullableString(text, charSize) {
-        this.pushBool(text != null);
-        if (text == null)
-            return this;
-        let length = text.length;
-        let p = this._pos;
-        this._ensureAllocation((length + 1) * charSize);
-        if (charSize == 1) {
-            for (let i = 0; i < length; i++) {
-                this._view.setUint8(this._pos, text.charCodeAt(i));
-                this._pos++;
-            }
-            this._view.setUint8(this._pos, 0);
-        }
-        else {
-            for (let i = 0; i < length; i++) {
-                this._view.setUint16(this._pos, text.charCodeAt(i));
-                this._pos += 2;
-            }
-            this._view.setUint16(this._pos, 0);
-        }
-        this._pos += charSize;
-        return this;
-    }
-    pushAnsi(text) { return this._pushNullableString(text, 1); }
-    pushUnicode(text) { return this._pushNullableString(text, 2); }
-}
-exports.ByteStreamW = ByteStreamW;
-class ByteStreamR_ {
-    _wstream;
-    _view;
-    _pos = 0;
-    isThrowable = true;
-    constructor(data) { this._view = (data instanceof ArrayBuffer) ? new DataView(data) : data; }
-    UpdateFrom(stream) {
-        console.assert(stream != null);
-        if (stream != this._wstream)
-            if (!this._wstream)
-                this._wstream = stream;
-            else
-                throw ("Stream is not same as before!");
-        this._view = stream.data;
-    }
-    __readNumber(bytes, isInteger, isSigned = true) {
-        let pos = this._pos;
-        let view = this._view;
-        if (pos + bytes > view.byteLength)
-            if (this.isThrowable) {
-                console.trace();
-                throw ("Not enough stream size for reading a value");
-            }
-            else
-                return null;
-        let value = function () {
-            if (isInteger) {
-                if (isSigned) {
-                    switch (bytes) {
-                        case 1: return view.getInt8(pos);
-                        case 2: return view.getInt16(pos);
-                        case 3: return view.getInt16(pos) | (view.getInt8(pos + 2) << 16);
-                        case 4: return view.getInt32(pos);
-                        case 6: return view.getInt32(pos) | view.getInt16(pos + 4) * 0x10000000;
-                        case 8: return view.getInt32(pos) | view.getInt32(pos + 4) * 0x10000000;
-                    }
-                }
-                else {
-                    switch (bytes) {
-                        case 1: return view.getUint8(pos);
-                        case 2: return view.getUint16(pos);
-                        case 3: return view.getUint16(pos) | (view.getUint8(pos + 2) << 16);
-                        case 4: return view.getUint32(pos);
-                        case 6: return view.getUint32(pos) | view.getUint16(pos + 4) * 0x10000000;
-                        case 8: return view.getUint32(pos) | view.getUint32(pos + 4) * 0x10000000;
-                    }
-                }
-            }
-            else
-                switch (bytes) {
-                    case 4: return view.getFloat32(pos);
-                    case 8: return view.getFloat64(pos);
-                }
-            return null;
-        }();
-        if (value == null)
-            if (this.isThrowable)
-                throw ("Wrong byte length: " + bytes);
-            else
-                return null;
-        this._pos += bytes;
-        return value;
-    }
-    _readNumber(bytes, isInteger, isSigned = true) { return this.__readNumber(bytes, isInteger, isSigned); }
-    noThrow() { if (!this.isThrowable)
-        return this; let other = new ByteStreamR_(this._view); other._pos = this._pos; other.isThrowable = false; return other; }
-    readInt8() { return this._readNumber(1, true); }
-    readInt16() { return this._readNumber(2, true); }
-    readInt24() { return this._readNumber(3, true); }
-    readInt32() { return this._readNumber(4, true); }
-    readInt48() { return this._readNumber(6, true); }
-    readInt64() { return this._readNumber(8, true); }
-    readUint8() { return this._readNumber(1, true, false); }
-    readUint16() { return this._readNumber(2, true, false); }
-    readUint24() { return this._readNumber(3, true, false); }
-    readUint32() { return this._readNumber(4, true, false); }
-    readUint48() { return this._readNumber(6, true, false); }
-    readUint64() { return this._readNumber(8, true, false); }
-    readFloat() { return this._readNumber(4, false); }
-    readDouble() { return this._readNumber(8, false); }
-    readBool() { let res = this.readInt8(); return (res != null ? res != 0 : null); }
-    readNumber(type) { return this._getReadFuncForNumeric(type)(this); }
-    readDate() { return new Date(this.readInt64() ?? 0); }
-    toType(value) { return value; }
-    _getReadFuncForNumeric(type) {
-        let [isNullable, numType] = (type instanceof Nullable) ? [true, type.value] : [false, type];
-        let typeInfo = getNumericTypeInfo(numType);
-        if (!typeInfo)
-            throw ("Wrong type: " + type);
-        return ((stream) => { if (!isNullable || stream.readBool())
-            return stream.__readNumber(typeInfo.size, typeInfo.integer, typeInfo.signed); return null; });
-    }
-    readNullable(reader) { return this.readBool() ? reader.read(this) : null; }
-    readArray(arg) {
-        if (typeof arg == "string" || arg instanceof Nullable)
-            return this._readArrayOfNumeric(arg);
-        if (0)
-            return [arg.read(this)];
-        if (arg instanceof Function)
-            if (arg.hasOwnProperty("read"))
-                return this._readArrayByReader(arg);
-            else
-                return this._readArrayByFunc(arg);
-        else if ("read" in arg)
-            return this._readArrayByReader(arg);
-        throw ("Wrong argument in readArray");
-    }
-    _readArrayByFunc(func) {
-        let size = this.readUint32();
-        if (size == null)
-            return null;
-        let array = new Array(size);
-        for (let i = 0; i < size; i++)
-            array[i] = func(this);
-        return array;
-    }
-    _readArrayOfNumeric(type) {
-        if (type == "int8" || type == "uint8") {
-            let arrayClass = type == "int8" ? Int8Array : Uint8Array;
-            let size = this.readUint32();
-            if (size == null)
-                return null;
-            let bufpos = this._view.byteOffset + this._pos;
-            new arrayClass(this._view.buffer.slice(bufpos, bufpos + size));
-        }
-        return this._readArrayByFunc(this._getReadFuncForNumeric(type));
-    }
-    _readArrayByReader(reader) { return this._readArrayByFunc(reader.read); }
-    _readNullableString(charSize) {
-        if (!this.readBool())
-            return null;
-        let chars = [];
-        let nullTerminated = false;
-        if (charSize == 1) {
-            for (; this._pos < this._view.byteLength; this._pos++) {
-                let char = this._view.getUint8(this._pos);
-                if (char != 0)
-                    chars.push(char);
-                else {
-                    nullTerminated = true;
-                    break;
-                }
-            }
-        }
-        else {
-            for (; this._pos < this._view.byteLength; this._pos += 2) {
-                let char = this._view.getUint16(this._pos);
-                if (char != 0)
-                    chars.push(char);
-                else {
-                    nullTerminated = true;
-                    break;
-                }
-            }
-        }
-        if (!nullTerminated)
-            throw "Can't get null-terminated string!";
-        this._pos += charSize;
-        return String.fromCharCode(...chars);
-    }
-    readAnsi() { return this._readNullableString(1); }
-    readUnicode() { return this._readNullableString(2); }
-}
-;
-class ByteStreamR extends ByteStreamR_ {
-    constructor(data) { super(data); }
-}
-exports.ByteStreamR = ByteStreamR;
-;
-function Test() {
-    class A {
-        a;
-        b;
-        write(stream) { stream.pushDouble(this.a).pushDouble(this.b); }
-        constructor(a, b) { this.a = a; this.b = b; }
-        static read(stream) { let [a, b] = [stream.readDouble(), stream.readDouble()]; return new A(a, b); }
-    }
-    let stream = new ByteStreamW;
-    stream.pushInt16(1000);
-    stream.pushInt8(150);
-    stream.pushInt24(100000);
-    stream.pushInt32(90000000);
-    stream.pushFloat(0.5);
-    stream.pushDouble(0.05);
-    stream.pushArrayNumeric([1, 2, 3, 4, 5], "int16");
-    stream.pushUnicode("myString");
-    stream.pushAnsi("myString");
-    stream.pushArray([new A(33, 44), new A(55, 66)]);
-    console.log(stream);
-    let rstream = new ByteStreamR(stream.data);
-    let result = [
-        rstream.readInt16(),
-        rstream.readInt8(),
-        rstream.readInt24(),
-        rstream.readInt32(),
-        rstream.readFloat(),
-        rstream.readDouble(),
-        rstream.readArray("int16"),
-        rstream.readUnicode(),
-        rstream.readAnsi(),
-        rstream.readArray(A.read),
-    ];
-    console.log(result);
-}
-class X {
-    fff(arg) { }
-}
-let x = new X;
-//# sourceMappingURL=ByteStream.js.map