easy-currencies 1.10.2 → 2.0.0

package/dist/converter.d.ts

@@ -1,6 +1,8 @@
+import { RetryOptions } from "./parts/requester";
 import { Provider, ProviderReference } from "./parts/providers";
-import { Config, ProxyConfiguration } from "./parts/config";
+import { Config } from "./parts/config";
 export { Chainer as Convert } from "./parts/chainer";
+import { HttpClient } from "./parts/client";
 /**
  * A simple map object for rates
  *
@@ -18,6 +20,17 @@ export interface rateObject {
  * as before.
  */
 export declare const RATES_BASE: unique symbol;
+/**
+ * The enumerable twin of `RATES_BASE`.
+ *
+ * A symbol is invisible to `JSON.stringify`, spread, `Object.assign` and
+ * `structuredClone`, so a table that has been through a cache loses the marker
+ * and a conversion against the wrong base is then accepted silently. That is
+ * the caching workflow this guard exists for, so the base also travels as an
+ * ordinary key. Underscores are not valid in a currency code, see
+ * `CURRENCY_CODE`, so this can never collide with a rate.
+ */
+export declare const RATES_BASE_KEY = "__base";
 /**
  * Regular converter class definition.
  *
@@ -32,6 +45,22 @@ export declare class Converter {
      * @memberof Converter
      */
     config: Config;
+    /**
+     * Called with each handled provider error before the next provider is tried.
+     *
+     * A library does not own the consumer's stderr, so this is the single point
+     * where that reporting happens. It defaults to the previous behaviour;
+     * assign your own to route the errors elsewhere, or assign a no-op to
+     * silence them entirely.
+     *
+     * @example
+     * const converter = new Converter();
+     * converter.onError = () => {};                 // silence
+     * converter.onError = (e) => logger.warn(e);    // or route
+     *
+     * @memberof Converter
+     */
+    onError: (error: unknown) => void;
     /**
      * Creates an instance of Converter.
      * @param {(...ProviderReference[] | undefined[] | string[])} config
@@ -48,15 +77,43 @@ export declare class Converter {
     get providers(): Provider[];
     get active(): Provider[];
     add: Config["add"];
-    addProvider: Config["add"];
     addMultiple: Config["addMultiple"];
-    addMultipleProviders: Config["addMultiple"];
     remove: Config["remove"];
     /**
-     * Method to set the proxy configuration.
-     * @param proxyConfiguration  The proxy configuration.
+     * Replaces the HTTP client.
+     *
+     * The default client uses the global fetch, which has no proxy option, so
+     * proxying (or a custom agent, or instrumentation) means supplying your own.
+     *
+     * @example
+     * import { ProxyAgent } from "undici";
+     * const dispatcher = new ProxyAgent("http://proxy:8080");
+     * converter.setClient({
+     *   get: (url) =>
+     *     fetch(url, { dispatcher } as any).then(async (r) => ({
+     *       status: r.status,
+     *       data: await r.json()
+     *     }))
+     * });
+     *
+     * @param {HttpClient} client - the client to use
+     */
+    setClient: (client: HttpClient) => void;
+    /**
+     * Tunes retries and the time a conversion may take.
+     *
+     * `budgetMs` is wall clock for the whole call, spent across every provider
+     * rather than reset for each one, and it covers the requests themselves: a
+     * client that never settles cannot hold a conversion open past it. Fields
+     * merge, so one can be set without restating the rest.
+     *
+     * @example
+     * converter.setRetryOptions({ budgetMs: 5000 });   // an HTTP handler
+     * converter.setRetryOptions({ maxRetries: 0 });    // never retry a 429
+     *
+     * @param {RetryOptions} options - the tuning to apply
      */
