zuzu-js 0.4.0 → 0.6.0

package/lib/runtime.js

@@ -40,6 +40,7 @@ const {
 	resolveWeakValue,
 	retainValue,
 	releaseValue,
+	strongReferenceCount,
 	retainCollectionValue,
 	releaseCollectionValue,
 	releaseCollectionValues,
@@ -121,6 +122,12 @@ function installHostCollectionMethods() {
 		this.add( makeWeakValue( value ) );
 		return this;
 	} );
+	define( Set.prototype, 'push_weak', function _pushWeak( ...values ) {
+		for ( const value of values ) {
+			this.add( makeWeakValue( value ) );
+		}
+		return this;
+	} );
 	define( Set.prototype, 'copy', function _copy() {
 		return makeSet( this );
 	} );
@@ -463,8 +470,12 @@ async function runSwitchAsync( value, comparator, cases, defaultBody ) {
 		switch ( comparator ) {
 			case 'eq':
 				return stringCompare( left, right ) === 0;
+			case 'eqi':
+				return stringCompare( left, right, { insensitive: true } ) === 0;
 			case 'ne':
 				return stringCompare( left, right ) !== 0;
+			case 'nei':
+				return stringCompare( left, right, { insensitive: true } ) !== 0;
 			case '=':
 				return numericEqual( zuzuToNumber( left ), zuzuToNumber( right ) );
 			case '==':
@@ -474,7 +485,18 @@ async function runSwitchAsync( value, comparator, cases, defaultBody ) {
 	};
 	let runNext = false;
 	for ( const section of cases ) {
-		const matched = section.values.some( (item) => cmp( value, item ) );
+		let matched = false;
+		if ( Array.isArray( section.tests ) ) {
+			for ( const test of section.tests ) {
+				if ( zuzuTruthy( await taskRuntime.awaitValue( test( value ) ) ) ) {
+					matched = true;
+					break;
+				}
+			}
+		}
+		else {
+			matched = section.values.some( (item) => cmp( value, item ) );
+		}
 		if ( matched || runNext ) {
 			const result = await taskRuntime.awaitValue( section.body() );
 			runNext = result === true;
@@ -739,9 +761,7 @@ function isPlainObjectLike( value ) {
 }
 
 function isDictMethodReceiver( value ) {
-	return value
-		&& typeof value === 'object'
-		&& !Array.isArray( value )
+	return isPlainObjectLike( value )
 		&& !isPairListLike( value )
 		&& !isSetLike( value )
 		&& !isBagLike( value );
@@ -764,18 +784,371 @@ function normalizeDictKey( key ) {
 	return String( key );
 }
 
+function arraySliceBounds( length, start, end = length ) {
+	let from = Number( start ?? 0 );
+	let to = Number( end ?? length );
+	from = Number.isFinite( from ) ? Math.trunc( from ) : 0;
+	to = Number.isFinite( to ) ? Math.trunc( to ) : length;
+	if ( from < 0 ) {
+		from += length;
+	}
+	if ( to < 0 ) {
+		to += length;
+	}
+	from = Math.max( 0, Math.min( length, from ) );
+	to = Math.max( 0, Math.min( length, to ) );
+	return [ Math.min( from, to ), Math.max( from, to ) ];
+}
+
+function arrayMethodArity( name, actual, min, max = min ) {
+	const count = actual - 1;
+	if ( count < min || count > max ) {
+		throw new Error(
+			min === max
+				? `${name} expects ${min} argument${min === 1 ? '' : 's'}`
+				: `${name} expects between ${min} and ${max} arguments`
+		);
+	}
+}
+
+function arrayIndex( length, idx ) {
+	let index = Number( idx );
+	index = Number.isFinite( index ) ? Math.trunc( index ) : 0;
+	if ( index < 0 ) {
+		index += length;
+	}
+	return index;
+}
+
+function shuffledArrayValues( self ) {
+	const out = self.slice();
+	for ( let idx = out.length - 1; idx > 0; idx-- ) {
+		const swapIdx = Math.floor( Math.random() * ( idx + 1 ) );
+		[ out[idx], out[swapIdx] ] = [ out[swapIdx], out[idx] ];
+	}
+	return out;
+}
+
+function arrayJoin( self, separator, fallback, hasFallback ) {
+	const sep = operatorString( separator );
+	let fallbackString;
+	const out = [];
+	for ( const value of self ) {
+		try {
+			out.push( operatorString( value ) );
+		}
+		catch ( err ) {
+			if ( !hasFallback ) {
+				throw err;
+			}
+			if ( typeof fallback === 'function' ) {
+				out.push( operatorString( fallback( value ) ) );
+			}
+			else {
+				if ( fallbackString === undefined ) {
+					fallbackString = operatorString( fallback );
+				}
+				out.push( fallbackString );
+			}
+		}
+	}
+	return out.join( sep );
+}
+
+const ARRAY_METHODS = Object.freeze( {
+	append( self, ...values ) {
+		self.push( ...values.map( (value) => retainCollectionValue( self, value ) ) );
+		return self;
+	},
+	push( self, ...values ) {
+		return ARRAY_METHODS.append( self, ...values );
+	},
+	add( self, ...values ) {
+		return ARRAY_METHODS.append( self, ...values );
+	},
+	push_weak( self, ...values ) {
+		self.push( ...values.map( makeWeakValue ) );
+		return self;
+	},
+	pop( self ) {
+		return self.length ? self.pop() : null;
+	},
+	prepend( self, ...values ) {
+		self.unshift( ...values.map( (value) => retainCollectionValue( self, value ) ) );
+		return self;
+	},
+	unshift( self, ...values ) {
+		return ARRAY_METHODS.prepend( self, ...values );
+	},
+	unshift_weak( self, ...values ) {
+		self.unshift( ...values.map( makeWeakValue ) );
+		return self;
+	},
+	shift( self ) {
+		return self.length ? self.shift() : null;
+	},
+	length( self ) {
+		return self.length;
+	},
+	count( self ) {
+		return self.length;
+	},
+	empty( self ) {
+		return self.length === 0 ? 1 : 0;
+	},
+	is_empty( self ) {
+		return ARRAY_METHODS.empty( self );
+	},
+	copy( self ) {
+		return makeArray( self );
+	},
+	to_Array( self ) {
+		return makeArray( self );
+	},
+	get( self, idx, fallback = null ) {
+		arrayMethodArity( 'Array.get', arguments.length, 1, 2 );
+		const index = arrayIndex( self.length, idx );
+		return index >= 0 && index < self.length ? self[index] : fallback;
+	},
+	set( self, idx, value ) {
+		arrayMethodArity( 'Array.set', arguments.length, 2 );
+		const index = arrayIndex( self.length, idx );
+		if ( index < 0 ) {
+			throw new Error( 'Array index is out of range' );
+		}
+		releaseCollectionValue( self, self[index] );
+		self[index] = retainCollectionValue( self, value );
+		return self;
+	},
+	set_weak( self, idx, value ) {
+		arrayMethodArity( 'Array.set_weak', arguments.length, 2 );
+		const index = arrayIndex( self.length, idx );
+		if ( index < 0 ) {
+			throw new Error( 'Array index is out of range' );
+		}
+		releaseCollectionValue( self, self[index] );
+		self[index] = makeWeakValue( value );
+		return self;
+	},
+	clear( self ) {
+		releaseCollectionValues( self );
+		self.splice( 0, self.length );
+		return self;
+	},
+	join( self, separator, fallback ) {
+		return arrayJoin( self, separator, fallback, arguments.length > 2 );
+	},
+	slice( self, start, end ) {
+		const [ from, to ] = arraySliceBounds( self.length, start, end );
+		return makeArray( self.slice( from, to ) );
+	},
+	head( self, n = 1 ) {
+		arrayMethodArity( 'Array.head', arguments.length, 0, 1 );
+		return makeArray( self.slice( 0, Math.max( 0, Number( n ) || 0 ) ) );
+	},
+	tail( self, n = 1 ) {
+		arrayMethodArity( 'Array.tail', arguments.length, 0, 1 );
+		const count = Math.max( 0, Number( n ) || 0 );
+		return makeArray( count === 0 ? [] : self.slice( -count ) );
+	},
+	to_Set( self ) {
+		return makeSet( self );
+	},
+	to_Bag( self ) {
+		return makeBag( self );
+	},
+	to_Iterator( self ) {
+		return self[Symbol.iterator]();
+	},
+	sort( self, fn ) {
+		const out = self.slice();
+		out.sort( ( left, right ) => Number( fn( left, right ) ) || 0 );
+		return makeArray( out );
+	},
+	sortstr( self ) {
+		return makeArray( self.slice().sort( stringSortComparator ) );
+	},
+	sortnum( self ) {
+		return makeArray(
+			self
+				.map( (item) => Number( item ) )
+				.sort( (a, b) => a - b )
+		);
+	},
+	reverse( self ) {
+		return makeArray( self.slice().reverse() );
+	},
+	sum( self ) {
+		return self.reduce( (a, b) => Number( a ) + Number( b ), 0 );
+	},
+	product( self ) {
+		return self.reduce( (a, b) => Number( a ) * Number( b ), 1 );
+	},
+	shuffle( self ) {
+		arrayMethodArity( 'Array.shuffle', arguments.length, 0 );
+		return makeArray( shuffledArrayValues( self ) );
+	},
+	sample( self, n = 1 ) {
+		arrayMethodArity( 'Array.sample', arguments.length, 0, 1 );
+		return makeArray(
+			shuffledArrayValues( self ).slice( 0, Math.max( 0, Number( n ) || 0 ) )
+		);
+	},
+	contains( self, value ) {
+		return self.includes( value ) ? 1 : 0;
+	},
+	map( self, fn ) {
+		arrayMethodArity( 'Array.map', arguments.length, 1 );
+		return makeArray( self.map( (value) => fn( value ) ) );
+	},
+	grep( self, fn ) {
+		arrayMethodArity( 'Array.grep', arguments.length, 1 );
+		return makeArray( self.filter( (value) => fn( value ) ) );
+	},
+	any( self, fn ) {
+		arrayMethodArity( 'Array.any', arguments.length, 1 );
+		return self.some( (value) => fn( value ) ) ? 1 : 0;
+	},
+	all( self, fn ) {
+		arrayMethodArity( 'Array.all', arguments.length, 1 );
+		return self.every( (value) => fn( value ) ) ? 1 : 0;
+	},
+	first( self, fn ) {
+		arrayMethodArity( 'Array.first', arguments.length, 1 );
+		for ( const value of self ) {
+			if ( fn( value ) ) {
+				return value;
+			}
+		}
+		return null;
+	},
+	remove( self, fn ) {
+		for ( let idx = self.length - 1; idx >= 0; idx-- ) {
+			if ( fn( self[idx] ) ) {
+				releaseCollectionValue( self, self[idx] );
+				self.splice( idx, 1 );
+			}
+		}
+		return self;
+	},
+	first_index( self, fn ) {
+		for ( let idx = 0; idx < self.length; idx++ ) {
+			if ( fn( self[idx] ) ) {
+				return idx;
+			}
+		}
+		return -1;
+	},
+	for_each_value( self, fn ) {
+		for ( const value of self ) {
+			fn( value );
+		}
+		return self;
+	},
+	reduce( self, fn ) {
+		if ( self.length === 0 ) {
+			return null;
+		}
+		let acc = self[0];
+		for ( let idx = 1; idx < self.length; idx++ ) {
+			acc = fn( acc, self[idx] );
+		}
+		return acc;
+	},
+	reductions( self, fn ) {
+		if ( self.length === 0 ) {
+			return makeArray( [] );
+		}
+		const out = [ self[0] ];
+		for ( let idx = 1; idx < self.length; idx++ ) {
+			out.push( fn( out[out.length - 1], self[idx] ) );
+		}
+		return makeArray( out );
+	},
+} );
+
+const ARRAY_ZERO_ARG_METHODS = new Set( [
+	'copy',
+	'count',
+	'empty',
+	'is_empty',
+	'length',
+	'pop',
+	'reverse',
+	'shift',
+	'shuffle',
+	'sortnum',
+	'sortstr',
+	'to_Array',
+	'to_Bag',
+	'to_Iterator',
+	'to_Set',
+] );
+
+function getArrayMethod( object, property ) {
+	if ( typeof property === 'symbol' ) {
+		return null;
+	}
+	const name = String( property );
+	if ( !Array.isArray( object ) || !Object.prototype.hasOwnProperty.call( ARRAY_METHODS, name ) ) {
+		return null;
+	}
+	return function zuzuArrayMethod( ...args ) {
+		return ARRAY_METHODS[name]( object, ...args );
+	};
+}
+
+const SET_METHODS = Object.freeze( {
+	add_weak( self, ...values ) {
+		for ( const value of values ) {
+			self.add( makeWeakValue( value ) );
+		}
+		return self;
+	},
+	push_weak( self, ...values ) {
+		return SET_METHODS.add_weak( self, ...values );
+	},
+	clear( self ) {
+		releaseCollectionValues( self );
+		Set.prototype.clear.call( self );
+		return self;
+	},
+} );
+
+const SET_ZERO_ARG_METHODS = new Set( [ 'clear' ] );
+
+function getSetMethod( object, property ) {
+	if ( typeof property === 'symbol' ) {
+		return null;
+	}
+	const name = String( property );
+	if (
+		!isSetLike( object )
+		|| !Object.prototype.hasOwnProperty.call( SET_METHODS, name )
+	) {
+		return null;
+	}
+	return function zuzuSetMethod( ...args ) {
+		return SET_METHODS[name]( object, ...args );
+	};
+}
+
+function dictSortedKeys( self ) {
+	return isDictMethodReceiver( self ) ? Object.keys( self ).sort() : [];
+}
+
 const DICT_METHODS = Object.freeze( {
 	length( self ) {
 		return isDictMethodReceiver( self ) ? Object.keys( self ).length : 0;
 	},
 	keys( self ) {
-		return isDictMethodReceiver( self ) ? Object.keys( self ).sort() : [];
+		return makeSet( dictSortedKeys( self ) );
 	},
 	values( self ) {
 		if ( !isDictMethodReceiver( self ) ) {
-			return [];
+			return makeBag( [] );
 		}
-		return DICT_METHODS.keys( self ).map( (key) => resolveWeakValue( self[key] ) );
+		return makeBag( dictSortedKeys( self ).map( (key) => resolveWeakValue( self[key] ) ) );
 	},
 	copy( self ) {
 		if ( !isDictMethodReceiver( self ) ) {
@@ -789,11 +1162,11 @@ const DICT_METHODS = Object.freeze( {
 	},
 	enumerate( self ) {
 		if ( !isDictMethodReceiver( self ) ) {
-			return [];
+			return makeBag( [] );
 		}
-		return DICT_METHODS.keys( self ).map(
+		return makeBag( dictSortedKeys( self ).map(
 			(key) => new Pair( { pair: [ key, resolveWeakValue( self[key] ) ] } )
-		);
+		) );
 	},
 	has( self, key ) {
 		return isDictMethodReceiver( self )
@@ -847,13 +1220,13 @@ const DICT_METHODS = Object.freeze( {
 			return [];
 		}
 		const out = [];
-		for ( const key of DICT_METHODS.keys( self ) ) {
+		for ( const key of dictSortedKeys( self ) ) {
 			out.push( key, resolveWeakValue( self[key] ) );
 		}
 		return out;
 	},
 	sorted_keys( self ) {
-		return DICT_METHODS.keys( self );
+		return dictSortedKeys( self );
 	},
 	remove( self, key ) {
 		if ( !isDictMethodReceiver( self ) ) {
@@ -886,26 +1259,31 @@ const DICT_METHODS = Object.freeze( {
 		return DICT_METHODS.empty( self );
 	},
 	to_Array( self ) {
-		return DICT_METHODS.enumerate( self );
+		if ( !isDictMethodReceiver( self ) ) {
+			return [];
+		}
+		return makeArray( dictSortedKeys( self ).map(
+			(key) => new Pair( { pair: [ key, resolveWeakValue( self[key] ) ] } )
+		) );
 	},
 	to_Iterator( self ) {
-		return DICT_METHODS.keys( self )[Symbol.iterator]();
+		return dictSortedKeys( self )[Symbol.iterator]();
 	},
 	for_each_key( self, fn ) {
-		for ( const key of DICT_METHODS.keys( self ) ) {
+		for ( const key of dictSortedKeys( self ) ) {
 			fn( key );
 		}
 		return self;
 	},
 	for_each_value( self, fn ) {
-		for ( const value of DICT_METHODS.values( self ) ) {
-			fn( value );
+		for ( const key of dictSortedKeys( self ) ) {
+			fn( resolveWeakValue( self[key] ) );
 		}
 		return self;
 	},
 	for_each_pair( self, fn ) {
-		for ( const pair of DICT_METHODS.enumerate( self ) ) {
-			fn( pair );
+		for ( const key of dictSortedKeys( self ) ) {
+			fn( new Pair( { pair: [ key, resolveWeakValue( self[key] ) ] } ) );
 		}
 		return self;
 	},
@@ -941,6 +1319,12 @@ function getDictMethod( object, property ) {
 		return null;
 	}
 	const name = String( property );
+	for ( let proto = Object.getPrototypeOf( object ); proto; proto = Object.getPrototypeOf( proto ) ) {
+		const descriptor = Object.getOwnPropertyDescriptor( proto, name );
+		if ( descriptor && typeof descriptor.value === 'function' ) {
+			return null;
+		}
+	}
 	if (
 		!isDictMethodReceiver( object )
 		|| Object.prototype.hasOwnProperty.call( object, name )
@@ -988,8 +1372,8 @@ function zuzuBoundMethod( receiver, name, fn ) {
 		enumerable: false,
 		configurable: true,
 	} );
-	bound.invoke = function invoke( _self, args = [] ) {
-		return fn.apply( receiver, args );
+	bound.invoke = function invoke( self, args = [] ) {
+		return fn.apply( self, args );
 	};
 	bound.to_String = function to_String() {
 		return methodName;
@@ -1502,6 +1886,22 @@ function zuzuGetMember( object, property ) {
 	if ( object == null ) {
 		return null;
 	}
+	if ( property !== 'length' ) {
+		const arrayMethod = getArrayMethod( object, property );
+		if ( arrayMethod && ARRAY_ZERO_ARG_METHODS.has( String( property ) ) ) {
+			return arrayMethod();
+		}
+		if ( arrayMethod ) {
+			return arrayMethod;
+		}
+	}
+	const setMethod = getSetMethod( object, property );
+	if ( setMethod && SET_ZERO_ARG_METHODS.has( String( property ) ) ) {
+		return setMethod();
+	}
+	if ( setMethod ) {
+		return setMethod;
+	}
 	const value = resolveWeakValue( object[property] );
 	if (
 		typeof value === 'function'
@@ -1541,6 +1941,18 @@ function zuzuCallMember( object, property, ...args ) {
 	if ( property instanceof ZuzuMethod || ( property && property.__zuzu_method ) ) {
 		return property.invoke( object, args );
 	}
+	const arrayMethod = getArrayMethod( object, property );
+	if ( arrayMethod ) {
+		return arrayMethod( ...args );
+	}
+	const setMethod = getSetMethod( object, property );
+	if ( setMethod ) {
+		return setMethod( ...args );
+	}
+	const dictMethod = getDictMethod( object, property );
+	if ( dictMethod ) {
+		return dictMethod( ...args );
+	}
 	const value = resolveWeakValue( object[property] );
 	if ( typeof value === 'function' ) {
 		return value.apply( object, args );
@@ -1553,22 +1965,24 @@ function zuzuCallMember( object, property, ...args ) {
 		}
 		proto = Object.getPrototypeOf( proto );
 	}
-	const dictMethod = getDictMethod( object, property );
-	if ( dictMethod ) {
-		return dictMethod( ...args );
-	}
 	throw new TypeError( `${String( property )} is not a function` );
 }
 
-function zuzuMaybeDemolish( value ) {
+function zuzuMaybeDemolish( value, preserved = null ) {
 	const original = value;
 	value = resolveWeakValue( value );
-	let result = null;
-	if ( value && typeof value.__demolish__ === 'function' ) {
-		result = value.__demolish__();
+	const shouldDemolish =
+		value
+		&& value !== resolveWeakValue( preserved )
+		&& typeof value.__demolish__ === 'function';
+	releaseValue( original, {
+		preserveCollectionValues: value === resolveWeakValue( preserved ),
+		suppressDemolish: true,
+	} );
+	if ( shouldDemolish && strongReferenceCount( value ) === 0 ) {
+		return value.__demolish__();
 	}
-	releaseValue( original );
-	return result;
+	return null;
 }
 
 function zuzuCan( value, methodName ) {
@@ -1577,6 +1991,12 @@ function zuzuCan( value, methodName ) {
 		return 0;
 	}
 	const key = String( methodName || '' );
+	if ( getArrayMethod( value, key ) ) {
+		return 1;
+	}
+	if ( getSetMethod( value, key ) ) {
+		return 1;
+	}
 	if ( getDictMethod( value, key ) ) {
 		return 1;
 	}
@@ -2094,15 +2514,25 @@ class ZuzuScript {
 		this.transpiler = normalizeTranspilerName(
 			options.transpiler || DEFAULT_TRANSPILER
 		);
+		this.asyncImports = options.asyncImports === true;
 		if ( typeof this.host.loadJsModule !== 'function' ) {
 			this.host.loadJsModule = ( filename ) => require( filename );
 		}
 	}
 
+	usesAsyncImports() {
+		return this.asyncImports
+			|| (
+				typeof this.host.hasAsyncModules === 'function'
+				&& this.host.hasAsyncModules()
+			);
+	}
+
 	transpile( source, options = {} ) {
 		return transpile( source, {
 			...options,
 			transpiler: options.transpiler || this.transpiler,
+			asyncImports: options.asyncImports ?? this.usesAsyncImports(),
 		} );
 	}
 
@@ -2474,6 +2904,7 @@ class ZuzuScript {
 			defineRuntimeMethod( Set.prototype, 'empty', function _emptySet() { return this.size === 0 ? 1 : 0; } );
 			defineRuntimeMethod( Set.prototype, 'is_empty', function _isEmptySet() { return this.empty(); } );
 			defineRuntimeMethod( Set.prototype, 'push', function _pushSet( ...values ) { for ( const v of values ) { addSetValue( this, v ); } return this; } );
+			defineRuntimeMethod( Set.prototype, 'push_weak', function _pushWeakSet( ...values ) { for ( const v of values ) { this.add( makeWeakValue( v ) ); } return this; } );
 			defineRuntimeMethod( Set.prototype, 'contains', function _containsSet( value ) { return contains( this, value ); } );
 			defineRuntimeMethod( Set.prototype, 'remove', function _removeSet( value ) { const resolved = resolveWeakValue( value ); if ( this.delete( resolved ) ) { releaseCollectionValue( this, resolved ); } return this; } );
 			defineRuntimeMethod( Set.prototype, 'to_Array', function _setToArray() { return makeArray( this ); } );
@@ -2559,6 +2990,7 @@ class ZuzuScript {
 			__file__: this.fileValueForFilename( filename ),
 			__zuzu_system_seed: systemGlobalSeed,
 			__zuzu_current_system: currentSystem,
+			__zuzu_operator_string: zuzuOperatorString,
 			DEBUG: this.debugLevel,
 			__zuzu_host_capabilities: capabilityFlags,
 			has_capability( name ) {
@@ -2922,9 +3354,9 @@ class ZuzuScript {
 			__zuzu_length: operatorLength,
 			__zuzu_num( value ) { return zuzuToNumber( value ); },
 			__zuzu_truthy( value ) { return zuzuTruthy( value ); },
-			__zuzu_not( value ) { return zuzuTruthy( value ) ? 0 : 1; },
-			__zuzu_and( left, right ) { return zuzuTruthy( left ) && zuzuTruthy( right ) ? 1 : 0; },
-			__zuzu_or( left, right ) { return zuzuTruthy( left ) || zuzuTruthy( right ) ? 1 : 0; },
+			__zuzu_not( value ) { return !zuzuTruthy( value ); },
+			__zuzu_and( left, right ) { return zuzuTruthy( left ) && zuzuTruthy( right ); },
+			__zuzu_or( left, right ) { return zuzuTruthy( left ) || zuzuTruthy( right ); },
 			__zuzu_typeof( value ) { return zuzuTypeof( value ); },
 			__zuzu_instanceof( value, klass ) { return zuzuInstanceof( value, klass ); },
 			__zuzu_trait( name, methods, source = null, captures = {} ) {
@@ -3100,11 +3532,11 @@ class ZuzuScript {
 			__zuzu_resolve_brace_key( object, literalProperty, getDynamicProperty ) {
 				return zuzuResolveBraceKey( object, literalProperty, getDynamicProperty );
 			},
-			__zuzu_maybe_demolish( value ) {
-				return zuzuMaybeDemolish( value );
+			__zuzu_maybe_demolish( value, preserved = null ) {
+				return zuzuMaybeDemolish( value, preserved );
 			},
-			__zuzu_xor( left, right ) { return ( zuzuTruthy( left ) !== zuzuTruthy( right ) ) ? 1 : 0; },
-			__zuzu_nand( left, right ) { return ( zuzuTruthy( left ) && zuzuTruthy( right ) ) ? 0 : 1; },
+			__zuzu_xor( left, right ) { return zuzuTruthy( left ) !== zuzuTruthy( right ); },
+			__zuzu_nand( left, right ) { return !( zuzuTruthy( left ) && zuzuTruthy( right ) ); },
 			__zuzu_num_eq( left, right ) {
 				if ( !isNumericComparable( left ) || !isNumericComparable( right ) ) {
 					return zuzuEqual( left, right );
@@ -3183,6 +3615,9 @@ class ZuzuScript {
 			if ( name === 'std/eval' ) {
 				return { eval: context.__zuzu_native_eval };
 			}
+			if ( this.usesAsyncImports() ) {
+				return this.loadModuleAsync( name, filename, context );
+			}
 			return this.loadModule( name, filename, context );
 		};
 		return context;
@@ -3260,6 +3695,41 @@ class ZuzuScript {
 						Object.defineProperty( proto, name, desc );
 					}
 				};
+				if ( Array.prototype.join.__zuzu_array_join !== true ) {
+					const __zuzu_native_array_join = Array.prototype.join;
+					const joinDesc = Object.create( null );
+					joinDesc.value = function _join( separator, fallback ) {
+						const hasFallback = arguments.length > 1;
+						let fallbackString;
+						const sep = __zuzu_operator_string( separator );
+						const out = [];
+						for ( const value of this ) {
+							try {
+								out.push( __zuzu_operator_string( value ) );
+							}
+							catch ( err ) {
+								if ( !hasFallback ) {
+									throw err;
+								}
+								if ( typeof fallback === 'function' ) {
+									out.push( __zuzu_operator_string( fallback( value ) ) );
+								}
+								else {
+									if ( fallbackString === undefined ) {
+										fallbackString = __zuzu_operator_string( fallback );
+									}
+									out.push( fallbackString );
+								}
+							}
+						}
+						return __zuzu_native_array_join.call( out, sep );
+					};
+					joinDesc.value.__zuzu_array_join = true;
+					joinDesc.enumerable = false;
+					joinDesc.configurable = true;
+					joinDesc.writable = true;
+					Object.defineProperty( Array.prototype, 'join', joinDesc );
+				}
 				define( Array.prototype, 'length', function _length() { return this.length; } );
 				define( Array.prototype, 'count', function _count() { return this.length; } );
 				define( Array.prototype, 'empty', function _empty() { return this.length === 0 ? 1 : 0; } );
@@ -3302,6 +3772,7 @@ class ZuzuScript {
 				define( Set.prototype, 'is_empty', function _is_empty() { return this.empty(); } );
 				define( Set.prototype, 'push', function _push( ...values ) { for ( const v of values ) { __zuzu_add_set_value( this, v ); } return this; } );
 				define( Set.prototype, 'add_weak', function _add_weak( value ) { this.add( __zuzu_make_weak_value( value ) ); return this; } );
+				define( Set.prototype, 'push_weak', function _push_weak( ...values ) { for ( const v of values ) { this.add( __zuzu_make_weak_value( v ) ); } return this; } );
 				define( Set.prototype, 'contains', function _contains( value ) { return __zuzu_contains( this, value ); } );
 				define( Set.prototype, 'remove', function _remove( value ) { const resolved = __zuzu_resolve_weak_value( value ); if ( this.delete( resolved ) ) { __zuzu_release_collection_value( this, resolved ); } return this; } );
 				define( Set.prototype, 'to_Array', function _to_array() { return __zuzu_array( this ); } );
@@ -3553,6 +4024,74 @@ class ZuzuScript {
 		return moduleObj.exports;
 	}
 
+	async loadModuleAsync( moduleName, fromFile, contextForPolicy = null ) {
+		if ( /(^|\/)\.\.(\/|$)/.test( moduleName ) ) {
+			throw new Error( "Import module path cannot contain '..' segments" );
+		}
+		this.enforceModulePolicy( moduleName );
+		const resolved = this.resolveModulePath( moduleName, fromFile );
+		const cacheable = moduleName !== 'test/more'
+			&& this.evalCapabilityOverrides == null;
+		if ( cacheable && this.moduleCache.has( resolved ) ) {
+			return this.moduleCache.get( resolved );
+		}
+		if ( resolved.endsWith( '.js' ) ) {
+			return this.loadModule( moduleName, fromFile, contextForPolicy );
+		}
+		if ( this.moduleLoading.has( resolved ) ) {
+			throw new Error( 'Circular module loading detected' );
+		}
+		this.moduleLoading.add( resolved );
+		try {
+			const source = typeof this.host.readFileTextAsync === 'function'
+				? await this.host.readFileTextAsync( resolved )
+				: this.host.readFileText( resolved );
+			let js = this.transpile( source, {
+				asyncImports: true,
+				deferAsyncWrapper: true,
+			} );
+			const exportNames = resolved.endsWith( '.zzm' )
+				? collectTopLevelDeclarations( source, stripPod )
+				: [];
+			let exportBridge = '';
+			if ( exportNames.length > 0 ) {
+				exportBridge = exportNames
+					.map( (name) => {
+						if ( name.startsWith( '_' ) ) {
+							return `if ( typeof ${name} !== "undefined" ) { const __zuzu_desc = Object.create( null ); __zuzu_desc.get = function() { return ${name}; }; __zuzu_desc.set = function( value ) { ${name} = value; }; __zuzu_desc.enumerable = false; __zuzu_desc.configurable = true; Object.defineProperty( module.exports, ${JSON.stringify( name )}, __zuzu_desc ); }`;
+						}
+						return `if ( typeof ${name} !== "undefined" ) { const __zuzu_desc = Object.create( null ); __zuzu_desc.get = function() { return ${name}; }; __zuzu_desc.set = function( value ) { ${name} = value; }; __zuzu_desc.enumerable = true; __zuzu_desc.configurable = true; Object.defineProperty( module.exports, ${JSON.stringify( name )}, __zuzu_desc ); }`;
+					} )
+					.join( '\n' );
+			}
+			js = `( async () => {\n${js}\n${exportBridge}\n} )()`;
+			setCompiledSource( resolved, js );
+			const moduleObj = { exports: {} };
+			const context = this.buildContext( {
+				exports: moduleObj.exports,
+				module: moduleObj,
+				filename: resolved,
+			} );
+			context.__global__ = Object.create( null );
+			this.installCollectionMethods( context );
+			const moduleRunOptions = { filename: resolved };
+			if ( this.executionTimeoutMs != null ) {
+				moduleRunOptions.timeout = this.executionTimeoutMs;
+			}
+			const result = this.host.runInContext( js, context, moduleRunOptions );
+			if ( result && typeof result.then === 'function' ) {
+				await result;
+			}
+			if ( cacheable ) {
+				this.moduleCache.set( resolved, moduleObj.exports );
+			}
+			return moduleObj.exports;
+		}
+		finally {
+			this.moduleLoading.delete( resolved );
+		}
+	}
+
 	runSource( source, options = {} ) {
 		const filename = options.filename || this.host.join( this.repoRoot, '<inline>.zzs' );
 		let js;