phantasma-sdk-ts 0.7.0 → 0.8.0

package/dist/esm/types/contract.js

@@ -0,0 +1,363 @@
+import { VMType } from '../vm/vm-type.js';
+import { arrayNumberToUint8Array, uint8ArrayToNumberArray } from '../utils/index.js';
+import { PBinaryReader, PBinaryWriter } from './extensions/index.js';
+export class ContractParameter {
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+}
+export class ContractInterface {
+    get methods() {
+        return Array.from(this._methods.values());
+    }
+    set methods(value) {
+        this._methods = new Map();
+        for (const entry of value) {
+            this._methods.set(entry.name, entry);
+        }
+    }
+    /** @deprecated Use `methods` instead. This alias will be removed in v1.0. */
+    get Methods() {
+        return this.methods;
+    }
+    set Methods(value) {
+        this.methods = value;
+    }
+    get methodCount() {
+        return this._methods.size;
+    }
+    /** @deprecated Use `methodCount` instead. This alias will be removed in v1.0. */
+    get MethodCount() {
+        return this.methodCount;
+    }
+    set MethodCount(_value) {
+        // Compatibility no-op: the method count is derived from the method map.
+    }
+    get events() {
+        return this._events;
+    }
+    set events(value) {
+        this._events = value;
+    }
+    /** @deprecated Use `events` instead. This alias will be removed in v1.0. */
+    Events() {
+        return this.events;
+    }
+    get eventCount() {
+        return this._events.length;
+    }
+    /** @deprecated Use `eventCount` instead. This alias will be removed in v1.0. */
+    EventCount() {
+        return this.eventCount;
+    }
+    newEmpty() {
+        this._methods = new Map();
+        this._events = [];
+    }
+    constructor(methods = [], events = []) {
+        this._methods = new Map();
+        // Keep legacy public fields visible to reflection/spread consumers while
+        // deriving their values from the canonical method map.
+        Object.defineProperties(this, {
+            Methods: {
+                configurable: true,
+                enumerable: true,
+                get: () => this.methods,
+                set: (value) => {
+                    this.methods = value;
+                },
+            },
+            MethodCount: {
+                configurable: true,
+                enumerable: true,
+                get: () => this.methodCount,
+                set: () => {
+                    // Compatibility no-op: the method count is derived from the method map.
+                },
+            },
+        });
+        for (const entry of methods) {
+            this._methods.set(entry.name, entry);
+        }
+        this._events = events;
+    }
+    get(name) {
+        return this.findMethod(name);
+    }
+    hasMethod(name) {
+        return this._methods.has(name);
+    }
+    /** @deprecated Use `hasMethod` instead. This alias will be removed in v1.0. */
+    HasMethod(name) {
+        return this.hasMethod(name);
+    }
+    hasTokenTrigger(trigger) {
+        const strName = trigger.toString();
+        const name = strName[0].toLowerCase() + strName.slice(1);
+        return this._methods.has(name);
+    }
+    /** @deprecated Use `hasTokenTrigger` instead. This alias will be removed in v1.0. */
+    HasTokenTrigger(trigger) {
+        return this.hasTokenTrigger(trigger);
+    }
+    findMethod(name) {
+        return this._methods.get(name) ?? null;
+    }
+    /** @deprecated Use `findMethod` instead. This alias will be removed in v1.0. */
+    FindMethod(name) {
+        return this.findMethod(name);
+    }
+    findEvent(value) {
+        for (const evt of this._events) {
+            if (evt.value === value) {
+                return evt;
+            }
+        }
+        return null;
+    }
+    /** @deprecated Use `findEvent` instead. This alias will be removed in v1.0. */
+    FindEvent(value) {
+        return this.findEvent(value);
+    }
+    implementsEvent(evt) {
+        for (const entry of this.events) {
+            if (entry.name === evt.name &&
+                entry.value === evt.value &&
+                entry.returnType === evt.returnType) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @deprecated Use `implementsEvent` instead. This alias will be removed in v1.0. */
+    ImplementsEvent(evt) {
+        return this.implementsEvent(evt);
+    }
+    implementsMethod(method) {
+        const thisMethod = this._methods.get(method.name);
+        if (thisMethod === undefined) {
+            return false;
+        }
+        if (thisMethod.parameters.length !== method.parameters.length) {
+            return false;
+        }
+        for (let i = 0; i < method.parameters.length; i++) {
+            if (thisMethod.parameters[i].type !== method.parameters[i].type) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** @deprecated Use `implementsMethod` instead. This alias will be removed in v1.0. */
+    ImplementsMethod(method) {
+        return this.implementsMethod(method);
+    }
+    implementsInterface(other) {
+        for (const method of other.methods) {
+            if (!this.implementsMethod(method)) {
+                return false;
+            }
+        }
+        for (const evt of other.events) {
+            if (!this.implementsEvent(evt)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** @deprecated Use `implementsInterface` instead. This alias will be removed in v1.0. */
+    ImplementsInterface(other) {
+        return this.implementsInterface(other);
+    }
+    unserializeData(reader) {
+        const len = reader.readByte();
+        this._methods.clear();
+        for (let i = 0; i < len; i++) {
+            const method = ContractMethod.deserialize(reader);
+            this._methods.set(method.name, method);
+        }
+        const eventLen = reader.readByte();
+        this._events = [];
+        for (let i = 0; i < eventLen; i++) {
+            this._events.push(ContractEvent.deserialize(reader));
+        }
+    }
+    /** @deprecated Use `unserializeData` instead. This alias will be removed in v1.0. */
+    UnserializeData(reader) {
+        this.unserializeData(reader);
+    }
+    serializeData(writer) {
+        writer.writeByte(this._methods.size);
+        for (const value of this._methods.values()) {
+            value.serialize(writer);
+        }
+        writer.writeByte(this._events.length);
+        for (const entry of this._events) {
+            entry.serialize(writer);
+        }
+    }
+    /** @deprecated Use `serializeData` instead. This alias will be removed in v1.0. */
+    SerializeData(writer) {
+        this.serializeData(writer);
+    }
+}
+ContractInterface.empty = new ContractInterface([], []);
+/** @deprecated Use `empty` instead. This alias will be removed in v1.0. */
+ContractInterface.Empty = ContractInterface.empty;
+export class ContractMethod {
+    serializeData(writer) {
+        this.serialize(writer);
+    }
+    /** @deprecated Use `serializeData` instead. This alias will be removed in v1.0. */
+    SerializeData(writer) {
+        this.serializeData(writer);
+    }
+    unserializeData(reader) {
+        const restored = ContractMethod.deserialize(reader);
+        this.name = restored.name;
+        this.returnType = restored.returnType;
+        this.offset = restored.offset;
+        this.parameters = restored.parameters;
+    }
+    /** @deprecated Use `unserializeData` instead. This alias will be removed in v1.0. */
+    UnserializeData(reader) {
+        this.unserializeData(reader);
+    }
+    constructorOne(name, returnType, labels, parameters) {
+        if (!labels.has(name)) {
+            throw new Error(`Missing offset in label map for method ${name}`);
+        }
+        const offset = labels.get(name);
+        if (offset === undefined) {
+            throw new Error(`Missing offset in label map for method ${name}`);
+        }
+        this.name = name;
+        this.offset = offset;
+        this.returnType = returnType;
+        this.parameters = parameters;
+    }
+    constructor(name = '', returnType = VMType.None, offset = 0, parameters = []) {
+        this.name = name;
+        this.offset = offset;
+        this.returnType = returnType;
+        this.parameters = parameters;
+    }
+    isProperty() {
+        if (this.name.length >= 4 &&
+            this.name.startsWith('get') &&
+            this.name[3] === this.name[3].toUpperCase()) {
+            return true;
+        }
+        if (this.name.length >= 3 &&
+            this.name.startsWith('is') &&
+            this.name[2] === this.name[2].toUpperCase()) {
+            return true;
+        }
+        return false;
+    }
+    isTrigger() {
+        if (this.name.length >= 3 &&
+            this.name.startsWith('on') &&
+            this.name[2] === this.name[2].toUpperCase()) {
+            return true;
+        }
+        return false;
+    }
+    toString() {
+        return `${this.name} : ${this.returnType}`;
+    }
+    static fromBytes(bytes) {
+        const stream = new Uint8Array(bytes);
+        const reader = new PBinaryReader(stream);
+        return ContractMethod.deserialize(reader);
+    }
+    static deserialize(reader) {
+        const name = reader.readString();
+        const returnType = reader.readByte();
+        const offset = reader.readInt();
+        const len = reader.readByte();
+        const parameters = new Array(len);
+        for (let i = 0; i < len; i++) {
+            const pName = reader.readString();
+            const pVMType = reader.readByte();
+            parameters[i] = new ContractParameter(pName, pVMType);
+        }
+        return new ContractMethod(name, returnType, offset, parameters);
+    }
+    /** @deprecated Use `deserialize` instead. This alias will be removed in v1.0. */
+    static Unserialize(reader) {
+        return ContractMethod.deserialize(reader);
+    }
+    serialize(writer) {
+        writer.writeString(this.name);
+        writer.writeByte(this.returnType);
+        writer.writeInt(this.offset);
+        writer.writeByte(this.parameters.length);
+        this.parameters.forEach((entry) => {
+            writer.writeString(entry.name);
+            writer.writeByte(entry.type);
+        });
+    }
+    /** @deprecated Use `serialize` instead. This alias will be removed in v1.0. */
+    Serialize(writer) {
+        this.serialize(writer);
+    }
+    toArray() {
+        const stream = new Uint8Array();
+        const writer = new PBinaryWriter(stream);
+        this.serialize(writer);
+        return stream;
+    }
+}
+export class ContractEvent {
+    constructor(value = 0, name = '', returnType = VMType.None, description = new Uint8Array()) {
+        this.value = value;
+        this.name = name;
+        this.returnType = returnType;
+        this.description = description;
+    }
+    serializeData(writer) {
+        this.serialize(writer);
+    }
+    /** @deprecated Use `serializeData` instead. This alias will be removed in v1.0. */
+    SerializeData(writer) {
+        this.serializeData(writer);
+    }
+    unserializeData(reader) {
+        const restored = ContractEvent.deserialize(reader);
+        this.value = restored.value;
+        this.name = restored.name;
+        this.returnType = restored.returnType;
+        this.description = restored.description;
+    }
+    /** @deprecated Use `unserializeData` instead. This alias will be removed in v1.0. */
+    UnserializeData(reader) {
+        this.unserializeData(reader);
+    }
+    toString() {
+        return `${this.name} : ${this.returnType} => ${this.value}`;
+    }
+    static deserialize(reader) {
+        const value = reader.readByte();
+        const name = reader.readString();
+        const returnType = reader.readByte();
+        const description = reader.readBytes(reader.readByte());
+        return new ContractEvent(value, name, returnType, arrayNumberToUint8Array(description));
+    }
+    /** @deprecated Use `deserialize` instead. This alias will be removed in v1.0. */
+    static Unserialize(reader) {
+        return ContractEvent.deserialize(reader);
+    }
+    serialize(writer) {
+        writer.writeByte(this.value);
+        writer.writeString(this.name);
+        writer.writeByte(this.returnType);
+        writer.writeByte(this.description.length);
+        writer.writeBytes(uint8ArrayToNumberArray(this.description));
+    }
+    /** @deprecated Use `serialize` instead. This alias will be removed in v1.0. */
+    Serialize(writer) {
+        this.serialize(writer);
+    }
+}

package/dist/esm/types/domain-settings.js

@@ -0,0 +1,100 @@
+export var TriggerResult;
+(function (TriggerResult) {
+    TriggerResult[TriggerResult["Failure"] = 0] = "Failure";
+    TriggerResult[TriggerResult["Missing"] = 1] = "Missing";
+    TriggerResult[TriggerResult["Success"] = 2] = "Success";
+})(TriggerResult || (TriggerResult = {}));
+export var AccountTrigger;
+(function (AccountTrigger) {
+    AccountTrigger[AccountTrigger["OnMint"] = 0] = "OnMint";
+    AccountTrigger[AccountTrigger["OnBurn"] = 1] = "OnBurn";
+    AccountTrigger[AccountTrigger["OnSend"] = 2] = "OnSend";
+    AccountTrigger[AccountTrigger["OnReceive"] = 3] = "OnReceive";
+    AccountTrigger[AccountTrigger["OnWitness"] = 4] = "OnWitness";
+    AccountTrigger[AccountTrigger["OnUpgrade"] = 5] = "OnUpgrade";
+    AccountTrigger[AccountTrigger["OnMigrate"] = 6] = "OnMigrate";
+    AccountTrigger[AccountTrigger["OnKill"] = 7] = "OnKill";
+})(AccountTrigger || (AccountTrigger = {}));
+export var TokenTrigger;
+(function (TokenTrigger) {
+    TokenTrigger[TokenTrigger["OnMint"] = 0] = "OnMint";
+    TokenTrigger[TokenTrigger["OnBurn"] = 1] = "OnBurn";
+    TokenTrigger[TokenTrigger["OnSend"] = 2] = "OnSend";
+    TokenTrigger[TokenTrigger["OnReceive"] = 3] = "OnReceive";
+    TokenTrigger[TokenTrigger["OnInfuse"] = 4] = "OnInfuse";
+    TokenTrigger[TokenTrigger["OnUpgrade"] = 5] = "OnUpgrade";
+    TokenTrigger[TokenTrigger["OnSeries"] = 6] = "OnSeries";
+    TokenTrigger[TokenTrigger["OnWrite"] = 7] = "OnWrite";
+    TokenTrigger[TokenTrigger["OnMigrate"] = 8] = "OnMigrate";
+    TokenTrigger[TokenTrigger["OnKill"] = 9] = "OnKill";
+})(TokenTrigger || (TokenTrigger = {}));
+export var OrganizationTrigger;
+(function (OrganizationTrigger) {
+    OrganizationTrigger[OrganizationTrigger["OnAdd"] = 0] = "OnAdd";
+    OrganizationTrigger[OrganizationTrigger["OnRemove"] = 1] = "OnRemove";
+    OrganizationTrigger[OrganizationTrigger["OnUpgrade"] = 2] = "OnUpgrade";
+})(OrganizationTrigger || (OrganizationTrigger = {}));
+export class StakeReward {
+    constructor(staker, date) {
+        this.staker = staker;
+        this.date = date;
+    }
+}
+export class DomainSettings {
+}
+DomainSettings.LatestKnownProtocol = 19;
+DomainSettings.Phantasma20Protocol = 7;
+DomainSettings.Phantasma30Protocol = 8;
+DomainSettings.MaxTxPerBlock = 1024;
+DomainSettings.MaxOracleEntriesPerBlock = 5120;
+DomainSettings.MaxEventsPerBlock = 2048;
+DomainSettings.MaxEventsPerTx = 8096;
+DomainSettings.MaxTriggerLoop = 5;
+DomainSettings.MAX_TOKEN_DECIMALS = 18;
+DomainSettings.DefaultMinimumGasFee = 100000;
+DomainSettings.InitialValidatorCount = 4;
+DomainSettings.FuelTokenSymbol = 'KCAL';
+DomainSettings.FuelTokenName = 'Phantasma Energy';
+DomainSettings.FuelTokenDecimals = 10;
+DomainSettings.NexusMainnet = 'mainnet';
+DomainSettings.NexusTestnet = 'testnet';
+DomainSettings.StakingTokenSymbol = 'SOUL';
+DomainSettings.StakingTokenName = 'Phantasma Stake';
+DomainSettings.StakingTokenDecimals = 8;
+DomainSettings.FiatTokenSymbol = 'USD';
+DomainSettings.FiatTokenName = 'Dollars';
+DomainSettings.FiatTokenDecimals = 8;
+DomainSettings.RewardTokenSymbol = 'CROWN';
+DomainSettings.RewardTokenName = 'Phantasma Crown';
+DomainSettings.LiquidityTokenSymbol = 'LP';
+DomainSettings.LiquidityTokenName = 'Phantasma Liquidity';
+DomainSettings.LiquidityTokenDecimals = 8;
+DomainSettings.FuelPerContractDeployTag = 'nexus.contract.cost';
+DomainSettings.FuelPerTokenDeployTag = 'nexus.token.cost';
+DomainSettings.FuelPerOrganizationDeployTag = 'nexus.organization.cost';
+DomainSettings.SystemTokens = [
+    DomainSettings.FuelTokenSymbol,
+    DomainSettings.StakingTokenSymbol,
+    DomainSettings.FiatTokenSymbol,
+    DomainSettings.RewardTokenSymbol,
+    DomainSettings.LiquidityTokenSymbol,
+];
+DomainSettings.RootChainName = 'main';
+DomainSettings.ValidatorsOrganizationName = 'validators';
+DomainSettings.MastersOrganizationName = 'masters';
+DomainSettings.StakersOrganizationName = 'stakers';
+DomainSettings.PhantomForceOrganizationName = 'phantom_force';
+//public static PlatformSupply = UnitConversion.ToBigInteger(100000000, FuelTokenDecimals);
+DomainSettings.PlatformName = 'phantasma';
+DomainSettings.ArchiveMinSize = 64;
+DomainSettings.ArchiveMaxSize = 104857600;
+//public static ArchiveBlockSize = MerkleTree.ChunkSize;
+DomainSettings.InfusionName = 'infusion';
+//public static InfusionAddress = SmartContract.GetAddressFromContractName(InfusionName);
+DomainSettings.NameMaxLength = 255;
+DomainSettings.UrlMaxLength = 2048;
+DomainSettings.ArgsMax = 64;
+DomainSettings.AddressMaxSize = 34;
+DomainSettings.ScriptMaxSize = 32767;
+DomainSettings.FieldMaxLength = 80;
+DomainSettings.FieldMinLength = 1;

package/dist/esm/types/ed25519-signature.js

@@ -0,0 +1,100 @@
+import { SignatureKind } from '../interfaces/signature.js';
+import { stringToUint8Array } from '../utils/index.js';
+import { PBinaryWriter } from './extensions/index.js';
+import { signEd25519, verifyEd25519 } from './ed25519.js';
+export class Ed25519Signature {
+    constructor(bytes = new Uint8Array()) {
+        this.kind = SignatureKind.Ed25519;
+        this.bytes = bytes;
+        // Preserve the old public-field reflection shape while routing behavior to
+        // the canonical lower-camel storage. Some consumers inspect or spread SDK
+        // objects instead of only reading properties.
+        Object.defineProperties(this, {
+            Bytes: {
+                configurable: true,
+                enumerable: true,
+                get: () => this.bytes,
+                set: (value) => {
+                    this.bytes = value;
+                },
+            },
+            Kind: {
+                configurable: true,
+                enumerable: true,
+                get: () => this.kind,
+                set: (value) => {
+                    this.kind = value;
+                },
+            },
+        });
+    }
+    /** @deprecated Use `bytes` instead. This alias will be removed in v1.0. */
+    get Bytes() {
+        return this.bytes;
+    }
+    set Bytes(value) {
+        this.bytes = value;
+    }
+    /** @deprecated Use `kind` instead. This alias will be removed in v1.0. */
+    get Kind() {
+        return this.kind;
+    }
+    set Kind(value) {
+        this.kind = value;
+    }
+    verify(message, address) {
+        return this.verifyMultiple(message, [address]);
+    }
+    /** @deprecated Use `verify` instead. This alias will be removed in v1.0. */
+    Verify(message, address) {
+        return this.verify(message, address);
+    }
+    verifyMultiple(message, addresses) {
+        for (const address of addresses) {
+            if (!address.isUser) {
+                continue;
+            }
+            const pubKey = address.toByteArray().slice(2);
+            if (verifyEd25519(message, this.bytes, pubKey)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** @deprecated Use `verifyMultiple` instead. This alias will be removed in v1.0. */
+    VerifyMultiple(message, addresses) {
+        return this.verifyMultiple(message, addresses);
+    }
+    serializeData(writer) {
+        writer.writeByteArray(this.bytes);
+    }
+    /** @deprecated Use `serializeData` instead. This alias will be removed in v1.0. */
+    SerializeData(writer) {
+        this.serializeData(writer);
+    }
+    unserializeData(reader) {
+        this.bytes = stringToUint8Array(reader.readString());
+    }
+    /** @deprecated Use `unserializeData` instead. This alias will be removed in v1.0. */
+    UnserializeData(reader) {
+        this.unserializeData(reader);
+    }
+    toByteArray() {
+        const stream = new Uint8Array(64);
+        const writer = new PBinaryWriter(stream);
+        this.serializeData(writer);
+        return new Uint8Array(stream);
+    }
+    /** @deprecated Use `toByteArray` instead. This alias will be removed in v1.0. */
+    ToByteArray() {
+        return this.toByteArray();
+    }
+    static generate(keypair, message) {
+        const privateKey = 'privateKey' in keypair ? keypair.privateKey : keypair.PrivateKey;
+        return new Ed25519Signature(signEd25519(message, privateKey));
+    }
+    /** @deprecated Use `generate` instead. This alias will be removed in v1.0. */
+    static Generate(keypair, message) {
+        return Ed25519Signature.generate(keypair, message);
+    }
+}

package/dist/esm/types/ed25519.js

@@ -0,0 +1,25 @@
+import nacl from 'tweetnacl';
+import { bytesToHex, hexToBytes } from '../utils/index.js';
+function requireLength(name, bytes, expected) {
+    if (bytes.length !== expected) {
+        throw new Error(`${name} should have length ${expected} but has ${bytes.length}`);
+    }
+}
+export function getEd25519PublicKey(privateKey) {
+    requireLength('privateKey', privateKey, 32);
+    return nacl.sign.keyPair.fromSeed(privateKey).publicKey;
+}
+export function getEd25519PublicKeyHex(privateKeyHex) {
+    return bytesToHex(getEd25519PublicKey(hexToBytes(privateKeyHex)));
+}
+export function signEd25519(message, privateKey) {
+    requireLength('privateKey', privateKey, 32);
+    const keyPair = nacl.sign.keyPair.fromSeed(privateKey);
+    return nacl.sign.detached(message, keyPair.secretKey);
+}
+export function verifyEd25519(message, signature, publicKey) {
+    if (signature.length !== 64 || publicKey.length !== 32) {
+        return false;
+    }
+    return nacl.sign.detached.verify(message, signature, publicKey);
+}

package/dist/esm/types/entropy.js

@@ -0,0 +1,18 @@
+import crypto from 'crypto';
+export class Entropy {
+    //private static rnd = crypto.randomBytes(24);
+    static getRandomBytes(targetLength) {
+        const rnd = new Uint8Array(targetLength);
+        const privateKey = Buffer.alloc(rnd.byteLength);
+        crypto.getRandomValues(rnd);
+        for (let i = 0; i < 32; ++i) {
+            privateKey.writeUInt8(rnd[i], i);
+        }
+        //let pk = this.ToBuffer(rnd);
+        return privateKey;
+    }
+    /** @deprecated Use `getRandomBytes` instead. This alias will be removed in v1.0. */
+    static GetRandomBytes(targetLength) {
+        return Entropy.getRandomBytes(targetLength);
+    }
+}

package/dist/esm/types/extensions/base16.js

@@ -0,0 +1,30 @@
+import { stringToUint8Array } from '../../utils/index.js';
+export class Base16 {
+    static encode(str) {
+        if (!str)
+            return '';
+        return str
+            .split('')
+            .map((c) => c.charCodeAt(0).toString(16).padStart(2, '0'))
+            .join('');
+    }
+    static encodeUint8Array(arr) {
+        return Array.from(arr)
+            .map((c) => c.toString(16).padStart(2, '0'))
+            .join('')
+            .toUpperCase();
+    }
+    static decode(str) {
+        if (!str || str.length % 2 !== 0)
+            return '';
+        return (str
+            .match(/.{1,2}/g)
+            ?.map((c) => String.fromCharCode(parseInt(c, 16)))
+            .join('') ?? '');
+    }
+    static decodeUint8Array(str) {
+        if (!str || str.length % 2 !== 0)
+            return new Uint8Array(0);
+        return new Uint8Array(stringToUint8Array(this.decode(str)));
+    }
+}

package/dist/esm/types/extensions/describer.js

@@ -0,0 +1,17 @@
+export class Describer {
+    static describe(val, parent = false) {
+        let result = [];
+        if (parent) {
+            const proto = Object.getPrototypeOf(val.prototype);
+            if (proto) {
+                result = result.concat(this.describe(proto.constructor, parent));
+            }
+        }
+        result = result.concat(val.toString().match(this.FRegEx) || []);
+        /*.filter((x) => {
+            x.replace("this.", "");
+          })*/
+        return result;
+    }
+}
+Describer.FRegEx = new RegExp(/(?:this\.)(.+?(?= ))/g);

package/dist/esm/types/extensions/index.js

@@ -0,0 +1,4 @@
+export * from './p-binary-reader.js';
+export * from './p-binary-writer.js';
+export * from './base16.js';
+export * from './describer.js';