Node.js v25.0.0 ドキュメンテーション

new ReadableStream([underlyingSource [, strategy]])#

• underlyingSource <Object>
  • start <Function> ReadableStream が作成されるとすぐに呼び出されるユーザー定義関数。
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • 戻り値: undefined または undefined で解決される promise。
  • pull <Function> ReadableStream の内部キューが一杯でないときに繰り返し呼び出されるユーザー定義関数。操作は同期または非同期で行うことができます。非同期の場合、以前に返された promise が解決されるまで、この関数は再度呼び出されません。
    • controller <ReadableStreamDefaultController> | <ReadableByteStreamController>
    • 戻り値: undefined で解決される promise。
  • cancel <Function> ReadableStream がキャンセルされたときに呼び出されるユーザー定義関数。
    • reason <any>
    • 戻り値: undefined で解決される promise。
  • type <string> 'bytes' または undefined でなければなりません。
  • autoAllocateChunkSize <number> type が 'bytes' に等しい場合にのみ使用されます。ゼロ以外の値に設定すると、ビューバッファが ReadableByteStreamController.byobRequest に自動的に割り当てられます。設定されていない場合、デフォルトリーダー ReadableStreamDefaultReader を介してデータを転送するためにストリームの内部キューを使用する必要があります。
• strategy <Object>
  • highWaterMark <number> バックプレッシャーが適用される前の最大内部キューサイズ。
  • size <Function> 各データチャンクのサイズを識別するために使用されるユーザー定義関数。
    • chunk <any>
    • 戻り値: <number>

readableStream.locked#

• 型: <boolean> この <ReadableStream> にアクティブなリーダーがある場合に true に設定されます。

readableStream.locked プロパティはデフォルトで false であり、ストリームのデータを消費するアクティブなリーダーがある間は true に切り替えられます。

readableStream.cancel([reason])#

• reason <any>
• 戻り値: キャンセルが完了すると undefined で解決される promise。

readableStream.getReader([options])#

• options <Object>
  • mode <string> 'byob' または undefined
• 戻り値: <ReadableStreamDefaultReader> | <ReadableStreamBYOBReader>

import { ReadableStream } from 'node:stream/web';

const stream = new ReadableStream();

const reader = stream.getReader();

console.log(await reader.read());const { ReadableStream } = require('node:stream/web');

const stream = new ReadableStream();

const reader = stream.getReader();

reader.read().then(console.log);copy

readableStream.locked を true にします。

readableStream.pipeThrough(transform[, options])#

• transform <Object>
  • readable <ReadableStream> この ReadableStream から受け取った、潜在的に変更されたデータを transform.writable がプッシュする ReadableStream。
  • writable <WritableStream> この ReadableStream のデータが書き込まれる WritableStream。
• options <Object>
  • preventAbort <boolean> true の場合、この ReadableStream のエラーは transform.writable が中断される原因にはなりません。
  • preventCancel <boolean> true の場合、宛先 transform.writable のエラーは、この ReadableStream がキャンセルされる原因にはなりません。
  • preventClose <boolean> true の場合、この ReadableStream を閉じても transform.writable は閉じられません。
  • signal <AbortSignal> <AbortController> を使用してデータ転送をキャンセルできます。
• 戻り値: <ReadableStream> transform.readable から。

この <ReadableStream> を、transform 引数で提供される <ReadableStream> と <WritableStream> のペアに接続し、この <ReadableStream> からのデータが transform.writable に書き込まれ、場合によっては変換されてから transform.readable にプッシュされるようにします。パイプラインが設定されると、transform.readable が返されます。

パイプ操作がアクティブな間、readableStream.locked を true にします。

import {
  ReadableStream,
  TransformStream,
} from 'node:stream/web';

const stream = new ReadableStream({
  start(controller) {
    controller.enqueue('a');
  },
});

const transform = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

const transformedStream = stream.pipeThrough(transform);

for await (const chunk of transformedStream)
  console.log(chunk);
  // Prints: Aconst {
  ReadableStream,
  TransformStream,
} = require('node:stream/web');

const stream = new ReadableStream({
  start(controller) {
    controller.enqueue('a');
  },
});

