diff --git a/Jint.Tests/Runtime/FunctionTests.cs b/Jint.Tests/Runtime/FunctionTests.cs
index 3ee6d4260a..6de1202854 100644
--- a/Jint.Tests/Runtime/FunctionTests.cs
+++ b/Jint.Tests/Runtime/FunctionTests.cs
@@ -1,3 +1,4 @@
+using System.Text.RegularExpressions;
 using Jint.Native;
 using Jint.Native.Function;
 using Jint.Runtime;
@@ -335,4 +336,396 @@ function findIt(array, kind) {
         Assert.Equal(values[0], found1);
         Assert.Equal(values[1], found2);
     }
+
+    [Theory]
+    [InlineData(
+        """
+        /* before */ function fn() {
+          return 0;
+        } /* after */
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        function fn() {
+          return 0;
+        }
+        """)]
+    [InlineData(
+        """
+        /* before */ async function* g() {
+          yield 0;
+        } /* after */
+        [g.toString(), g.toString()]
+        """,
+        """
+        async function* g() {
+          yield 0;
+        }
+        """)]
+    [InlineData(
+        """
+        /* before */ var fn = async function f() {
+          return 0;
+        } /* after */ ;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        async function f() {
+          return 0;
+        }
+        """)]
+    [InlineData(
+        """
+        /* before */ let g = function*() {
+          yield 0;
+        }; /* after */
+        [g.toString(), g.toString()]
+        """,
+        """
+        function*() {
+          yield 0;
+        }
+        """)]
+    [InlineData(
+        """
+        /* before */ var fn = () => {
+          return 0;
+        } /* after */
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        () => {
+          return 0;
+        }
+        """)]
+    [InlineData(
+        """
+        /* before */ const o = {
+          m () {
+            return 0;
+          }
+        } /* after */
+        const m = o.m;
+        [m.toString(), m.toString()]
+        """,
+        """
+        m () {
+            return 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ const o = {
+          *g( ) {
+            yield 0;
+          }
+        } /* after */
+        const g = o.g;
+        [g.toString(), g.toString()]
+        """,
+        """
+        *g( ) {
+            yield 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ const o = {
+          get p() {
+            return 0;
+          }
+        } /* after */
+        const getter = Object.getOwnPropertyDescriptor(o, "p").get;
+        [getter.toString(), getter.toString()]
+        """,
+        """
+        get p() {
+            return 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ const o = {
+          set p(_) {
+          }
+        } /* after */
+        const setter = Object.getOwnPropertyDescriptor(o, "p").set;
+        [setter.toString(), setter.toString()]
+        """,
+        """
+        set p(_) {
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A extends Object.prototype.constructor {
+          constructor() { super(); }
+        } /* after */
+        const ctor = A.prototype.constructor;
+        [ctor.toString(), ctor.toString()]
+        """,
+        """
+        class A extends Object.prototype.constructor {
+          constructor() { super(); }
+        }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          m() {
+            return 0;
+          }
+        } /* after */
+        const m = A.prototype.m;
+        [m.toString(), m.toString()]
+        """,
+        """
+        m() {
+            return 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          * g( ) {
+            yield 0;
+          }
+        } /* after */
+        const g = A.prototype.g;
+        [g.toString(), g.toString()]
+        """,
+        """
+        * g( ) {
+            yield 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          get p() {
+            return 0;
+          }
+        } /* after */
+        const getter = Object.getOwnPropertyDescriptor(A.prototype, "p").get;
+        [getter.toString(), getter.toString()]
+        """,
+        """
+        get p() {
+            return 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          set p(_) {
+          }
+        } /* after */
+        const setter = Object.getOwnPropertyDescriptor(A.prototype, "p").set;
+        [setter.toString(), setter.toString()]
+        """,
+        """
+        set p(_) {
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          static m() {
+            return 0;
+          }
+        } /* after */
+        const m = A.m;
+        [m.toString(), m.toString()]
+        """,
+        """
+        m() {
+            return 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          static async * g() {
+            yield 0;
+          }
+        } /* after */
+        const g = A.g;
+        [g.toString(), g.toString()]
+        """,
+        """
+        async * g() {
+            yield 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          static get p() {
+            return 0;
+          }
+        } /* after */
+        const getter = Object.getOwnPropertyDescriptor(A, "p").get;
+        [getter.toString(), getter.toString()]
+        """,
+        """
+        get p() {
+            return 0;
+          }
+        """)]
+    [InlineData(
+        """
+        /* before */ class A {
+          static set p(_) {
+          }
+        } /* after */
+        const setter = Object.getOwnPropertyDescriptor(A, "p").set;
+        [setter.toString(), setter.toString()]
+        """,
+        """
+        set p(_) {
+          }
+        """)]
+    [InlineData(
+        """
+        var fn = /* before */Function()/* after */;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        function anonymous(
+        ) {
+
+        }
+        """)]
+    [InlineData(
+        """
+        var Generator = (function*() {}).constructor;
+        var fn = /* before */Generator()/* after */;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        function* anonymous(
+        ) {
+
+        }
+        """)]
+    [InlineData(
+        """
+        var AsyncFunction = (async function() {}).constructor;
+        var fn = /* before */AsyncFunction()/* after */;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        async function anonymous(
+        ) {
+
+        }
+        """)]
+    [InlineData(
+        """
+        var AsyncGenerator = (async function*() {}).constructor;
+        var fn = /* before */AsyncGenerator()/* after */;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        async function* anonymous(
+        ) {
+
+        }
+        """)]
+    [InlineData(
+        """
+        var p1 = "a //", p2 = "/*a */ b, c";
+        var fn = /* before */Function(p1, p2, "return Promise.resolve(a+b+c) /* d */ //")/* after */;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        function anonymous(a //,/*a */ b, c
+        ) {
+        return Promise.resolve(a+b+c) /* d */ //
+        }
+        """)]
+    [InlineData(
+        """
+        var Generator = (function*() {}).constructor;
+        var p1 = "a //", p2 = "/*a */ b, c";
+        var fn = /* before */Generator(p1, p2, "return Promise.resolve(a+b+c) /* d */ //")/* after */;
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        function* anonymous(a //,/*a */ b, c
+        ) {
+        return Promise.resolve(a+b+c) /* d */ //
+        }
+        """)]
+    [InlineData(
+        """
+        var AsyncFunction = (async function() {}).constructor;
+        var p1 = "a //", p2 = "/*a */ b, c";
+        var fn = /* before */AsyncFunction(p1, p2, "return Promise.resolve(a+b+c) /* d */ //")/* after */; 
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        async function anonymous(a //,/*a */ b, c
+        ) {
+        return Promise.resolve(a+b+c) /* d */ //
+        }
+        """)]
+    [InlineData(
+        """
+        var AsyncGenerator = (async function*() {}).constructor;
+        var p1 = "a //", p2 = "/*a */ b, c";
+        var fn = /* before */AsyncGenerator(p1, p2, "return Promise.resolve(a+b+c) /* d */ //")/* after */; 
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        async function* anonymous(a //,/*a */ b, c
+        ) {
+        return Promise.resolve(a+b+c) /* d */ //
+        }
+        """)]
+    [InlineData(
+        """
+        eval('function fn() {\n}');
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        function fn() {
+        }
+        """)]
+    [InlineData(
+        """
+        const fn = new ShadowRealm().evaluate('(\n)=>0');
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        (
+        )=>0
+        """)]
+    [InlineData(
+        """
+        const fn = (0, eval)(
+          new ShadowRealm().evaluate('(\n)=>0')
+        );
+        [fn.toString(), fn.toString()]
+        """,
+        """
+        (
+        )=>0
+        """)]
+    public void ToStringShouldProduceStandardsCompliantResultByDefault(string code, string expectedResult)
+    {
+        code = Regex.Replace(code, @"\r\n?", "\n", RegexOptions.CultureInvariant); // normalize line endings to '\n'
+        expectedResult = Regex.Replace(expectedResult, @"\r\n?", "\n", RegexOptions.CultureInvariant); // normalize line endings to '\n'
+
+        var returnValue = new Engine().Evaluate(code);
+
+        var actualResults = Assert.IsType<JsArray>(returnValue);
+        Assert.Equal(2u, actualResults.Length);
+
+        var actualResult1 = Assert.IsType<JsString>(actualResults[0]).ToString();
+        Assert.Equal(expectedResult, actualResult1);
+
+        var actualResult2 = Assert.IsType<JsString>(actualResults[1]).ToString();
+        Assert.Same(actualResult1, actualResult2);
+    }
 }
