try {
	const reader = stream.getReader();
  const { value, done } = reader.read();
} finally {
	reader.releaseLock(); // 자원 해제
}

try {
	const resource = getResource();
	try {
		const reader = resource.getReader();
		// ...
	} finally {
		reader.close();
	}
} finally {
	resource.release();
}

{
  using resource = getResource();
	using reader = resource.getReader();
  const { value, done } = reader.read();
} // 블록을 벗어날 때 'reader' => 'resource' 순으로 자원 해제

const getResource = () => ({
	[Symbol.dispose]: () => {
    console.log("Release!");
  }
});

{
	console.log("I'm using resource");
	using resource = getResource();
	// ... something do
} // Run `resource[Symbol.dispose]?.()`
console.log("Finished!");

// Output:
// I'm using resource
// Release!
// Finished!

try {
	console.log("I'm using resource");
	const resource = getResource();
	// ... something do
} finally {
	resource[Symbol.dispose]?.();
}
console.log("Finished!");

const res = { [Symbol.dispose]() {} };
const asyncRes = { [Symbol.asyncDispose]() {} };

using x = res; // ok: `res` has @@dispose
using y = asyncRes; // throws: `asyncRes` does not have @@dispose

await using x = res; // ok: `res` has @@dispose (fallback)
await using y = asyncres; // ok: `asyncRes` has @@asyncDispose

// `await using`의 예상 자원 해제 코드
const disposable = [x, y];
for (const _disposable of disposable.toReversed()) {
	await _disposable[Symbol.dispose]?.();
}

class DisposableStack {
  constructor();

  /**
   * Gets a value indicating whether the stack has been disposed.
   * @returns {boolean}
   */
  get disposed();

  /**
   * Alias for `[Symbol.dispose]()`.
   */
  dispose();

  /**
   * Adds a resource to the top of the stack. Has no effect if provided `null` or `undefined`.
   * @template {Disposable | null | undefined} T
   * @param {T} value - A `Disposable` object, `null`, or `undefined`.
   * @returns {T} The provided value.
   */
  use(value);

  /**
   * Adds a non-disposable resource and a disposal callback to the top of the stack.
   * @template T
   * @param {T} value - A resource to be disposed.
   * @param {(value: T) => void} onDispose - A callback invoked to dispose the provided value.
   * @returns {T} The provided value.
   */
  adopt(value, onDispose);

  /**
   * Adds a disposal callback to the top of the stack.
   * @param {() => void} onDispose - A callback to evaluate when this object is disposed.
   * @returns {void}
   */
  defer(onDispose);

  /**
   * Moves all resources currently in this stack into a new `DisposableStack`.
   * @returns {DisposableStack} The new `DisposableStack`.
   */
  move();

  /**
   * Disposes of resources within this object.
   * @returns {void}
   */
  [Symbol.dispose]();

  [Symbol.toStringTag];
} 

// sync
const stack = new DisposableStack();
const resource1 = stack.use(getResource1());
const resource2 = stack.use(getResource2());
const resource3 = stack.use(getResource3());
stack[Symbol.dispose](); // disposes of resource3, then resource2, then resource1

{
  using stack = new DisposableStack();
  const reader = stack.adopt(createReader(), reader => reader.releaseLock());
  ...
}

class ParentClass {
  #disposed = false;
  #disposables;

  #socketio;

  constructor() {
		// DisposableStack 객체를 생성해 생성자에서 나갈때 자원이 해제되도록 합니다.
		// 현재 생성자가 성공하면 자원이 남아 있어야 하므로, `stack.move()`를 후에 사용합니다.
    using stack = new DisposableStack();

		// socket.io 객체를 생성해 등록합니다.
		// 만약 `Symbol.dispose`가 구현된 객체라면 `stack.use(createResource())`를 사용하면 됩니다.
		this.#socketio = stack.adopt(io('wss://localhost:3000', socket => socket.destory());

		// 여기까지 도달하면, 오류없이 자원을 생성했으므로 `stack`에서 `disposable`로 옮길 수 있습니다.
    this.#disposables = stack.move();

		// 생성자에서 실패를 하면, `stack`은 여기에 도달해서 자원을 해제하게됩니다.
		// 이벤트 핸들러가 제거되면서 `#socketio`는 GC됩니다.
  }

  [Symbol.dispose]() {
    if (!this.#disposed) {
      this.#disposed = true;
      const disposables = this.#disposables;

			// 아래 `disposables[Symbol.dispose]()`로 자원을 해제하기 때문에,
			// 이 과정은 필수는 아니지만, 사용하지 않는 객체를 지워두는게 좋습니다.
      this.#socketio = undefined;
      this.#disposables = undefined;

      // Dispose all resources in `disposables`
			// `DisposableStack`에 등록된 자원들을 해제합니다.
      disposables[Symbol.dispose]();
    }
  }
}

// 자식 클래스
class SubClass extends ParentClass {
	#disposables;

	#logger;

  constructor() {
    super();

		// 자식 클래스의 생성자를 덮을 `DisposableStack`을 생성합니다.
    using stack = new DisposableStack();

		// 자원 해제의 마지막에 부모 클래스인 `super`의 자원 해제를 실행하도록합니다.
    stack.defer(() => super[Symbol.dispose]());

		// `Symbol.dispose` 메서드가 구현된 자원인 Logger를 만들어 등록합니다.
		this.#logger = stack.use(createLogger());

		// 아래 `stack.move()`가 실행되기 전에 실패하면, stack의 자원은 `using` 키워드의 규칙대로 해제됩니다.
		// 부모 클래스가 등록되어 있으므로, 부모 클래스의 자원 또한 같이 해제됩니다.

		// stack의 자원을 유지시킵니다.
		this.#disposables = stack.move();
  }

	[Symbol.dispose]() {
    this.#logger = undefined;

		// `#logger`의 자원이 해제됩니다.
		// 또한 위 생성자 주석에서 설명했듯이, 부모 클래스를 등록할 때 `stack.defer`를 사용했으므로,
		// `#logger` => super 순으로 자원이 해제됩니다.
    this.#disposables[Symbol.dispose]();
  }
}