const transform = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

const transformedStream = stream.pipeThrough(transform);

(async () => {
  for await (const chunk of transformedStream)
    console.log(chunk);
    // Prints: A
})();copy

readableStream.pipeTo(destination[, options])#

• destination <WritableStream> この ReadableStream のデータが書き込まれる <WritableStream>。
• options <Object>
  • preventAbort <boolean> true の場合、この ReadableStream のエラーは destination が中断される原因にはなりません。
  • preventCancel <boolean> true の場合、destination のエラーはこの ReadableStream がキャンセルされる原因にはなりません。
  • preventClose <boolean> true の場合、この ReadableStream を閉じても destination は閉じられません。
  • signal <AbortSignal> <AbortController> を使用してデータ転送をキャンセルできます。
• 戻り値: undefined で解決される promise

パイプ操作がアクティブな間、readableStream.locked を true にします。

readableStream.tee()#

• 戻り値: <ReadableStream[]>

この ReadableStream のデータが転送される、新しい <ReadableStream> インスタンスのペアを返します。各インスタンスは同じデータを受け取ります。

readableStream.locked を true にします。

readableStream.values([options])#

• options <Object>
  • preventCancel <boolean> true の場合、非同期イテレータが突然終了したときに <ReadableStream> が閉じられるのを防ぎます。デフォルト: false。

この ReadableStream のデータを消費するために使用できる非同期イテレータを作成して返します。

非同期イテレータがアクティブな間、readableStream.locked を true にします。

import { Buffer } from 'node:buffer';

const stream = new ReadableStream(getSomeSource());

for await (const chunk of stream.values({ preventCancel: true }))
  console.log(Buffer.from(chunk).toString()); copy

非同期イテレーション#

<ReadableStream> オブジェクトは、for await 構文を使用して非同期イテレータプロトコルをサポートします。

import { Buffer } from 'node:buffer';

const stream = new ReadableStream(getSomeSource());

for await (const chunk of stream)
  console.log(Buffer.from(chunk).toString()); copy

非同期イテレータは、終了するまで <ReadableStream> を消費します。

デフォルトでは、非同期イテレータが早期に終了した場合 (break、return、または throw のいずれかによる)、<ReadableStream> は閉じられます。<ReadableStream> が自動的に閉じられるのを防ぐには、readableStream.values() メソッドを使用して非同期イテレータを取得し、preventCancel オプションを true に設定します。

<ReadableStream> はロックされていてはなりません (つまり、既存のアクティブなリーダーがあってはなりません)。非同期イテレーション中、<ReadableStream> はロックされます。

postMessage() を使った転送#

<ReadableStream> インスタンスは <MessagePort> を使用して転送できます。

const stream = new ReadableStream(getReadableSourceSomehow());

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => {
  data.getReader().read().then((chunk) => {
    console.log(chunk);
  });
};

port2.postMessage(stream, [stream]); copy

new ReadableStreamDefaultReader(stream)#

• stream <ReadableStream>

指定された <ReadableStream> にロックされた新しい <ReadableStreamDefaultReader> を作成します。

readableStreamDefaultReader.cancel([reason])#

• reason <any>
• 戻り値: undefined で解決される promise。

<ReadableStream> をキャンセルし、基になるストリームがキャンセルされたときに解決される promise を返します。

readableStreamDefaultReader.closed#

• 型: <Promise> 関連付けられた <ReadableStream> が閉じられたときに undefined で解決されます。ストリームがエラーになった場合、またはストリームが閉じる前にリーダーのロックが解放された場合は拒否されます。

readableStreamDefaultReader.read()#

• 戻り値: オブジェクトで解決される promise
  • value <any>
  • done <boolean>

基になる <ReadableStream> から次のデータチャンクを要求し、データが利用可能になるとそのデータで解決される promise を返します。

readableStreamDefaultReader.releaseLock()#

このリーダーの基になる <ReadableStream> に対するロックを解放します。

new ReadableStreamBYOBReader(stream)#

• stream <ReadableStream>

指定された <ReadableStream> にロックされた新しい ReadableStreamBYOBReader を作成します。

