stanza 12.17.1 → 12.18.0

package/Client.d.ts

@@ -7,6 +7,7 @@ import * as JXT from './jxt';
 import { JSONData } from './jxt';
 import * as SASL from './lib/sasl';
 import { IQ, Message, Presence, StreamError, Stream } from './protocol';
+import NetworkDiscovery from './helpers/NetworkDiscovery';
 interface StreamData {
     kind: string;
     stanza: any;
@@ -18,6 +19,7 @@ export default class Client extends EventEmitter {
     sm: StreamManagement;
     transport?: Transport;
     stanzas: JXT.Registry;
+    resolver: NetworkDiscovery;
     sessionStarting?: boolean;
     sessionStarted?: boolean;
     sessionTerminating?: boolean;

package/Client.js

@@ -12,6 +12,7 @@ const protocol_1 = tslib_1.__importDefault(require("./protocol"));
 const bosh_1 = tslib_1.__importDefault(require("./transports/bosh"));
 const websocket_1 = tslib_1.__importDefault(require("./transports/websocket"));
 const Utils_1 = require("./Utils");
+const NetworkDiscovery_1 = tslib_1.__importDefault(require("./helpers/NetworkDiscovery"));
 class Client extends events_1.EventEmitter {
     constructor(opts = {}) {
         super();
@@ -34,6 +35,7 @@ class Client extends events_1.EventEmitter {
         this.sasl.register('ANONYMOUS', SASL.ANONYMOUS, 0);
         this.stanzas = new JXT.Registry();
         this.stanzas.define(protocol_1.default);
+        this.resolver = new NetworkDiscovery_1.default();
         this.use(plugins_1.core);
         this.sm = new StreamManagement_1.default();
         if (this.config.allowResumption !== undefined) {
@@ -220,6 +222,7 @@ class Client extends events_1.EventEmitter {
         });
     }
     updateConfig(opts = {}) {
+        var _a;
         const currConfig = this.config || {};
         this.config = {
             allowResumption: true,
@@ -229,6 +232,7 @@ class Client extends events_1.EventEmitter {
                 websocket: true
             },
             useStreamManagement: true,
+            transportPreferenceOrder: ['websocket', 'bosh'],
             ...currConfig,
             ...opts
         };
@@ -240,6 +244,9 @@ class Client extends events_1.EventEmitter {
             this.config.credentials.password = this.config.password;
             delete this.config.password;
         }
+        if (!this.config.transportPreferenceOrder) {
+            this.config.transportPreferenceOrder = Object.keys((_a = this.config.transports) !== null && _a !== void 0 ? _a : {});
+        }
     }
     get stream() {
         return this.transport ? this.transport.stream : undefined;
@@ -270,47 +277,60 @@ class Client extends events_1.EventEmitter {
         return this._getConfiguredCredentials();
     }
     async connect() {
+        var _a, _b, _c;
         this.sessionTerminating = false;
         this.sessionStarting = true;
         this.emit('--reset-stream-features');
         if (this.transport) {
             this.transport.disconnect(false);
         }
-        const transportPref = ['websocket', 'bosh'];
+        const transportPref = (_a = this.config.transportPreferenceOrder) !== null && _a !== void 0 ? _a : [];
         let endpoints;
         for (const name of transportPref) {
-            let conf = this.config.transports[name];
-            if (!conf) {
+            const settings = this.config.transports[name];
+            if (!settings || !this.transports[name]) {
                 continue;
             }
-            if (typeof conf === 'string') {
-                conf = { url: conf };
+            let config = {
+                acceptLanguages: this.config.acceptLanguages || [(_b = this.config.lang) !== null && _b !== void 0 ? _b : 'en'],
+                jid: this.config.jid,
+                lang: (_c = this.config.lang) !== null && _c !== void 0 ? _c : 'en',
+                server: this.config.server
+            };
+            const transport = new this.transports[name](this, this.sm, this.stanzas);
+            if (typeof settings === 'string') {
+                config.url = settings;
             }
-            else if (conf === true) {
-                if (!endpoints) {
-                    try {
-                        endpoints = await this.discoverBindings(this.config.server);
-                    }
-                    catch (err) {
-                        console.error(err);
+            else if (settings == true) {
+                if (transport.discoverBindings) {
+                    const discovered = await transport.discoverBindings(this.config.server);
+                    if (!discovered) {
                         continue;
                     }
+                    config = {
+                        ...config,
+                        ...discovered
+                    };
                 }
-                endpoints[name] = (endpoints[name] || []).filter(url => url.startsWith('wss:') || url.startsWith('https:'));
-                if (!endpoints[name] || !endpoints[name].length) {
-                    continue;
+                else {
+                    if (!endpoints) {
+                        try {
+                            endpoints = await this.discoverBindings(this.config.server);
+                        }
+                        catch (err) {
+                            console.error(err);
+                            continue;
+                        }
+                    }
+                    endpoints[name] = (endpoints[name] || []).filter(url => url.startsWith('wss:') || url.startsWith('https:'));
+                    if (!endpoints[name] || !endpoints[name].length) {
+                        continue;
+                    }
+                    config.url = endpoints[name][0];
                 }
-                conf = { url: endpoints[name][0] };
             }
-            this.transport = new this.transports[name](this, this.sm, this.stanzas);
-            this.transport.connect({
-                acceptLanguages: this.config.acceptLanguages || ['en'],
-                jid: this.config.jid,
-                lang: this.config.lang || 'en',
-                server: this.config.server,
-                url: conf.url,
-                ...conf
-            });
+            this.transport = transport;
+            this.transport.connect(config);
             return;
         }
         console.error('No endpoints found for the requested transports.');

package/Constants.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.directionToSenders = exports.sendersToDirection = exports.JINGLE_INFO_RECEIVED_5 = exports.JINGLE_INFO_CHECKSUM_5 = exports.JINGLE_INFO_RINGING = exports.JINGLE_INFO_ACTIVE = exports.JINGLE_INFO_UNHOLD = exports.JINGLE_INFO_HOLD = exports.JINGLE_INFO_UNMUTE = exports.JINGLE_INFO_MUTE = exports.JINGLE_INFO = exports.USER_ACTIVITY_SPECIFIC = exports.USER_ACTIVITY_GENERAL = exports.USER_MOODS = exports.JingleReasonCondition = exports.JingleErrorCondition = exports.JingleAction = exports.JingleContentSenders = exports.JingleApplicationDirection = exports.JingleSessionRole = exports.ChatState = exports.PubsubErrorCondition = exports.MUCStatusCode = exports.MUCRole = exports.MUCAffiliation = exports.DataFormFieldType = exports.DataFormType = exports.RosterSubscription = exports.PresenceShow = exports.IQType = exports.PresenceType = exports.MessageType = exports.StanzaErrorCondition = exports.StreamErrorCondition = exports.SASLFailureCondition = exports.StreamType = exports.VERSION = void 0;
 const Namespaces_1 = require("./Namespaces");
-exports.VERSION = '12.17.1';
+exports.VERSION = '12.18.0';
 // ====================================================================
 // Frequently Used Values
 // ====================================================================

package/README.md

@@ -69,14 +69,6 @@ client.connect();
 
 MUC Room: [discuss@stanzajs.org](https://stanzajs.org/discuss/logs) / [Logs](https://stanzajs.org/discuss/logs)
 
-## Related Modules
-
-These are related modules that form part of StanzaJS:
-
-| Name                                                   | Description                                                          | Source                                              |
-| ------------------------------------------------------ | -------------------------------------------------------------------- | --------------------------------------------------- |
-| [stanza-shims](https://npmjs.org/package/stanza-shims) | Runtime shims used by StanzaJS for node, browsers, and React Native. | [Source](https://github.com/legastero/stanza-shims) |
-
 ## Recommended Modules
 
 These are some additional modules that are highly recommended for use with StanzaJS:

package/Utils.d.ts

@@ -8,6 +8,8 @@
  */
 /// <reference types="node" />
 export declare function timeoutPromise<T>(target: Promise<T>, delay: number, rejectValue?: () => any): Promise<T>;
+export declare function promiseAny<T>(promises: Array<Promise<T>>): Promise<T>;
+export declare function shuffle<T>(array: T[]): T[];
 export declare function sleep(time: number): Promise<void>;
 export declare function octetCompare(str1: string | Buffer, str2: string | Buffer): number;
 export declare function uuid(): string;

package/Utils.js

@@ -8,9 +8,9 @@
  * - uuid, Copyright (c) 2010-2016 Robert Kieffer and other contributors
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reviveData = exports.uuid = exports.octetCompare = exports.sleep = exports.timeoutPromise = void 0;
+exports.reviveData = exports.uuid = exports.octetCompare = exports.sleep = exports.shuffle = exports.promiseAny = exports.timeoutPromise = void 0;
 // tslint:disable no-bitwise
-const stanza_shims_1 = require("stanza-shims");
+const platform_1 = require("./platform");
 const bth = [];
 for (let i = 0; i < 256; ++i) {
     bth[i] = (i + 0x100).toString(16).substr(1);
@@ -27,6 +27,30 @@ async function timeoutPromise(target, delay, rejectValue = () => undefined) {
     return result;
 }
 exports.timeoutPromise = timeoutPromise;
+async function promiseAny(promises) {
+    try {
+        const errors = await Promise.all(promises.map(p => {
+            return p.then(val => Promise.reject(val), err => Promise.resolve(err));
+        }));
+        return Promise.reject(errors);
+    }
+    catch (val) {
+        return Promise.resolve(val);
+    }
+}
+exports.promiseAny = promiseAny;
+function shuffle(array) {
+    let end = array.length;
+    while (end > 0) {
+        const selected = Math.floor(Math.random() * end);
+        end -= 1;
+        const tmp = array[end];
+        array[end] = array[selected];
+        array[selected] = tmp;
+    }
+    return array;
+}
+exports.shuffle = shuffle;
 async function sleep(time) {
     return new Promise(resolve => {
         setTimeout(() => resolve(), time);
@@ -34,13 +58,13 @@ async function sleep(time) {
 }
 exports.sleep = sleep;
 function octetCompare(str1, str2) {
-    const b1 = typeof str1 === 'string' ? Buffer.from(str1, 'utf8') : str1;
-    const b2 = typeof str2 === 'string' ? Buffer.from(str2, 'utf8') : str2;
+    const b1 = typeof str1 === 'string' ? platform_1.Buffer.from(str1, 'utf8') : str1;
+    const b2 = typeof str2 === 'string' ? platform_1.Buffer.from(str2, 'utf8') : str2;
     return b1.compare(b2);
 }
 exports.octetCompare = octetCompare;
 function uuid() {
-    const buf = stanza_shims_1.randomBytes(16);
+    const buf = platform_1.randomBytes(16);
     // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
     buf[6] = (buf[6] & 0x0f) | 0x40;
     buf[8] = (buf[8] & 0x3f) | 0x80;
@@ -90,7 +114,7 @@ function reviveData(key, value) {
         typeof value === 'object' &&
         value.type === 'Buffer' &&
         Array.isArray(value.data)) {
-        return Buffer.from(value);
+        return platform_1.Buffer.from(value);
     }
     return value;
 }

package/helpers/LegacyEntityCapabilities.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verify = exports.generate = void 0;
-const tslib_1 = require("tslib");
-const Hashes = tslib_1.__importStar(require("stanza-shims"));
+const platform_1 = require("../platform");
 const Utils_1 = require("../Utils");
 function escape(value) {
-    return Buffer.from(value.replace(/</g, '&lt;'), 'utf-8');
+    return platform_1.Buffer.from(value.replace(/</g, '&lt;'), 'utf-8');
 }
 function encodeIdentities(identities = []) {
     const result = [];
@@ -115,7 +114,7 @@ function encodeForms(extensions = []) {
 }
 function generate(info, hashName) {
     const S = [];
-    const separator = Buffer.from('<', 'utf8');
+    const separator = platform_1.Buffer.from('<', 'utf8');
     const append = (b1) => {
         S.push(b1);
         S.push(separator);
@@ -135,7 +134,7 @@ function generate(info, hashName) {
     for (const form of extensions) {
         append(form);
     }
-    return Hashes.createHash(hashName).update(Buffer.concat(S)).digest('base64');
+    return platform_1.createHash(hashName).update(platform_1.Buffer.concat(S)).digest('base64');
 }
 exports.generate = generate;
 function verify(info, hashName, check) {

package/helpers/NetworkDiscovery.d.ts

@@ -0,0 +1,36 @@
+import { XRD } from '../protocol/xrd';
+export interface Candidate {
+    host: string;
+    port: number;
+    secure?: boolean;
+}
+export interface DNSOptions {
+    srvType?: string;
+    srvTypeSecure?: string;
+}
+export interface SRVRecord {
+    name: string;
+    port: number;
+    priority: number;
+    weight: number;
+    secure?: boolean;
+    used?: boolean;
+    runningSum?: number;
+    id?: number;
+}
+export interface SRVResult {
+    records: SRVRecord[];
+    allowFallback: boolean;
+}
+export default class NetworkDiscovery {
+    private resolver?;
+    private registry;
+    private hostMetaCache;
+    private hostMetaTTL;
+    constructor();
+    getHostMeta(domain: string): Promise<XRD>;
+    resolveTXT(domain: string): Promise<string[][]>;
+    resolve(domain: string, defaultPort: number, opts?: DNSOptions): Promise<Candidate[]>;
+    resolveWeightedSRV(domain: string, srvType: string, srvTypeSecure?: string): Promise<SRVResult>;
+    resolveSRV(domain: string, srvType: string, secure?: boolean): Promise<SRVResult>;
+}

package/helpers/NetworkDiscovery.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const platform_1 = require("../platform");
+const Utils_1 = require("../Utils");
+const jxt_1 = require("../jxt");
+const xrd_1 = tslib_1.__importDefault(require("../protocol/xrd"));
+class NetworkDiscovery {
+    constructor() {
+        this.hostMetaCache = new Map();
+        this.hostMetaTTL = 30000;
+        this.resolver = platform_1.createResolver();
+        this.registry = new jxt_1.Registry();
+        this.registry.define(xrd_1.default);
+    }
+    async getHostMeta(domain) {
+        const cached = this.hostMetaCache.get(domain);
+        if (cached) {
+            if (cached.created + this.hostMetaTTL < Date.now()) {
+                return cached.hostmeta;
+            }
+            else {
+                this.hostMetaCache.delete(domain);
+            }
+        }
+        const hostmeta = Utils_1.promiseAny([
+            platform_1.fetch(`https://${domain}/.well-known/host-meta.json`).then(async (res) => {
+                if (!res.ok) {
+                    throw new Error('could-not-fetch-json');
+                }
+                return res.json();
+            }),
+            platform_1.fetch(`https://${domain}/.well-known/host-meta`).then(async (res) => {
+                if (!res.ok) {
+                    throw new Error('could-not-fetch-xml');
+                }
+                const data = await res.text();
+                const xml = jxt_1.parse(data);
+                if (xml) {
+                    return this.registry.import(xml);
+                }
+                else {
+                    throw new Error('could-not-import-xml');
+                }
+            })
+        ]);
+        this.hostMetaCache.set(domain, { created: Date.now(), hostmeta });
+        hostmeta.catch(() => {
+            this.hostMetaCache.delete(domain);
+        });
+        return hostmeta;
+    }
+    async resolveTXT(domain) {
+        var _a, _b;
+        return (_b = (_a = this.resolver) === null || _a === void 0 ? void 0 : _a.resolveTxt(domain)) !== null && _b !== void 0 ? _b : [];
+    }
+    async resolve(domain, defaultPort, opts = {}) {
+        if (!this.resolver) {
+            return [];
+        }
+        let candidates = [];
+        let allowFallback = true;
+        if (opts.srvType) {
+            const srvResults = await this.resolveWeightedSRV(domain, opts.srvType, opts.srvTypeSecure);
+            allowFallback = srvResults.allowFallback;
+            candidates = srvResults.records.map(record => ({
+                host: record.name,
+                port: record.port,
+                secure: record.secure
+            }));
+        }
+        if (allowFallback) {
+            candidates.push({ host: domain, port: defaultPort });
+        }
+        return candidates;
+    }
+    async resolveWeightedSRV(domain, srvType, srvTypeSecure) {
+        const [records, secureRecords] = await Promise.all([
+            this.resolveSRV(domain, srvType),
+            srvTypeSecure
+                ? this.resolveSRV(domain, srvTypeSecure, true)
+                : Promise.resolve({ records: [], allowFallback: false })
+        ]);
+        const allRecords = [...records.records, ...secureRecords.records];
+        const priorities = new Map();
+        let id = 0;
+        for (const record of allRecords) {
+            record.id = id++;
+            record.runningSum = 0;
+            if (!priorities.has(record.priority)) {
+                priorities.set(record.priority, []);
+            }
+            const priorityGroup = priorities.get(record.priority);
+            priorityGroup.push(record);
+        }
+        const weightRecords = (unweightedRecords) => {
+            const sorted = [];
+            while (sorted.length < unweightedRecords.length) {
+                const ordered = Utils_1.shuffle(unweightedRecords.filter(record => record.weight === 0 && !record.used));
+                const unordered = Utils_1.shuffle(unweightedRecords.filter(record => {
+                    return record.weight !== 0 && !record.used;
+                }));
+                let weightSum = 0;
+                for (const record of unordered) {
+                    weightSum += record.weight;
+                    record.runningSum = weightSum;
+                    ordered.push(record);
+                }
+                const selector = Math.floor(Math.random() * (weightSum + 1));
+                for (const record of ordered) {
+                    if (record.runningSum >= selector) {
+                        record.used = true;
+                        sorted.push(record);
+                        break;
+                    }
+                }
+            }
+            return sorted;
+        };
+        let sortedRecords = [];
+        for (const priority of Array.from(priorities.keys()).sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+            const priorityGroup = priorities.get(priority);
+            sortedRecords = sortedRecords.concat(weightRecords(priorityGroup));
+        }
+        return {
+            records: sortedRecords,
+            allowFallback: records.allowFallback
+        };
+    }
+    async resolveSRV(domain, srvType, secure) {
+        var _a, _b;
+        try {
+            const records = (_b = (await ((_a = this.resolver) === null || _a === void 0 ? void 0 : _a.resolveSrv(`${srvType}.${domain}`)))) !== null && _b !== void 0 ? _b : [];
+            if (records.length === 1 && (records[0].name === '.' || records[0].name === '')) {
+                return { records: [], allowFallback: false };
+            }
+            return {
+                records: records
+                    .map(record => ({ secure, ...record }))
+                    .filter(record => record.name !== '' && record.name !== '.'),
+                allowFallback: false
+            };
+        }
+        catch (_c) {
+            return {
+                records: [],
+                allowFallback: true
+            };
+        }
+    }
+}
+exports.default = NetworkDiscovery;

package/helpers/RSM.d.ts

@@ -18,9 +18,15 @@ export declare class ResultSetPager<T> {
     private direction;
     private reverse;
     private pageSize;
+    private resultCount?;
+    private resultComplete;
+    private fetchedCount;
+    private yieldedCount;
     constructor(opts: RSMOptions<T>);
     [Symbol.asyncIterator](): AsyncGenerator<T>;
     size(): Promise<number | undefined>;
+    queryCompleted(): boolean;
+    finished(): boolean;
     private fetchPage;
 }
 export declare function createPager<T>(opts: RSMOptions<T>): ResultSetPager<T>;

package/helpers/RSM.js

@@ -4,6 +4,9 @@ exports.createPager = exports.ResultSetPager = void 0;
 class ResultSetPager {
     constructor(opts) {
         var _a, _b, _c;
+        this.resultComplete = false;
+        this.fetchedCount = 0;
+        this.yieldedCount = 0;
         this.cursor = { first: opts.before, last: opts.after };
         this.query = opts.query;
         this.direction = (_a = opts.direction) !== null && _a !== void 0 ? _a : 'forward';
@@ -15,14 +18,25 @@ class ResultSetPager {
         do {
             currentResults = await this.fetchPage();
             for (const item of currentResults) {
+                this.yieldedCount += 1;
                 yield item;
             }
         } while (currentResults.length > 0);
     }
     async size() {
+        if (this.resultCount !== undefined) {
+            return this.resultCount;
+        }
         const { paging } = await this.query({ max: 0 });
+        this.resultCount = paging.count;
         return paging.count;
     }
+    queryCompleted() {
+        return this.resultComplete;
+    }
+    finished() {
+        return this.resultComplete && this.yieldedCount === this.fetchedCount;
+    }
     async fetchPage() {
         var _a;
         const { results, paging } = await this.query({
@@ -31,6 +45,12 @@ class ResultSetPager {
             max: this.pageSize
         });
         this.cursor = paging;
+        this.resultCount = paging.count;
+        this.fetchedCount += results.length;
+        if ((this.pageSize && results.length < this.pageSize) ||
+            (this.resultCount && this.fetchedCount === this.resultCount)) {
+            this.resultComplete = true;
+        }
         if (this.reverse) {
             results.reverse();
         }

package/index.d.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from 'events';
 import Client from './Client';
 import * as Constants from './Constants';
 import * as RTT from './helpers/RTT';
+import NetworkDiscovery from './helpers/NetworkDiscovery';
 import SM from './helpers/StreamManagement';
 import * as JID from './JID';
 import * as Jingle from './jingle';
@@ -13,6 +14,7 @@ import * as Namespaces from './Namespaces';
 import * as Stanzas from './protocol';
 import { CSI, IQ, Message, Presence, SASL, Stream, StreamError, StreamFeatures, StreamManagement } from './protocol';
 import * as Utils from './Utils';
+import * as Platform from './platform';
 export * from './helpers/StreamManagement';
 export interface TopLevelElements {
     message: Message;
@@ -102,9 +104,13 @@ export interface Agent extends StrictEventEmitter<EventEmitter, AgentEvents> {
     sm: SM;
     sasl: LibSASL.Factory;
     stanzas: JXT.Registry;
+    resolver: NetworkDiscovery;
     sessionStarting: boolean;
     sessionStarted: boolean;
     sessionTerminating: boolean;
+    transports: {
+        [key: string]: new (client: Agent, sm: StreamManagement, registry: JXT.Registry) => Transport;
+    };
     use(plugin: (agent: Agent, registry: JXT.Registry, config: AgentConfig) => void): void;
     nextId(): string;
     updateConfig(opts?: AgentConfig): void;
@@ -177,14 +183,21 @@ export interface AgentConfig {
      *
      * If a transport is set to a string, that will be used as the connection URL.
      *
-     * If a transport is set to an object, it MUST include a <code>url</code> value for
-     * the connection URL.
-     *
      * @default { websocket: true, bosh: true }
      */
     transports?: {
         [key: string]: boolean | string | Partial<TransportConfig>;
     };
+    /**
+     * Transport Preference Order
+     *
+     * Specify the order in which transports should be tried when connecting.
+     *
+     * If a configured transport type is not listed, it will be skipped.
+     *
+     * @default ['websocket', 'bosh']
+     */
+    transportPreferenceOrder?: string[];
     /**
      * Account Password
      *
@@ -208,17 +221,18 @@ export interface Transport {
     hasStream?: boolean;
     stream?: Stream;
     authenticated?: boolean;
+    discoverBindings?(host: string): Promise<Partial<TransportConfig> | null>;
     connect(opts: TransportConfig): void;
     disconnect(cleanly?: boolean): void;
     restart(): void;
     send(name: string, data?: JXT.JSONData): Promise<void>;
 }
 export interface TransportConfig {
-    lang?: string;
-    acceptLanguages?: string[];
     server: string;
-    url: string;
     jid: string;
+    lang?: string;
+    acceptLanguages?: string[];
+    url?: string;
     sid?: string;
     rid?: number;
     maxRetries?: number;
@@ -227,7 +241,7 @@ export interface TransportConfig {
 }
 import * as RSM from './helpers/RSM';
 import * as DataForms from './helpers/DataForms';
-export { Client, Constants, DataForms, JXT, JID, Namespaces, Stanzas, Jingle, Utils, RSM, RTT, LibSASL as SASL };
+export { Client, Constants, DataForms, JXT, JID, Namespaces, Stanzas, Jingle, Utils, RSM, RTT, LibSASL as SASL, Platform };
 export declare const VERSION = "__STANZAJS_VERSION__";
 export * from './plugins';
 export declare function createClient(opts: AgentConfig): Agent;

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClient = exports.VERSION = exports.SASL = exports.RTT = exports.RSM = exports.Utils = exports.Jingle = exports.Stanzas = exports.Namespaces = exports.JID = exports.JXT = exports.DataForms = exports.Constants = exports.Client = void 0;
+exports.createClient = exports.VERSION = exports.Platform = exports.SASL = exports.RTT = exports.RSM = exports.Utils = exports.Jingle = exports.Stanzas = exports.Namespaces = exports.JID = exports.JXT = exports.DataForms = exports.Constants = exports.Client = void 0;
 const tslib_1 = require("tslib");
 const Client_1 = tslib_1.__importDefault(require("./Client"));
 exports.Client = Client_1.default;
@@ -22,6 +22,8 @@ const Stanzas = tslib_1.__importStar(require("./protocol"));
 exports.Stanzas = Stanzas;
 const Utils = tslib_1.__importStar(require("./Utils"));
 exports.Utils = Utils;
+const Platform = tslib_1.__importStar(require("./platform"));
+exports.Platform = Platform;
 tslib_1.__exportStar(require("./helpers/StreamManagement"), exports);
 const RSM = tslib_1.__importStar(require("./helpers/RSM"));
 exports.RSM = RSM;

package/index.module.js

@@ -0,0 +1,23 @@
+import Client from './Client';
+import * as Constants from './Constants';
+import * as RTT from './helpers/RTT';
+import * as JID from './JID';
+import * as Jingle from './jingle';
+import * as JXT from './jxt';
+import * as LibSASL from './lib/sasl';
+import * as Namespaces from './Namespaces';
+import * as Stanzas from './protocol';
+import * as Utils from './Utils';
+import * as Platform from './platform';
+export * from './helpers/StreamManagement';
+import * as RSM from './helpers/RSM';
+import * as DataForms from './helpers/DataForms';
+export { Client, Constants, DataForms, JXT, JID, Namespaces, Stanzas, Jingle, Utils, RSM, RTT, LibSASL as SASL, Platform };
+export const VERSION = Constants.VERSION;
+import Plugins from './plugins';
+export * from './plugins';
+export function createClient(opts) {
+    const client = new Client(opts);
+    client.use(Plugins);
+    return client;
+}

package/jingle/FileTransferSession.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import * as Hashes from 'stanza-shims';
+import * as Hashes from '../platform';
 import { FileDescription, Hash, Jingle } from '../protocol';
 import ICESession, { ICESessionOpts } from './ICESession';
 import { ActionCallback } from './Session';