diff --git a/Jint/AstExtensions.cs b/Jint/AstExtensions.cs
index 0dbfa72940..4c826efb3a 100644
--- a/Jint/AstExtensions.cs
+++ b/Jint/AstExtensions.cs
@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using System.Threading;
 using Jint.Native;
 using Jint.Native.Function;
 using Jint.Native.Object;
@@ -17,6 +18,8 @@ public static class AstExtensions
     internal static readonly SourceLocation DefaultLocation;
 #pragma warning restore CS0649 // Field is never assigned to, and will always have its default value
 
+    private static Tokenizer? s_cachedTokenizer;
+
     public static JsValue GetKey<T>(this T property, Engine engine) where T : IProperty => GetKey(property.Key, engine, property.Computed);
 
     public static JsValue GetKey(this Expression expression, Engine engine, bool resolveComputed = false)
@@ -325,7 +328,7 @@ internal static void BindingInitialization(
     /// <summary>
     /// https://tc39.es/ecma262/#sec-runtime-semantics-definemethod
     /// </summary>
-    internal static Record DefineMethod<T>(this T m, ObjectInstance obj, ObjectInstance? functionPrototype = null) where T : IProperty
+    internal static Record DefineMethod<T>(this T m, ObjectInstance obj, ObjectInstance? functionPrototype, INode sourceTextNode) where T : IProperty
     {
         var engine = obj.Engine;
         var propKey = TypeConverter.ToPropertyKey(m.GetKey(engine));
@@ -342,7 +345,7 @@ internal static Record DefineMethod<T>(this T m, ObjectInstance obj, ObjectInsta
             Throw.SyntaxError(engine.Realm);
         }
 
-        var definition = new JintFunctionDefinition(function);
+        var definition = new JintFunctionDefinition(function, sourceTextNode);
         var closure = intrinsics.Function.OrdinaryFunctionCreate(prototype, definition, definition.ThisMode, env, privateEnv);
         closure.MakeMethod(obj);
 
@@ -523,6 +526,23 @@ internal static DisposeHint GetDisposeHint(this VariableDeclarationKind statemen
         };
     }
 
+    internal static int GetSecondTokenStartIndex(string sourceText, int start, int end)
+    {
+        var tokenizer = Interlocked.Exchange(ref s_cachedTokenizer, value: null) ?? new Tokenizer(string.Empty);
+        try
+        {
+            tokenizer.Reset(sourceText, start, end - start, SourceType.Script);
+            tokenizer.Next();
+            tokenizer.Next(); // skip first token + potential whitespace and/or comments
+            return tokenizer.Current.Start;
+        }
+        finally
+        {
+            tokenizer.Reset(string.Empty);
+            Volatile.Write(ref s_cachedTokenizer, tokenizer);
+        }
+    }
+
     private sealed class MinimalSyntaxElement : Node
     {
         public MinimalSyntaxElement(in SourceLocation location) : base(NodeType.Unknown)
diff --git a/Jint/Engine.Ast.cs b/Jint/Engine.Ast.cs
index c352832c74..c3a5cecd8f 100644
--- a/Jint/Engine.Ast.cs
+++ b/Jint/Engine.Ast.cs
@@ -20,25 +20,17 @@ public static Prepared<Script> PrepareScript(string code, string? source = null,
         source ??= "<anonymous>";
         options ??= ScriptPreparationOptions.Default;
 
+        var sourceOffset = options.ParsingOptions.SourceOffset;
+        var padding = AcornimaExtensions.CreateSourceOffsetPadding(sourceOffset);
+        var paddedCode = padding.Length > 0 ? padding + code : code;
+
         var astAnalyzer = new AstAnalyzer(options);
         var parserOptions = options.GetParserOptions();
         var parser = new Parser(parserOptions with { OnNode = astAnalyzer.NodeVisitor });
 
         try
         {
-            Script preparedScript;
-            var sourceOffset = options.ParsingOptions.SourceOffset;
-            var padding = AcornimaExtensions.CreateSourceOffsetPadding(sourceOffset);
-
-            if (padding.Length > 0)
-            {
-                var paddedCode = padding + code;
-                preparedScript = parser.ParseScript(paddedCode, padding.Length, code.Length, source, strict);
-            }
-            else
-            {
-                preparedScript = parser.ParseScript(code, source, strict);
-            }
+            var preparedScript = parser.ParseScript(paddedCode, padding.Length, code.Length, source, strict);
 
             return new Prepared<Script>(preparedScript, parserOptions);
         }
@@ -85,7 +77,7 @@ public AstAnalyzer(IPreparationOptions<IParsingOptions> preparationOptions)
             _preparationOptions = preparationOptions;
         }
 
-        public void NodeVisitor(Node node, in OnNodeContext _)
+        public void NodeVisitor(Node node, in OnNodeContext ctx)
         {
             switch (node.Type)
             {
@@ -115,7 +107,7 @@ public void NodeVisitor(Node node, in OnNodeContext _)
                 case NodeType.ArrowFunctionExpression:
                 case NodeType.FunctionDeclaration:
                 case NodeType.FunctionExpression:
-                    node.UserData = JintFunctionDefinition.BuildState((IFunction) node);
+                    node.UserData = JintFunctionDefinition.BuildState((IFunction) node, ctx.Input);
                     break;
 
                 case NodeType.Program:
diff --git a/Jint/Engine.Defaults.cs b/Jint/Engine.Defaults.cs
index 1116a51032..0b7bf97077 100644
--- a/Jint/Engine.Defaults.cs
+++ b/Jint/Engine.Defaults.cs
@@ -1,3 +1,5 @@
+using Jint.Native.Function;
+
 namespace Jint;
 
 public partial class Engine
@@ -45,4 +47,16 @@ internal RegExpParseResult HandleOnRegExp(in RegExpParsingContext ctx)
             return RegExpParseResult.ForSuccess(additionalData: this);
         }
     }
+
+    /// <summary>
+    /// Cached OnNode callback that stores the source text being parsed in <see cref="Node.UserData"/> of function nodes
+    /// to support <see cref="Function.ToString"><c>Function.prototype.toString()</c> implementation</see>.
+    /// </summary>
+    internal static readonly OnNodeHandler DefaultNodeHandler = static (node, in ctx) =>
+    {
+        if (node.Type is NodeType.ArrowFunctionExpression or NodeType.FunctionDeclaration or NodeType.FunctionExpression)
+        {
+            node.UserData = ctx.Input;
+        }
+    };
 }
diff --git a/Jint/Extensions/AcornimaExtensions.cs b/Jint/Extensions/AcornimaExtensions.cs
index ec733e1901..2e46d6441b 100644
--- a/Jint/Extensions/AcornimaExtensions.cs
+++ b/Jint/Extensions/AcornimaExtensions.cs
@@ -7,12 +7,11 @@ internal static class AcornimaExtensions
     public static Script ParseScriptGuarded(this Parser parser, Realm realm, string code, Position sourceOffset = default, string? source = null, bool strict = false)
     {
         var padding = CreateSourceOffsetPadding(sourceOffset);
+        var paddedCode = padding.Length > 0 ? padding + code : code;
 
         try
         {
-            return padding.Length > 0
-                ? parser.ParseScript(padding + code, padding.Length, code.Length, source, strict)
-                : parser.ParseScript(code, source, strict);
+            return parser.ParseScript(paddedCode, padding.Length, code.Length, source, strict);
         }
         catch (ParseErrorException e)
         {
@@ -26,9 +25,14 @@ public static Script ParseScriptGuarded(this Parser parser, Realm realm, string
     /// </summary>
     internal static string CreateSourceOffsetPadding(Position sourceOffset)
     {
-        var lineOffset = sourceOffset.Line > 0 ? sourceOffset.Line - 1 : 0;
-        var columnOffset = sourceOffset.Column > 0 ? sourceOffset.Column : 0;
-        return new string('\n', lineOffset) + new string(' ', columnOffset);
+        if (sourceOffset.Line > 0)
+        {
+            var lineOffset = sourceOffset.Line - 1;
+            var columnOffset = sourceOffset.Column > 0 ? sourceOffset.Column : 0;
+            return new string('\n', lineOffset) + new string(' ', columnOffset);
+        }
+
+        return string.Empty;
     }
 
     public static Module ParseModuleGuarded(this Parser parser, Engine engine, string code, string? source = null)
diff --git a/Jint/Native/Function/ClassDefinition.cs b/Jint/Native/Function/ClassDefinition.cs
index 145054aacf..dc8204b5d8 100644
--- a/Jint/Native/Function/ClassDefinition.cs
+++ b/Jint/Native/Function/ClassDefinition.cs
@@ -37,18 +37,16 @@ static MethodDefinition CreateConstructorMethodDefinition(Parser parser, string
         _emptyConstructor = CreateConstructorMethodDefinition(parser, "class temp { constructor() {} }");
     }
 
-    private readonly NodeList<Decorator> _classDecorators;
+    private readonly IClass _class;
 
     public ClassDefinition(
         string? className,
-        Expression? superClass,
-        ClassBody body,
-        in NodeList<Decorator> classDecorators = default)
+        IClass @class)
     {
         _className = className;
-        _superClass = superClass;
-        _body = body;
-        _classDecorators = classDecorators;
+        _superClass = @class.SuperClass;
+        _body = @class.Body;
+        _class = @class;
     }
 
     /// <summary>
@@ -79,7 +77,7 @@ public JsValue BuildConstructor(EvaluationContext context, Environment env, stri
         if (hasDecorators)
         {
             // Evaluate class-level decorators
-            classDecoratorValues = EvaluateDecorators(context, _classDecorators);
+            classDecoratorValues = EvaluateDecorators(context, _class.Decorators);
 
             // Evaluate element-level decorators
             ref readonly var bodyElements = ref _body.Body;
@@ -183,7 +181,7 @@ public JsValue BuildConstructor(EvaluationContext context, Environment env, stri
         ScriptFunction F;
         try
         {
-            var constructorInfo = constructor.DefineMethod(proto, constructorParent);
+            var constructorInfo = constructor.DefineMethod(proto, constructorParent, sourceTextNode: _class);
             F = constructorInfo.Closure;
 
             F.SetFunctionName(_className ?? classBinding ?? "");
@@ -761,14 +759,12 @@ public ClassStaticBlockFunction(StaticBlock staticBlock) : base(NodeType.StaticB
 
         if (method.Kind != PropertyKind.Get && method.Kind != PropertyKind.Set && !function.Generator)
         {
-            var methodDef = method.DefineMethod(obj);
+            var methodDef = method.DefineMethod(obj, functionPrototype: null, sourceTextNode: method);
             methodDef.Closure.SetFunctionName(methodDef.Key);
             return DefineMethodProperty(obj, methodDef.Key, methodDef.Closure, enumerable);
         }
 
-        var getter = method.Kind == PropertyKind.Get;
-
-        var definition = new JintFunctionDefinition(function);
+        var definition = new JintFunctionDefinition(function, sourceTextNode: method);
         var intrinsics = engine.Realm.Intrinsics;
 
         var value = method.TryGetKey(engine);
@@ -803,6 +799,8 @@ public ClassStaticBlockFunction(StaticBlock staticBlock) : base(NodeType.StaticB
         }
         else
         {
+            var getter = method.Kind == PropertyKind.Get;
+
             var closure = intrinsics.Function.OrdinaryFunctionCreate(intrinsics.Function.PrototypeObject, definition, definition.ThisMode, env, privateEnv);
             closure.MakeMethod(obj);
             closure.SetFunctionName(propKey, getter ? "get" : "set");
@@ -1092,7 +1090,7 @@ private static AccessorDecoratorResult ApplyAccessorDecorators(
     /// </summary>
     private bool HasDecorators()
     {
-        if (_classDecorators.Count > 0) return true;
+        if (_class.Decorators.Count > 0) return true;
 
         ref readonly var elements = ref _body.Body;
         for (var i = 0; i < elements.Count; i++)
diff --git a/Jint/Native/Function/Function.cs b/Jint/Native/Function/Function.cs
index 9c387d7a10..eecdc45260 100644
--- a/Jint/Native/Function/Function.cs
+++ b/Jint/Native/Function/Function.cs
@@ -375,9 +375,19 @@ public sealed override object ToObject()
 
     public override string ToString()
     {
-        if (_functionDefinition?.Function is Node node && _engine.Options.Host.FunctionToStringHandler(this, node) is { } s)
+        if (_functionDefinition is not null)
         {
-            return s;
+            var sourceTextNode = (Node) _functionDefinition.SourceTextNode;
+            if (_engine.Options.Host.FunctionToStringHandler(this, sourceTextNode) is { } s)
+            {
+                return s;
+            }
+
+            var state = _functionDefinition.Initialize();
+            if (state.SourceText.GetValue(sourceTextNode) is { } sourceText)
+            {
+                return sourceText;
+            }
         }
 
         var nameValue = _nameDescriptor != null ? UnwrapJsValue(_nameDescriptor) : JsString.Empty;
diff --git a/Jint/Native/Function/FunctionInstance.Dynamic.cs b/Jint/Native/Function/FunctionInstance.Dynamic.cs
index 66597d5c4d..a25f5abea9 100644
--- a/Jint/Native/Function/FunctionInstance.Dynamic.cs
+++ b/Jint/Native/Function/FunctionInstance.Dynamic.cs
@@ -84,16 +84,16 @@ internal Function CreateDynamicFunction(
                 switch (kind)
                 {
                     case FunctionKind.Normal:
-                        functionExpression = "function f(){}";
+                        functionExpression = "function anonymous(\n) {\n\n}";
                         break;
                     case FunctionKind.Generator:
-                        functionExpression = "function* f(){}";
+                        functionExpression = "function* anonymous(\n) {\n\n}";
                         break;
                     case FunctionKind.Async:
-                        functionExpression = "async function f(){}";
+                        functionExpression = "async function anonymous(\n) {\n\n}";
                         break;
                     case FunctionKind.AsyncGenerator:
-                        functionExpression = "async function* f(){}";
+                        functionExpression = "async function* anonymous(\n) {\n\n}";
                         break;
                     default:
                         Throw.ArgumentOutOfRangeException(nameof(kind), kind.ToString());
@@ -105,16 +105,16 @@ internal Function CreateDynamicFunction(
                 switch (kind)
                 {
                     case FunctionKind.Normal:
-                        functionExpression = "function f(";
+                        functionExpression = "function anonymous(";
                         break;
                     case FunctionKind.Async:
-                        functionExpression = "async function f(";
+                        functionExpression = "async function anonymous(";
                         break;
                     case FunctionKind.Generator:
-                        functionExpression = "function* f(";
+                        functionExpression = "function* anonymous(";
                         break;
                     case FunctionKind.AsyncGenerator:
-                        functionExpression = "async function* f(";
+                        functionExpression = "async function* anonymous(";
                         break;
                     default:
                         Throw.ArgumentOutOfRangeException(nameof(kind), kind.ToString());
@@ -124,7 +124,7 @@ internal Function CreateDynamicFunction(
                 // Per spec (CreateDynamicFunction step 29), a line feed follows the parameters,
                 // and the body is wrapped with line feeds (step 16). This ensures HTML-like
                 // comments (<!-- and -->) are correctly handled as line comments.
-                functionExpression += p + "\n){\n" + body + "\n}";
+                functionExpression += p + "\n) {\n" + body + "\n}";
             }
 
             var parserOptions = _engine.GetActiveParserOptions();
diff --git a/Jint/Native/Function/SourceText.cs b/Jint/Native/Function/SourceText.cs
new file mode 100644
index 0000000000..f982d772a6
--- /dev/null
+++ b/Jint/Native/Function/SourceText.cs
@@ -0,0 +1,47 @@
+using System.Runtime.CompilerServices;
+
+namespace Jint.Native.Function
+{
+    internal struct SourceText
+    {
+        // Either a string that stores the full source text that the function was parsed from,
+        // or a StrongBox<string> containing the materialized source text of the function,
+        // or null when the function doesn't have source text.
+        private object? _fullSourceTextOrBoxedValue;
+
+        public SourceText(string? fullSourceText)
+        {
+            _fullSourceTextOrBoxedValue = fullSourceText;
+        }
+
+        public string? GetValue(Node sourceTextNode)
+        {
+            if (_fullSourceTextOrBoxedValue is null)
+            {
+                return null;
+            }
+
+            if (_fullSourceTextOrBoxedValue is StrongBox<string> boxedValue)
+            {
+                return boxedValue.Value;
+            }
+
+            var fullSourceText = (string) _fullSourceTextOrBoxedValue;
+
+            var (start, end) = sourceTextNode.Range;
+
+            // In the case of static class methods, the static keyword is not included.
+            if (sourceTextNode is MethodDefinition { Static: true } m)
+            {
+                start = AstExtensions.GetSecondTokenStartIndex(fullSourceText, start, end);
+            }
+
+            var value = fullSourceText.Substring(start, end - start);
+
+            // Setting this field also releases the reference to the full source text string instance.
+            _fullSourceTextOrBoxedValue = new StrongBox<string>(value);
+
+            return value;
+        }
+    }
+}
diff --git a/Jint/Native/ShadowRealm/ShadowRealm.cs b/Jint/Native/ShadowRealm/ShadowRealm.cs
index 84f4d2bdcf..59bc61e226 100644
--- a/Jint/Native/ShadowRealm/ShadowRealm.cs
+++ b/Jint/Native/ShadowRealm/ShadowRealm.cs
@@ -387,6 +387,8 @@ protected internal override JsValue Call(JsValue thisArgument, JsCallArguments a
 
             return GetWrappedValue(callerRealm, callerRealm, result);
         }
+
+        public override string ToString() => _wrappedTargetFunction.ToString();
     }
 
     /// <summary>
diff --git a/Jint/Options.cs b/Jint/Options.cs
index a892fbe004..6424949fe7 100644
--- a/Jint/Options.cs
+++ b/Jint/Options.cs
@@ -495,9 +495,19 @@ public class HostOptions
         public bool StringCompilationAllowed { get; set; } = true;
 
         /// <summary>
-        /// Possibility to override Jint's default function() { [native code] } format for functions using AST Node.
-        /// If callback return null, Jint will use its own default logic.
+        /// Possibility to override Jint's default <c>Function.prototype.toString()</c> implementation.
+        /// If the callback returns <see langword="null"/>, Jint will use its own default logic.
         /// </summary>
+        /// <remarks>
+        /// In most cases, the AST node passed to the callback is of type <see cref="IFunction" />.
+        /// However, there are some special cases:<br/>
+        /// - For class constructors, a node of type <see cref="IClass"/> is passed
+        ///   since <c>toString()</c> should return the code of the entire class as per specification.<br/>
+        /// - For class methods and getters/setters, a node of type <see cref="MethodDefinition"/> is passed
+        ///   since <c>toString()</c> should include the <c>get</c> or <c>set</c> tokens for getters/setters and the member name as per specification.<br/>
+        /// - For object methods and getters/setters, a node of type <see cref="ObjectProperty"/> is passed
+        ///   since <c>toString()</c> should include the <c>get</c> or <c>set</c> tokens for getters/setters and the member name as per specification.
+        /// </remarks>
         public Func<Function, Node, string?> FunctionToStringHandler { get; set; } = (_, _) => null;
     }
 
diff --git a/Jint/ParsingOptions.cs b/Jint/ParsingOptions.cs
index c4d8f4e8b4..8c40919bdb 100644
--- a/Jint/ParsingOptions.cs
+++ b/Jint/ParsingOptions.cs
@@ -43,6 +43,7 @@ public sealed record ScriptParsingOptions : IParsingOptions
         AllowReturnOutsideFunction = true,
         AllowTopLevelUsing = true,
         OnRegExp = Engine.DefaultConvertRegExpHandler,
+        OnNode = Engine.DefaultNodeHandler,
     };
 
     public static readonly ScriptParsingOptions Default = new();
@@ -110,6 +111,7 @@ public sealed record class ModuleParsingOptions : IParsingOptions
     private static readonly ParserOptions _defaultParserOptions = Engine.BaseParserOptions with
     {
         OnRegExp = Engine.DefaultConvertRegExpHandler,
+        OnNode = Engine.DefaultNodeHandler,
     };
 
     public static readonly ModuleParsingOptions Default = new();
diff --git a/Jint/Runtime/Interpreter/Expressions/JintClassExpression.cs b/Jint/Runtime/Interpreter/Expressions/JintClassExpression.cs
index 72d163e5c6..70eb77662b 100644
--- a/Jint/Runtime/Interpreter/Expressions/JintClassExpression.cs
+++ b/Jint/Runtime/Interpreter/Expressions/JintClassExpression.cs
@@ -9,7 +9,7 @@ internal sealed class JintClassExpression : JintExpression
 
     public JintClassExpression(ClassExpression expression) : base(expression)
     {
-        _classDefinition = new ClassDefinition(expression.Id?.Name, expression.SuperClass, expression.Body, expression.Decorators);
+        _classDefinition = new ClassDefinition(expression.Id?.Name, expression);
     }
 
     protected override object EvaluateInternal(EvaluationContext context)
diff --git a/Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs b/Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs
index 2dbfbaf5c3..49d2cce3a9 100644
--- a/Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs
+++ b/Jint/Runtime/Interpreter/Expressions/JintObjectExpression.cs
@@ -21,10 +21,10 @@ private sealed class ObjectProperty
     {
         internal readonly string? _key;
         private JsString? _keyJsString;
-        internal readonly Property _value;
+        internal readonly Acornima.Ast.ObjectProperty _value;
         private JintFunctionDefinition? _functionDefinition;
 
-        public ObjectProperty(string? key, Property property)
+        public ObjectProperty(string? key, Acornima.Ast.ObjectProperty property)
         {
             _key = key;
             _value = property;
@@ -32,7 +32,7 @@ public ObjectProperty(string? key, Property property)
 
         public JsString? KeyJsString => _keyJsString ??= _key != null ? JsString.Create(_key) : null;
 
-        public JintFunctionDefinition GetFunctionDefinition(Engine engine)
+        public JintFunctionDefinition GetFunctionDefinition(Engine engine, Acornima.Ast.ObjectProperty property)
         {
             if (_functionDefinition is not null)
             {
@@ -45,7 +45,7 @@ public JintFunctionDefinition GetFunctionDefinition(Engine engine)
                 Throw.SyntaxError(engine.Realm);
             }
 
-            _functionDefinition = new JintFunctionDefinition(function);
+            _functionDefinition = new JintFunctionDefinition(function, sourceTextNode: property);
             return _functionDefinition;
         }
     }
@@ -240,7 +240,7 @@ private object BuildObjectNormal(EvaluationContext context)
             }
             else if (property.Kind is PropertyKind.Get or PropertyKind.Set)
             {
-                var function = objectProperty.GetFunctionDefinition(engine);
+                var function = objectProperty.GetFunctionDefinition(engine, property);
                 var closure = engine.Realm.Intrinsics.Function.OrdinaryFunctionCreate(
                     engine.Realm.Intrinsics.Function.PrototypeObject,
                     function,
diff --git a/Jint/Runtime/Interpreter/JintFunctionDefinition.cs b/Jint/Runtime/Interpreter/JintFunctionDefinition.cs
index 92277ad085..729766e51f 100644
--- a/Jint/Runtime/Interpreter/JintFunctionDefinition.cs
+++ b/Jint/Runtime/Interpreter/JintFunctionDefinition.cs
@@ -21,12 +21,20 @@ internal sealed class JintFunctionDefinition
     public readonly string? Name;
     public readonly IFunction Function;
 
-    public JintFunctionDefinition(IFunction function)
+    // Stores the AST node needed for creating the source text.
+    // (This might be different from the Function node, e.g., in the case of class methods.)
+    public readonly INode SourceTextNode;
+
+    public JintFunctionDefinition(IFunction function, INode sourceTextNode)
     {
         Function = function;
         Name = !string.IsNullOrEmpty(function.Id?.Name) ? function.Id!.Name : null;
+        SourceTextNode = sourceTextNode;
     }
 
+    public JintFunctionDefinition(IFunction function)
+        : this(function, function) { }
+
     public bool Strict => Function.IsStrict();
 
     public FunctionThisMode ThisMode => Function.IsStrict() ? FunctionThisMode.Strict : FunctionThisMode.Global;
@@ -257,7 +265,11 @@ private Completion EvaluateAsyncGeneratorBody(
     internal State Initialize()
     {
         var node = (Node) Function;
-        var state = (State) (node.UserData ??= BuildState(Function));
+        var stateOrFullSourceText = node.UserData;
+        if (stateOrFullSourceText is not State state)
+        {
+            node.UserData = state = BuildState(Function, stateOrFullSourceText as string);
+        }
         return state;
     }
 
@@ -298,10 +310,12 @@ internal sealed class State
         public bool EnvironmentMayEscape;
         public Binding[]? _cachedSlots;
 
+        public SourceText SourceText;
+
         internal readonly record struct VariableValuePair(Key Name, JsValue? InitialValue);
     }
 
-    internal static State BuildState(IFunction function)
+    internal static State BuildState(IFunction function, string? fullSourceText = null)
     {
         var state = new State();
 
@@ -556,6 +570,8 @@ internal static State BuildState(IFunction function)
             }
         }
 
+        state.SourceText = new SourceText(fullSourceText);
+
         return state;
     }
 
diff --git a/Jint/Runtime/Interpreter/Statements/JintClassDeclarationStatement.cs b/Jint/Runtime/Interpreter/Statements/JintClassDeclarationStatement.cs
index 9452703e01..f4ad959774 100644
--- a/Jint/Runtime/Interpreter/Statements/JintClassDeclarationStatement.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintClassDeclarationStatement.cs
@@ -9,7 +9,7 @@ internal sealed class JintClassDeclarationStatement : JintStatement<ClassDeclara
 
     public JintClassDeclarationStatement(ClassDeclaration classDeclaration) : base(classDeclaration)
     {
-        _classDefinition = new ClassDefinition(className: classDeclaration.Id?.Name, classDeclaration.SuperClass, classDeclaration.Body, classDeclaration.Decorators);
+        _classDefinition = new ClassDefinition(className: classDeclaration.Id?.Name, classDeclaration);
     }
 
     protected override Completion ExecuteInternal(EvaluationContext context)
diff --git a/Jint/Runtime/Interpreter/Statements/JintExportDefaultDeclaration.cs b/Jint/Runtime/Interpreter/Statements/JintExportDefaultDeclaration.cs
index 58be53ad5d..c8eeee716b 100644
--- a/Jint/Runtime/Interpreter/Statements/JintExportDefaultDeclaration.cs
+++ b/Jint/Runtime/Interpreter/Statements/JintExportDefaultDeclaration.cs
@@ -17,7 +17,7 @@ public JintExportDefaultDeclaration(ExportDefaultDeclaration statement) : base(s
     {
         if (statement.Declaration is ClassDeclaration classDeclaration)
         {
-            _classDefinition = new ClassDefinition(className: classDeclaration.Id?.Name ?? "default", classDeclaration.SuperClass, classDeclaration.Body);
+            _classDefinition = new ClassDefinition(className: classDeclaration.Id?.Name ?? "default", classDeclaration);
         }
         else if (statement.Declaration is FunctionDeclaration functionDeclaration)
         {