readableStreamBYOBReader.cancel([reason])#

• reason <any>
• 戻り値: undefined で解決される promise。

<ReadableStream> をキャンセルし、基になるストリームがキャンセルされたときに解決される promise を返します。

readableStreamBYOBReader.closed#

• 型: <Promise> 関連付けられた <ReadableStream> が閉じられたときに undefined で解決されます。ストリームがエラーになった場合、またはストリームが閉じる前にリーダーのロックが解放された場合は拒否されます。

readableStreamBYOBReader.read(view[, options])#

• view <Buffer> | <TypedArray> | <DataView>
• options <Object>
  • min <number> 設定されている場合、返される promise は min 個の要素が利用可能になった時点で解決されます。設定されていない場合、promise は少なくとも1つの要素が利用可能になった時点で解決されます。
• 戻り値: オブジェクトで解決される promise
  • value <TypedArray> | <DataView>
  • done <boolean>

基になる <ReadableStream> から次のデータチャンクを要求し、データが利用可能になるとそのデータで解決される promise を返します。

プールされた <Buffer> オブジェクトインスタンスをこのメソッドに渡さないでください。プールされた Buffer オブジェクトは Buffer.allocUnsafe() または Buffer.from() を使用して作成されるか、さまざまな node:fs モジュールのコールバックによって返されることがよくあります。これらのタイプの Buffer は、すべてのプールされた Buffer インスタンスからのすべてのデータを含む共有の基になる <ArrayBuffer> オブジェクトを使用します。Buffer, <TypedArray>, または <DataView> が readableStreamBYOBReader.read() に渡されると、ビューの基になる ArrayBuffer は デタッチ され、その ArrayBuffer 上に存在する可能性のあるすべての既存のビューが無効になります。これはアプリケーションに壊滅的な結果をもたらす可能性があります。

readableStreamBYOBReader.releaseLock()#

このリーダーの基になる <ReadableStream> に対するロックを解放します。

readableStreamDefaultController.close()#

このコントローラーが関連付けられている <ReadableStream> を閉じます。

readableStreamDefaultController.desiredSize#

• 型: <number>

<ReadableStream> のキューを埋めるために残っているデータの量を返します。

readableStreamDefaultController.enqueue([chunk])#

• chunk <any>

<ReadableStream> のキューに新しいデータチャンクを追加します。

readableStreamDefaultController.error([error])#

• error <any>

<ReadableStream> がエラーになり閉じる原因となるエラーを通知します。

readableByteStreamController.byobRequest#

• 型: <ReadableStreamBYOBRequest>

readableByteStreamController.close()#

このコントローラーが関連付けられている <ReadableStream> を閉じます。

readableByteStreamController.desiredSize#

• 型: <number>

<ReadableStream> のキューを埋めるために残っているデータの量を返します。

readableByteStreamController.enqueue(chunk)#

• chunk <Buffer> | <TypedArray> | <DataView>

<ReadableStream> のキューに新しいデータチャンクを追加します。

readableByteStreamController.error([error])#

• error <any>

<ReadableStream> がエラーになり閉じる原因となるエラーを通知します。

readableStreamBYOBRequest.respond(bytesWritten)#

• bytesWritten <number>

readableStreamBYOBRequest.view に bytesWritten バイト数が書き込まれたことを通知します。

readableStreamBYOBRequest.respondWithNewView(view)#

• view <Buffer> | <TypedArray> | <DataView>

新しい Buffer、TypedArray、または DataView に書き込まれたバイトで要求が満たされたことを通知します。

readableStreamBYOBRequest.view#

• 型: <Buffer> | <TypedArray> | <DataView>

new WritableStream([underlyingSink[, strategy]])#

