ccxt 4.2.18 → 4.2.20

package/dist/cjs/js/src/base/functions/generic.js

@@ -1,193 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var type = require('./type.js');
-
-// ----------------------------------------------------------------------------
-// ----------------------------------------------------------------------------
-const keys = Object.keys; // eslint-disable-line padding-line-between-statements
-const values = (x) => ((!type.isArray(x)) ? Object.values(x) : x); // don't copy arrays if they're already arrays
-const index = (x) => new Set(values(x));
-const extend = (...args) => Object.assign({}, ...args); // NB: side-effect free
-const clone = (x) => (type.isArray(x) ? Array.from(x) : extend(x)); // clone arrays or objects
-// ----------------------------------------------------------------------------
-const ordered = (x) => x; // a stub to keep assoc keys in order (in JS it does nothing, it's mostly for Python)
-const unique = (x) => Array.from(index(x));
-const arrayConcat = (a, b) => a.concat(b);
-// ------------------------------------------------------------------------
-const inArray = (needle, haystack) => haystack.includes(needle);
-const toArray = (object) => Object.values(object);
-const isEmpty = (object) => {
-    if (!object) {
-        return true;
-    }
-    return (Array.isArray(object) ? object : Object.keys(object)).length < 1;
-};
-const keysort = (x, out = {}) => {
-    for (const k of keys(x).sort()) {
-        out[k] = x[k];
-    }
-    return out;
-};
-/*
-    Accepts a map/array of objects and a key name to be used as an index:
-    array = [
-        { someKey: 'value1', anotherKey: 'anotherValue1' },
-        { someKey: 'value2', anotherKey: 'anotherValue2' },
-        { someKey: 'value3', anotherKey: 'anotherValue3' },
-    ]
-    key = 'someKey'
-    Returns a map:
-    {
-        value1: { someKey: 'value1', anotherKey: 'anotherValue1' },
-        value2: { someKey: 'value2', anotherKey: 'anotherValue2' },
-        value3: { someKey: 'value3', anotherKey: 'anotherValue3' },
-    }
-*/
-const groupBy = (x, k, out = {}) => {
-    for (const v of values(x)) {
-        if (k in v) {
-            const p = v[k];
-            out[p] = out[p] || [];
-            out[p].push(v);
-        }
-    }
-    return out;
-};
-const indexBy = (x, k, out = {}) => {
-    for (const v of values(x)) {
-        if (k in v) {
-            out[v[k]] = v;
-        }
-    }
-    return out;
-};
-const filterBy = (x, k, value = undefined, out = []) => {
-    for (const v of values(x)) {
-        if (v[k] === value) {
-            out.push(v);
-        }
-    }
-    return out;
-};
-const sortBy = (array, key, descending = false, defaultValue = 0, direction = descending ? -1 : 1) => array.sort((a, b) => {
-    const first = (key in a) ? a[key] : defaultValue;
-    const second = (key in b) ? b[key] : defaultValue;
-    if (first < second) {
-        return -direction;
-    }
-    else if (first > second) {
-        return direction;
-    }
-    else {
-        return 0;
-    }
-});
-const sortBy2 = (array, key1, key2, descending = false, direction = descending ? -1 : 1) => array.sort((a, b) => {
-    if (a[key1] < b[key1]) {
-        return -direction;
-    }
-    else if (a[key1] > b[key1]) {
-        return direction;
-    }
-    else {
-        if (a[key2] < b[key2]) {
-            return -direction;
-        }
-        else if (a[key2] > b[key2]) {
-            return direction;
-        }
-        else {
-            return 0;
-        }
-    }
-});
-const flatten = function flatten(x, out = []) {
-    for (const v of x) {
-        if (type.isArray(v)) {
-            flatten(v, out);
-        }
-        else {
-            out.push(v);
-        }
-    }
-    return out;
-};
-const pluck = (x, k) => values(x).filter((v) => k in v).map((v) => v[k]);
-const omit = (x, ...args) => {
-    if (!Array.isArray(x)) {
-        const out = clone(x);
-        for (const k of args) {
-            if (type.isArray(k)) { // omit (x, ['a', 'b'])
-                for (const kk of k) {
-                    delete out[kk];
-                }
-            }
-            else {
-                delete out[k]; // omit (x, 'a', 'b')
-            }
-        }
-        return out;
-    }
-    return x;
-};
-const sum = (...xs) => {
-    const ns = xs.filter(type.isNumber); // leave only numbers
-    return (ns.length > 0) ? ns.reduce((a, b) => a + b, 0) : undefined;
-};
-const deepExtend = function deepExtend(...xs) {
-    let out = undefined;
-    for (const x of xs) {
-        if (type.isDictionary(x)) {
-            if (!type.isDictionary(out)) {
-                out = {};
-            }
-            for (const k in x) {
-                out[k] = deepExtend(out[k], x[k]);
-            }
-        }
-        else {
-            out = x;
-        }
-    }
-    return out;
-};
-const merge = (target, ...args) => {
-    // doesn't overwrite defined keys with undefined
-    const overwrite = {};
-    const merged = Object.assign({}, ...args);
-    const keys = Object.keys(merged);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        if (target[key] === undefined) {
-            overwrite[key] = merged[key];
-        }
-    }
-    // eslint-disable-next-line
-    return Object.assign({}, target, overwrite);
-};
-
-exports.arrayConcat = arrayConcat;
-exports.clone = clone;
-exports.deepExtend = deepExtend;
-exports.extend = extend;
-exports.filterBy = filterBy;
-exports.flatten = flatten;
-exports.groupBy = groupBy;
-exports.inArray = inArray;
-exports.index = index;
-exports.indexBy = indexBy;
-exports.isEmpty = isEmpty;
-exports.keys = keys;
-exports.keysort = keysort;
-exports.merge = merge;
-exports.omit = omit;
-exports.ordered = ordered;
-exports.pluck = pluck;
-exports.sortBy = sortBy;
-exports.sortBy2 = sortBy2;
-exports.sum = sum;
-exports.toArray = toArray;
-exports.unique = unique;
-exports.values = values;