-    setProxyConfiguration: (proxyConfiguration: ProxyConfiguration) => void;
+    setRetryOptions: (options: RetryOptions) => void;
     /**
      * Conversion function (non chainable).
      *
@@ -69,23 +126,35 @@ export declare class Converter {
      * @param {string} from - base currency
      * @param {string} to - conversion currency
      * @param {any} rates - conversion rates, if they were pre-fetched
+     * @throws {Error} - if the amount is not finite, or a currency is missing
      * @returns {Promise<number>} - converted amount
      */
     convert: (amount: number, from: string, to: string, rates?: any) => Promise<number>;
     /**
      * Performs safe multiplication to get the result amount.
+     *
+     * A usable rate is finite and greater than zero; anything else multiplies
+     * into a plausible-looking wrong amount.
+     *
      * @param {number} amount - amount to be converted
      * @param {string} to - conversion currency
      * @param {any} rates - conversion rates, if they were pre-fetched
-     * @returns
+     * @throws {Error} - if the amount, the currency, the rates or the rate is invalid
+     * @returns {number} - converted amount
      */
     convertRate: (amount: number, to: string, rates?: any) => number;
     /**
-     * Rate fetch function
+     * Rate fetch function.
+     *
+     * Walks a snapshot of the chain, so concurrent calls do not shrink each
+     * other's list. A failure applies to the call, not the chain: no provider is
+     * removed, so one unknown currency cannot degrade a long-lived converter.
+     *
      * @param {string} from - base currency
      * @param {string} to - conversion currency
      * @param {boolean} multiple - determines conversion mode
-     * @returns
+     * @throws {Error} - if a currency is missing, or every provider failed
+     * @returns {Promise<rateObject>} - the fetched rates
      */
     getRates: (from: string, to: string, multiple?: boolean) => Promise<rateObject>;
 }

package/dist/converter.js

@@ -8,17 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Converter = exports.RATES_BASE = exports.Convert = void 0;
+exports.Converter = exports.RATES_BASE_KEY = exports.RATES_BASE = exports.Convert = void 0;
 const requester_1 = require("./parts/requester");
 const config_1 = require("./parts/config");
 var chainer_1 = require("./parts/chainer");
 Object.defineProperty(exports, "Convert", { enumerable: true, get: function () { return chainer_1.Chainer; } });
 const utils_1 = require("./parts/utils");
-const axios_1 = __importDefault(require("axios"));
 /**
  * Marks a rate map with the base currency it was fetched for.
  *
@@ -27,6 +23,149 @@ const axios_1 = __importDefault(require("axios"));
  * as before.
  */
 exports.RATES_BASE = Symbol.for("easy-currencies.ratesBase");