• underlyingSink <Object>
  • start <Function> WritableStream が作成されるとすぐに呼び出されるユーザー定義関数。
    • controller <WritableStreamDefaultController>
    • 戻り値: undefined または undefined で解決される promise。
  • write <Function> データチャンクが WritableStream に書き込まれたときに呼び出されるユーザー定義関数。
    • chunk <any>
    • controller <WritableStreamDefaultController>
    • 戻り値: undefined で解決される promise。
  • close <Function> WritableStream が閉じられたときに呼び出されるユーザー定義関数。
    • 戻り値: undefined で解決される promise。
  • abort <Function> WritableStream を突然閉じるために呼び出されるユーザー定義関数。
    • reason <any>
    • 戻り値: undefined で解決される promise。
  • type <any> type オプションは将来の使用のために予約されており、必ず undefined でなければなりません。
• strategy <Object>
  • highWaterMark <number> バックプレッシャーが適用される前の最大内部キューサイズ。
  • size <Function> 各データチャンクのサイズを識別するために使用されるユーザー定義関数。
    • chunk <any>
    • 戻り値: <number>

writableStream.abort([reason])#

• reason <any>
• 戻り値: undefined で解決される promise。

WritableStream を突然終了します。キューに入れられたすべての書き込みはキャンセルされ、関連する promise は拒否されます。

writableStream.close()#

• 戻り値: undefined で解決される promise。

追加の書き込みが予期されない場合に WritableStream を閉じます。

writableStream.getWriter()#

• 戻り値: <WritableStreamDefaultWriter>

WritableStream にデータを書き込むために使用できる新しいライターインスタンスを作成して返します。

writableStream.locked#

• 型: <boolean>

writableStream.locked プロパティはデフォルトで false であり、この WritableStream にアクティブなライターがアタッチされている間は true に切り替えられます。

postMessage() を使った転送#

<WritableStream> インスタンスは <MessagePort> を使用して転送できます。

const stream = new WritableStream(getWritableSinkSomehow());

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => {
  data.getWriter().write('hello');
};

port2.postMessage(stream, [stream]); copy

new WritableStreamDefaultWriter(stream)#

• stream <WritableStream>

指定された WritableStream にロックされた新しい WritableStreamDefaultWriter を作成します。

writableStreamDefaultWriter.abort([reason])#

• reason <any>
• 戻り値: undefined で解決される promise。

WritableStream を突然終了します。キューに入れられたすべての書き込みはキャンセルされ、関連する promise は拒否されます。

writableStreamDefaultWriter.close()#

• 戻り値: undefined で解決される promise。

追加の書き込みが予期されない場合に WritableStream を閉じます。

writableStreamDefaultWriter.closed#

• 型: <Promise> 関連付けられた <WritableStream> が閉じられたときに undefined で解決されます。ストリームがエラーになった場合、またはストリームが閉じる前にライターのロックが解放された場合は拒否されます。

writableStreamDefaultWriter.desiredSize#

• 型: <number>

<WritableStream> のキューを埋めるのに必要なデータの量。

writableStreamDefaultWriter.ready#

• 型: <Promise> ライターが使用可能になったときに undefined で解決されます。

writableStreamDefaultWriter.releaseLock()#

このライターの基になる <ReadableStream> に対するロックを解放します。

writableStreamDefaultWriter.write([chunk])#

• chunk <any>
• 戻り値: undefined で解決される promise。

<WritableStream> のキューに新しいデータチャンクを追加します。

writableStreamDefaultController.error([error])#

• error <any>

WritableStream データの処理中にエラーが発生したことを通知するためにユーザーコードによって呼び出されます。呼び出されると、<WritableStream> は中断され、現在保留中の書き込みはキャンセルされます。

writableStreamDefaultController.signal#

• 型: <AbortSignal> <WritableStream> が中断されたときに、保留中の書き込みまたはクローズ操作をキャンセルするために使用できる AbortSignal。

new TransformStream([transformer[, writableStrategy[, readableStrategy]]])#

• transformer <Object>
  • start <Function> TransformStream が作成されるとすぐに呼び出されるユーザー定義関数。
    • controller <TransformStreamDefaultController>
    • 戻り値: undefined または undefined で解決される promise
  • transform <Function> transformStream.writable に書き込まれたデータチャンクを受け取り、潜在的に変更してから、transformStream.readable に転送するユーザー定義関数。
    • chunk <any>
    • controller <TransformStreamDefaultController>
    • 戻り値: undefined で解決される promise。
  • flush <Function> TransformStream の書き込み可能な側が閉じられる直前に呼び出され、変換プロセスの終了を通知するユーザー定義関数。
    • controller <TransformStreamDefaultController>
    • 戻り値: undefined で解決される promise。
  • readableType <any> readableType オプションは将来の使用のために予約されており、必ず undefined でなければなりません。
  • writableType <any> writableType オプションは将来の使用のために予約されており、必ず undefined でなければなりません。
