@ethersphere/bee-js 3.2.0 → 3.3.0

package/dist/mjs/utils/data.js

@@ -0,0 +1,39 @@
+import Blob from 'cross-blob';
+import { isNodeReadable, isReadableStream, readableWebToNode } from './stream';
+/**
+ * Prepare data for valid input for node-fetch.
+ *
+ * node-fetch is not using WHATWG ReadableStream but NodeJS Readable so we need to convert in case of ReadableStream,
+ * but the typings are set to use ReadableStream so hence why type conversion here.
+ *
+ * @param data any string, ArrayBuffer, Uint8Array or Readable
+ */
+export async function prepareData(data) {
+    if (typeof data === 'string')
+        return new Blob([data], { type: 'text/plain' });
+    if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+        return new Blob([data], { type: 'application/octet-stream' });
+    }
+    if (data instanceof Blob || isNodeReadable(data))
+        return data;
+    if (isReadableStream(data)) {
+        return readableWebToNode(data);
+    }
+    throw new TypeError('unknown data type');
+}
+function isBufferArray(buffer) {
+    return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
+}
+export async function prepareWebsocketData(data) {
+    if (typeof data === 'string')
+        return new TextEncoder().encode(data);
+    if (data instanceof Buffer)
+        return new Uint8Array(data);
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (data instanceof Blob)
+        return new Uint8Array(await new Response(data).arrayBuffer());
+    if (isBufferArray(data))
+        return new Uint8Array(Buffer.concat(data));
+    throw new TypeError('unknown websocket data type');
+}

package/dist/mjs/utils/error.js

@@ -0,0 +1,48 @@
+export class BeeError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+export class BeeArgumentError extends BeeError {
+    value;
+    constructor(message, value) {
+        super(message);
+        this.value = value;
+    }
+}
+export class BeeRequestError extends BeeError {
+    requestOptions;
+    /**
+     * @param message
+     * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
+     */
+    constructor(message, requestOptions) {
+        super(message);
+        this.requestOptions = requestOptions;
+    }
+}
+export class BeeResponseError extends BeeError {
+    status;
+    response;
+    responseBody;
+    requestOptions;
+    /**
+     * @param status HTTP status code number
+     * @param response Response returned from the server
+     * @param responseBody Response body as string which is returned from response.text() call
+     * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
+     * @param message
+     */
+    constructor(status, response, responseBody, requestOptions, message) {
+        super(message);
+        this.status = status;
+        this.response = response;
+        this.responseBody = responseBody;
+        this.requestOptions = requestOptions;
+    }
+}
+export class BeeNotAJsonError extends BeeError {
+    constructor() {
+        super(`Received response is not valid JSON.`);
+    }
+}

package/dist/mjs/utils/eth.js

