zuzu-js 0.2.0 → 0.4.0

package/lib/cli.js

@@ -254,7 +254,7 @@ function stripShebang( source ) {
 }
 
 function printVersion( runtime, verbose ) {
-	process.stdout.write( 'zuzu-js version 0.2.0\n' );
+	process.stdout.write( 'zuzu-js version 0.4.0\n' );
 	if ( verbose ) {
 		process.stdout.write( '\nlib search paths:\n' );
 		for ( const p of runtime.getModuleSearchRoots() ) {

package/lib/collections.js

@@ -24,6 +24,10 @@ function makeSet( values ) {
 	return runtimeHelpers().makeSet( values );
 }
 
+function stringSortComparator( a, b ) {
+	return runtimeHelpers().stringSortComparator( a, b );
+}
+
 class ZuzuBag {
 	constructor( ...items ) {
 		let values;
@@ -105,7 +109,7 @@ class ZuzuBag {
 	sum() { return this.items.reduce( (a, b) => Number( a ) + Number( b ), 0 ); }
 	product() { return this.items.reduce( (a, b) => Number( a ) * Number( b ), 1 ); }
 	sort( fn ) { return this.to_Array().sort( fn ); }
-	sortstr() { return this.to_Array().sort( (a, b) => String( a ).localeCompare( String( b ) ) ); }
+	sortstr() { return this.to_Array().sort( stringSortComparator ); }
 	sortnum() { return this.to_Array().map( (item) => Number( item ) ).sort( (a, b) => a - b ); }
 	clear() { releaseCollectionValues( this ); this.items = []; return this; }
 	[Symbol.iterator]() { return this.items[Symbol.iterator](); }
@@ -338,7 +342,7 @@ function withArrayMethods() {
 	define( 'shuffle', function _shuffle() { return this.slice(); } );
 	define( 'sample', function _sample( n ) { return this.slice( 0, n ); } );
 	define( 'for_each_value', function _for_each_value( fn ) { this.forEach( fn ); return this; } );
-	define( 'sortstr', function _sortstr() { return this.slice().sort( (a, b) => String( a ).localeCompare( String( b ) ) ); } );
+	define( 'sortstr', function _sortstr() { return this.slice().sort( stringSortComparator ); } );
 	define(
 		'sortnum',
 		function _sortnum() {

package/lib/runtime-helpers.js

@@ -886,6 +886,40 @@ function operatorString( value ) {
 	throw new Error( `TypeException: cannot coerce ${typeName( value )} to String` );
 }
 
+const surrogatePattern = /[\uD800-\uDFFF]/;
+
+// Compare two native strings by Unicode code point, matching the string
+// ordering used by zuzu-rust and zuzu-perl. Plain UTF-16 comparison only
+// disagrees with code-point order when astral characters (surrogate
+// pairs) meet code units in the U+E000..U+FFFF range, so the slow path is
+// only taken when a surrogate is present.
+function codePointStringCompare( left, right ) {
+	if ( left === right ) {
+		return 0;
+	}
+	if ( surrogatePattern.test( left ) || surrogatePattern.test( right ) ) {
+		const leftPoints = Array.from( left );
+		const rightPoints = Array.from( right );
+		const shared = Math.min( leftPoints.length, rightPoints.length );
+		for ( let i = 0; i < shared; i++ ) {
+			const a = leftPoints[i].codePointAt( 0 );
+			const b = rightPoints[i].codePointAt( 0 );
+			if ( a !== b ) {
+				return a < b ? -1 : 1;
+			}
+		}
+		if ( leftPoints.length === rightPoints.length ) {
+			return 0;
+		}
+		return leftPoints.length < rightPoints.length ? -1 : 1;
+	}
+	return left < right ? -1 : 1;
+}
+
+function stringSortComparator( a, b ) {
+	return codePointStringCompare( String( a ), String( b ) );
+}
+
 function operatorRegexp( value ) {
 	value = resolveWeakValue( value );
 	if ( value instanceof RegExp || Object.prototype.toString.call( value ) === '[object RegExp]' ) {
@@ -915,6 +949,8 @@ module.exports = {
 	lengthOf,
 	operatorString,
 	operatorRegexp,
+	codePointStringCompare,
+	stringSortComparator,
 	ZuzuBinary,
 	BinaryString,
 	ZuzuWeakCell,

package/lib/runtime.js

@@ -46,6 +46,8 @@ const {
 	addSetValue,
 	assignStrongValue,
 	assignWeakValue,
+	codePointStringCompare,
+	stringSortComparator,
 } = require( './runtime-helpers' );
 const taskRuntime = require( '../modules/std/task' );
 
@@ -53,6 +55,28 @@ const textEncoder = new TextEncoder();
 const utf8Decoder = new TextDecoder( 'utf-8', { fatal: true } );
 const ZUZU_SKIP_BUILD = Symbol.for( 'zuzu.skip_build' );
 
+const runtimeVersion = (() => {
+	if ( typeof globalThis === 'object' && globalThis !== null ) {
+		const globalVersion = globalThis.__ZUZU_RUNTIME_VERSION;
+		if ( typeof globalVersion === 'string' && globalVersion.trim() ) {
+			return String( globalVersion );
+		}
+	}
+	if ( typeof process === 'object' && process && process.versions ) {
+		try {
+			const packageMetadata = require( '../package.json' );
+			const packageVersion = packageMetadata && packageMetadata.version;
+			if ( packageVersion ) {
+				return String( packageVersion );
+			}
+		}
+		catch ( err ) {
+			return 'dev';
+		}
+	}
+	return 'dev';
+})();
+
 function defaultModuleSearchRoots( host, repoRoot, includePaths ) {
 	if ( host.name === 'browser' ) {
 		return [
@@ -226,11 +250,21 @@ function stringCompare( left, right, options = {} ) {
 	const r = options.insensitive
 		? zuzuOperatorString( right ).toLowerCase()
 		: zuzuOperatorString( right );
-	return l.localeCompare( r );
+	// Code-point order, matching zuzu-rust and zuzu-perl; localeCompare
+	// would give locale-dependent, case-folded ordering.
+	return codePointStringCompare( l, r );
 }
 
 function parseNumericString( value ) {
 	const text = String( value ).trim();
+	// Coercion is more permissive than the lexer: radix prefixes match
+	// either case.
+	const radix = text.match( /^([+-]?)0([xX][0-9a-fA-F]+|[bB][01]+|[oO][0-7]+)$/ );
+	if ( radix ) {
+		const base = 'xX'.includes( radix[2][0] ) ? 16 : 'bB'.includes( radix[2][0] ) ? 2 : 8;
+		const magnitude = parseInt( radix[2].slice( 1 ), base );
+		return radix[1] === '-' ? -magnitude : magnitude;
+	}
 	const match = text.match( /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/ );
 	if ( !match ) {
 		throw new Error( `TypeException: cannot coerce String to Number: ${JSON.stringify( String( value ) )}` );
@@ -565,6 +599,52 @@ function bitwiseNot( value ) {
 	return ( ~( zuzuToNumber( value ) >>> 0 ) ) >>> 0;
 }
 
+// BinaryStrings shift as one whole bit string: bits carry across byte
+// boundaries, length is preserved, vacated bits are 0. Numbers shift via
+// float multiply/divide so counts beyond 32 bits behave portably.
+function shiftBitstream( bytes, count, left ) {
+	const len = bytes.length;
+	const out = new Uint8Array( len );
+	if ( len === 0 || count >= len * 8 ) {
+		return out;
+	}
+	const byteShift = Math.floor( count / 8 );
+	const bitShift = count % 8;
+	for ( let i = 0; i < len; i++ ) {
+		let value;
+		if ( left ) {
+			const src = i + byteShift;
+			const hi = src < len ? bytes[src] : 0;
+			const lo = src + 1 < len ? bytes[src + 1] : 0;
+			value = ( ( ( hi << 8 ) | lo ) << bitShift ) >> 8;
+		}
+		else {
+			if ( i < byteShift ) {
+				continue;
+			}
+			const lo = bytes[i - byteShift];
+			const hi = i > byteShift ? bytes[i - byteShift - 1] : 0;
+			value = ( ( hi << 8 ) | lo ) >> bitShift;
+		}
+		out[i] = value & 0xff;
+	}
+	return out;
+}
+
+function shiftValue( left, right, leftward ) {
+	left = resolveWeakValue( left );
+	const count = Math.trunc( zuzuToNumber( right ) );
+	if ( !( count >= 0 ) || !Number.isFinite( count ) ) {
+		throw new Error( 'Exception: shift count must be a non-negative integer' );
+	}
+	if ( left instanceof ZuzuBinary ) {
+		return new BinaryString( shiftBitstream( left.bytes, count, leftward ) );
+	}
+	const value = Math.trunc( zuzuToNumber( left ) );
+	const factor = Math.pow( 2, count );
+	return leftward ? value * factor : Math.floor( value / factor );
+}
+
 function zuzuComparableValue( value ) {
 	value = resolveWeakValue( value );
 	if ( typeof value === 'function' && value.length === 0 ) {
@@ -1283,7 +1363,11 @@ function defineZuzuClass( name, base, spec = {} ) {
 					zuzuStoreField( this, field, value );
 				}
 				let named = null;
-				if ( ctorArgs.length === 1 && isPairListLike( ctorArgs[0] ) ) {
+				const lastArg = ctorArgs[ctorArgs.length - 1];
+				if (
+					ctorArgs.length === 1
+					&& isPairListLike( ctorArgs[0] )
+				) {
 					named = ctorArgs[0];
 				}
 				else if (
@@ -1294,6 +1378,20 @@ function defineZuzuClass( name, base, spec = {} ) {
 				) {
 					named = ctorArgs[0];
 				}
+				else if (
+					ctorArgs.length > 1
+					&& isPairListLike( lastArg )
+				) {
+					named = lastArg;
+				}
+				else if (
+					ctorArgs.length > 1
+					&& lastArg
+					&& typeof lastArg === 'object'
+					&& !Array.isArray( lastArg )
+				) {
+					named = lastArg;
+				}
 				const releaseTemporaryNamed = !skipBuild
 					&& isPairListLike( named )
 					&& named.__zuzu_temporary_call_args === true;
@@ -1459,9 +1557,6 @@ function zuzuCallMember( object, property, ...args ) {
 	if ( dictMethod ) {
 		return dictMethod( ...args );
 	}
-	if ( args.length === 0 ) {
-		return value;
-	}
 	throw new TypeError( `${String( property )} is not a function` );
 }
 
@@ -2128,7 +2223,13 @@ class ZuzuScript {
 		}
 		const moduleSearchRoots = this.getModuleSearchRoots();
 		const emit = ( value ) => {
-			const line = String( value );
+			let line = String( value );
+			if ( line === 'Infinity' ) {
+				line = 'Inf';
+			}
+			else if ( line === '-Infinity' ) {
+				line = '-Inf';
+			}
 			if ( this.outputLines ) {
 				this.outputLines.push( line );
 			}
@@ -2387,7 +2488,7 @@ class ZuzuScript {
 			defineRuntimeMethod( Set.prototype, 'is_disjoint', function _setIsDisjoint( other ) { return this.intersection( other ).size === 0 ? 1 : 0; } );
 			defineRuntimeMethod( Set.prototype, 'equals', function _setEquals( other ) { return collectionEquivalentOf( this, other ); } );
 			defineRuntimeMethod( Set.prototype, 'sort', function _setSort( fn ) { return [ ...this ].sort( fn ); } );
-			defineRuntimeMethod( Set.prototype, 'sortstr', function _setSortstr() { return [ ...this ].sort( (a, b) => String( a ).localeCompare( String( b ) ) ); } );
+			defineRuntimeMethod( Set.prototype, 'sortstr', function _setSortstr() { return [ ...this ].sort( stringSortComparator ); } );
 			defineRuntimeMethod( Set.prototype, 'sortnum', function _setSortnum() { return [ ...this ].map( (item) => Number( item ) ).sort( (a, b) => a - b ); } );
 			defineRuntimeMethod( Set.prototype, 'map', function _setMap( fn ) { return new Set( [ ...this ].map( fn ) ); } );
 			defineRuntimeMethod( Set.prototype, 'grep', function _setGrep( fn ) { return new Set( [ ...this ].filter( fn ) ); } );
@@ -2421,7 +2522,7 @@ class ZuzuScript {
 		const systemGlobalSeed = {
 			language_version: 0,
 			runtime: 'zuzu-js',
-			runtime_version: 'dev',
+			runtime_version: runtimeVersion,
 			platform: this.host.name,
 			inc: Object.freeze( moduleSearchRoots.slice() ),
 			deny_fs: capabilityFlags.fs ? false : true,
@@ -2767,6 +2868,14 @@ class ZuzuScript {
 					if ( input == null ) {
 						return [];
 					}
+					if ( input instanceof ZuzuBinary ) {
+						// Iterate byte-by-byte, each as a 1-byte BinaryString.
+						return Array.from( input.bytes, (byte) => new BinaryString( [ byte ] ) );
+					}
+					if ( typeof input === 'string' || input instanceof String ) {
+						// Iterate character-by-character (code points).
+						return Array.from( String( input ) );
+					}
 					if ( typeof input[Symbol.iterator] === 'function' ) {
 						return input;
 					}
@@ -2880,6 +2989,15 @@ class ZuzuScript {
 				return value.isAscii();
 			},
 			__zuzu_bit_and( left, right ) { return bitwiseAnd( left, right ); },
+			__zuzu_shift_left( left, right ) { return shiftValue( left, right, true ); },
+			// The left operand is the divisor: a ∣ b tests b mod a.
+			__zuzu_divides( left, right ) {
+				return ( zuzuToNumber( right ) % zuzuToNumber( left ) ) === 0;
+			},
+			__zuzu_ndivides( left, right ) {
+				return zuzuToNumber( right ) % zuzuToNumber( left );
+			},
+			__zuzu_shift_right( left, right ) { return shiftValue( left, right, false ); },
 			__zuzu_bit_or( left, right ) { return bitwiseOr( left, right ); },
 			__zuzu_bit_xor( left, right ) { return bitwiseXor( left, right ); },
 			__zuzu_bit_not( value ) { return bitwiseNot( value ); },
@@ -3169,7 +3287,7 @@ class ZuzuScript {
 				define( Array.prototype, 'shuffle', function _shuffle() { return this.slice(); } );
 				define( Array.prototype, 'sample', function _sample( n ) { return this.slice( 0, n ); } );
 				define( Array.prototype, 'for_each_value', function _for_each_value( fn ) { this.forEach( fn ); return this; } );
-				define( Array.prototype, 'sortstr', function _sortstr() { return this.slice().sort( (a, b) => String( a ).localeCompare( String( b ) ) ); } );
+				define( Array.prototype, 'sortstr', function _sortstr() { return this.slice().sort( stringSortComparator ); } );
 				define( Array.prototype, 'sortnum', function _sortnum() { return this.map( (item) => Number( item ) ).sort( (a, b) => a - b ); } );
 				define( Array.prototype, 'to_Array', function _to_array() { return __zuzu_array( this ); } );
 				define( Array.prototype, 'to_Set', function _to_set() { return __zuzu_set( this ); } );
@@ -3199,7 +3317,7 @@ class ZuzuScript {
 				define( Set.prototype, 'is_disjoint', function _is_disjoint( other ) { return this.intersection( other ).size === 0 ? 1 : 0; } );
 				define( Set.prototype, 'equals', function _equals( other ) { return __zuzu_equivalentof( this, other ); } );
 				define( Set.prototype, 'sort', function _sort( fn ) { return [ ...this ].sort( fn ); } );
-				define( Set.prototype, 'sortstr', function _sortstr() { return [ ...this ].sort( (a, b) => String( a ).localeCompare( String( b ) ) ); } );
+				define( Set.prototype, 'sortstr', function _sortstr() { return [ ...this ].sort( stringSortComparator ); } );
 				define( Set.prototype, 'sortnum', function _sortnum() { return [ ...this ].map( (item) => Number( item ) ).sort( (a, b) => a - b ); } );
 				define( Set.prototype, 'map', function _map( fn ) { return new Set( [ ...this ].map( fn ) ); } );
 				define( Set.prototype, 'grep', function _grep( fn ) { return new Set( [ ...this ].filter( fn ) ); } );

package/lib/transpiler-new/codegen.js

@@ -609,6 +609,8 @@ function extractSpecialPreludeNames( signature ) {
 			return [ '__zuzu_call_args', signature.headName, signature.restName, signature.namedName, '__i', '__a' ];
 		case 'scalar_pairlist':
 			return [ '__zuzu_call_args', signature.headName, signature.namedName, '__i', '__a' ];
+		case 'scalar_pairlist_array':
+			return [ '__zuzu_call_args', signature.headName, signature.namedName, signature.restName, '__i', '__a' ];
 		case 'variadic':
 			return [ '__zuzu_call_args', signature.headName, signature.restName, '__i', '__a' ];
 		default:
@@ -694,6 +696,22 @@ function analyzeSpecialSignature( params ) {
 			namedName: params[1].name,
 		};
 	}
+	if (
+		params.length === 3
+		&& params[0].type === 'Parameter'
+		&& params[1].type === 'SpecialParameter'
+		&& params[1].special === 'rest_only'
+		&& params[1].containerType === 'PairList'
+		&& params[2].type === 'Parameter'
+		&& ( params[2].typeName === 'Array' || params[2].typeName == null )
+	) {
+		return {
+			kind: 'scalar_pairlist_array',
+			headName: params[0].name,
+			namedName: params[1].name,
+			restName: params[2].name,
+		};
+	}
 	if (
 		params.length === 1
 		&& params[0].type === 'SpecialParameter'
@@ -835,6 +853,19 @@ function emitSpecialFunctionPreamble( signature ) {
 				'}',
 				`const ${signature.namedName} = __zuzu_named_args;`,
 			].join( '\n' );
+		case 'scalar_pairlist_array':
+			return [
+				'const __zuzu_call_args = Array.prototype.slice.call( arguments );',
+				`const ${signature.headName} = __zuzu_call_args[0];`,
+				'let __zuzu_named_args = __zuzu_pairlist_literal( [] );',
+				'const __zuzu_rest_args = [];',
+				'for ( let __i = 1; __i < __zuzu_call_args.length; __i++ ) {',
+				'const __a = __zuzu_call_args[__i];',
+				'if ( __zuzu_is_pairlist( __a ) ) { __zuzu_named_args = __a; } else { __zuzu_rest_args.push( __a ); }',
+				'}',
+				`const ${signature.restName} = __zuzu_rest_args;`,
+				`const ${signature.namedName} = __zuzu_named_args;`,
+			].join( '\n' );
 		case 'variadic':
 			return [
 				'const __zuzu_call_args = Array.prototype.slice.call( arguments );',
@@ -2121,6 +2152,17 @@ function emitBinaryExpression( node ) {
 			return `__zuzu_bit_or( ${left}, ${right} )`;
 		case '^':
 			return `__zuzu_bit_xor( ${left}, ${right} )`;
+		case '<<':
+		case '«':
+			return `__zuzu_shift_left( ${left}, ${right} )`;
+		case '∣':
+		case 'divides':
+			return `__zuzu_divides( ${left}, ${right} )`;
+		case '∤':
+			return `__zuzu_ndivides( ${left}, ${right} )`;
+		case '>>':
+		case '»':
+			return `__zuzu_shift_right( ${left}, ${right} )`;
 		default:
 			return `( ${left} ${node.operator} ${right} )`;
 	}
@@ -2163,6 +2205,9 @@ function emitAssignmentExpression( node ) {
 					: `${left} = __zuzu_assign_strong( ${left}, ${right} )`;
 			}
 			if ( node.left && node.left.type === 'MemberExpression' ) {
+				if ( !node.left.computed ) {
+					throw new UnsupportedSyntaxError( 'Invalid assignment target' );
+				}
 				const object = emitExpression( node.left.object );
 				const objectTarget = emitAssignmentTarget( node.left.object );
 				const key = node.left.computed

package/lib/transpiler-new/lexer.js

@@ -103,6 +103,7 @@ const KEYWORDS = new Set( [
 	'throw',
 	'sub',
 	'union',
+	'divides',
 	'intersection',
 	'difference',
 	'subsetof',
@@ -772,6 +773,29 @@ function tokenize( source ) {
 		}
 
 		if ( isDigit( ch ) ) {
+			// Radix-prefixed integers: 0x… hex, 0b… binary, 0o… octal.
+			// Lowercase prefixes only; the token value is normalised to
+			// decimal so later stages treat it as a plain number.
+			const radixDigitOk = ch === '0'
+				? ( peek( 1 ) === 'x'
+					? (c) => /[0-9a-fA-F]/.test( c || '' )
+					: peek( 1 ) === 'b'
+						? (c) => c === '0' || c === '1'
+						: peek( 1 ) === 'o'
+							? (c) => /[0-7]/.test( c || '' )
+							: null )
+				: null;
+			if ( radixDigitOk && radixDigitOk( peek( 2 ) ) ) {
+				const radix = peek( 1 ) === 'x' ? 16 : peek( 1 ) === 'b' ? 2 : 8;
+				advance();
+				advance();
+				let digits = '';
+				while ( radixDigitOk( peek() ) ) {
+					digits += advance();
+				}
+				addToken( 'number', String( parseInt( digits, radix ) ), start, cursor() );
+				continue;
+			}
 			let value = '';
 			while ( isDigit( peek() ) ) {
 				value += advance();
@@ -782,6 +806,21 @@ function tokenize( source ) {
 					value += advance();
 				}
 			}
+			// Exponent: uppercase E only (lowercase e is not part of
+			// the language).
+			if (
+				peek() === 'E'
+				&& ( isDigit( peek( 1 ) )
+					|| ( ( peek( 1 ) === '+' || peek( 1 ) === '-' ) && isDigit( peek( 2 ) ) ) )
+			) {
+				value += advance();
+				if ( peek() === '+' || peek() === '-' ) {
+					value += advance();
+				}
+				while ( isDigit( peek() ) ) {
+					value += advance();
+				}
+			}
 			addToken( 'number', value, start, cursor() );
 			continue;
 		}
@@ -812,7 +851,7 @@ function tokenize( source ) {
 			continue;
 		}
 
-		if ( [ '≡', '≢', '≠', '≤', '≥', '→', '√', '⌊', '⌋', '⌈', '⌉', '∈', '∉', '⋃', '⋂', '∖', '⊂', '⊃', '«', '»', '≶', '≷', '▷', '◁' ].includes( ch ) ) {
+		if ( [ '≡', '≢', '≠', '≤', '≥', '→', '√', '⌊', '⌋', '⌈', '⌉', '∈', '∉', '⋃', '⋂', '∖', '⊂', '⊃', '«', '»', '≶', '≷', '▷', '◁', '∣', '∤' ].includes( ch ) ) {
 			advance();
 			addToken( 'operator', ch, start, cursor() );
 			continue;

package/lib/transpiler-new/parser.js

@@ -8,6 +8,7 @@ const {
 } = require( './errors' );
 
 function parse( tokens, options = {} ) {
+	const pendingSetClosers = [];
 	let index = 0;
 	let asyncContextDepth = 1;
 
@@ -1541,20 +1542,31 @@ function parse( tokens, options = {} ) {
 
 	function parseBitwise() {
 		return parseLeftAssociative(
-			parseComparison,
+			parseShift,
 			(token) => token.type === 'operator' && [ '&', '|', '^' ].includes( token.value )
 		);
 	}
 
+	function parseShift() {
+		return parseLeftAssociative(
+			parseComparison,
+			(token) => token.type === 'operator'
+				&& [ '<<', '>>', '«', '»' ].includes( token.value )
+				// Inside << ... >> or « ... » the pending closer ends the
+				// set literal instead of acting as a shift operator.
+				&& token.value !== pendingSetClosers[pendingSetClosers.length - 1]
+		);
+	}
+
 	function parseComparison() {
 		return parseLeftAssociative(
 			parseRange,
 			(token) => (
 				token.type === 'operator'
-				&& [ '<', '<=', '>', '>=', '≤', '≥', '~', '<=>', '@', '@@', '@?', '\\', '∈', '∉', '⋃', '⋂', '∖', '⊂', '⊃', '⊂⊃', '≶', '≷' ].includes( token.value )
+				&& [ '<', '<=', '>', '>=', '≤', '≥', '~', '<=>', '@', '@@', '@?', '\\', '∈', '∉', '⋃', '⋂', '∖', '⊂', '⊃', '⊂⊃', '≶', '≷', '∣', '∤' ].includes( token.value )
 			) || (
 				token.type === 'keyword'
-				&& [ 'gt', 'ge', 'lt', 'le', 'cmp', 'eqi', 'nei', 'gti', 'gei', 'lti', 'lei', 'cmpi', 'in', 'not_in', 'union', 'intersection', 'difference', 'subsetof', 'supersetof', 'equivalentof', 'does', 'can' ].includes( token.value )
+				&& [ 'gt', 'ge', 'lt', 'le', 'cmp', 'eqi', 'nei', 'gti', 'gei', 'lti', 'lei', 'cmpi', 'in', 'not_in', 'union', 'intersection', 'difference', 'subsetof', 'supersetof', 'equivalentof', 'does', 'can', 'divides' ].includes( token.value )
 			) || (
 				token.type === 'identifier' && token.value === 'instanceof'
 			)
@@ -2252,18 +2264,24 @@ function parse( tokens, options = {} ) {
 		if ( match( 'operator', closer ) ) {
 			return elements;
 		}
-		while ( true ) {
-			if ( match( 'punctuation', ',' ) ) {
-				continue;
-			}
-			if ( match( 'operator', closer ) ) {
-				break;
-			}
-			elements.push( parseExpression() );
-			if ( match( 'operator', closer ) ) {
-				break;
+		pendingSetClosers.push( closer );
+		try {
+			while ( true ) {
+				if ( match( 'punctuation', ',' ) ) {
+					continue;
+				}
+				if ( match( 'operator', closer ) ) {
+					break;
+				}
+				elements.push( parseExpression() );
+				if ( match( 'operator', closer ) ) {
+					break;
+				}
+				match( 'punctuation', ',' );
 			}
-			match( 'punctuation', ',' );
+		}
+		finally {
+			pendingSetClosers.pop();
 		}
 		return elements;
 	}

package/lib/transpiler-new/validate-bindings.js

@@ -235,6 +235,7 @@ function validateExpression( node, scope ) {
 			}
 			return;
 		case 'UpdateExpression':
+			requireValidAssignmentTarget( node.argument );
 			if ( node.argument && node.argument.type === 'Identifier' ) {
 				requireMutable( node.argument, scope );
 			}
@@ -242,6 +243,23 @@ function validateExpression( node, scope ) {
 				validateExpression( node.argument, scope );
 			}
 			return;
+		case 'UnaryExpression':
+			if ( node.operator === '++' || node.operator === '--' ) {
+				requireValidAssignmentTarget( node.argument );
+				if ( node.argument && node.argument.type === 'Identifier' ) {
+					requireMutable( node.argument, scope );
+				}
+				else {
+					validateExpression( node.argument, scope );
+				}
+				return;
+			}
+			validateChildNodes( node, scope );
+			return;
+		case 'RefExpression':
+			requireValidAssignmentTarget( node.argument );
+			validateExpression( node.argument, scope );
+			return;
 		case 'FunctionExpression':
 			validateFunctionBody( node, scope );
 			return;
@@ -261,11 +279,13 @@ function requireValidAssignmentTarget( node ) {
 	}
 	if (
 		target.type === 'Identifier'
-		|| target.type === 'MemberExpression'
 		|| target.type === 'SliceExpression'
 	) {
 		return;
 	}
+	if ( target.type === 'MemberExpression' && target.computed ) {
+		return;
+	}
 	if (
 		target.type === 'BinaryExpression'
 		&& [ '@', '@@', '@?' ].includes( target.operator )