+/**
+ * The enumerable twin of `RATES_BASE`.
+ *
+ * A symbol is invisible to `JSON.stringify`, spread, `Object.assign` and
+ * `structuredClone`, so a table that has been through a cache loses the marker
+ * and a conversion against the wrong base is then accepted silently. That is
+ * the caching workflow this guard exists for, so the base also travels as an
+ * ordinary key. Underscores are not valid in a currency code, see
+ * `CURRENCY_CODE`, so this can never collide with a rate.
+ */
+exports.RATES_BASE_KEY = "__base";
+/** The base a table was fetched for, or undefined for one built by hand. */
+function baseOf(rates) {
+    var _a;
+    const marked = (_a = rates[exports.RATES_BASE]) !== null && _a !== void 0 ? _a : rates[exports.RATES_BASE_KEY];
+    return typeof marked === "string" ? marked : undefined;
+}
+/** A rejection that is not contract-shaped is a bug, not a provider failure, and must not trigger fallback. */
+function isProviderFailure(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.handled === "boolean");
+}
+/**
+ * Providers describe failures with strings and numeric codes; consumers write
+ * `catch (e) { log(e.message) }`. Wrap so that reads something, keeping the
+ * original on `cause`.
+ */
+function asError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    const message = typeof value === "string" && value.length > 0
+        ? value
+        : `Rate provider failed: ${String(value)}`;
+    const error = new Error(message);
+    error.cause = value;
+    return error;
+}
+/** Describes a rejected rate without dumping the whole object into the message. */
+function describeRate(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (value === null || typeof value !== "object") {
+        return String(value);
+    }
+    return Array.isArray(value) ? "an array" : "an object";
+}
+/** A currency library must never hand back NaN. */
+function requireAmount(amount) {
+    if (typeof amount !== "number" || !Number.isFinite(amount)) {
+        throw new Error(`Conversion amount must be a finite number, received ${describeRate(amount)}.`);
+    }
+    return amount;
+}
+/**
+ * Asserts that a currency argument is a non-empty string.
+ *
+ * Without this, a missing currency reached the vendor as the literal
+ * `undefined` and came back as a confusing "Currency not found".
+ *
+ * @param {unknown} currency - the value to check
+ * @param {string} label - the parameter name, so the error says which is missing
+ * @returns {string} - the validated currency
+ */
+/**
+ * Every code the configured providers accept is alphanumeric: ISO 4217 is three
+ * letters, and the crypto tickers they carry include `USDT`, `1INCH`, `0G` and
+ * `00`, so neither "starts with a letter" nor "letters only" holds. AlphaVantage
+ * publishes `SBDf`, so the check is case-insensitive.
+ */
+const CURRENCY_CODE = /^[A-Za-z0-9]{1,16}$/;
+function requireCurrency(currency, label) {
+    if (typeof currency !== "string" || currency.trim().length === 0) {
+        throw new Error(`The '${label}' currency must be a non-empty string, received ${describeRate(currency)}.`);
+    }
+    // Encoding alone does not close this: `.` is unreserved in RFC 3986, so
+    // encodeURIComponent("..") is "..", and the URL parser then resolves the dot
+    // segment and climbs the path. Rejecting the value is what actually stops it.
+    if (!CURRENCY_CODE.test(currency)) {
+        throw new Error(`The '${label}' currency must be alphanumeric, received ${describeRate(currency)}.`);
+    }
+    return currency;
+}
+/**
+ * Whether a table holds at least one entry that will actually convert.
+ *
+ * Uses the same coercion as `convertRate`, so a table that passes here cannot
+ * fail every lookup for want of a usable value.
+ */
+function hasUsableRate(rates) {
+    return Object.keys(rates).some((key) => {
+        const raw = rates[key];
+        const value = typeof raw === "number" || typeof raw === "string" ? Number(raw) : NaN;
+        return Number.isFinite(value) && value > 0;
+    });
+}
+/**
+ * Reads the rates out of a successful response.
+ *
+ * Returns the failure rather than throwing, so the caller can move to the next
+ * provider: a vendor answering for a different base, or a handler that trips on
+ * an unexpected shape, says nothing about the providers behind it.
+ */
+function readRates(provider, data, from) {
+    // Some vendors truncate an unrecognised code to a valid prefix and answer for
+    // that instead: exchangerate-api turns "CNYqqqwwC" into "CNY".
+    const echoed = data && (data.base || data.source);
+    if (typeof echoed === "string" && echoed.toLowerCase() !== from.toLowerCase()) {
+        return [
+            new Error(`Provider answered for base '${echoed}', not the requested '${from}'.`),
+            {}
+        ];
+    }
+    let rates;
+    try {
+        rates = provider.handler(data);
+    }
+    catch (e) {
+        return [asError(e), {}];
+    }
+    if (!rates || typeof rates !== "object") {
+        return [new Error("Provider returned no usable rates."), {}];
+    }
+    // Three of the built-in handlers return {} by design when the body is not the
+    // shape they expect, and FloatRates turns a junk 200 into {undefined: NaN}.
+    // Treating that as a successful fetch of zero rates stops the chain with
+    // healthy providers still behind it, and hands raw mode a garbage table.
+    if (!hasUsableRate(rates)) {
+        return [new Error("Provider returned a rate table with no usable rates."), {}];
+    }
+    // Stamp a copy, not the handler's own object. A handler may return a frozen
+    // table, where writing throws, or a memoised one, where a later fetch for a
+    // different base rewrites the marker under a caller still holding it.
+    const marked = Object.assign(Object.assign({}, rates), { [exports.RATES_BASE_KEY]: from });
+    Object.defineProperty(marked, exports.RATES_BASE, {
+        value: from,
+        enumerable: false,
+        configurable: true
+    });
+    return [null, marked];
+}
 /**
  * Regular converter class definition.
  *
@@ -41,11 +180,61 @@ class Converter {
      */
     constructor(...config) {
         /**
-         * Method to set the proxy configuration.
-         * @param proxyConfiguration  The proxy configuration.
+         * Called with each handled provider error before the next provider is tried.
+         *
+         * A library does not own the consumer's stderr, so this is the single point
+         * where that reporting happens. It defaults to the previous behaviour;
+         * assign your own to route the errors elsewhere, or assign a no-op to
+         * silence them entirely.
+         *
+         * @example
+         * const converter = new Converter();
+         * converter.onError = () => {};                 // silence
+         * converter.onError = (e) => logger.warn(e);    // or route
+         *
+         * @memberof Converter
+         */
+        this.onError = (error) => {
+            console.error(error);
+        };
+        /**
+         * Replaces the HTTP client.
+         *
+         * The default client uses the global fetch, which has no proxy option, so
+         * proxying (or a custom agent, or instrumentation) means supplying your own.
+         *
+         * @example
+         * import { ProxyAgent } from "undici";
+         * const dispatcher = new ProxyAgent("http://proxy:8080");
+         * converter.setClient({
+         *   get: (url) =>
+         *     fetch(url, { dispatcher } as any).then(async (r) => ({
+         *       status: r.status,
+         *       data: await r.json()
+         *     }))
+         * });
+         *
+         * @param {HttpClient} client - the client to use
+         */
+        this.setClient = (client) => {
+            this.config.setClient(client);
+        };
+        /**
+         * Tunes retries and the time a conversion may take.
+         *
+         * `budgetMs` is wall clock for the whole call, spent across every provider
+         * rather than reset for each one, and it covers the requests themselves: a
+         * client that never settles cannot hold a conversion open past it. Fields
+         * merge, so one can be set without restating the rest.
+         *
+         * @example
+         * converter.setRetryOptions({ budgetMs: 5000 });   // an HTTP handler
+         * converter.setRetryOptions({ maxRetries: 0 });    // never retry a 429
+         *
+         * @param {RetryOptions} options - the tuning to apply
          */
-        this.setProxyConfiguration = (proxyConfiguration) => {
-            this.config.setClient(axios_1.default.create({ proxy: proxyConfiguration }));
+        this.setRetryOptions = (options) => {
+            this.config.setRetryOptions(options);
         };
         /**
          * Conversion function (non chainable).
@@ -59,13 +248,19 @@ class Converter {
          * @param {string} from - base currency
          * @param {string} to - conversion currency
          * @param {any} rates - conversion rates, if they were pre-fetched
+         * @throws {Error} - if the amount is not finite, or a currency is missing
          * @returns {Promise<number>} - converted amount
          */
         this.convert = (amount_1, from_1, to_1, ...args_1) => __awaiter(this, [amount_1, from_1, to_1, ...args_1], void 0, function* (amount, from, to, rates = undefined) {
+            // Validating before anything is requested: an unset amount used to come
+            // back as NaN, and an unset currency reached the vendor as "undefined".
+            requireAmount(amount);
+            requireCurrency(from, "from");
+            requireCurrency(to, "to");
             // Returining conversion from provided rates
-            if (typeof rates !== "undefined") {
-                const base = rates[exports.RATES_BASE];
-                if (typeof base === "string" &&
+            if (rates !== undefined && rates !== null) {
+                const base = baseOf(rates);
+                if (base !== undefined &&
                     typeof from === "string" &&
                     base.toLowerCase() !== from.toLowerCase()) {
                     throw new Error(`Rates were fetched for base '${base}', but conversion asked for '${from}'.`);
@@ -75,7 +270,7 @@ class Converter {
             //Fetching conversion rates from the active provider
             const [err, data] = yield (0, utils_1._to)(this.getRates(from, to, false));
             if (err) {
-                throw err;
+                throw asError(err);
             }
             if (!data || Object.keys(data).length == 0) {
                 throw new Error("No data returned for rate fetch.");
@@ -85,86 +280,120 @@ class Converter {
         });
         /**
          * Performs safe multiplication to get the result amount.
+         *
+         * A usable rate is finite and greater than zero; anything else multiplies
+         * into a plausible-looking wrong amount.
+         *
          * @param {number} amount - amount to be converted
          * @param {string} to - conversion currency
          * @param {any} rates - conversion rates, if they were pre-fetched
-         * @returns
+         * @throws {Error} - if the amount, the currency, the rates or the rate is invalid
+         * @returns {number} - converted amount
          */
         this.convertRate = (amount, to, rates = undefined) => {
-            const keys = Object.keys(rates);
-            const rateKey = keys.find(key => key.toLowerCase() === to.toLowerCase());
-            const rate = rateKey ? rates[rateKey] : undefined;
-            if (!rate) {
-                throw new Error(`No '${to}' present in rates: ${JSON.stringify(rates, null, 2)}`);
+            var _a;
+            requireAmount(amount);
+            requireCurrency(to, "to");
+            if (typeof rates !== "object" || rates === null) {
+                throw new Error(`Rates must be an object mapping currency to rate, received ${describeRate(rates)}.`);
+            }
+            // The base marker rides along as an ordinary key; it is not a rate, so it
+            // is neither a lookup candidate nor part of the "N rates available" count.
+            const keys = Object.keys(rates).filter((key) => key !== exports.RATES_BASE_KEY);
+            // Exact match wins, so a response carrying both "EUR" and "eur" does not
+            // resolve differently depending on JSON key order.
+            const rateKey = (_a = keys.find((key) => key === to)) !== null && _a !== void 0 ? _a : keys.find((key) => key.toLowerCase() === to.toLowerCase());
+            // Truthiness would report a present-but-zero rate as missing.
+            if (rateKey === undefined) {
+                // The full table is ~4KB in production.
+                throw new Error(`No '${to}' present in rates (${keys.length} rate${keys.length === 1 ? "" : "s"} available).`);
+            }
+            const raw = rates[rateKey];
+            // Number(["0.9"]) === 0.9, so check the type before the value.
+            const numericRate = typeof raw === "number" || typeof raw === "string" ? Number(raw) : NaN;
+            if (!Number.isFinite(numericRate) || numericRate <= 0) {
+                throw new Error(`Invalid rate value for '${to}': expected a finite number greater than zero, received ${describeRate(raw)}.`);
             }
-            const numericRate = parseFloat(rate);
-            if (isNaN(numericRate)) {
-                throw new Error(`Invalid rate value for '${to}': ${rate}`);
+            const converted = amount * numericRate;
+            // Both operands are already finite and the rate is positive, so a result
+            // that is not finite overflowed and a result of zero from a non-zero amount
+            // underflowed. Either way the product is not the answer, and returning it
+            // hands back a wrong number that looks like a right one.
+            if (!Number.isFinite(converted) || (converted === 0 && amount !== 0)) {
+                throw new Error(`Converting ${amount} at rate ${numericRate} is not representable as a number.`);
             }
-            return amount * numericRate;
+            return converted;
         };
         /**
-         * Rate fetch function
+         * Rate fetch function.
+         *
+         * Walks a snapshot of the chain, so concurrent calls do not shrink each
+         * other's list. A failure applies to the call, not the chain: no provider is
+         * removed, so one unknown currency cannot degrade a long-lived converter.
+         *
          * @param {string} from - base currency
          * @param {string} to - conversion currency
          * @param {boolean} multiple - determines conversion mode
-         * @returns
+         * @throws {Error} - if a currency is missing, or every provider failed
+         * @returns {Promise<rateObject>} - the fetched rates
          */
-        this.getRates = (from_2, to_2, ...args_2) => __awaiter(this, [from_2, to_2, ...args_2], void 0, function* (from, to, multiple = false) {
-            // Getting the current active provider
-            const provider = this.config.activeProvider();
+        this.getRates = (from_1, to_1, ...args_1) => __awaiter(this, [from_1, to_1, ...args_1], void 0, function* (from, to, multiple = false) {
+            requireCurrency(from, "from");
+            // In multiple mode the whole table is fetched for the base currency, so
+            // there is no target currency to validate.
+            if (!multiple) {
+                requireCurrency(to, "to");
+            }
+            // Per-call snapshot of the fallback chain.
+            const chain = [...this.config.providers];
+            if (chain.length === 0) {
+                throw new Error("No rate providers are configured.");
+            }
             // Getting the client
             const client = this.config.getClient();
-            // Fetching conversion rates from the active provider.
-            const [err, data] = yield (0, utils_1._to)((0, requester_1.fetchRates)(client, provider, {
-                FROM: from,
-                TO: to,
-                multiple: multiple
-            }));
-            // error handling:
-            // if the error is not in the registered list of errors (is undefined), then throw.
-            // if the error is in the list, but there are no backup providers, then throw.
-            // if the error is in the list and there is a backup, log the error and continue.
-            if (!err) {
-                // Some vendors truncate an unrecognised code to a valid prefix and answer
-                // for that instead: exchangerate-api turns "CNYqqqwwC" into "CNY".
-                const echoed = data && (data.base || data.source);
-                if (typeof echoed === "string" &&
-                    typeof from === "string" &&
-                    echoed.toLowerCase() !== from.toLowerCase()) {
-                    throw new Error(`Provider answered for base '${echoed}', not the requested '${from}'.`);
+            // One deadline for the whole chain. Per provider it would let a
+            // three-provider chain spend three budgets, which is how a rate-limited
+            // conversion reached 102 seconds.
+            const retry = this.config.getRetryOptions();
+            const deadline = (0, requester_1.deadlineFrom)(retry);
+            let lastError = new Error("No rate providers were tried.");
+            for (let index = 0; index < chain.length; index++) {
+                const provider = chain[index];
+                // A whole-table fetch has no target currency, so a provider whose template
+                // needs one cannot serve it: the request would go out asking for an empty
+                // symbol list. That is this provider's limitation, so move to the next.
+                if (multiple && provider.endpoint.single.includes("%TO%")) {
+                    lastError = new Error("Provider cannot fetch a whole rate table; it requires a target currency.");
+                    this.onError(lastError);
+                    continue;
                 }
-                const rates = provider.handler(data);
-                if (rates && typeof rates === "object") {
-                    Object.defineProperty(rates, exports.RATES_BASE, {
-                        value: from,
-                        enumerable: false,
-                        configurable: true
-                    });
+                const [err, data] = yield (0, utils_1._to)((0, requester_1.fetchRates)(client, provider, { FROM: from, TO: to, multiple: multiple }, Object.assign(Object.assign({}, retry), { deadline })));
+                if (!err) {
+                    // A provider answering wrongly, or a handler throwing on a shape it did
+                    // not expect, is that provider's failure. Aborting here would give up on
+                    // the healthy providers behind it.
+                    const [failure, rates] = readRates(provider, data, from);
+                    if (!failure) {
+                        return rates;
+                    }
+                    this.onError(failure);
+                    lastError = failure;
+                    continue;
                 }
-                return rates;
-            }
-            // unrecognized error
-            if (!err.handled) {
-                throw err.error;
-            }
-            // logging existing error
-            console.error(err.error);
-            if (this.config.providers.length <= 1) {
-                throw err.error;
+                // A rejection that does not follow the failure contract was not
+                // classified by the requester, so there is nothing to fall back for.
+                if (!isProviderFailure(err) || !err.handled) {
+                    throw asError(isProviderFailure(err) ? err.error : err);
+                }
+                this.onError(err.error);
+                lastError = asError(err.error);
             }
-            // removing current provider from active list
-            this.config.remove(provider);
-            // Retrying...
-            return this.getRates(from, to, multiple);
+            // Every provider in the snapshot failed.
+            throw lastError;
         });
         this.config = new config_1.Config(...config);
-        // Forwarding config adder function (with the alternative handle)
         this.add = this.config.add;
-        this.addProvider = this.config.add;
-        // Forwarding config multiple adder function (with the alternative handle)
         this.addMultiple = this.config.addMultiple;
-        this.addMultipleProviders = this.config.addMultiple;
         this.remove = this.config.remove;
     }
     /**
@@ -175,11 +404,13 @@ class Converter {
      * @memberof Converter
      */
     get providers() {
-        return this.config.providers;
+        // A copy: the readme tells callers to read this, and handing back the live
+        // array lets `providers.length = 0` empty the chain.
+        return [...this.config.providers];
     }
     get active() {
-        return this.config.providers;
+        return [...this.config.providers];
     }
 }
 exports.Converter = Converter;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"converter.js","sourceRoot":"","sources":["../src/converter.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export { Converter, Convert } from "./converter";
+export { Converter, Convert, RATES_BASE_KEY } from "./converter";
 export { providers } from "./parts/providers";
 export type { rateObject } from "./converter";
 export type { Provider, ProviderErrors, ProviderReference, Providers, UserDefinedProvider } from "./parts/providers";
-export type { Config, ProxyConfiguration } from "./parts/config";
+export type { Config } from "./parts/config";
+export type { HttpClient, HttpResponse, HttpError, ClientOptions } from "./parts/client";
+export { createClient } from "./parts/client";
 export type { chainableConverter } from "./parts/chainer";
+export type { RetryOptions } from "./parts/requester";