package/dist/cjs/js/src/base/functions/misc.js

@@ -1,96 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var number = require('./number.js');
-var type = require('./type.js');
-var errors = require('../errors.js');
-
-//-------------------------------------------------------------------------
-// converts timeframe to seconds
-const parseTimeframe = (timeframe) => {
-    const amount = type.asFloat(timeframe.slice(0, -1));
-    const unit = timeframe.slice(-1);
-    let scale = undefined;
-    if (unit === 'y') {
-        scale = 60 * 60 * 24 * 365;
-    }
-    else if (unit === 'M') {
-        scale = 60 * 60 * 24 * 30;
-    }
-    else if (unit === 'w') {
-        scale = 60 * 60 * 24 * 7;
-    }
-    else if (unit === 'd') {
-        scale = 60 * 60 * 24;
-    }
-    else if (unit === 'h') {
-        scale = 60 * 60;
-    }
-    else if (unit === 'm') {
-        scale = 60;
-    }
-    else if (unit === 's') {
-        scale = 1;
-    }
-    else {
-        throw new errors.NotSupported('timeframe unit ' + unit + ' is not supported');
-    }
-    return amount * scale;
-};
-const roundTimeframe = (timeframe, timestamp, direction = number.ROUND_DOWN) => {
-    const ms = parseTimeframe(timeframe) * 1000;
-    // Get offset based on timeframe in milliseconds
-    const offset = timestamp % ms;
-    return timestamp - offset + ((direction === number.ROUND_UP) ? ms : 0);
-};
-const extractParams = (string) => {
-    /**
-     * @ignore
-     * @method
-     * @param string usually a url path
-     * @returns {[string]} all substrings surrounded by {} from parameter string
-     */
-    const re = /{([\w-]+)}/g;
-    const matches = [];
-    let match = re.exec(string);
-    while (match) {
-        matches.push(match[1]);
-        match = re.exec(string);
-    }
-    return matches;
-};
-const implodeParams = (string, params) => {
-    if (!Array.isArray(params)) {
-        const keys = Object.keys(params);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            if (!Array.isArray(params[key])) {
-                string = string.replace('{' + key + '}', params[key]);
-            }
-        }
-    }
-    return string;
-};
-function vwap(baseVolume, quoteVolume) {
-    return ((baseVolume !== undefined) && (quoteVolume !== undefined) && (baseVolume > 0)) ? (quoteVolume / baseVolume) : undefined;
-}
-/*  ------------------------------------------------------------------------ */
-function aggregate(bidasks) {
-    const result = {};
-    for (let i = 0; i < bidasks.length; i++) {
-        const [price, volume] = bidasks[i];
-        if (volume > 0) {
-            result[price] = (result[price] || 0) + volume;
-        }
-    }
-    return Object.keys(result).map((price) => [parseFloat(price), parseFloat(result[price])]);
-}
-/*  ------------------------------------------------------------------------ */
-
-exports.aggregate = aggregate;
-exports.extractParams = extractParams;
-exports.implodeParams = implodeParams;
-exports.parseTimeframe = parseTimeframe;
-exports.roundTimeframe = roundTimeframe;
-exports.vwap = vwap;

