zuzu-js 0.1.0 → 0.1.1

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.1\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 );
@@ -2981,6 +3032,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

@@ -2164,14 +2164,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 +2176,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/package.json

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