zuzu-js 0.1.0 → 0.1.2

package/lib/cli.js

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

package/lib/runtime-helpers.js

@@ -37,15 +37,18 @@ class ZuzuBinary {
 	}
 
 	slice( start, end ) {
-		return new ZuzuBinary( this.bytes.slice( start, end ) );
+		return new this.constructor( this.bytes.slice( start, end ) );
 	}
 
 	at( index ) {
-		const idx = Number( index );
+		let idx = Number( index );
+		if ( idx < 0 ) {
+			idx = this.bytes.length + idx;
+		}
 		if ( idx < 0 || idx >= this.bytes.length ) {
 			return null;
 		}
-		return new ZuzuBinary( [ this.bytes[idx] ] );
+		return new this.constructor( [ this.bytes[idx] ] );
 	}
 
 	to_String() {

package/lib/runtime.js

@@ -1573,10 +1573,11 @@ function zuzuGetIndex( target, index ) {
 	if ( typeof target === 'string' || Array.isArray( target ) ) {
 		let resolved = Number( index );
 		if ( Number.isFinite( resolved ) ) {
+			const indexed = typeof target === 'string' ? [ ...target ] : target;
 			if ( resolved < 0 ) {
-				resolved = target.length + resolved;
+				resolved = indexed.length + resolved;
 			}
-			return resolveWeakValue( target[resolved] );
+			return resolveWeakValue( indexed[resolved] ?? null );
 		}
 	}
 	if (
@@ -1592,24 +1593,62 @@ function zuzuGetIndex( target, index ) {
 	return resolveWeakValue( target[index] );
 }
 
+function zuzuSliceBounds( size, from, length ) {
+	let start = Number( from ?? 0 );
+	if ( !Number.isFinite( start ) ) {
+		start = 0;
+	}
+	if ( start < 0 ) {
+		start = size + start;
+	}
+	start = Math.max( 0, Math.min( size, start ) );
+	if ( length == null ) {
+		return [ start, size ];
+	}
+	const span = Number( length );
+	if ( !Number.isFinite( span ) ) {
+		return [ start, start ];
+	}
+	const end = span < 0
+		? Math.max( 0, Math.min( size, size + span ) )
+		: Math.max( 0, Math.min( size, start + span ) );
+	return [ Math.min( start, end ), Math.max( start, end ) ];
+}
+
+function zuzuGetSlice( target, from, length ) {
+	target = resolveWeakValue( target );
+	if ( target == null ) {
+		return null;
+	}
+	if ( typeof target === 'string' ) {
+		const chars = [ ...target ];
+		const [ start, end ] = zuzuSliceBounds( chars.length, from, length );
+		return chars.slice( start, end ).join( '' );
+	}
+	if ( target instanceof ZuzuBinary ) {
+		const [ start, end ] = zuzuSliceBounds( target.length, from, length );
+		return target.slice( start, end );
+	}
+	if ( Array.isArray( target ) ) {
+		const [ start, end ] = zuzuSliceBounds( target.length, from, length );
+		return target.slice( start, end );
+	}
+	return target.slice( from, length == null ? undefined : Number( from ) + Number( length ) );
+}
+
 function zuzuAssignSlice( target, from, length, value ) {
 	const hasLength = length != null;
-	const span = hasLength ? Number( length ) : null;
 	const replacement = value == null ? '' : value;
 	if ( typeof target === 'string' ) {
-		let start = Number( from );
-		if ( start < 0 ) {
-			start = target.length + start;
-		}
-		start = Math.max( 0, Math.min( target.length, start ) );
-		const end = hasLength
-			? Math.max( 0, Math.min( target.length, span >= 0 ? start + span : target.length + span ) )
-			: target.length;
-		return target.slice( 0, start ) + String( replacement ) + target.slice( end );
+		const chars = [ ...target ];
+		const [ start, end ] = zuzuSliceBounds( chars.length, from, length );
+		chars.splice( start, end - start, ...[ ...String( replacement ) ] );
+		return chars.join( '' );
 	}
 	const start = Number( from );
 	if ( Array.isArray( target ) ) {
 		const items = Array.isArray( replacement ) ? replacement : [ replacement ];
+		const span = hasLength ? Number( length ) : null;
 		if ( hasLength ) {
 			target.splice( start, span, ...items );
 		}
@@ -1619,7 +1658,16 @@ function zuzuAssignSlice( target, from, length, value ) {
 		return target;
 	}
 	if ( target instanceof ZuzuBinary ) {
-		throw new Error( 'Exception: BinaryString slice assignment is not supported' );
+		if ( !( value instanceof ZuzuBinary ) ) {
+			throw new Error( `TypeException: BinaryString slice assignment expects BinaryString, got ${zuzuTypeof( value )}` );
+		}
+		const [ byteStart, byteEnd ] = zuzuSliceBounds( target.length, from, length );
+		const next = new Uint8Array( target.length - ( byteEnd - byteStart ) + value.bytes.length );
+		next.set( target.bytes.slice( 0, byteStart ), 0 );
+		next.set( value.bytes, byteStart );
+		next.set( target.bytes.slice( byteEnd ), byteStart + value.bytes.length );
+		target.bytes = next;
+		return target;
 	}
 	throw new Error( `TypeException: slice assignment expects String or Array, got ${zuzuTypeof( target )}` );
 }
@@ -1641,18 +1689,27 @@ function assignIndexedValue( target, index, value, isWeakWrite = false, assignTa
 		throw new Error( 'TypeException: cannot assign to null' );
 	}
 	if ( target instanceof ZuzuBinary ) {
-		throw new Error( 'Exception: BinaryString index assignment is not supported' );
+		if ( !( value instanceof ZuzuBinary ) ) {
+			throw new Error( `TypeException: BinaryString index assignment expects BinaryString, got ${zuzuTypeof( value )}` );
+		}
+		zuzuAssignSlice( target, index, 1, value );
+		if ( typeof assignTarget === 'function' ) {
+			assignTarget( target );
+		}
+		return target;
 	}
 	if ( typeof target === 'string' ) {
 		let resolved = Number( index );
 		if ( !Number.isFinite( resolved ) ) {
 			throw new Error( 'TypeException: String index assignment expects numeric index' );
 		}
+		const chars = [ ...target ];
 		if ( resolved < 0 ) {
-			resolved = target.length + resolved;
+			resolved = chars.length + resolved;
 		}
-		resolved = Math.max( 0, Math.min( target.length, resolved ) );
-		const updated = target.slice( 0, resolved ) + String( value ?? '' ) + target.slice( resolved + 1 );
+		resolved = Math.max( 0, Math.min( chars.length, resolved ) );
+		chars.splice( resolved, resolved < chars.length ? 1 : 0, ...[ ...String( value ?? '' ) ] );
+		const updated = chars.join( '' );
 		return typeof assignTarget === 'function' ? assignTarget( updated ) : updated;
 	}
 	if ( isPairListLike( target ) ) {
@@ -1673,16 +1730,10 @@ function refSlice( target, from, length ) {
 		const hasLength = length != null;
 		const span = hasLength ? Number( length ) : null;
 		if ( arguments.length === 0 ) {
-			const end = hasLength
-				? ( span >= 0 ? start + span : span )
-				: undefined;
-			if ( target instanceof ZuzuBinary ) {
-				return target.slice( start, end );
-			}
-			return target.slice( start, end );
+			return zuzuGetSlice( target, start, hasLength ? span : null );
 		}
-		if ( target instanceof ZuzuBinary ) {
-			throw new Error( 'Exception: BinaryString slice assignment is not supported' );
+		if ( target instanceof ZuzuBinary || typeof target === 'string' ) {
+			return zuzuAssignSlice( target, start, hasLength ? span : null, maybeValue );
 		}
 		if ( !hasLength ) {
 			target.splice( start, target.length - start, ...maybeValue );
@@ -1853,6 +1904,13 @@ function zuzuTypeMatches( value, typeName ) {
 		if ( typeName === 'PairList' ) {
 			return isPairListLike( value ) ? 1 : 0;
 		}
+		if ( typeName === 'Exception' ) {
+			const globalType = globalThis.Exception;
+			if ( globalType != null && zuzuInstanceof( value, globalType ) ) {
+				return 1;
+			}
+			return value instanceof Error ? 1 : 0;
+		}
 		return zuzuTypeof( value ) === typeName ? 1 : 0;
 	}
 	if ( typeName === 'BinaryString' ) {
@@ -2981,6 +3039,7 @@ class ZuzuScript {
 			},
 			__zuzu_ref_index( target, index ) { return refIndex( target, index ); },
 			__zuzu_ref_key( target, key ) { return refKey( target, key ); },
+			__zuzu_get_slice( target, from, length ) { return zuzuGetSlice( target, from, length ); },
 			__zuzu_ref_slice( target, from, length ) { return refSlice( target, from, length ); },
 			__zuzu_assign_slice( target, from, length, value ) { return zuzuAssignSlice( target, from, length, value ); },
 			Pair,

package/lib/transpiler-new/codegen.js

@@ -32,6 +32,7 @@ function emitProgram( ast, options = {} ) {
 		...options,
 		asyncContext: needsAsyncWrapper && !syncEval,
 		asyncNames: new Set( collectAsyncFunctionNames( ast.body ) ),
+		evalNames: new Set( [ 'eval', ...collectEvalImportNames( ast.body ) ] ),
 		weakStorageNames: new Set( collectWeakDeclaredNames( ast.body ) ),
 		scopeNames: new Set( [
 			...expressionDeclaredNames,
@@ -91,6 +92,7 @@ function marshalCaptureNames( node, options = currentEmitContext() ) {
 		'__file__',
 		'__global__',
 		'__system__',
+		...( options.evalNames || [] ),
 	].filter( Boolean ) );
 	const localKinds = new Set( [
 		'FunctionDeclaration',
@@ -124,6 +126,21 @@ function marshalCaptureNames( node, options = currentEmitContext() ) {
 			}
 			return;
 		}
+		if ( value.type === 'TryStatement' ) {
+			visit( value.block, value );
+			for ( const handler of value.handlers || [] ) {
+				const paramName = handler.paramName;
+				const hadParam = paramName ? declared.has( paramName ) : false;
+				if ( paramName ) {
+					declared.add( paramName );
+				}
+				visit( handler.body, handler );
+				if ( paramName && !hadParam ) {
+					declared.delete( paramName );
+				}
+			}
+			return;
+		}
 		if ( value.type === 'VariableUnpackDeclaration' ) {
 			visit( value.init, value );
 			for ( const entry of bindingEntriesForPattern( value.pattern ) ) {
@@ -204,6 +221,7 @@ function nestedFunctionOptions( options = {} ) {
 		syncEval: options.syncEval,
 		asyncContext: options.asyncContext,
 		asyncNames: options.asyncNames,
+		evalNames: options.evalNames,
 		weakStorageNames: options.weakStorageNames,
 		scopeNames: options.scopeNames,
 		bodylessFunctionNames: options.bodylessFunctionNames,
@@ -898,7 +916,6 @@ function emitImportDeclaration( node, options = {} ) {
 		if (
 			node.source === 'std/eval'
 			&& importedName === 'eval'
-			&& specifier.local === 'eval'
 		) {
 			return '';
 		}
@@ -1101,6 +1118,22 @@ function collectAsyncFunctionNames( statements = [] ) {
 	return names;
 }
 
+function collectEvalImportNames( statements = [] ) {
+	const names = [];
+	for ( const stmt of statements ) {
+		if ( stmt.type !== 'ImportDeclaration' || stmt.source !== 'std/eval' ) {
+			continue;
+		}
+		for ( const specifier of stmt.specifiers || [] ) {
+			const importedName = normalizeImportedName( stmt.source, specifier.imported );
+			if ( importedName === 'eval' && specifier.local ) {
+				names.push( specifier.local );
+			}
+		}
+	}
+	return names;
+}
+
 function collectDeclaredNames( statements ) {
 	const names = [];
 	for ( const stmt of statements || [] ) {
@@ -1684,7 +1717,11 @@ function emitCallExpression( node, options = {} ) {
 		const argArray = emitCallArgumentArray( node.arguments );
 		source = `__zuzu_super_dispatch( __zuzu_super_static__, self, __zuzu_super_class__, __zuzu_super_method__, ${argArray} )`;
 	}
-	else if ( node.callee.type === 'Identifier' && node.callee.name === 'eval' && node.arguments.length > 0 ) {
+	else if (
+		node.callee.type === 'Identifier'
+		&& ( options.evalNames || new Set( [ 'eval' ] ) ).has( node.callee.name )
+		&& node.arguments.length > 0
+	) {
 		source = emitEvalCall( node.arguments );
 	}
 	else if (
@@ -1968,7 +2005,7 @@ function emitBinaryExpression( node ) {
 			return `__zuzu_ne( ${left}, ${right} )`;
 		case '!=':
 		case '≠':
-			return `__zuzu_num_ne( ${left}, ${right} )`;
+			return `__zuzu_ne( ${left}, ${right} )`;
 		case '~':
 			return `__zuzu_match( ${left}, ${right} )`;
 		case '_':
@@ -2164,14 +2201,8 @@ function emitAssignmentTarget( node ) {
 function emitSliceExpression( node ) {
 	const object = emitExpression( node.object );
 	const start = node.start ? emitExpression( node.start ) : '0';
-	if ( node.length == null ) {
-		return `${object}.slice( ${start} )`;
-	}
-	const length = emitExpression( node.length );
-	const end = isNegativeNumericLiteral( node.length )
-		? length
-		: `__zuzu_add( ${start}, ${length} )`;
-	return `${object}.slice( ${start}, ${end} )`;
+	const length = node.length == null ? 'null' : emitExpression( node.length );
+	return `__zuzu_get_slice( ${object}, ${start}, ${length} )`;
 }
 
 function unwrapGroupedExpression( node ) {
@@ -2182,16 +2213,6 @@ function unwrapGroupedExpression( node ) {
 	return current;
 }
 
-function isNegativeNumericLiteral( node ) {
-	return !!(
-		node
-		&& node.type === 'UnaryExpression'
-		&& node.operator === '-'
-		&& node.argument
-		&& node.argument.type === 'NumericLiteral'
-	);
-}
-
 function emitRegexReplaceExpression( node ) {
 	const leftTarget = unwrapGroupedExpression( node.left );
 	if (

package/modules/std/io.js

@@ -389,6 +389,14 @@ class Path {
 	slurp_utf8_async() {
 		return new Task( async () => fs.promises.readFile( this.value, 'utf8' ) );
 	}
+	append( value ) {
+		traceBlockingOperation( 'std/io Path.append' );
+		if ( !( value && value.bytes instanceof Uint8Array ) ) {
+			throw new Error( `TypeException: Path.append expects BinaryString, got ${typeName( value )}` );
+		}
+		fs.appendFileSync( this.value, Buffer.from( value.bytes ) );
+		return this;
+	}
 	append_async( value ) {
 		return new Task( async () => {
 			if ( !( value && value.bytes instanceof Uint8Array ) ) {
@@ -398,6 +406,14 @@ class Path {
 			return this;
 		} );
 	}
+	append_utf8( text ) {
+		traceBlockingOperation( 'std/io Path.append_utf8' );
+		if ( typeof text !== 'string' ) {
+			throw new Error( `TypeException: Path.append_utf8 expects String, got ${typeName( text )}` );
+		}
+		fs.appendFileSync( this.value, text, 'utf8' );
+		return this;
+	}
 	append_utf8_async( text ) {
 		return new Task( async () => {
 			if ( typeof text !== 'string' ) {

package/modules/std/proc.js

@@ -2,6 +2,7 @@
 
 const { spawn, spawnSync } = require( 'node:child_process' );
 const fs = require( 'node:fs' );
+const os = require( 'node:os' );
 const path = require( 'node:path' );
 const { Task, traceBlockingOperation } = require( './task' );
 
@@ -134,12 +135,15 @@ function runCommand( cmd, options = {} ) {
 		return cwdErrorResult( cmd, options, cwd.error );
 	}
 
+	const stdinDir = fs.mkdtempSync( path.join( os.tmpdir(), 'zuzu-proc-stdin-' ) );
+	const stdinPath = path.join( stdinDir, 'stdin' );
+	fs.writeFileSync( stdinPath, stdin, 'utf8' );
+	const stdinFd = fs.openSync( stdinPath, 'r' );
 	const spawnOptions = {
-		input: stdin,
 		encoding: 'utf8',
 		maxBuffer: 10 * 1024 * 1024,
 		stdio: [
-			'pipe',
+			stdinFd,
 			captureStdout ? 'pipe' : 'ignore',
 			mergeStderr ? 'pipe' : ( captureStderr ? 'pipe' : 'ignore' ),
 		],
@@ -166,7 +170,19 @@ function runCommand( cmd, options = {} ) {
 		}
 	}
 
-	const spawned = spawnSync( cmd[0], cmd.slice( 1 ), spawnOptions );
+	let spawned;
+	try {
+		spawned = spawnSync( cmd[0], cmd.slice( 1 ), spawnOptions );
+	}
+	finally {
+		fs.closeSync( stdinFd );
+		try {
+			fs.unlinkSync( stdinPath );
+			fs.rmdirSync( stdinDir );
+		}
+		catch ( _err ) {
+		}
+	}
 	const timedOut = spawned.error && spawned.error.code === 'ETIMEDOUT';
 	const signal = timedOut
 		? 14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuzu-js",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "JavaScript runtime, compiler, and browser bundle for ZuzuScript.",
   "main": "lib/zuzu.js",
   "bin": {