• writableStrategy <Object>
  • highWaterMark <number> バックプレッシャーが適用される前の最大内部キューサイズ。
  • size <Function> 各データチャンクのサイズを識別するために使用されるユーザー定義関数。
    • chunk <any>
    • 戻り値: <number>
• readableStrategy <Object>
  • highWaterMark <number> バックプレッシャーが適用される前の最大内部キューサイズ。
  • size <Function> 各データチャンクのサイズを識別するために使用されるユーザー定義関数。
    • chunk <any>
    • 戻り値: <number>

transformStream.readable#

• 型: <ReadableStream>

transformStream.writable#

• 型: <WritableStream>

postMessage() を使った転送#

<TransformStream> インスタンスは <MessagePort> を使用して転送できます。

const stream = new TransformStream();

const { port1, port2 } = new MessageChannel();

port1.onmessage = ({ data }) => {
  const { writable, readable } = data;
  // ...
};

port2.postMessage(stream, [stream]); copy

transformStreamDefaultController.desiredSize#

• 型: <number>

読み取り可能な側のキューを埋めるのに必要なデータの量。

transformStreamDefaultController.enqueue([chunk])#

• chunk <any>

読み取り可能な側のキューにデータチャンクを追加します。

transformStreamDefaultController.error([reason])#

• reason <any>

変換データの処理中にエラーが発生したことを読み取り可能な側と書き込み可能な側の両方に通知し、両方の側が突然閉じられる原因となります。

transformStreamDefaultController.terminate()#

トランスポートの読み取り可能な側を閉じ、書き込み可能な側がエラーで突然閉じられる原因となります。

new ByteLengthQueuingStrategy(init)#

• init <Object>
  • highWaterMark <number>

byteLengthQueuingStrategy.highWaterMark#

• 型: <number>

byteLengthQueuingStrategy.size#

• 型: <Function>
  • chunk <any>
  • 戻り値: <number>

new CountQueuingStrategy(init)#

• init <Object>
  • highWaterMark <number>

countQueuingStrategy.highWaterMark#

• 型: <number>

countQueuingStrategy.size#

• 型: <Function>
  • chunk <any>
  • 戻り値: <number>

new TextEncoderStream()#

新しい TextEncoderStream インスタンスを作成します。

textEncoderStream.encoding#

• 型: <string>

TextEncoderStream インスタンスがサポートするエンコーディング。

textEncoderStream.readable#

• 型: <ReadableStream>

textEncoderStream.writable#

• 型: <WritableStream>

new TextDecoderStream([encoding[, options]])#

• encoding <string> この TextDecoder インスタンスがサポートする encoding を識別します。デフォルト: 'utf-8'。
• options <Object>
  • fatal <boolean> デコードエラーが致命的である場合は true。
  • ignoreBOM <boolean> true の場合、TextDecoderStream はバイトオーダーマークをデコードされた結果に含めます。false の場合、バイトオーダーマークは出力から削除されます。このオプションは encoding が 'utf-8', 'utf-16be', または 'utf-16le' の場合にのみ使用されます。デフォルト: false。

新しい TextDecoderStream インスタンスを作成します。

textDecoderStream.encoding#

• 型: <string>

TextDecoderStream インスタンスがサポートするエンコーディング。

textDecoderStream.fatal#

• 型: <boolean>

デコードエラーが TypeError のスローにつながる場合、値は true になります。

textDecoderStream.ignoreBOM#

• 型: <boolean>

デコード結果にバイトオーダーマークが含まれる場合、値は true になります。

textDecoderStream.readable#

• 型: <ReadableStream>

textDecoderStream.writable#

• 型: <WritableStream>

new CompressionStream(format)#

