.

Author: rogeralsing

src/Asynkron.JsEngine/Ast/AssignmentReference.cs

@@ -159,6 +159,20 @@ TypedAstEvaluator.PropertyHandle GetHandle()
 
         if (target is JsArray jsArray && JsOps.TryResolveArrayIndex(propertyValue, out var arrayIndex, context))
         {
+            var propertyName = JsOps.GetRequiredPropertyName(propertyValue, context);
+            if (ShouldUsePropertyHandle(jsArray, propertyName))
+            {
+                var propertyHandle = TypedAstEvaluator.PropertyHandle.Resolve(
+                    jsArray,
+                    propertyName,
+                    context,
+                    context.CurrentScope.IsStrict,
+                    allowPrivate: !member.IsComputed);
+                return new AssignmentReference(
+                    () => propertyHandle.GetValue(),
+                    newValue => propertyHandle.SetValue(newValue));
+            }
+
             return new AssignmentReference(
                 () => jsArray.GetElement(arrayIndex),
                 newValue => jsArray.SetElement(arrayIndex, newValue));
@@ -191,6 +205,28 @@ TypedAstEvaluator.PropertyHandle GetHandle()
             newValue => handle.SetValue(newValue));
     }
 
+    private static bool ShouldUsePropertyHandle(IJsPropertyAccessor target, string propertyName)
+    {
+        IJsPropertyAccessor? current = target;
+        while (current is not null)
+        {
+            var descriptor = current.GetOwnPropertyDescriptor(propertyName);
+            if (descriptor is not null)
+            {
+                return descriptor.IsAccessorDescriptor || descriptor is { Writable: false };
+            }
+
+            current = current switch
+            {
+                IJsObjectLike objectLike => objectLike.Prototype,
+                IPrototypeAccessorProvider provider => provider.PrototypeAccessor,
+                _ => null
+            };
+        }
+
+        return false;
+    }
+
     internal static object? ReadIdentifierValue(Func<object?> getter, EvaluationContext context)
     {
         try

src/Asynkron.JsEngine/Ast/TypedAstEvaluator.cs

@@ -248,6 +248,29 @@ private static bool TryAwaitPromise(object? candidate, EvaluationContext context
                 yield break;
             }
 
+            case TypedArrayBase typedArray:
+            {
+                // TypedArray for-in only exposes own enumerable properties (indices and custom slots).
+                var seenKeys = new HashSet<string>(StringComparer.Ordinal);
+                foreach (var key in typedArray.GetOwnPropertyNames().ToList())
+                {
+                    if (!seenKeys.Add(key))
+                    {
+                        continue;
+                    }
+
+                    var desc = typedArray.GetOwnPropertyDescriptor(key);
+                    if (desc is null || desc is { Enumerable: false })
+                    {
+                        continue;
+                    }
+
+                    yield return key;
+                }
+
+                yield break;
+            }
+
             case string s:
             {
                 for (var i = 0; i < s.Length; i++)

src/Asynkron.JsEngine/Parser/TypedAstParser.cs

@@ -1604,12 +1604,52 @@ private StatementNode ParseForStatement(Token forToken)
             }
             else
             {
+                if (Check(TokenType.Await) && CheckAhead(TokenType.Using))
+                {
+                    if (!IsAwaitAllowed)
+                    {
+                        throw new ParseException("'await using' is only allowed inside async contexts.", Peek(),
+                            _source);
+                    }
+
+                    Advance(); // await
+                    Advance(); // using
+                    var previousAllowIn = _allowInExpressions;
+                    _allowInExpressions = false;
+                    try
+                    {
+                        initializerDeclaration =
+                            (VariableDeclaration)ParseVariableDeclaration(VariableKind.AwaitUsing, false, true);
+                        initializer = initializerDeclaration;
+                    }
+                    finally
+                    {
+                        _allowInExpressions = previousAllowIn;
+                    }
+                }
+                else if (Match(TokenType.Using))
+                {
+                    var previousAllowIn = _allowInExpressions;
+                    _allowInExpressions = false;
+                    try
+                    {
+                        initializerDeclaration =
+                            (VariableDeclaration)ParseVariableDeclaration(VariableKind.Using, false, true);
+                        initializer = initializerDeclaration;
+                    }
+                    finally
+                    {
+                        _allowInExpressions = previousAllowIn;
+                    }
+                }
+                else
                 // In non-strict mode, 'for (let' is only a lexical declaration if followed by '[', '{'
                 // or a binding identifier. Otherwise 'let' is just an identifier expression.
                 // See: for ( [lookahead ∉ { let [ }] Expression
                 if (Check(TokenType.Let) &&
                     (InStrictContext || CheckAhead(TokenType.LeftBracket) || CheckAhead(TokenType.LeftBrace) ||
-                     (CheckAheadBindingIdentifier() && !CheckAhead(TokenType.Let))))
+                     (CheckAheadBindingIdentifier() && !CheckAhead(TokenType.Let)) &&
+                     !CheckAhead(TokenType.In)))
                 {
                     Advance(); // consume 'let'
                     var previousAllowIn = _allowInExpressions;