@@ -0,0 +1,184 @@
+import { keccak256, sha3_256 } from 'js-sha3';
+import { hexToBytes, intToHex, makeHexString, assertHexString } from './hex';
+import { assertBytes } from './bytes';
+const ETH_ADDR_BYTES_LENGTH = 20;
+const ETH_ADDR_HEX_LENGTH = 40;
+export function makeEthAddress(address) {
+    if (typeof address === 'string') {
+        const hexAddr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
+        const ownerBytes = hexToBytes(hexAddr);
+        assertBytes(ownerBytes, ETH_ADDR_BYTES_LENGTH);
+        return ownerBytes;
+    }
+    else if (address instanceof Uint8Array) {
+        assertBytes(address, ETH_ADDR_BYTES_LENGTH);
+        return address;
+    }
+    throw new TypeError('Invalid EthAddress');
+}
+export function makeHexEthAddress(address) {
+    try {
+        return makeHexString(address, ETH_ADDR_HEX_LENGTH);
+    }
+    catch (e) {
+        if (e instanceof TypeError) {
+            e.message = `Invalid HexEthAddress: ${e.message}`;
+        }
+        throw e;
+    }
+}
+/**
+ * Check if this is all caps or small caps eth address (=address without checksum)
+ *
+ * @param address Ethereum address as hex string
+ */
+function isEthAddrCaseIns(address) {
+    // Check it's string, all small caps or all all caps hex and 40 chars long without the `0x` prefix
+    return (typeof address === 'string' && (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)));
+}
+/**
+ * Check if this is checksummed ethereum address
+ *
+ * @param address Ethereum address as hex string
+ */
+function isValidChecksummedEthAddress(address) {
+    try {
+        // Check for valid case insensitive hex type string, 40 chars
+        const addr = makeHexString(address, ETH_ADDR_HEX_LENGTH);
+        // Check the checksum
+        const addressHash = keccak256(addr.toLowerCase());
+        for (let i = 0; i < 40; i += 1) {
+            // the nth letter should be uppercase if the nth digit of casemap is 1
+            if ((parseInt(addressHash[i], 16) > 7 && addr[i].toUpperCase() !== addr[i]) ||
+                (parseInt(addressHash[i], 16) <= 7 && addr[i].toLowerCase() !== addr[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        if (e instanceof TypeError) {
+            return false;
+        }
+        throw e;
+    }
+}
+/**
+ * Check if is valid ethereum address
+ *
+ * Pretty much typed version from web3js
+ * https://github.com/ChainSafe/web3.js/blob/1.x/packages/web3-utils/src/utils.js
+ *
+ * @param address  Ethereum address as hex string
+ *
+ * @return True if is valid eth address
+ */
+export function isHexEthAddress(address) {
+    return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
+}
+/**
+ * Convert big-endian hex or number to little-endian.
+ * Note: Before conversion it is automatically padded to even length hexstring
+ *
+ * @param bigEndian Big-endian hex string or number to convert
+ * @param pad       Length to which the string should be padded before conversion (defaul: 2)
+ *
+ * @return little-endian encoded hexstring
+ */
+export function toLittleEndian(bigEndian, pad = 2) {
+    if (!(Number.isInteger(pad) && pad >= 2 && pad % 2 === 0)) {
+        throw new TypeError('minimal padding for conversion needs to be positive even integer');
+    }
+    let hexRep;
+    if (typeof bigEndian === 'string')
+        hexRep = makeHexString(bigEndian);
+    else if (typeof bigEndian === 'number')
+        hexRep = intToHex(bigEndian);
+    else
+        throw new TypeError('incorrect input type');
+    hexRep = hexRep.padStart(pad, '0');
+    // Extend to an even length hexstring
+    if (hexRep.length % 2 !== 0)
+        hexRep = hexRep.padStart(hexRep.length + 1, '0');
+    // Match all two pairs in the hexstring, reverse the pairs and join it again
+    const littleEndian = hexRep.match(/../g)?.reverse().join('');
+    if (littleEndian)
+        return littleEndian;
+    throw new Error('failed to convert');
+}
+/**
+ * Convert little-endian hex or number to big-endian
+ * Note: Before conversion it is automatically padded to even length hexstring
+ *
+ * @param littleEndian Little-endian hex string or number to convert
+ * @param pad          Length to which the string should be padded before conversion (defaul: 2)
+ *
+ * @return big-endian encoded hexstring
+ */
+export function fromLittleEndian(littleEndian, pad = 2) {
+    // It's a reversible function
+    return toLittleEndian(littleEndian, pad);
+}
+function assertEthAddress(ethAddress) {
+    if (!isHexEthAddress(ethAddress))
+        throw new TypeError('invalid ETH address');
+}
+function assertSwarmNetworkId(networkId) {
+    if (Number.isInteger(networkId && networkId > 0 && networkId < Number.MAX_SAFE_INTEGER)) {
+        throw new TypeError('swarm network id must be positive integer');
+    }
+}
+/**
+ * Get swarm overlay address from public ethereum address and swarm network id
+ *
+ * @param ethAddress  Public ethereum address
+ * @param networkId   Swarm network id
+ *
+ * @return Swarm overlay address
+ */
+export function ethToSwarmAddress(ethAddress, networkId = 1) {
+    assertEthAddress(ethAddress);
+    assertSwarmNetworkId(networkId);
+    const hex = `${makeHexString(ethAddress)}${toLittleEndian(networkId, 16)}`;
+    assertHexString(hex);
+    const overlayAddress = sha3_256(hexToBytes(hex));
+    return overlayAddress;
+}
+/**
+ * Function that takes Ethereum EIP-1193 compatible provider and create an Signer instance that
+ * uses `personal_sign` method to sign requested data.
+ *
+ * @param provider Injected web3 provider like window.ethereum or other compatible with EIP-1193
+ * @param ethAddress Optional address of the account which the data should be signed with. If not specified `eth_requestAccounts` request is used to get the account address.
+ */
+export async function makeEthereumWalletSigner(provider, ethAddress) {
+    let executorFnc;
+    if (typeof provider !== 'object' || provider === null) {
+        throw new TypeError('We need JsonRPC provider object!');
+    }
+    if (provider.request) {
+        executorFnc = provider.request;
+    }
+    else if (provider.sendAsync) {
+        executorFnc = provider.sendAsync;
+    }
+    else {
+        throw new Error('Incompatible interface of given provider!');
+    }
+    if (!ethAddress) {
+        ethAddress = (await executorFnc({ method: 'eth_requestAccounts' }))[0];
+    }
+    const bytesEthAddress = makeEthAddress(ethAddress);
+    const hexEthAddress = makeHexEthAddress(ethAddress);
+    return {
+        address: bytesEthAddress,
+        sign: async (data) => {
+            const result = await executorFnc({
+                jsonrpc: '2.0',
+                method: 'personal_sign',
+                params: ['0x' + data.hex(), '0x' + hexEthAddress],
+            });
+            return result;
+        },
+    };
+}

package/dist/mjs/utils/expose.js

@@ -0,0 +1,9 @@
+export { getCollectionSize } from './collection';
+export { getFolderSize } from './collection.node';
+export { isBytes, assertBytes, isFlexBytes, assertFlexBytes, bytesAtOffset, flexBytesAtOffset, bytesEqual, } from './bytes';
+export { makeHexString, hexToBytes, bytesToHex, intToHex, isHexString, assertHexString, assertPrefixedHexString, } from './hex';
+export { makeEthAddress, makeHexEthAddress, isHexEthAddress, ethToSwarmAddress, toLittleEndian, fromLittleEndian, makeEthereumWalletSigner, } from './eth';
+export { readableWebToNode, readableNodeToWeb, isReadableStream, isNodeReadable, normalizeToReadableStream, isReadable, } from './stream';
+export { keccak256Hash } from './hash';
+export { makeMaxTarget } from './pss';
+export { getStampUsage } from './stamps';

package/dist/mjs/utils/file.js

@@ -0,0 +1,33 @@
+/**
+ * Compatibility functions for working with File API objects
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/File
+ */
+export function isFile(file) {
+    // browser
+    if (typeof File === 'function') {
+        return file instanceof File;
+    }
+    // node.js
+    const f = file;
+    return (typeof f === 'object' &&
+        typeof f.name === 'string' &&
+        (typeof f.stream === 'function' || typeof f.arrayBuffer === 'function'));
+}
+/**
+ * Compatibility helper for browsers where the `arrayBuffer function is
+ * missing from `File` objects.
+ *
+ * @param file A File object
+ */
+export async function fileArrayBuffer(file) {
+    if (file.arrayBuffer) {
+        return file.arrayBuffer();
+    }
+    // workaround for Safari where arrayBuffer is not supported on Files
+    return new Promise(resolve => {
+        const fr = new FileReader();
+        fr.onload = () => resolve(fr.result);
+        fr.readAsArrayBuffer(file);
+    });
+}

package/dist/mjs/utils/hash.js

@@ -0,0 +1,12 @@
+import { keccak256 } from 'js-sha3';
+/**
+ * Helper function for calculating the keccak256 hash with
+ * correct types.
+ *
+ * @param messages Any number of messages (strings, byte arrays etc.)
+ */
+export function keccak256Hash(...messages) {
+    const hasher = keccak256.create();
+    messages.forEach(bytes => hasher.update(bytes));
+    return Uint8Array.from(hasher.digest());
+}

package/dist/mjs/utils/headers.js

@@ -0,0 +1,54 @@
+import { BeeError } from './error';
+/**
+ * Read the filename from the content-disposition header
+ * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
+ *
+ * @param header the content-disposition header value
+ *
+ * @returns the filename
+ */
+function readContentDispositionFilename(header) {
+    if (!header) {
+        throw new BeeError('missing content-disposition header');
+    }
+    // Regex was found here
+    // https://stackoverflow.com/questions/23054475/javascript-regex-for-extracting-filename-from-content-disposition-header
+    const dispositionMatch = header.match(/filename\*?=['"]?(?:UTF-\d['"]*)?([^;\r\n"']*)['"]?;?/i);
+    if (dispositionMatch && dispositionMatch.length > 0) {
+        return dispositionMatch[1];
+    }
+    throw new BeeError('invalid content-disposition header');
+}
+function readTagUid(header) {
+    if (!header) {
+        return undefined;
+    }
+    return parseInt(header, 10);
+}
+export function readFileHeaders(headers) {
+    const name = readContentDispositionFilename(headers.get('content-disposition'));
+    const tagUid = readTagUid(headers.get('swarm-tag-uid'));
+    const contentType = headers.get('content-type') || undefined;
+    return {
+        name,
+        tagUid,
+        contentType,
+    };
+}
+export function extractUploadHeaders(postageBatchId, options) {
+    if (!postageBatchId) {
+        throw new BeeError('Postage BatchID has to be specified!');
+    }
+    const headers = {
+        'swarm-postage-batch-id': postageBatchId,
+    };
+    if (options?.pin)
+        headers['swarm-pin'] = String(options.pin);
+    if (options?.encrypt)
+        headers['swarm-encrypt'] = String(options.encrypt);
+    if (options?.tag)
+        headers['swarm-tag'] = String(options.tag);
+    if (typeof options?.deferred === 'boolean')
+        headers['swarm-deferred-upload'] = options.deferred.toString();
+    return headers;
+}

package/dist/mjs/utils/hex.js

@@ -0,0 +1,139 @@
+import { makeBytes } from './bytes';
+/**
+ * Creates unprefixed hex string from wide range of data.
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param input
+ * @param len of the resulting HexString WITHOUT prefix!
+ */
+export function makeHexString(input, len) {
+    if (typeof input === 'number') {
+        return intToHex(input, len);
+    }
+    if (input instanceof Uint8Array) {
+        return bytesToHex(input, len);
+    }
+    if (typeof input === 'string') {
+        if (isPrefixedHexString(input)) {
+            const hex = input.slice(2);
+            if (len && hex.length !== len) {
+                throw new TypeError(`Length mismatch for valid hex string. Expecting length ${len}: ${hex}`);
+            }
+            return hex;
+        }
+        else {
+            // We use assertHexString() as there might be more reasons why a string is not valid hex string
+            // and usage of isHexString() would not give enough information to the user on what is going
+            // wrong.
+            assertHexString(input, len);
+            return input;
+        }
+    }
+    throw new TypeError('Not HexString compatible type!');
+}
+/**
+ * Converts a hex string to Uint8Array
+ *
+ * @param hex string input without 0x prefix!
+ */
+export function hexToBytes(hex) {
+    assertHexString(hex);
+    const bytes = makeBytes(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        const hexByte = hex.substr(i * 2, 2);
+        bytes[i] = parseInt(hexByte, 16);
+    }
+    return bytes;
+}
+/**
+ * Converts array of number or Uint8Array to HexString without prefix.
+ *
+ * @param bytes   The input array
+ * @param len     The length of the non prefixed HexString
+ */
+export function bytesToHex(bytes, len) {
+    const hexByte = (n) => n.toString(16).padStart(2, '0');
+    const hex = Array.from(bytes, hexByte).join('');
+    // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+    if (len && hex.length !== len) {
+        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+    }
+    return hex;
+}
+/**
+ * Converts integer number to hex string.
+ *
+ * Optionally provides '0x' prefix or padding
+ *
+ * @param int         The positive integer to be converted
+ * @param len     The length of the non prefixed HexString
+ */
+export function intToHex(int, len) {
+    if (!Number.isInteger(int))
+        throw new TypeError('the value provided is not integer');
+    if (int > Number.MAX_SAFE_INTEGER)
+        throw new TypeError('the value provided exceeds safe integer');
+    if (int < 0)
+        throw new TypeError('the value provided is a negative integer');
+    const hex = int.toString(16);
+    // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+    if (len && hex.length !== len) {
+        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+    }
+    return hex;
+}
+/**
+ * Type guard for HexStrings.
+ * Requires no 0x prefix!
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ */
+export function isHexString(s, len) {
+    return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
+}
+/**
+ * Type guard for PrefixedHexStrings.
+ * Does enforce presence of 0x prefix!
+ *
+ * @param s string input
+ */
+export function isPrefixedHexString(s) {
+    return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
+}
+/**
+ * Verifies if the provided input is a HexString.
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ * @param name optional name for the asserted value
+ * @returns HexString or throws error
+ */
+export function assertHexString(s, len, name = 'value') {
+    if (!isHexString(s, len)) {
+        if (isPrefixedHexString(s)) {
+            throw new TypeError(`${name} not valid non prefixed hex string (has 0x prefix): ${s}`);
+        }
+        // Don't display length error if no length specified in order not to confuse user
+        const lengthMsg = len ? ` of length ${len}` : '';
+        throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
+    }
+}
+/**
+ * Verifies if the provided input is a PrefixedHexString.
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ * @param name optional name for the asserted value
+ * @returns HexString or throws error
+ */
+export function assertPrefixedHexString(s, name = 'value') {
+    if (!isPrefixedHexString(s)) {
+        throw new TypeError(`${name} not valid prefixed hex string: ${s}`);
+    }
+}

package/dist/mjs/utils/http.js

@@ -0,0 +1,136 @@
+import { BeeError, BeeNotAJsonError, BeeRequestError, BeeResponseError } from './error';
+import kyFactory from 'ky-universal';
+import { normalizeToReadableStream } from './stream';
+import { deepMerge } from './merge';
+import { isObject, isStrictlyObject } from './type';
+const DEFAULT_KY_CONFIG = {
+    headers: {
+        accept: 'application/json, text/plain, */*',
+        'user-agent': `bee-js`,
+    },
+};
+function isHttpError(e) {
+    return isObject(e) && typeof e.response !== 'undefined';
+}
+function isHttpRequestError(e) {
+    return isObject(e) && typeof e.request !== 'undefined';
+}
+function headersToObject(header) {
+    return [...header.entries()].reduce((obj, [key, val]) => {
+        obj[key] = val;
+        return obj;
+    }, {});
+}
+function wrapRequest(request) {
+    return {
+        url: request.url,
+        method: request.method.toUpperCase(),
+        headers: headersToObject(request.headers),
+    };
+}
+export function wrapRequestClosure(cb) {
+    return async (request) => {
+        await cb(wrapRequest(request));
+    };
+}
+export function wrapResponseClosure(cb) {
+    return async (request, options, response) => {
+        await cb({
+            headers: headersToObject(response.headers),
+            status: response.status,
+            statusText: response.statusText,
+            request: wrapRequest(request),
+        });
+    };
+}
+/**
+ * Filters out entries that has undefined value from headers object.
+ * Modifies the original object!
+ *
+ * @param obj
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function filterHeaders(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    isStrictlyObject(obj);
+    const typedObj = obj;
+    for (const key in typedObj) {
+        if (typedObj[key] === undefined) {
+            delete typedObj[key];
+        }
+    }
+    if (Object.keys(typedObj).length === 0) {
+        return undefined;
+    }
+    return typedObj;
+}
+/**
+ * Main utility function to make HTTP requests.
+ * @param ky
+ * @param config
+ */
+export async function http(ky, config) {
+    try {
+        const { path, responseType, ...kyConfig } = config;
+        const response = (await ky(path, {
+            ...kyConfig,
+            searchParams: filterHeaders(kyConfig.searchParams),
+        }));
+        switch (responseType) {
+            case 'stream':
+                if (!response.body) {
+                    throw new BeeError('Response was expected to get data but did not get any!');
+                }
+                response.data = normalizeToReadableStream(response.body);
+                break;
+            case 'arraybuffer':
+                response.data = (await response.arrayBuffer());
+                break;
+            case 'json':
+                try {
+                    response.data = (await response.json());
+                }
+                catch (e) {
+                    throw new BeeNotAJsonError();
+                }
+                break;
+            default:
+                break; // If responseType is not set, then no data are expected
+        }
+        return response;
+    }
+    catch (e) {
+        // Passthrough thrown errors
+        if (e instanceof BeeNotAJsonError) {
+            throw e;
+        }
+        if (isHttpError(e)) {
+            let message;
+            // We store the response body here as it can be read only once in Response's lifecycle so to make it exposed
+            // to the user in the BeeResponseError, for further analysis.
+            const body = await e.response.text();
+            try {
+                // The response can be Bee's JSON with structure `{code, message}` lets try to parse it
+                message = JSON.parse(body).message;
+            }
+            catch (e) { }
+            if (message) {
+                throw new BeeResponseError(e.response.status, e.response, body, config, `${e.response.statusText}: ${message}`);
+            }
+            else {
+                throw new BeeResponseError(e.response.status, e.response, body, config, e.response.statusText);
+            }
+        }
+        else if (isHttpRequestError(e)) {
+            throw new BeeRequestError(e.message, config);
+        }
+        else {
+            throw new BeeError(e.message);
+        }
+    }
+}
+export function makeDefaultKy(kyConfig) {
+    return kyFactory.create(deepMerge(DEFAULT_KY_CONFIG, kyConfig));
+}

package/dist/mjs/utils/merge.js

@@ -0,0 +1,30 @@
+import { isObject } from './type';
+/**
+ * Function that deep merges objects
+ *
+ * @copyright https://github.com/sindresorhus/ky/blob/b3c9e88fa49d50150dbb6e6b771b4af56cb40c98/source/utils/merge.ts
+ * @licence MIT
+ * @param sources
+ */
+export function deepMerge(...sources) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let returnValue = {};
+    for (const source of sources) {
+        if (Array.isArray(source)) {
+            if (!Array.isArray(returnValue)) {
+                returnValue = [];
+            }
+            returnValue = [...returnValue, ...source];
+        }
+        else if (isObject(source)) {
+            // eslint-disable-next-line prefer-const
+            for (let [key, value] of Object.entries(source)) {
+                if (isObject(value) && key in returnValue) {
+                    value = deepMerge(returnValue[key], value);
+                }
+                returnValue = { ...returnValue, [key]: value };
+            }
+        }
+    }
+    return returnValue;
+}