• format <string> 'deflate', 'deflate-raw', 'gzip', または 'brotli' のいずれか。

compressionStream.readable#

• 型: <ReadableStream>

compressionStream.writable#

• 型: <WritableStream>

new DecompressionStream(format)#

• format <string> 'deflate', 'deflate-raw', 'gzip', または 'brotli' のいずれか。

decompressionStream.readable#

• 型: <ReadableStream>

decompressionStream.writable#

• 型: <WritableStream>

streamConsumers.arrayBuffer(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• 戻り値: <Promise> ストリームの全内容を含む ArrayBuffer で解決されます。

import { arrayBuffer } from 'node:stream/consumers';
import { Readable } from 'node:stream';
import { TextEncoder } from 'node:util';

const encoder = new TextEncoder();
const dataArray = encoder.encode('hello world from consumers!');

const readable = Readable.from(dataArray);
const data = await arrayBuffer(readable);
console.log(`from readable: ${data.byteLength}`);
// Prints: from readable: 76const { arrayBuffer } = require('node:stream/consumers');
const { Readable } = require('node:stream');
const { TextEncoder } = require('node:util');

const encoder = new TextEncoder();
const dataArray = encoder.encode('hello world from consumers!');
const readable = Readable.from(dataArray);
arrayBuffer(readable).then((data) => {
  console.log(`from readable: ${data.byteLength}`);
  // Prints: from readable: 76
});copy

streamConsumers.blob(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• 戻り値: <Promise> ストリームの全内容を含む <Blob> で解決されます。

import { blob } from 'node:stream/consumers';

const dataBlob = new Blob(['hello world from consumers!']);

const readable = dataBlob.stream();
const data = await blob(readable);
console.log(`from readable: ${data.size}`);
// Prints: from readable: 27const { blob } = require('node:stream/consumers');

const dataBlob = new Blob(['hello world from consumers!']);

const readable = dataBlob.stream();
blob(readable).then((data) => {
  console.log(`from readable: ${data.size}`);
  // Prints: from readable: 27
});copy

streamConsumers.buffer(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• 戻り値: <Promise> ストリームの全内容を含む <Buffer> で解決されます。

import { buffer } from 'node:stream/consumers';
import { Readable } from 'node:stream';
import { Buffer } from 'node:buffer';

const dataBuffer = Buffer.from('hello world from consumers!');

const readable = Readable.from(dataBuffer);
const data = await buffer(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 27const { buffer } = require('node:stream/consumers');
const { Readable } = require('node:stream');
const { Buffer } = require('node:buffer');

const dataBuffer = Buffer.from('hello world from consumers!');

const readable = Readable.from(dataBuffer);
buffer(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 27
});copy

streamConsumers.json(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• 戻り値: <Promise> UTF-8エンコードされた文字列として解析され、その後 JSON.parse() に渡されたストリームの内容で解決されます。

import { json } from 'node:stream/consumers';
import { Readable } from 'node:stream';

const items = Array.from(
  {
    length: 100,
  },
  () => ({
    message: 'hello world from consumers!',
  }),
);

const readable = Readable.from(JSON.stringify(items));
const data = await json(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 100const { json } = require('node:stream/consumers');
const { Readable } = require('node:stream');

const items = Array.from(
  {
    length: 100,
  },
  () => ({
    message: 'hello world from consumers!',
  }),
);

const readable = Readable.from(JSON.stringify(items));
json(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 100
});copy

streamConsumers.text(stream)#

• stream <ReadableStream> | <stream.Readable> | <AsyncIterator>
• 戻り値: <Promise> UTF-8エンコードされた文字列として解析されたストリームの内容で解決されます。

import { text } from 'node:stream/consumers';
import { Readable } from 'node:stream';

const readable = Readable.from('Hello world from consumers!');
const data = await text(readable);
console.log(`from readable: ${data.length}`);
// Prints: from readable: 27const { text } = require('node:stream/consumers');
const { Readable } = require('node:stream');

const readable = Readable.from('Hello world from consumers!');
text(readable).then((data) => {
  console.log(`from readable: ${data.length}`);
  // Prints: from readable: 27
});copy