@ruby/wasm-wasi 2.3.0-2023-12-04-a → 2.3.0-2023-12-05-a

package/dist/browser.script.umd.js

@@ -3101,8 +3101,27 @@
     class RbExceptionFormatter {
         constructor() {
             this.literalsCache = null;
+            this.isFormmatting = false;
         }
         format(error, vm, privateObject) {
+            // All Ruby exceptions raised during formatting exception message should
+            // be caught and return a fallback message.
+            // Therefore, we don't need to worry about infinite recursion here ideally
+            // but checking re-entrancy just in case.
+            class RbExceptionFormatterError extends Error {
+            }
+            if (this.isFormmatting) {
+                throw new RbExceptionFormatterError("Unexpected exception occurred during formatting exception message");
+            }
+            this.isFormmatting = true;
+            try {
+                return this._format(error, vm, privateObject);
+            }
+            finally {
+                this.isFormmatting = false;
+            }
+        }
+        _format(error, vm, privateObject) {
             const [zeroLiteral, oneLiteral, newLineLiteral] = (() => {
                 if (this.literalsCache == null) {
                     const zeroOneNewLine = [
@@ -3117,18 +3136,43 @@
                     return this.literalsCache;
                 }
             })();
-            const backtrace = error.call("backtrace");
+            let className;
+            let backtrace;
+            let message;
+            try {
+                className = error.call("class").toString();
+            }
+            catch (e) {
+                className = "unknown";
+            }
+            try {
+                message = error.toString();
+            }
+            catch (e) {
+                message = "unknown";
+            }
+            try {
+                backtrace = error.call("backtrace");
+            }
+            catch (e) {
+                return this.formatString(className, message);
+            }
             if (backtrace.call("nil?").toString() === "true") {
-                return this.formatString(error.call("class").toString(), error.toString());
+                return this.formatString(className, message);
+            }
+            try {
+                const firstLine = backtrace.call("at", zeroLiteral);
+                const restLines = backtrace
+                    .call("drop", oneLiteral)
+                    .call("join", newLineLiteral);
+                return this.formatString(className, message, [
+                    firstLine.toString(),
+                    restLines.toString(),
+                ]);
+            }
+            catch (e) {
+                return this.formatString(className, message);
             }
-            const firstLine = backtrace.call("at", zeroLiteral);
-            const restLines = backtrace
-                .call("drop", oneLiteral)
-                .call("join", newLineLiteral);
-            return this.formatString(error.call("class").toString(), error.toString(), [
-                firstLine.toString(),
-                restLines.toString(),
-            ]);
         }
         formatString(klass, message, backtrace) {
             if (backtrace) {

package/dist/browser.umd.js

@@ -3059,8 +3059,27 @@
   class RbExceptionFormatter {
       constructor() {
           this.literalsCache = null;
+          this.isFormmatting = false;
       }
       format(error, vm, privateObject) {
+          // All Ruby exceptions raised during formatting exception message should
+          // be caught and return a fallback message.
+          // Therefore, we don't need to worry about infinite recursion here ideally
+          // but checking re-entrancy just in case.
+          class RbExceptionFormatterError extends Error {
+          }
+          if (this.isFormmatting) {
+              throw new RbExceptionFormatterError("Unexpected exception occurred during formatting exception message");
+          }
+          this.isFormmatting = true;
+          try {
+              return this._format(error, vm, privateObject);
+          }
+          finally {
+              this.isFormmatting = false;
+          }
+      }
+      _format(error, vm, privateObject) {
           const [zeroLiteral, oneLiteral, newLineLiteral] = (() => {
               if (this.literalsCache == null) {
                   const zeroOneNewLine = [
@@ -3075,18 +3094,43 @@
                   return this.literalsCache;
               }
           })();
-          const backtrace = error.call("backtrace");
+          let className;
+          let backtrace;
+          let message;
+          try {
+              className = error.call("class").toString();
+          }
+          catch (e) {
+              className = "unknown";
+          }
+          try {
+              message = error.toString();
+          }
+          catch (e) {
+              message = "unknown";
+          }
+          try {
+              backtrace = error.call("backtrace");
+          }
+          catch (e) {
+              return this.formatString(className, message);
+          }
           if (backtrace.call("nil?").toString() === "true") {
-              return this.formatString(error.call("class").toString(), error.toString());
+              return this.formatString(className, message);
+          }
+          try {
+              const firstLine = backtrace.call("at", zeroLiteral);
+              const restLines = backtrace
+                  .call("drop", oneLiteral)
+                  .call("join", newLineLiteral);
+              return this.formatString(className, message, [
+                  firstLine.toString(),
+                  restLines.toString(),
+              ]);
+          }
+          catch (e) {
+              return this.formatString(className, message);
           }
-          const firstLine = backtrace.call("at", zeroLiteral);
-          const restLines = backtrace
-              .call("drop", oneLiteral)
-              .call("join", newLineLiteral);
-          return this.formatString(error.call("class").toString(), error.toString(), [
-              firstLine.toString(),
-              restLines.toString(),
-          ]);
       }
       formatString(klass, message, backtrace) {
           if (backtrace) {

package/dist/cjs/index.d.ts

@@ -169,7 +169,9 @@ type RubyVMPrivate = {
 };
 declare class RbExceptionFormatter {
     private literalsCache;
+    private isFormmatting;
     format(error: RbValue, vm: RubyVM, privateObject: RubyVMPrivate): string;
+    private _format;
     formatString(klass: string, message: string, backtrace?: [string, string]): string;
 }
 /**

package/dist/cjs/index.js

@@ -470,8 +470,27 @@ var ruby_tag_type;
 class RbExceptionFormatter {
     constructor() {
         this.literalsCache = null;
+        this.isFormmatting = false;
     }
     format(error, vm, privateObject) {
+        // All Ruby exceptions raised during formatting exception message should
+        // be caught and return a fallback message.
+        // Therefore, we don't need to worry about infinite recursion here ideally
+        // but checking re-entrancy just in case.
+        class RbExceptionFormatterError extends Error {
+        }
+        if (this.isFormmatting) {
+            throw new RbExceptionFormatterError("Unexpected exception occurred during formatting exception message");
+        }
+        this.isFormmatting = true;
+        try {
+            return this._format(error, vm, privateObject);
+        }
+        finally {
+            this.isFormmatting = false;
+        }
+    }
+    _format(error, vm, privateObject) {
         const [zeroLiteral, oneLiteral, newLineLiteral] = (() => {
             if (this.literalsCache == null) {
                 const zeroOneNewLine = [
@@ -486,18 +505,43 @@ class RbExceptionFormatter {
                 return this.literalsCache;
             }
         })();
-        const backtrace = error.call("backtrace");
+        let className;
+        let backtrace;
+        let message;
+        try {
+            className = error.call("class").toString();
+        }
+        catch (e) {
+            className = "unknown";
+        }
+        try {
+            message = error.toString();
+        }
+        catch (e) {
+            message = "unknown";
+        }
+        try {
+            backtrace = error.call("backtrace");
+        }
+        catch (e) {
+            return this.formatString(className, message);
+        }
         if (backtrace.call("nil?").toString() === "true") {
-            return this.formatString(error.call("class").toString(), error.toString());
+            return this.formatString(className, message);
+        }
+        try {
+            const firstLine = backtrace.call("at", zeroLiteral);
+            const restLines = backtrace
+                .call("drop", oneLiteral)
+                .call("join", newLineLiteral);
+            return this.formatString(className, message, [
+                firstLine.toString(),
+                restLines.toString(),
+            ]);
+        }
+        catch (e) {
+            return this.formatString(className, message);
         }
-        const firstLine = backtrace.call("at", zeroLiteral);
-        const restLines = backtrace
-            .call("drop", oneLiteral)
-            .call("join", newLineLiteral);
-        return this.formatString(error.call("class").toString(), error.toString(), [
-            firstLine.toString(),
-            restLines.toString(),
-        ]);
     }
     formatString(klass, message, backtrace) {
         if (backtrace) {

package/dist/esm/index.d.ts

@@ -169,7 +169,9 @@ type RubyVMPrivate = {
 };
 declare class RbExceptionFormatter {
     private literalsCache;
+    private isFormmatting;
     format(error: RbValue, vm: RubyVM, privateObject: RubyVMPrivate): string;
+    private _format;
     formatString(klass: string, message: string, backtrace?: [string, string]): string;
 }
 /**

package/dist/esm/index.js

@@ -464,8 +464,27 @@ var ruby_tag_type;
 class RbExceptionFormatter {
     constructor() {
         this.literalsCache = null;
+        this.isFormmatting = false;
     }
     format(error, vm, privateObject) {
+        // All Ruby exceptions raised during formatting exception message should
+        // be caught and return a fallback message.
+        // Therefore, we don't need to worry about infinite recursion here ideally
+        // but checking re-entrancy just in case.
+        class RbExceptionFormatterError extends Error {
+        }
+        if (this.isFormmatting) {
+            throw new RbExceptionFormatterError("Unexpected exception occurred during formatting exception message");
+        }
+        this.isFormmatting = true;
+        try {
+            return this._format(error, vm, privateObject);
+        }
+        finally {
+            this.isFormmatting = false;
+        }
+    }
+    _format(error, vm, privateObject) {
         const [zeroLiteral, oneLiteral, newLineLiteral] = (() => {
             if (this.literalsCache == null) {
                 const zeroOneNewLine = [
@@ -480,18 +499,43 @@ class RbExceptionFormatter {
                 return this.literalsCache;
             }
         })();
-        const backtrace = error.call("backtrace");
+        let className;
+        let backtrace;
+        let message;
+        try {
+            className = error.call("class").toString();
+        }
+        catch (e) {
+            className = "unknown";
+        }
+        try {
+            message = error.toString();
+        }
+        catch (e) {
+            message = "unknown";
+        }
+        try {
+            backtrace = error.call("backtrace");
+        }
+        catch (e) {
+            return this.formatString(className, message);
+        }
         if (backtrace.call("nil?").toString() === "true") {
-            return this.formatString(error.call("class").toString(), error.toString());
+            return this.formatString(className, message);
+        }
+        try {
+            const firstLine = backtrace.call("at", zeroLiteral);
+            const restLines = backtrace
+                .call("drop", oneLiteral)
+                .call("join", newLineLiteral);
+            return this.formatString(className, message, [
+                firstLine.toString(),
+                restLines.toString(),
+            ]);
+        }
+        catch (e) {
+            return this.formatString(className, message);
         }
-        const firstLine = backtrace.call("at", zeroLiteral);
-        const restLines = backtrace
-            .call("drop", oneLiteral)
-            .call("join", newLineLiteral);
-        return this.formatString(error.call("class").toString(), error.toString(), [
-            firstLine.toString(),
-            restLines.toString(),
-        ]);
     }
     formatString(klass, message, backtrace) {
         if (backtrace) {

package/dist/index.umd.js

@@ -1065,8 +1065,27 @@
   class RbExceptionFormatter {
       constructor() {
           this.literalsCache = null;
+          this.isFormmatting = false;
       }
       format(error, vm, privateObject) {
+          // All Ruby exceptions raised during formatting exception message should
+          // be caught and return a fallback message.
+          // Therefore, we don't need to worry about infinite recursion here ideally
+          // but checking re-entrancy just in case.
+          class RbExceptionFormatterError extends Error {
+          }
+          if (this.isFormmatting) {
+              throw new RbExceptionFormatterError("Unexpected exception occurred during formatting exception message");
+          }
+          this.isFormmatting = true;
+          try {
+              return this._format(error, vm, privateObject);
+          }
+          finally {
+              this.isFormmatting = false;
+          }
+      }
+      _format(error, vm, privateObject) {
           const [zeroLiteral, oneLiteral, newLineLiteral] = (() => {
               if (this.literalsCache == null) {
                   const zeroOneNewLine = [
@@ -1081,18 +1100,43 @@
                   return this.literalsCache;
               }
           })();
-          const backtrace = error.call("backtrace");
+          let className;
+          let backtrace;
+          let message;
+          try {
+              className = error.call("class").toString();
+          }
+          catch (e) {
+              className = "unknown";
+          }
+          try {
+              message = error.toString();
+          }
+          catch (e) {
+              message = "unknown";
+          }
+          try {
+              backtrace = error.call("backtrace");
+          }
+          catch (e) {
+              return this.formatString(className, message);
+          }
           if (backtrace.call("nil?").toString() === "true") {
-              return this.formatString(error.call("class").toString(), error.toString());
+              return this.formatString(className, message);
+          }
+          try {
+              const firstLine = backtrace.call("at", zeroLiteral);
+              const restLines = backtrace
+                  .call("drop", oneLiteral)
+                  .call("join", newLineLiteral);
+              return this.formatString(className, message, [
+                  firstLine.toString(),
+                  restLines.toString(),
+              ]);
+          }
+          catch (e) {
+              return this.formatString(className, message);
           }
-          const firstLine = backtrace.call("at", zeroLiteral);
-          const restLines = backtrace
-              .call("drop", oneLiteral)
-              .call("join", newLineLiteral);
-          return this.formatString(error.call("class").toString(), error.toString(), [
-              firstLine.toString(),
-              restLines.toString(),
-          ]);
       }
       formatString(klass, message, backtrace) {
           if (backtrace) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruby/wasm-wasi",
-  "version": "2.3.0-2023-12-04-a",
+  "version": "2.3.0-2023-12-05-a",
   "description": "WebAssembly port of CRuby with WASI",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",