@ohos-ports/lmdb 2.5.3 → 2.8.5-beta.0

package/src/writer.cpp

@@ -13,6 +13,7 @@ inline value?
 */
 #include "lmdb-js.h"
 #include <atomic>
+#include <ctime>
 #ifndef _WIN32
 #include <unistd.h>
 #endif
@@ -34,6 +35,8 @@ const int HAS_KEY = 4;
 const int HAS_VALUE = 2;
 const int CONDITIONAL = 8;
 const int CONDITIONAL_VERSION = 0x100;
+const int CONDITIONAL_VERSION_LESS_THAN = 0x800;
+const int CONDITIONAL_ALLOW_NOTFOUND = 0x1000;
 const int SET_VERSION = 0x200;
 //const int HAS_INLINE_VALUE = 0x400;
 const int COMPRESSIBLE = 0x100000;
@@ -62,25 +65,13 @@ WriteWorker::WriteWorker(MDB_env* env, EnvWrap* envForTxn, uint32_t* instruction
 		env(env) {
 	//fprintf(stdout, "nextCompressibleArg %p\n", nextCompressibleArg);
 		interruptionStatus = 0;
+		resultCode = 0;
 		txn = nullptr;
 	}
 
-AsyncWriteWorker::AsyncWriteWorker(MDB_env* env, EnvWrap* envForTxn, uint32_t* instructions, const Function& callback)
-		: WriteWorker(env, envForTxn, instructions), AsyncProgressWorker(callback, "lmdb:write") {
-	//fprintf(stdout, "nextCompressibleArg %p\n", nextCompressibleArg);
-		interruptionStatus = 0;
-		txn = nullptr;
-	}
-
-void AsyncWriteWorker::Execute(const AsyncProgressWorker::ExecutionProgress& execution) {
-	executionProgress = (AsyncProgressWorker::ExecutionProgress*) &execution;
-	Write();
-}
 void WriteWorker::SendUpdate() {
-	fprintf(stderr, "This SendUpdate does not work!\n");
-}
-void AsyncWriteWorker::SendUpdate() {
-	executionProgress->Send(nullptr, 0);
+	if (WriteWorker::threadSafeCallsEnabled)
+		napi_call_threadsafe_function(progress, nullptr, napi_tsfn_blocking);
 }
 MDB_txn* WriteWorker::AcquireTxn(int* flags) {
 	bool commitSynchronously = *flags & TXN_SYNCHRONOUS_COMMIT;
@@ -89,16 +80,17 @@ MDB_txn* WriteWorker::AcquireTxn(int* flags) {
 	pthread_mutex_lock(envForTxn->writingLock);
 	retry:
 	if (commitSynchronously && interruptionStatus == WORKER_WAITING) {
-		//fprintf(stderr, "acquire interupting lock %p %u\n", this, commitSynchronously);
 		interruptionStatus = INTERRUPT_BATCH;
 		pthread_cond_signal(envForTxn->writingCond);
 		pthread_cond_wait(envForTxn->writingCond, envForTxn->writingLock);
 		if (interruptionStatus == RESTART_WORKER_TXN) {
 			*flags |= TXN_FROM_WORKER;
 			return nullptr;
+		} else if (interruptionStatus == WORKER_WAITING || interruptionStatus == INTERRUPT_BATCH) {
+		    interruptionStatus = WORKER_WAITING;
+		    goto retry;
 		} else {
-			interruptionStatus = WORKER_WAITING;
-			goto retry;
+			return nullptr;
 		}
 	} else {
 		//if (interruptionStatus == RESTART_WORKER_TXN)
@@ -112,48 +104,48 @@ MDB_txn* WriteWorker::AcquireTxn(int* flags) {
 }
 
 void WriteWorker::UnlockTxn() {
-	//fprintf(stderr, "release txn %u\n", interruptionStatus);
 	interruptionStatus = 0;
 	pthread_cond_signal(envForTxn->writingCond);
 	pthread_mutex_unlock(envForTxn->writingLock);
 }
-void WriteWorker::ReportError(const char* error) {
-	hasError = true;
-	fprintf(stderr, "Error %s\n", error);
-}
-void AsyncWriteWorker::ReportError(const char* error) {
-	hasError = true;
-	SetError(error);
-}
 int WriteWorker::WaitForCallbacks(MDB_txn** txn, bool allowCommit, uint32_t* target) {
 	int rc;
-	//fprintf(stderr, "wait for callback %p\n", target);
 	if (!finishedProgress)
 		SendUpdate();
 	pthread_cond_signal(envForTxn->writingCond);
 	interruptionStatus = WORKER_WAITING;
+	uint64_t start;
+	if (envForTxn->trackMetrics)
+		start = get_time64();
 	if (target) {
 		uint64_t delay = 1;
 		do {
 			cond_timedwait(envForTxn->writingCond, envForTxn->writingLock, delay);
 			delay = delay << 1ll;
-			//if (delay > 500)
-				//fprintf(stderr, "waited, %llu %p\n", delay, *target);
 			if ((*target & 0xf) || (allowCommit && finishedProgress)) {
 				// we are in position to continue writing or commit, so forward progress can be made without interrupting yet
+				if (envForTxn->trackMetrics) {
+					envForTxn->timeTxnWaiting += get_time64() - start;
+				}
 				interruptionStatus = 0;
 				return 0;
 			}
 		} while(interruptionStatus != INTERRUPT_BATCH);
-	} else
+	} else {
 		pthread_cond_wait(envForTxn->writingCond, envForTxn->writingLock);
+    }
+	if (envForTxn->trackMetrics) {
+		envForTxn->timeTxnWaiting += get_time64() - start;
+	}
 	if (interruptionStatus == INTERRUPT_BATCH) { // interrupted by JS code that wants to run a synchronous transaction
-	//	fprintf(stderr, "Performing batch interruption %u\n", allowCommit);
 		interruptionStatus = RESTART_WORKER_TXN;
 		rc = mdb_txn_commit(*txn);
+#ifdef MDB_EMPTY_TXN
+		if (rc == MDB_EMPTY_TXN)
+			rc = 0;
+#endif
 		if (rc == 0) {
 			// wait again until the sync transaction is completed
-			//fprintf(stderr, "Waiting after interruption\n");
 			this->txn = *txn = nullptr;
 			pthread_cond_signal(envForTxn->writingCond);
 			pthread_cond_wait(envForTxn->writingCond, envForTxn->writingLock);
@@ -179,15 +171,16 @@ int WriteWorker::DoWrites(MDB_txn* txn, EnvWrap* envForTxn, uint32_t* instructio
 	double conditionalVersion, setVersion = 0;
 	bool overlappedWord = !!worker;
 	uint32_t* start;
-		do {
+    do {
 next_inst:	start = instruction++;
 		uint32_t flags = *start;
 		MDB_dbi dbi = 0;
+		//fprintf(stderr, "do %u %u\n", flags, get_time64());
 		bool validated = conditionDepth == validatedDepth;
 		if (flags & 0xf0c0) {
 			fprintf(stderr, "Unknown flag bits %u %p\n", flags, start);
 			fprintf(stderr, "flags after message %u\n", *start);
-			worker->ReportError("Unknown flags\n");
+			worker->resultCode = 22;
 			return 0;
 		}
 		if (flags & HAS_KEY) {
@@ -228,12 +221,17 @@ next_inst:	start = instruction++;
 				instruction += 2;
 				MDB_val conditionalValue;
 				rc = mdb_get(txn, dbi, &key, &conditionalValue);
-				if (rc)
-					validated = false;
-				else if (conditionalVersion != ANY_VERSION) {
+				if (rc) {
+				    // not found counts as version 0, so this is acceptable for conditional less than,
+				    // otherwise does not validate
+					if (rc == MDB_NOTFOUND)
+						validated = flags & CONDITIONAL_ALLOW_NOTFOUND;
+					else
+						worker->resultCode = rc;
+				} else if (conditionalVersion != ANY_VERSION) {
 					double version;
 					memcpy(&version, conditionalValue.mv_data, 8);
-					validated = validated && conditionalVersion == version;
+					validated = validated && ((flags & CONDITIONAL_VERSION_LESS_THAN) ? version <= conditionalVersion : (version == conditionalVersion));
 				}
 			}
 			if (flags & SET_VERSION) {
@@ -242,7 +240,12 @@ next_inst:	start = instruction++;
 			}
 			if ((flags & IF_NO_EXISTS) && (flags & START_CONDITION_BLOCK)) {
 				rc = mdb_get(txn, dbi, &key, &value);
-				validated = validated && rc == MDB_NOTFOUND;
+				if (!rc)
+					validated = false;
+				else if (rc == MDB_NOTFOUND)
+					validated = true;
+				else
+					worker->resultCode = rc;
 			}
 		} else
 			instruction++;
@@ -283,7 +286,7 @@ next_inst:	start = instruction++;
 				else
 					rc = mdb_put(txn, dbi, &key, &value, flags & (MDB_NOOVERWRITE | MDB_NODUPDATA | MDB_APPEND | MDB_APPENDDUP));
 				if (flags & COMPRESSIBLE)
-					free(value.mv_data);
+					delete value.mv_data;
 				//fprintf(stdout, "put %u \n", key.mv_size);
 				break;
 			case DEL:
@@ -292,7 +295,7 @@ next_inst:	start = instruction++;
 			case DEL_VALUE:
 				rc = mdb_del(txn, dbi, &key, &value);
 				if (flags & COMPRESSIBLE)
-					free(value.mv_data);
+					delete value.mv_data;
 				break;
 			case START_BLOCK: case START_CONDITION_BLOCK:
 				rc = validated ? 0 : MDB_NOTFOUND;
@@ -320,13 +323,13 @@ next_inst:	start = instruction++;
 			default:
 				fprintf(stderr, "Unknown flags %u %p\n", flags, start);
 				fprintf(stderr, "flags after message %u\n", *start);
-				worker->ReportError("Unknown flags\n");
+				worker->resultCode = 22;
 				return 22;
 			}
 			if (rc) {
 				if (!(rc == MDB_KEYEXIST || rc == MDB_NOTFOUND)) {
 					if (worker) {
-						worker->ReportError(mdb_strerror(rc));
+						worker->resultCode = rc;
 					} else {
 						return rc;
 					}
@@ -347,83 +350,164 @@ next_inst:	start = instruction++;
 	return rc;
 }
 
+bool WriteWorker::threadSafeCallsEnabled = false;
+void txn_visible(const void* data) {
+	auto worker = (WriteWorker*) data;
+	worker->SendUpdate();
+}
+
+
+void do_write(napi_env env, void* data) {
+	auto worker = (WriteWorker*) data;
+	worker->Write();
+	napi_release_threadsafe_function(worker->progress, napi_tsfn_abort);
+}
+
+const int READER_CHECK_INTERVAL = 600; // ten minutes
 void WriteWorker::Write() {
 	int rc;
 	finishedProgress = true;
 	unsigned int envFlags;
 	mdb_env_get_flags(env, &envFlags);
+	time_t now = time(0);
+	if (now - envForTxn->lastReaderCheck > READER_CHECK_INTERVAL) {
+		int dead;
+		mdb_reader_check(env, &dead);
+		envForTxn->lastReaderCheck = now;
+	}
 	pthread_mutex_lock(envForTxn->writingLock);
-    #ifdef _WIN32
-	rc = mdb_txn_begin(env, nullptr, (envForTxn->jsFlags & MDB_OVERLAPPINGSYNC) ? MDB_NOSYNC : 0, &txn);
-    #else
-    int retries = 0;
-    retry:
-	rc = mdb_txn_begin(env, nullptr, (envForTxn->jsFlags & MDB_OVERLAPPINGSYNC) ? MDB_NOSYNC : 0, &txn);
-    if (rc == EINVAL) {
-        if (retries++ < 10) {
-            sleep(1);
-            goto retry;
-        }
-        return ReportError("Invalid parameter, which is often due to more transactions than available robust locked mutexes or semaphors (see docs for more info)");
-    }
-    #endif
+	#ifndef _WIN32
+	int retries = 0;
+	retry:
+	#endif
+	rc = mdb_txn_begin(env, nullptr,
+	#ifdef MDB_OVERLAPPINGSYNC
+		(envForTxn->jsFlags & MDB_OVERLAPPINGSYNC) ? MDB_NOSYNC :
+	#endif
+		0, &txn);
+	#if !defined(_WIN32) && defined(MDB_RPAGE_CACHE)
+	if (rc == MDB_LOCK_FAILURE) {
+		if (retries++ < 4) {
+			sleep(1);
+			goto retry;
+		}
+	}
+	#endif
 	if (rc != 0) {
-		return ReportError(mdb_strerror(rc));
+		resultCode = rc;
+		return;
 	}
-	hasError = false;
 	rc = DoWrites(txn, envForTxn, instructions, this);
-
-	if (rc || hasError)
+	uint32_t txnId = (uint32_t) mdb_txn_id(txn);
+	progressStatus = 1;
+	#ifdef MDB_OVERLAPPINGSYNC
+	if (envForTxn->jsFlags & MDB_OVERLAPPINGSYNC) {
+		mdb_txn_set_callback(txn, txn_visible, this);
+	}
+	#endif
+	if (rc || resultCode)
 		mdb_txn_abort(txn);
 	else
 		rc = mdb_txn_commit(txn);
+	#ifdef MDB_OVERLAPPINGSYNC
+	#endif
+#ifdef MDB_EMPTY_TXN
+	if (rc == MDB_EMPTY_TXN)
+		rc = 0;
+#endif
 	txn = nullptr;
+    interruptionStatus = 0;
+    pthread_cond_signal(envForTxn->writingCond); // in case there a sync txn waiting for us
 	pthread_mutex_unlock(envForTxn->writingLock);
-	if (rc || hasError) {
+	if (rc || resultCode) {
 		std::atomic_fetch_or((std::atomic<uint32_t>*) instructions, (uint32_t) TXN_HAD_ERROR);
 		if (rc)
-			ReportError(mdb_strerror(rc));
+			resultCode = rc ? rc : resultCode;
 		return;
 	}
+	*(instructions - 1) = txnId;
 	std::atomic_fetch_or((std::atomic<uint32_t>*) instructions, (uint32_t) TXN_COMMITTED);
 }
 
-void AsyncWriteWorker::OnProgress(const char* data, size_t count) {
-	if (progressStatus == 1) {
-		Callback().Call({ Number::New(Env(), progressStatus)});
+void write_progress(napi_env env,
+					napi_value js_callback,
+					void* context,
+					void* data) {
+	if (!js_callback)
+		return;
+	auto worker = (WriteWorker*) context;
+	napi_value result;
+	napi_value undefined;
+	napi_value arg;
+	napi_create_int32(env, worker->progressStatus, &arg);
+	napi_get_undefined(env, &undefined);
+	if (worker->progressStatus == 1) {
+		napi_call_function(env, undefined, js_callback, 1, &arg, &result);
 		return;
 	}
-	if (finishedProgress)
+	if (worker->finishedProgress)
 		return;
+	auto envForTxn = worker->envForTxn;
 	pthread_mutex_lock(envForTxn->writingLock);
-	while(!txn) // possible to jump in after an interrupted txn here
+	while(!worker->txn) // possible to jump in after an interrupted txn here
 		pthread_cond_wait(envForTxn->writingCond, envForTxn->writingLock);
-	envForTxn->writeTxn = new TxnTracked(txn, 0);
-	finishedProgress = true;
-	napi_value result, arg; // we use direct napi call here because node-addon-api interface with throw a fatal error if a worker thread is terminating, and bun doesn't support escapable scopes yet
-	napi_create_int32(Env(), progressStatus, &arg);
-	napi_call_function(Env(), Env().Undefined(), Callback().Value(), 1, &arg, &result);
-	delete envForTxn->writeTxn;
-	envForTxn->writeTxn = nullptr;
-	pthread_cond_signal(envForTxn->writingCond);
-	pthread_mutex_unlock(envForTxn->writingLock);
+	envForTxn->writeTxn = new TxnTracked(worker->txn, 0);
+	worker->finishedProgress = true;
+	napi_create_int32(env, worker->progressStatus, &arg);
+	napi_call_function(env, undefined, js_callback, 1, &arg, &result);
+	bool is_async = false;
+	napi_get_value_bool(env, result, &is_async);
+	if (!is_async) {
+		delete envForTxn->writeTxn;
+		envForTxn->writeTxn = nullptr;
+		pthread_cond_signal(envForTxn->writingCond);
+		pthread_mutex_unlock(envForTxn->writingLock);
+	}
 }
 
-void AsyncWriteWorker::OnOK() {
-	finishedProgress = true;
+void writes_complete(napi_env env,
+					 napi_status status,
+					 void* data) {
+	auto worker = (WriteWorker*) data;
+	worker->finishedProgress = true;
 	napi_value result, arg; // we use direct napi call here because node-addon-api interface with throw a fatal error if a worker thread is terminating, and bun doesn't support escapable scopes yet
-	napi_create_int32(Env(), 0, &arg);
-	napi_call_function(Env(), Env().Undefined(), Callback().Value(), 1, &arg, &result);
+	napi_create_int32(env, worker->resultCode, &arg);
+	napi_value callback;
+	napi_get_reference_value(env, worker->callback, &callback);
+	napi_call_function(env, callback, callback, 1, &arg, &result);
+	napi_delete_reference(env, worker->callback);
+	napi_delete_async_work(env, worker->work);
+	delete worker;
+}
+
+Value EnvWrap::resumeWriting(const Napi::CallbackInfo& info) {
+	// if we had async txns, now we resume
+	delete writeTxn;
+	writeTxn = nullptr;
+	pthread_cond_signal(writingCond);
+	pthread_mutex_unlock(writingLock);
+	return info.Env().Undefined();
 }
 
 Value EnvWrap::startWriting(const Napi::CallbackInfo& info) {
+	napi_env n_env = info.Env();
 	if (!this->env) {
 		return throwError(info.Env(), "The environment is already closed.");
 	}
+	hasWrites = true;
 	size_t instructionAddress = info[0].As<Number>().Int64Value();
-	AsyncWriteWorker* worker = new AsyncWriteWorker(this->env, this, (uint32_t*) instructionAddress, info[1].As<Function>());
+	napi_value resource;
+	napi_status status;
+	status = napi_create_object(n_env, &resource);
+	napi_value resource_name;
+	status = napi_create_string_latin1(n_env, "write", NAPI_AUTO_LENGTH, &resource_name);
+	auto worker = new WriteWorker(this->env, this, (uint32_t*) instructionAddress);
 	this->writeWorker = worker;
-	worker->Queue();
+	napi_create_reference(n_env, info[1].As<Function>(), 1, &worker->callback);
+	status = napi_create_async_work(n_env, resource, resource_name, do_write, writes_complete, worker, &worker->work);
+	napi_create_threadsafe_function(n_env, info[1].As<Function>(), resource, resource_name, 0, 1, nullptr, nullptr, worker, write_progress, &worker->progress);
+	status = napi_queue_async_work(n_env, worker->work);
+
 	return info.Env().Undefined();
 }
 
@@ -435,6 +519,7 @@ NAPI_FUNCTION(EnvWrap::write) {
 		napi_throw_error(env, nullptr, "The environment is already closed.");
 		RETURN_UNDEFINED;
 	}
+	ew->hasWrites = true;
 	
 	napi_get_value_int64(env, args[1], &i64);
 	uint32_t* instructionAddress = (uint32_t*) i64;

package/util/RangeIterable.js

@@ -1,4 +1,8 @@
-const SKIP = {};
+export const SKIP = {};
+const DONE = {
+	value: null,
+	done: true,
+}
 if (!Symbol.asyncIterator) {
 	Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator');
 }
@@ -11,9 +15,10 @@ export class RangeIterable {
 	}
 	map(func) {
 		let source = this;
-		let result = new RangeIterable();
-		result.iterate = (async) => {
+		let iterable = new RangeIterable();
+		iterable.iterate = (async) => {
 			let iterator = source[Symbol.iterator](async);
+			let i = 0;
 			return {
 				next(resolvedResult) {
 					let result;
@@ -30,31 +35,38 @@ export class RangeIterable {
 						}
 						if (iteratorResult.done === true) {
 							this.done = true;
+							if (iterable.onDone) iterable.onDone();
 							return iteratorResult;
 						}
-						result = func(iteratorResult.value);
+						result = func(iteratorResult.value, i++);
 						if (result && result.then) {
 							return result.then(result =>
-								result == SKIP ?
+								result === SKIP ?
 									this.next() :
 									{
 										value: result
 									});
 						}
-					} while(result == SKIP)
+					} while(result === SKIP);
+					if (result === DONE) {
+						if (iterable.onDone) iterable.onDone();
+						return result;
+					}
 					return {
 						value: result
 					};
 				},
 				return() {
+					if (iterable.onDone) iterable.onDone();
 					return iterator.return();
 				},
 				throw() {
+					if (iterable.onDone) iterable.onDone();
 					return iterator.throw();
 				}
 			};
 		};
-		return result;
+		return iterable;
 	}
 	[Symbol.asyncIterator]() {
 		return this.iterator = this.iterate();
@@ -63,7 +75,12 @@ export class RangeIterable {
 		return this.iterator = this.iterate();
 	}
 	filter(func) {
-		return this.map(element => func(element) ? element : SKIP);
+		return this.map(element => {
+			let result = func(element);
+			// handle promise
+			if (result?.then) return result.then((result) => result ? element : SKIP);
+			else return result ? element : SKIP;
+		});
 	}
 
 	forEach(callback) {
@@ -78,27 +95,104 @@ export class RangeIterable {
 		concatIterable.iterate = (async) => {
 			let iterator = this.iterator = this.iterate();
 			let isFirst = true;
-			let concatIterator = {
+			function iteratorDone(result) {
+				if (isFirst) {
+					isFirst = false;
+					iterator = secondIterable[Symbol.iterator](async);
+					result = iterator.next();
+					if (concatIterable.onDone) {
+						if (result.then)
+							result.then((result) => {
+								if (result.done()) concatIterable.onDone();
+							});
+						else if (result.done) concatIterable.onDone();
+					}
+				} else {
+					if (concatIterable.onDone) concatIterable.onDone();
+				}
+				return result;
+			}
+			return {
 				next() {
 					let result = iterator.next();
-					if (isFirst && result.done) {
-						isFirst = false;
-						iterator = secondIterable[Symbol.iterator](async);
-						return iterator.next();
-					}
+					if (result.then)
+						return result.then((result) => {
+							if (result.done) return iteratorDone(result);
+							return result;
+						});
+					if (result.done) return iteratorDone(result);
 					return result;
 				},
 				return() {
+					if (concatIterable.onDone) concatIterable.onDone();
 					return iterator.return();
 				},
 				throw() {
+					if (concatIterable.onDone) concatIterable.onDone();
 					return iterator.throw();
 				}
 			};
-			return concatIterator;
 		};
 		return concatIterable;
 	}
+
+	flatMap(callback) {
+		let mappedIterable = new RangeIterable();
+		mappedIterable.iterate = (async) => {
+			let iterator = this.iterator = this.iterate(async);
+			let isFirst = true;
+			let currentSubIterator;
+			return {
+				next() {
+					do {
+						if (currentSubIterator) {
+							let result = currentSubIterator.next();
+							if (!result.done) {
+								return result;
+							}
+						}
+						let result = iterator.next();
+						if (result.done) {
+							if (mappedIterable.onDone) mappedIterable.onDone();
+							return result;
+						}
+						let value = callback(result.value);
+						if (Array.isArray(value) || value instanceof RangeIterable)
+							currentSubIterator = value[Symbol.iterator]();
+						else {
+							currentSubIterator = null;
+							return { value };
+						}
+					} while(true);
+				},
+				return() {
+					if (mappedIterable.onDone) mappedIterable.onDone();
+					if (currentSubIterator)
+						currentSubIterator.return();
+					return iterator.return();
+				},
+				throw() {
+					if (mappedIterable.onDone) mappedIterable.onDone();
+					if (currentSubIterator)
+						currentSubIterator.throw();
+					return iterator.throw();
+				}
+			};
+		};
+		return mappedIterable;
+	}
+
+	slice(start, end) {
+		return this.map((element, i) => {
+			if (i < start)
+				return SKIP;
+			if (i >= end) {
+				DONE.value = element;
+				return DONE;
+			}
+			return element;
+		});
+	}
 	next() {
 		if (!this.iterator)
 			this.iterator = this.iterate();
@@ -108,7 +202,7 @@ export class RangeIterable {
 		if (this.asArray && this.asArray.forEach) {
 			return this.asArray;
 		}
-		throw new Error('Can not serialize async iteratables without first calling resolveJSON');
+		throw new Error('Can not serialize async iterables without first calling resolveJSON');
 		//return Array.from(this)
 	}
 	get asArray() {
@@ -118,6 +212,7 @@ export class RangeIterable {
 			let iterator = this.iterate();
 			let array = [];
 			let iterable = this;
+			Object.defineProperty(array, 'iterable', { value: iterable });
 			function next(result) {
 				while (result.done !== true) {
 					if (result.then) {
@@ -127,7 +222,6 @@ export class RangeIterable {
 					}
 					result = iterator.next();
 				}
-				array.iterable = iterable;
 				resolve(iterable._asArray = array);
 			}
 			next(iterator.next());
@@ -139,3 +233,4 @@ export class RangeIterable {
 		return this.asArray;
 	}
 }
+RangeIterable.prototype.DONE = DONE;

package/util/set-optional-deps.cjs

@@ -1,10 +1,14 @@
-let fs = require('fs');
-packageData = JSON.parse(fs.readFileSync('package.json'));
-let prebuilds = fs.readdirSync('prebuilds');
-let platformDeps = packageData.optionalDependencies = {};
-let packageName = packageData.name;
-let version = packageData.version;
-for (let prebuild of prebuilds) {
-	platformDeps['@' + packageName + '/' + packageName + '-' + prebuild] = version;
-}
-fs.writeFileSync('package.json', JSON.stringify(packageData, null, 2));
+let fs = require('fs');
+packageData = JSON.parse(fs.readFileSync('package.json'));
+let prebuilds = fs.readdirSync('prebuilds');
+let platformDeps = packageData.optionalDependencies = {};
+let packageName = packageData.name;
+let version = packageData.version;
+for (let prebuild of prebuilds) {
+	platformDeps['@' + packageName + '/' + packageName + '-' + prebuild] = version;
+}
+/*if (version.endsWith('-v1')) {
+	packageData.version = version.slice(0, -3);
+	packageData.name = packageName + '-v1';
+}*/
+fs.writeFileSync('package.json', JSON.stringify(packageData, null, 2));

package/util/when.js

@@ -1,8 +1,8 @@
-export function when(promise, callback, errback) {
-  if (promise && promise.then) {
-    return errback ?
-      promise.then(callback, errback) :
-      promise.then(callback);
-  }
-  return callback(promise);
-}
+export function when(promise, callback, errback) {
+  if (promise && promise.then) {
+    return errback ?
+      promise.then(callback, errback) :
+      promise.then(callback);
+  }
+  return callback(promise);
+}