package/dist/cjs/js/src/base/functions/number.js

@@ -1,297 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// ------------------------------------------------------------------------
-//
-//  NB: initially, I used objects for options passing:
-//
-//          decimalToPrecision ('123.456', { digits: 2, round: true, afterPoint: true })
-//
-//  ...but it turns out it's hard to port that across different languages and it is also
-//     probably has a performance penalty -- while it's a performance critical code! So
-//     I switched to using named constants instead, as it is actually more readable and
-//     succinct, and surely doesn't come with any inherent performance downside:
-//
-//          decimalToPrecision ('123.456', ROUND, 2, DECIMAL_PLACES)
-const TRUNCATE = 0; // rounding mode
-const ROUND = 1;
-const ROUND_UP = 2;
-const ROUND_DOWN = 3;
-const DECIMAL_PLACES = 2; // digits counting mode
-const SIGNIFICANT_DIGITS = 3;
-const TICK_SIZE = 4;
-const NO_PADDING = 5; // zero-padding mode
-const PAD_WITH_ZERO = 6;
-const precisionConstants = {
-    ROUND,
-    TRUNCATE,
-    ROUND_UP,
-    ROUND_DOWN,
-    DECIMAL_PLACES,
-    SIGNIFICANT_DIGITS,
-    TICK_SIZE,
-    NO_PADDING,
-    PAD_WITH_ZERO,
-};
-/*  ------------------------------------------------------------------------ */
-// See https://stackoverflow.com/questions/1685680/how-to-avoid-scientific-notation-for-large-numbers-in-javascript for discussion
-function numberToString(x) {
-    if (x === undefined)
-        return undefined;
-    if (typeof x !== 'number')
-        return x.toString();
-    const s = x.toString();
-    if (Math.abs(x) < 1.0) {
-        const n_e = s.split('e-');
-        const n = n_e[0].replace('.', '');
-        const e = parseInt(n_e[1]);
-        const neg = (s[0] === '-');
-        if (e) {
-            x = (neg ? '-' : '') + '0.' + (new Array(e)).join('0') + n.substring(neg);
-            return x;
-        }
-    }
-    else {
-        const parts = s.split('e');
-        if (parts[1]) {
-            let e = parseInt(parts[1]);
-            const m = parts[0].split('.');
-            let part = '';
-            if (m[1]) {
-                e -= m[1].length;
-                part = m[1];
-            }
-            return m[0] + part + (new Array(e + 1)).join('0');
-        }
-    }
-    return s;
-}
-//-----------------------------------------------------------------------------
-// expects non-scientific notation
-const truncate_regExpCache = [];
-const truncate_to_string = (num, precision = 0) => {
-    num = numberToString(num);
-    if (precision > 0) {
-        const re = truncate_regExpCache[precision] || (truncate_regExpCache[precision] = new RegExp('([-]*\\d+\\.\\d{' + precision + '})(\\d)'));
-        const [, result] = num.toString().match(re) || [null, num];
-        return result.toString();
-    }
-    return parseInt(num).toString();
-};
-const truncate = (num, precision = 0) => parseFloat(truncate_to_string(num, precision));
-function precisionFromString(str) {
-    // support string formats like '1e-4'
-    if (str.indexOf('e') > -1) {
-        const numStr = str.replace(/\de/, '');
-        return parseInt(numStr) * -1;
-    }
-    // support integer formats (without dot) like '1', '10' etc [Note: bug in decimalToPrecision, so this should not be used atm]
-    // if (str.indexOf ('.') === -1) {
-    //     return str.length * -1
-    // }
-    // default strings like '0.0001'
-    const split = str.replace(/0+$/g, '').split('.');
-    return (split.length > 1) ? (split[1].length) : 0;
-}
-/*  ------------------------------------------------------------------------ */
-const decimalToPrecision = (x, roundingMode, numPrecisionDigits, countingMode = DECIMAL_PLACES, paddingMode = NO_PADDING) => {
-    if (countingMode === TICK_SIZE) {
-        if (typeof numPrecisionDigits === 'string') {
-            numPrecisionDigits = parseFloat(numPrecisionDigits);
-        }
-        if (numPrecisionDigits <= 0) {
-            throw new Error('TICK_SIZE cant be used with negative or zero numPrecisionDigits');
-        }
-    }
-    if (numPrecisionDigits < 0) {
-        const toNearest = Math.pow(10, -numPrecisionDigits);
-        if (roundingMode === ROUND) {
-            return (toNearest * decimalToPrecision(x / toNearest, roundingMode, 0, countingMode, paddingMode)).toString();
-        }
-        if (roundingMode === TRUNCATE) {
-            return (x - (x % toNearest)).toString();
-        }
-    }
-    /*  handle tick size */
-    if (countingMode === TICK_SIZE) {
-        const precisionDigitsString = decimalToPrecision(numPrecisionDigits, ROUND, 22, DECIMAL_PLACES, NO_PADDING);
-        const newNumPrecisionDigits = precisionFromString(precisionDigitsString);
-        let missing = x % numPrecisionDigits;
-        // See: https://github.com/ccxt/ccxt/pull/6486
-        missing = Number(decimalToPrecision(missing, ROUND, 8, DECIMAL_PLACES, NO_PADDING));
-        const fpError = decimalToPrecision(missing / numPrecisionDigits, ROUND, Math.max(newNumPrecisionDigits, 8), DECIMAL_PLACES, NO_PADDING);
-        if (precisionFromString(fpError) !== 0) {
-            if (roundingMode === ROUND) {
-                if (x > 0) {
-                    if (missing >= numPrecisionDigits / 2) {
-                        x = x - missing + numPrecisionDigits;
-                    }
-                    else {
-                        x = x - missing;
-                    }
-                }
-                else {
-                    if (missing >= numPrecisionDigits / 2) {
-                        x = Number(x) - missing;
-                    }
-                    else {
-                        x = Number(x) - missing - numPrecisionDigits;
-                    }
-                }
-            }
-            else if (roundingMode === TRUNCATE) {
-                x = x - missing;
-            }
-        }
-        return decimalToPrecision(x, ROUND, newNumPrecisionDigits, DECIMAL_PLACES, paddingMode);
-    }
-    /*  Convert to a string (if needed), skip leading minus sign (if any)   */
-    const str = numberToString(x);
-    const isNegative = str[0] === '-';
-    const strStart = isNegative ? 1 : 0;
-    const strEnd = str.length;
-    /*  Find the dot position in the source buffer   */
-    for (var strDot = 0; strDot < strEnd; strDot++) {
-        if (str[strDot] === '.')
-            break;
-    }
-    const hasDot = strDot < str.length;
-    /*  Char code constants         */
-    const MINUS = 45;
-    const DOT = 46;
-    const ZERO = 48;
-    const ONE = (ZERO + 1);
-    const FIVE = (ZERO + 5);
-    const NINE = (ZERO + 9);
-    /*  For -123.4567 the `chars` array will hold 01234567 (leading zero is reserved for rounding cases when 099 → 100)    */
-    const chars = new Uint8Array((strEnd - strStart) + (hasDot ? 0 : 1));
-    chars[0] = ZERO;
-    /*  Validate & copy digits, determine certain locations in the resulting buffer  */
-    let afterDot = chars.length;
-    let digitsStart = -1; // significant digits
-    let digitsEnd = -1;
-    for (var i = 1, j = strStart; j < strEnd; j++, i++) {
-        const c = str.charCodeAt(j);
-        if (c === DOT) {
-            afterDot = i--;
-        }
-        else if ((c < ZERO) || (c > NINE)) {
-            throw new Error(`${str}: invalid number (contains an illegal character '${str[i - 1]}')`);
-        }
-        else {
-            chars[i] = c;
-            if ((c !== ZERO) && (digitsStart < 0))
-                digitsStart = i;
-        }
-    }
-    if (digitsStart < 0)
-        digitsStart = 1;
-    /*  Determine the range to cut  */
-    let precisionStart = (countingMode === DECIMAL_PLACES) ? afterDot // 0.(0)001234567
-        : digitsStart; // 0.00(1)234567
-    let precisionEnd = precisionStart
-        + numPrecisionDigits;
-    /*  Reset the last significant digit index, as it will change during the rounding/truncation.   */
-    digitsEnd = -1;
-    // Perform rounding/truncation per digit, from digitsEnd to digitsStart, by using the following
-    //  algorithm (rounding 999 → 1000, as an example):
-    //
-    //      step  =          i=3      i=2      i=1      i=0
-    //
-    //      chars =         0999     0999     0900     1000
-    //      memo  =         ---0     --1-     -1--     0---
-    let allZeros = true;
-    let signNeeded = isNegative;
-    for (let i = chars.length - 1, memo = 0; i >= 0; i--) {
-        let c = chars[i];
-        if (i !== 0) {
-            c += memo;
-            if (i >= (precisionStart + numPrecisionDigits)) {
-                const ceil = (roundingMode === ROUND)
-                    && (c >= FIVE)
-                    && !((c === FIVE) && memo); // prevents rounding of 1.45 to 2
-                c = ceil ? (NINE + 1) : ZERO;
-            }
-            if (c > NINE) {
-                c = ZERO;
-                memo = 1;
-            }
-            else
-                memo = 0;
-        }
-        else if (memo)
-            c = ONE; // leading extra digit (0900 → 1000)
-        chars[i] = c;
-        if (c !== ZERO) {
-            allZeros = false;
-            digitsStart = i;
-            digitsEnd = (digitsEnd < 0) ? (i + 1) : digitsEnd;
-        }
-    }
-    /*  Update the precision range, as `digitsStart` may have changed... & the need for a negative sign if it is only 0    */
-    if (countingMode === SIGNIFICANT_DIGITS) {
-        precisionStart = digitsStart;
-        precisionEnd = precisionStart + numPrecisionDigits;
-    }
-    if (allZeros) {
-        signNeeded = false;
-    }
-    /*  Determine the input character range     */
-    const readStart = ((digitsStart >= afterDot) || allZeros) ? (afterDot - 1) : digitsStart; // 0.000(1)234  ----> (0).0001234
-    const readEnd = (digitsEnd < afterDot) ? (afterDot) : digitsEnd; // 12(3)000     ----> 123000( )
-    /*  Compute various sub-ranges       */
-    const nSign = (signNeeded ? 1 : 0); // (-)123.456
-    const nBeforeDot = (nSign + (afterDot - readStart)); // (-123).456
-    const nAfterDot = Math.max(readEnd - afterDot, 0); // -123.(456)
-    const actualLength = (readEnd - readStart); // -(123.456)
-    const desiredLength = (paddingMode === NO_PADDING)
-        ? (actualLength) // -(123.456)
-        : (precisionEnd - readStart); // -(123.456    )
-    const pad = Math.max(desiredLength - actualLength, 0); //  -123.456(    )
-    const padStart = (nBeforeDot + 1 + nAfterDot); //  -123.456( )
-    const padEnd = (padStart + pad); //  -123.456     ( )
-    const isInteger = (nAfterDot + pad) === 0; //  -123
-    /*  Fill the output buffer with characters    */
-    const out = new Uint8Array(nBeforeDot + (isInteger ? 0 : 1) + nAfterDot + pad);
-    // ------------------------------------------------------------------------------------------ // ---------------------
-    if (signNeeded)
-        out[0] = MINUS; // -     minus sign
-    for (i = nSign, j = readStart; i < nBeforeDot; i++, j++)
-        out[i] = chars[j]; // 123   before dot
-    if (!isInteger)
-        out[nBeforeDot] = DOT; // .     dot
-    for (i = nBeforeDot + 1, j = afterDot; i < padStart; i++, j++)
-        out[i] = chars[j]; // 456   after dot
-    for (i = padStart; i < padEnd; i++)
-        out[i] = ZERO; // 000   padding
-    /*  Build a string from the output buffer     */
-    return String.fromCharCode(...out);
-};
-function omitZero(stringNumber) {
-    if (stringNumber === undefined || stringNumber === '') {
-        return undefined;
-    }
-    if (parseFloat(stringNumber) === 0) {
-        return undefined;
-    }
-    return stringNumber;
-}
-/*  ------------------------------------------------------------------------ */
-
-exports.DECIMAL_PLACES = DECIMAL_PLACES;
-exports.NO_PADDING = NO_PADDING;
-exports.PAD_WITH_ZERO = PAD_WITH_ZERO;
-exports.ROUND = ROUND;
-exports.ROUND_DOWN = ROUND_DOWN;
-exports.ROUND_UP = ROUND_UP;
-exports.SIGNIFICANT_DIGITS = SIGNIFICANT_DIGITS;
-exports.TICK_SIZE = TICK_SIZE;
-exports.TRUNCATE = TRUNCATE;
-exports.decimalToPrecision = decimalToPrecision;
-exports.numberToString = numberToString;
-exports.omitZero = omitZero;
-exports.precisionConstants = precisionConstants;
-exports.precisionFromString = precisionFromString;
-exports.truncate = truncate;
-exports.truncate_to_string = truncate_to_string;

