refactor: avoid using using due to performance concerns

It seems `using` in Node is not as performant as expected.
Note that the performance in Deno seems not to be affected by this
change.

  benchmark      time (avg)        iter/s             (min … max)       p75       p99      p995
  --------------------------------------------------------------- -----------------------------

  group Lock#lock
  v1.0.0         52.84 ms/iter          18.9   (45.86 ms … 57.58 ms) 55.68 ms 57.58 ms 57.58 ms
  main           53.55 ms/iter          18.7   (47.32 ms … 73.59 ms) 55.52 ms 73.59 ms 73.59 ms

  summary
    v1.0.0
    1.01x faster than main

See #31 for detail

Author: lambdalisue

lock.ts

@@ -43,7 +43,11 @@ export class Lock<T> {
    * @returns A Promise that resolves with the result of the function.
    */
   async lock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    using _lock = await this.#mu.acquire();
-    return await fn(this.#value);
+    const lock = await this.#mu.acquire();
+    try {
+      return await fn(this.#value);
+    } finally {
+      lock[Symbol.dispose]();
+    }
   }
 }

rw_lock.ts

@@ -50,9 +50,17 @@ export class RwLock<T> {
    * @returns A promise that resolves to the return value of the specified function.
    */
   async lock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    using _wlock = await this.#write.acquire();
-    using _rlock = await this.#read.acquire();
-    return await fn(this.#value);
+    const wlock = await this.#write.acquire();
+    try {
+      const rlock = await this.#read.acquire();
+      try {
+        return await fn(this.#value);
+      } finally {
+        rlock[Symbol.dispose]();
+      }
+    } finally {
+      wlock[Symbol.dispose]();
+    }
   }
 
   /**
@@ -63,11 +71,19 @@ export class RwLock<T> {
    * @returns A promise that resolves to the return value of the specified function.
    */
   async rlock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    using _wlock = this.#write.locked
+    const wlock = this.#write.locked
       ? await this.#write.acquire()
       : { [Symbol.dispose]: () => {} };
-    // Acquire the read lock without waiting to allow multiple readers to access the lock.
-    using _rlock = this.#read.acquire();
-    return await fn(this.#value);
+    try {
+      // Acquire the read lock without waiting to allow multiple readers to access the lock.
+      const rlock = this.#read.acquire();
+      try {
+        return await fn(this.#value);
+      } finally {
+        rlock[Symbol.dispose]();
+      }
+    } finally {
+      wlock[Symbol.dispose]();
+    }
   }
 }