function stringifyIndent (key, value, stack, spacer, indentation) {
	    switch (typeof value) {
	      case 'string':
	        return `"${strEscape(value)}"`
	      case 'object': {
	        if (value === null) {
	          return 'null'
	        }
	        if (typeof value.toJSON === 'function') {
	          value = value.toJSON(key);
	          // Prevent calling `toJSON` again.
	          if (typeof value !== 'object') {
	            return stringifyIndent(key, value, stack, spacer, indentation)
	          }
	          if (value === null) {
	            return 'null'
	          }
	        }
	        if (stack.indexOf(value) !== -1) {
	          return circularValue
	        }
	        const originalIndentation = indentation;

	        if (Array.isArray(value)) {
	          if (value.length === 0) {
	            return '[]'
	          }
	          if (maximumDepth < stack.length + 1) {
	            return '"[Array]"'
	          }
	          stack.push(value);
	          indentation += spacer;
	          let res = `\n${indentation}`;
	          const join = `,\n${indentation}`;
	          const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
	          let i = 0;
	          for (; i < maximumValuesToStringify - 1; i++) {
	            const tmp = stringifyIndent(i, value[i], stack, spacer, indentation);
	            res += tmp !== undefined ? tmp : 'null';
	            res += join;
	          }
	          const tmp = stringifyIndent(i, value[i], stack, spacer, indentation);
	          res += tmp !== undefined ? tmp : 'null';
	          if (value.length - 1 > maximumBreadth) {
	            const removedKeys = value.length - maximumBreadth - 1;
	            res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
	          }
	          res += `\n${originalIndentation}`;
	          stack.pop();
	          return `[${res}]`
	        }

	        let keys = Object.keys(value);
	        const keyLength = keys.length;
	        if (keyLength === 0) {
	          return '{}'
	        }
	        if (maximumDepth < stack.length + 1) {
	          return '"[Object]"'
	        }
	        indentation += spacer;
	        const join = `,\n${indentation}`;
	        let res = '';
	        let separator = '';
	        let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
	        if (isTypedArrayWithEntries(value)) {
	          res += stringifyTypedArray(value, join, maximumBreadth);
	          keys = keys.slice(value.length);
	          maximumPropertiesToStringify -= value.length;
	          separator = join;
	        }
	        if (deterministic) {
	          keys = insertSort(keys);
	        }
	        stack.push(value);
	        for (let i = 0; i < maximumPropertiesToStringify; i++) {
	          const key = keys[i];
	          const tmp = stringifyIndent(key, value[key], stack, spacer, indentation);
	          if (tmp !== undefined) {
	            res += `${separator}"${strEscape(key)}": ${tmp}`;
	            separator = join;
	          }
	        }
	        if (keyLength > maximumBreadth) {
	          const removedKeys = keyLength - maximumBreadth;
	          res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
	          separator = join;
	        }
	        if (separator !== '') {
	          res = `\n${indentation}${res}\n${originalIndentation}`;
	        }
	        stack.pop();
	        return `{${res}}`
	      }
	      case 'number':
	        return isFinite(value) ? String(value) : fail ? fail(value) : 'null'
	      case 'boolean':
	        return value === true ? 'true' : 'false'
	      case 'undefined':
	        return undefined
	      case 'bigint':
	        if (bigint) {
	          return String(value)
	        }
	        // fallthrough
	      default:
	        return fail ? fail(value) : undefined
	    }
	  }
Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
If the associated stream is errored when the lock is released, the reader will appear errored in the same way
from now on; otherwise, the reader will appear closed.

A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
do so will throw a `TypeError` and leave the reader locked to the stream.