package/dist/cjs/js/src/base/functions/platform.js

@@ -1,28 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// @ts-nocheck
-// ----------------------------------------------------------------------------
-// There's been a lot of messing with this code...
-// The problem is to satisfy the following requirements:
-// - properly detect isNode == true on server side and isNode == false in the browser (on client side)
-// - make sure create-react-app, react-starter-kit and other react frameworks work
-// - make sure it does not break the browserified version (when linked into a html from a cdn)
-// - make sure it does not break the webpacking and babel-transpiled scripts
-// - make sure it works in Electron
-// - make sure it works with Angular.js
-// - make sure it does not break other possible usage scenarios
-const isBrowser = typeof window !== 'undefined';
-const isElectron = typeof process !== 'undefined' &&
-    typeof process.versions !== 'undefined' &&
-    typeof process.versions.electron !== 'undefined';
-const isWebWorker = typeof WorkerGlobalScope !== 'undefined' && (self instanceof WorkerGlobalScope);
-const isWindows = typeof process !== 'undefined' && process.platform === "win32";
-const isNode = !(isBrowser || isWebWorker);
-
-exports.isBrowser = isBrowser;
-exports.isElectron = isElectron;
-exports.isNode = isNode;
-exports.isWebWorker = isWebWorker;
-exports.isWindows = isWindows;

package/dist/cjs/js/src/base/functions/rsa.js

@@ -1,34 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var JSEncrypt = require('../../static_dependencies/jsencrypt/JSEncrypt.js');
-var index = require('../../static_dependencies/scure-base/index.js');
-var encode = require('./encode.js');
-var crypto = require('./crypto.js');
-
-function rsa(request, secret, hash) {
-    const RSA = new JSEncrypt.JSEncrypt();
-    const digester = (input) => index.base16.encode(hash(input));
-    RSA.setPrivateKey(secret);
-    const name = (hash.create()).constructor.name.toLowerCase();
-    return RSA.sign(request, digester, name);
-}
-function jwt(request, secret, hash, isRSA = false) {
-    const alg = (isRSA ? 'RS' : 'HS') + (hash.outputLen * 8);
-    const encodedHeader = encode.urlencodeBase64(encode.stringToBase64(JSON.stringify({ 'alg': alg, 'typ': 'JWT' })));
-    const encodedData = encode.urlencodeBase64(encode.stringToBase64(JSON.stringify(request)));
-    const token = [encodedHeader, encodedData].join('.');
-    const algoType = alg.slice(0, 2);
-    let signature = undefined;
-    if (algoType === 'HS') {
-        signature = encode.urlencodeBase64(crypto.hmac(token, secret, hash, 'base64'));
-    }
-    else if (algoType === 'RS') {
-        signature = encode.urlencodeBase64(rsa(token, index.utf8.encode(secret), hash));
-    }
-    return [token, signature].join('.');
-}
-
-exports.jwt = jwt;
-exports.rsa = rsa;