quickjs 0.12.0 → 0.13.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64bdf2de37fc8ac24b7acec74dd724226f732a4acbef401d579b9b46e12c86f1
-  data.tar.gz: 4d76617466a380a038de3684495dc38eacb29be11002b3d6b1536c2c6caf0d80
+  metadata.gz: f27d3afc594731cc4df53661889a9787626121923ece35c544b581ef3f52722c
+  data.tar.gz: d3869683f9134339d1d2e44617845f8ece614e1503926841fb9d4ad6de3dc7ba
 SHA512:
-  metadata.gz: 0fcf3bde7047e39038983326a6d867430e4e5fc63ac65bc6823c44df4222904a8bef385abd12bcadcca5213c9610198a08cdf4f12bc949dc2f7613509a8e46fc
-  data.tar.gz: af03f93832d2400cbb1418c764fbdaca5b1a51fd232462731b404a897851ff60cb3437c745ab2c03e36a7a5219c3618751075649b1cdc2e9935689b4e218ccf7
+  metadata.gz: b5cfcad98315e8821644aa233ea86213f855900506767ccce01cb0c1a653326456e3d00c453d0821117e31eee543ec440ed1e4583dd6b420a62e49ffcb53e080
+  data.tar.gz: 7df6cc20b91fce4c14e2a2b96b31bb447ee50eba03498a99e336c8b35d62164a05874ed7753509a4d0c1958761f96c5c85f4de66c6301b79eecbe208dbcf8212

data/Rakefile

@@ -71,4 +71,11 @@ end
 
 task 'release:guard_clean' => 'polyfills:version:check'
 
-task default: %i[clobber compile test]
+namespace :rbs do
+  desc 'Validate RBS type definitions'
+  task :validate do
+    sh RbConfig.ruby, '-S', 'rbs', '-I', 'sig', 'validate'
+  end
+end
+
+task default: %i[clobber compile test rbs:validate]

data/ext/quickjsrb/extconf.rb

@@ -13,7 +13,9 @@ $srcs = [
   'quickjs-libc.c',
   'polyfill-intl-en.min.c',
   'polyfill-file.min.c',
+  'polyfill-encoding.min.c',
   'quickjsrb.c',
+  'quickjsrb_file.c',
 ]
 
 append_cflags('-I$(srcdir)/quickjs')
@@ -66,6 +68,10 @@ polyfill-file.min.js:
 		$(COPY) $(srcdir)/vendor/$@ $@
 polyfill-file.min.c: ./qjsc polyfill-file.min.js
 		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/file.so,file -m -o $@ polyfill-file.min.js
+polyfill-encoding.min.js:
+		$(COPY) $(srcdir)/vendor/$@ $@
+polyfill-encoding.min.c: ./qjsc polyfill-encoding.min.js
+		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/encoding.so,encoding -m -o $@ polyfill-encoding.min.js
 COMPILE_POLYFILL
   conf
 end

data/ext/quickjsrb/quickjsrb.c

@@ -1,4 +1,27 @@
 #include "quickjsrb.h"
+#include "quickjsrb_file.h"
+
+const char *featureStdId = "feature_std";
+const char *featureOsId = "feature_os";
+const char *featureTimeoutId = "feature_timeout";
+const char *featurePolyfillIntlId = "feature_polyfill_intl";
+const char *featurePolyfillFileId = "feature_polyfill_file";
+const char *featurePolyfillEncodingId = "feature_polyfill_encoding";
+
+const char *undefinedId = "undefined";
+const char *nanId = "NaN";
+
+const char *native_errors[] = {
+    "SyntaxError",
+    "TypeError",
+    "ReferenceError",
+    "RangeError",
+    "EvalError",
+    "URIError",
+    "AggregateError"};
+const int num_native_errors = sizeof(native_errors) / sizeof(native_errors[0]);
+
+static int dispatch_log(VMData *data, const char *severity, VALUE r_row);
 
 JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 {
@@ -10,7 +33,7 @@ JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 
   // Keep the error alive in VMData to prevent GC before find_ruby_error retrieves it
   VMData *data = JS_GetContextOpaque(ctx);
-  rb_hash_aset(data->alive_errors, r_object_id, r_error);
+  rb_hash_aset(data->alive_objects, r_object_id, r_error);
 
   VALUE r_exception_message = rb_funcall(r_error, rb_intern("message"), 0);
   const char *errorMessage = StringValueCStr(r_exception_message);
@@ -68,6 +91,12 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   }
   default:
   {
+    if (rb_obj_is_kind_of(r_value, rb_cFile))
+    {
+      VMData *data = JS_GetContextOpaque(ctx);
+      if (!JS_IsUndefined(data->j_file_proxy_creator))
+        return quickjsrb_file_to_js(ctx, r_value);
+    }
     if (TYPE(r_value) == T_OBJECT && RTEST(rb_funcall(
                                          r_value,
                                          rb_intern("is_a?"),
@@ -95,8 +124,8 @@ VALUE find_ruby_error(JSContext *ctx, JSValue j_error)
     {
       VMData *data = JS_GetContextOpaque(ctx);
       VALUE r_key = INT2NUM(errorOriginalRubyObjectId);
-      VALUE r_error = rb_hash_aref(data->alive_errors, r_key);
-      rb_hash_delete(data->alive_errors, r_key);
+      VALUE r_error = rb_hash_aref(data->alive_objects, r_key);
+      rb_hash_delete(data->alive_objects, r_key);
       return r_error;
     }
   }
@@ -177,6 +206,36 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       }
       // will support other errors like just returning an instance of Error
     }
+
+    // Check for Ruby object proxy (e.g., File proxy with rb_object_id on target)
+    {
+      JSValue j_rb_id = JS_GetPropertyStr(ctx, j_val, "rb_object_id");
+      if (JS_VALUE_GET_NORM_TAG(j_rb_id) == JS_TAG_INT || JS_VALUE_GET_NORM_TAG(j_rb_id) == JS_TAG_FLOAT64)
+      {
+        int64_t object_id;
+        JS_ToInt64(ctx, &object_id, j_rb_id);
+        JS_FreeValue(ctx, j_rb_id);
+        if (object_id > 0)
+        {
+          VMData *data = JS_GetContextOpaque(ctx);
+          VALUE r_obj = rb_hash_aref(data->alive_objects, LONG2NUM(object_id));
+          if (!NIL_P(r_obj) && !rb_obj_is_kind_of(r_obj, rb_eException))
+            return r_obj;
+        }
+      }
+      else
+      {
+        JS_FreeValue(ctx, j_rb_id);
+      }
+    }
+
+    // JS File → Quickjs::File
+    {
+      VALUE r_maybe_file = quickjsrb_try_convert_js_file(ctx, j_val);
+      if (!NIL_P(r_maybe_file))
+        return r_maybe_file;
+    }
+
     VALUE r_str = to_r_json(ctx, j_val);
 
     if (rb_funcall(r_str, rb_intern("=="), 1, rb_str_new2("undefined")))
@@ -227,7 +286,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
       VMData *data = JS_GetContextOpaque(ctx);
       VALUE r_headline = rb_str_new2(headline);
-      rb_ary_push(data->logs, r_log_new("error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline))));
+      dispatch_log(data, "error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline)));
 
       JS_FreeValue(ctx, j_errorClassMessage);
       JS_FreeValue(ctx, j_errorClassName);
@@ -269,7 +328,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
       VMData *data = JS_GetContextOpaque(ctx);
       VALUE r_headline = rb_str_new2(headline);
-      rb_ary_push(data->logs, r_log_new("error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline))));
+      dispatch_log(data, "error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline)));
 
       free(headline);
 
@@ -418,6 +477,43 @@ static JSValue js_quickjsrb_set_timeout(JSContext *ctx, JSValueConst _this, int
   return JS_UNDEFINED;
 }
 
+static VALUE r_try_call_listener(VALUE r_args)
+{
+  VALUE r_listener = RARRAY_AREF(r_args, 0);
+  VALUE r_log = RARRAY_AREF(r_args, 1);
+  return rb_funcall(r_listener, rb_intern("call"), 1, r_log);
+}
+
+static int dispatch_log(VMData *data, const char *severity, VALUE r_row)
+{
+  VALUE r_log = r_log_new(severity, r_row);
+  if (!NIL_P(data->log_listener))
+  {
+    VALUE r_args = rb_ary_new3(2, data->log_listener, r_log);
+    int error;
+    rb_protect(r_try_call_listener, r_args, &error);
+    if (error)
+      return error;
+  }
+  else
+  {
+    rb_ary_push(data->logs, r_log);
+  }
+  return 0;
+}
+
+static VALUE vm_m_on_log(VALUE r_self)
+{
+  rb_need_block();
+
+  VMData *data;
+  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
+
+  data->log_listener = rb_block_proc();
+
+  return Qnil;
+}
+
 static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, const char *severity)
 {
   VMData *data = JS_GetContextOpaque(ctx);
@@ -467,7 +563,14 @@ static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int argc, JS
     rb_ary_push(r_row, r_log_body_new(r_raw, r_c));
   }
 
-  rb_ary_push(data->logs, r_log_new(severity, r_row));
+  int error = dispatch_log(data, severity, r_row);
+  if (error)
+  {
+    VALUE r_error = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    JSValue j_error = j_error_from_ruby_error(ctx, r_error);
+    return JS_Throw(ctx, j_error);
+  }
   return JS_UNDEFINED;
 }
 
@@ -566,6 +669,15 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JSValue j_polyfillFileObject = JS_ReadObject(data->context, &qjsc_polyfill_file_min, qjsc_polyfill_file_min_size, JS_READ_OBJ_BYTECODE);
     JSValue j_polyfillFileResult = JS_EvalFunction(data->context, j_polyfillFileObject);
     JS_FreeValue(data->context, j_polyfillFileResult);
+
+    quickjsrb_init_file_proxy(data);
+  }
+
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillEncodingId))))
+  {
+    JSValue j_polyfillEncodingObject = JS_ReadObject(data->context, &qjsc_polyfill_encoding_min, qjsc_polyfill_encoding_min_size, JS_READ_OBJ_BYTECODE);
+    JSValue j_polyfillEncodingResult = JS_EvalFunction(data->context, j_polyfillEncodingObject);
+    JS_FreeValue(data->context, j_polyfillEncodingResult);
   }
 
   JSValue j_console = JS_NewObject(data->context);
@@ -740,6 +852,8 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
 
 static VALUE vm_m_logs(VALUE r_self)
 {
+  rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "Quickjs::VM#logs is deprecated; use Quickjs::VM#on_log instead");
+
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
@@ -762,5 +876,6 @@ RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
   rb_define_method(r_class_vm, "define_function", vm_m_defineGlobalFunction, -1);
   rb_define_method(r_class_vm, "import", vm_m_import, -1);
   rb_define_method(r_class_vm, "logs", vm_m_logs, 0);
+  rb_define_method(r_class_vm, "on_log", vm_m_on_log, 0);
   r_define_log_class(r_class_vm);
 }

data/ext/quickjsrb/quickjsrb.h

@@ -16,24 +16,21 @@ extern const uint32_t qjsc_polyfill_intl_en_min_size;
 extern const uint8_t qjsc_polyfill_intl_en_min;
 extern const uint32_t qjsc_polyfill_file_min_size;
 extern const uint8_t qjsc_polyfill_file_min;
+extern const uint32_t qjsc_polyfill_encoding_min_size;
+extern const uint8_t qjsc_polyfill_encoding_min;
 
-const char *featureStdId = "feature_std";
-const char *featureOsId = "feature_os";
-const char *featureTimeoutId = "feature_timeout";
-const char *featurePolyfillIntlId = "feature_polyfill_intl";
-const char *featurePolyfillFileId = "feature_polyfill_file";
+extern const char *featureStdId;
+extern const char *featureOsId;
+extern const char *featureTimeoutId;
+extern const char *featurePolyfillIntlId;
+extern const char *featurePolyfillFileId;
+extern const char *featurePolyfillEncodingId;
 
-const char *undefinedId = "undefined";
-const char *nanId = "NaN";
+extern const char *undefinedId;
+extern const char *nanId;
 
-const char *native_errors[] = {
-    "SyntaxError",
-    "TypeError",
-    "ReferenceError",
-    "RangeError",
-    "EvalError",
-    "URIError",
-    "AggregateError"};
+extern const char *native_errors[];
+extern const int num_native_errors;
 
 #define QUICKJSRB_SYM(id) \
   (VALUE) { ID2SYM(rb_intern(id)) }
@@ -52,7 +49,9 @@ typedef struct VMData
   VALUE defined_functions;
   struct EvalTime *eval_time;
   VALUE logs;
-  VALUE alive_errors;
+  VALUE log_listener;
+  VALUE alive_objects;
+  JSValue j_file_proxy_creator;
 } VMData;
 
 static void vm_free(void *ptr)
@@ -60,6 +59,9 @@ static void vm_free(void *ptr)
   VMData *data = (VMData *)ptr;
   free(data->eval_time);
 
+  if (!JS_IsUndefined(data->j_file_proxy_creator))
+    JS_FreeValue(data->context, data->j_file_proxy_creator);
+
   JSRuntime *runtime = JS_GetRuntime(data->context);
   JS_SetInterruptHandler(runtime, NULL, NULL);
   js_std_free_handlers(runtime);
@@ -69,7 +71,7 @@ static void vm_free(void *ptr)
   xfree(ptr);
 }
 
-size_t vm_size(const void *data)
+static size_t vm_size(const void *data)
 {
   return sizeof(VMData);
 }
@@ -79,7 +81,8 @@ static void vm_mark(void *ptr)
   VMData *data = (VMData *)ptr;
   rb_gc_mark_movable(data->defined_functions);
   rb_gc_mark_movable(data->logs);
-  rb_gc_mark_movable(data->alive_errors);
+  rb_gc_mark_movable(data->log_listener);
+  rb_gc_mark_movable(data->alive_objects);
 }
 
 static void vm_compact(void *ptr)
@@ -87,7 +90,8 @@ static void vm_compact(void *ptr)
   VMData *data = (VMData *)ptr;
   data->defined_functions = rb_gc_location(data->defined_functions);
   data->logs = rb_gc_location(data->logs);
-  data->alive_errors = rb_gc_location(data->alive_errors);
+  data->log_listener = rb_gc_location(data->log_listener);
+  data->alive_objects = rb_gc_location(data->alive_objects);
 }
 
 static const rb_data_type_t vm_type = {
@@ -107,7 +111,9 @@ static VALUE vm_alloc(VALUE r_self)
   VALUE obj = TypedData_Make_Struct(r_self, VMData, &vm_type, data);
   data->defined_functions = rb_hash_new();
   data->logs = rb_ary_new();
-  data->alive_errors = rb_hash_new();
+  data->log_listener = Qnil;
+  data->alive_objects = rb_hash_new();
+  data->j_file_proxy_creator = JS_UNDEFINED;
 
   EvalTime *eval_time = malloc(sizeof(EvalTime));
   data->eval_time = eval_time;
@@ -132,17 +138,12 @@ static char *random_string()
 
 static bool is_native_error_name(const char *error_name)
 {
-  bool is_native_error = false;
-  int numStrings = sizeof(native_errors) / sizeof(native_errors[0]);
-  for (int i = 0; i < numStrings; i++)
+  for (int i = 0; i < num_native_errors; i++)
   {
     if (strcmp(native_errors[i], error_name) == 0)
-    {
-      is_native_error = true;
-      break;
-    }
+      return true;
   }
-  return is_native_error;
+  return false;
 }
 
 // Constants
@@ -154,6 +155,7 @@ static void r_define_constants(VALUE r_parent_class)
   rb_define_const(r_parent_class, "FEATURE_TIMEOUT", QUICKJSRB_SYM(featureTimeoutId));
   rb_define_const(r_parent_class, "POLYFILL_INTL", QUICKJSRB_SYM(featurePolyfillIntlId));
   rb_define_const(r_parent_class, "POLYFILL_FILE", QUICKJSRB_SYM(featurePolyfillFileId));
+  rb_define_const(r_parent_class, "POLYFILL_ENCODING", QUICKJSRB_SYM(featurePolyfillEncodingId));
 
   VALUE rb_cQuickjsValue = rb_define_class_under(r_parent_class, "Value", rb_cObject);
   rb_define_const(rb_cQuickjsValue, "UNDEFINED", QUICKJSRB_SYM(undefinedId));
@@ -225,7 +227,7 @@ static VALUE r_log_body_new(VALUE r_raw, VALUE r_c)
 #define QUICKJSRB_ERROR_FOR(name) \
   (VALUE) { rb_const_get(rb_const_get(rb_cClass, rb_intern("Quickjs")), rb_intern(name)) }
 
-VALUE vm_m_initialize_quickjs_error(VALUE self, VALUE r_message, VALUE r_js_name)
+static VALUE vm_m_initialize_quickjs_error(VALUE self, VALUE r_message, VALUE r_js_name)
 {
   rb_call_super(1, &r_message);
   rb_iv_set(self, "@js_name", r_js_name);
@@ -239,9 +241,7 @@ static void r_define_exception_classes(VALUE r_parent_class)
   rb_define_method(r_runtime_error, "initialize", vm_m_initialize_quickjs_error, 2);
   rb_define_attr(r_runtime_error, "js_name", 1, 0);
 
-  // JS native errors
-  int numStrings = sizeof(native_errors) / sizeof(native_errors[0]);
-  for (int i = 0; i < numStrings; i++)
+  for (int i = 0; i < num_native_errors; i++)
   {
     rb_define_class_under(r_parent_class, native_errors[i], r_runtime_error);
   }

data/ext/quickjsrb/quickjsrb_file.c

@@ -0,0 +1,332 @@
+#include "quickjsrb.h"
+#include "quickjsrb_file.h"
+
+static VALUE r_find_alive_rb_file(JSContext *ctx, JSValue j_handle)
+{
+  int64_t handle;
+  JS_ToInt64(ctx, &handle, j_handle);
+  VMData *data = JS_GetContextOpaque(ctx);
+  return rb_hash_aref(data->alive_objects, LONG2NUM(handle));
+}
+
+static JSValue js_ruby_file_name(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  VALUE r_file = r_find_alive_rb_file(ctx, argv[0]);
+  if (NIL_P(r_file))
+    return JS_UNDEFINED;
+
+  VALUE r_path = rb_funcall(r_file, rb_intern("path"), 0);
+  VALUE r_basename = rb_funcall(rb_cFile, rb_intern("basename"), 1, r_path);
+  return JS_NewString(ctx, StringValueCStr(r_basename));
+}
+
+static JSValue js_ruby_file_size(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  VALUE r_file = r_find_alive_rb_file(ctx, argv[0]);
+  if (NIL_P(r_file))
+    return JS_UNDEFINED;
+
+  VALUE r_size = rb_funcall(r_file, rb_intern("size"), 0);
+  return JS_NewInt64(ctx, NUM2LONG(r_size));
+}
+
+static JSValue js_ruby_file_type(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  return JS_NewString(ctx, "");
+}
+
+static JSValue js_ruby_file_last_modified(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  VALUE r_file = r_find_alive_rb_file(ctx, argv[0]);
+  if (NIL_P(r_file))
+    return JS_UNDEFINED;
+
+  VALUE r_mtime = rb_funcall(r_file, rb_intern("mtime"), 0);
+  VALUE r_epoch_f = rb_funcall(r_mtime, rb_intern("to_f"), 0);
+  double epoch_ms = NUM2DBL(r_epoch_f) * 1000.0;
+  return JS_NewFloat64(ctx, epoch_ms);
+}
+
+static JSValue js_ruby_file_text(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  VALUE r_file = r_find_alive_rb_file(ctx, argv[0]);
+  if (NIL_P(r_file))
+    return JS_UNDEFINED;
+
+  JSValue promise, resolving_funcs[2];
+  promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+  if (JS_IsException(promise))
+    return JS_EXCEPTION;
+
+  rb_funcall(r_file, rb_intern("rewind"), 0);
+  VALUE r_content = rb_funcall(r_file, rb_intern("read"), 0);
+  JSValue j_content = JS_NewString(ctx, StringValueCStr(r_content));
+
+  JSValue ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED, 1, &j_content);
+  JS_FreeValue(ctx, j_content);
+  JS_FreeValue(ctx, ret);
+  JS_FreeValue(ctx, resolving_funcs[0]);
+  JS_FreeValue(ctx, resolving_funcs[1]);
+
+  return promise;
+}
+
+static JSValue js_ruby_file_array_buffer(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  VALUE r_file = r_find_alive_rb_file(ctx, argv[0]);
+  if (NIL_P(r_file))
+    return JS_UNDEFINED;
+
+  JSValue promise, resolving_funcs[2];
+  promise = JS_NewPromiseCapability(ctx, resolving_funcs);
+  if (JS_IsException(promise))
+    return JS_EXCEPTION;
+
+  rb_funcall(r_file, rb_intern("rewind"), 0);
+  VALUE r_content = rb_funcall(r_file, rb_intern("read"), 0);
+  rb_funcall(r_content, rb_intern("force_encoding"), 1, rb_str_new_cstr("BINARY"));
+  long len = RSTRING_LEN(r_content);
+  const char *ptr = RSTRING_PTR(r_content);
+
+  JSValue j_buf = JS_NewArrayBufferCopy(ctx, (const uint8_t *)ptr, len);
+
+  JSValue ret = JS_Call(ctx, resolving_funcs[0], JS_UNDEFINED, 1, &j_buf);
+  JS_FreeValue(ctx, j_buf);
+  JS_FreeValue(ctx, ret);
+  JS_FreeValue(ctx, resolving_funcs[0]);
+  JS_FreeValue(ctx, resolving_funcs[1]);
+
+  return promise;
+}
+
+static JSValue js_ruby_file_slice(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv)
+{
+  VALUE r_file = r_find_alive_rb_file(ctx, argv[0]);
+  if (NIL_P(r_file))
+    return JS_UNDEFINED;
+
+  VALUE r_size = rb_funcall(r_file, rb_intern("size"), 0);
+  long file_size = NUM2LONG(r_size);
+
+  long start = 0;
+  if (argc > 1 && !JS_IsUndefined(argv[1]))
+  {
+    int64_t s;
+    JS_ToInt64(ctx, &s, argv[1]);
+    start = (long)s;
+    if (start < 0)
+      start = file_size + start;
+    if (start < 0)
+      start = 0;
+    if (start > file_size)
+      start = file_size;
+  }
+
+  long end = file_size;
+  if (argc > 2 && !JS_IsUndefined(argv[2]))
+  {
+    int64_t e;
+    JS_ToInt64(ctx, &e, argv[2]);
+    end = (long)e;
+    if (end < 0)
+      end = file_size + end;
+    if (end < 0)
+      end = 0;
+    if (end > file_size)
+      end = file_size;
+  }
+
+  const char *content_type = "";
+  if (argc > 3 && JS_IsString(argv[3]))
+    content_type = JS_ToCString(ctx, argv[3]);
+
+  long len = end > start ? end - start : 0;
+
+  rb_funcall(r_file, rb_intern("rewind"), 0);
+  if (start > 0)
+    rb_funcall(r_file, rb_intern("seek"), 1, LONG2NUM(start));
+  VALUE r_bytes = rb_funcall(r_file, rb_intern("read"), 1, LONG2NUM(len));
+  rb_funcall(r_bytes, rb_intern("force_encoding"), 1, rb_str_new_cstr("BINARY"));
+
+  JSValue j_buf = JS_NewArrayBufferCopy(ctx, (const uint8_t *)RSTRING_PTR(r_bytes), RSTRING_LEN(r_bytes));
+  JSValue j_global = JS_GetGlobalObject(ctx);
+  JSValue j_uint8_ctor = JS_GetPropertyStr(ctx, j_global, "Uint8Array");
+  JSValue j_uint8 = JS_CallConstructor(ctx, j_uint8_ctor, 1, &j_buf);
+
+  JSValue j_parts = JS_NewArray(ctx);
+  JS_SetPropertyUint32(ctx, j_parts, 0, j_uint8);
+
+  JSValue j_opts = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, j_opts, "type", JS_NewString(ctx, content_type));
+
+  JSValue j_blob_ctor = JS_GetPropertyStr(ctx, j_global, "Blob");
+  JSValueConst blob_args[2] = {j_parts, j_opts};
+  JSValue j_blob = JS_CallConstructor(ctx, j_blob_ctor, 2, blob_args);
+
+  if (argc > 3 && JS_IsString(argv[3]))
+    JS_FreeCString(ctx, content_type);
+
+  JS_FreeValue(ctx, j_buf);
+  JS_FreeValue(ctx, j_uint8_ctor);
+  JS_FreeValue(ctx, j_parts);
+  JS_FreeValue(ctx, j_opts);
+  JS_FreeValue(ctx, j_blob_ctor);
+  JS_FreeValue(ctx, j_global);
+
+  return j_blob;
+}
+
+void quickjsrb_init_file_proxy(VMData *data)
+{
+  const char *factory_src =
+      "(function(getName, getSize, getType, getLastModified, getText, getArrayBuffer, getSlice) {\n"
+      "  return function(handle) {\n"
+      "    var target = Object.create(File.prototype);\n"
+      "    Object.defineProperty(target, 'rb_object_id', { value: handle, enumerable: false });\n"
+      "    return new Proxy(target, {\n"
+      "      getPrototypeOf: function() { return File.prototype; },\n"
+      "      get: function(target, prop, receiver) {\n"
+      "        if (prop === 'name') return getName(handle);\n"
+      "        if (prop === 'size') return getSize(handle);\n"
+      "        if (prop === 'type') return getType(handle);\n"
+      "        if (prop === 'lastModified') return getLastModified(handle);\n"
+      "        if (prop === 'text') return function() { return getText(handle); };\n"
+      "        if (prop === 'arrayBuffer') return function() { return getArrayBuffer(handle); };\n"
+      "        if (prop === 'slice') return function(start, end, contentType) { return getSlice(handle, start, end, contentType); };\n"
+      "        if (prop === Symbol.toStringTag) return 'File';\n"
+      "        if (prop === 'toString') return function() { return '[object File]'; };\n"
+      "        return Reflect.get(target, prop, receiver);\n"
+      "      }\n"
+      "    });\n"
+      "  };\n"
+      "})";
+  JSValue j_factory_fn = JS_Eval(data->context, factory_src, strlen(factory_src), "<file-proxy>", JS_EVAL_TYPE_GLOBAL);
+
+  JSValue j_helpers[7];
+  j_helpers[0] = JS_NewCFunction(data->context, js_ruby_file_name, "__rb_file_name", 1);
+  j_helpers[1] = JS_NewCFunction(data->context, js_ruby_file_size, "__rb_file_size", 1);
+  j_helpers[2] = JS_NewCFunction(data->context, js_ruby_file_type, "__rb_file_type", 1);
+  j_helpers[3] = JS_NewCFunction(data->context, js_ruby_file_last_modified, "__rb_file_last_modified", 1);
+  j_helpers[4] = JS_NewCFunction(data->context, js_ruby_file_text, "__rb_file_text", 1);
+  j_helpers[5] = JS_NewCFunction(data->context, js_ruby_file_array_buffer, "__rb_file_array_buffer", 1);
+  j_helpers[6] = JS_NewCFunction(data->context, js_ruby_file_slice, "__rb_file_slice", 4);
+
+  data->j_file_proxy_creator = JS_Call(data->context, j_factory_fn, JS_UNDEFINED, 7, j_helpers);
+
+  JS_FreeValue(data->context, j_factory_fn);
+  for (int i = 0; i < 7; i++)
+    JS_FreeValue(data->context, j_helpers[i]);
+}
+
+JSValue quickjsrb_file_to_js(JSContext *ctx, VALUE r_file)
+{
+  VMData *data = JS_GetContextOpaque(ctx);
+  VALUE r_object_id = rb_funcall(r_file, rb_intern("object_id"), 0);
+  rb_hash_aset(data->alive_objects, r_object_id, r_file);
+  JSValue j_handle = JS_NewInt64(ctx, NUM2LONG(r_object_id));
+  JSValue j_proxy = JS_Call(ctx, data->j_file_proxy_creator, JS_UNDEFINED, 1, &j_handle);
+  JS_FreeValue(ctx, j_handle);
+  return j_proxy;
+}
+
+static VALUE r_extract_blob_content(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_ab_fn = JS_GetPropertyStr(ctx, j_val, "arrayBuffer");
+  JSValue j_promise = JS_Call(ctx, j_ab_fn, j_val, 0, NULL);
+  JS_FreeValue(ctx, j_ab_fn);
+
+  JSContext *ctx2;
+  while (JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx2) > 0)
+  {
+  }
+
+  VALUE r_content = rb_str_new("", 0);
+  if (JS_PromiseState(ctx, j_promise) == JS_PROMISE_FULFILLED)
+  {
+    JSValue j_result = JS_PromiseResult(ctx, j_promise);
+    size_t buf_len;
+    uint8_t *buf = JS_GetArrayBuffer(ctx, &buf_len, j_result);
+    if (buf)
+      r_content = rb_str_new((const char *)buf, buf_len);
+    JS_FreeValue(ctx, j_result);
+  }
+  JS_FreeValue(ctx, j_promise);
+
+  rb_funcall(r_content, rb_intern("force_encoding"), 1, rb_str_new_cstr("BINARY"));
+  return r_content;
+}
+
+static void r_populate_blob_attrs(JSContext *ctx, JSValue j_val, VALUE r_obj)
+{
+  JSValue j_size = JS_GetPropertyStr(ctx, j_val, "size");
+  int64_t size_val;
+  JS_ToInt64(ctx, &size_val, j_size);
+  rb_iv_set(r_obj, "@size", LONG2NUM(size_val));
+  JS_FreeValue(ctx, j_size);
+
+  JSValue j_type = JS_GetPropertyStr(ctx, j_val, "type");
+  const char *type_str = JS_ToCString(ctx, j_type);
+  rb_iv_set(r_obj, "@type", rb_str_new_cstr(type_str ? type_str : ""));
+  JS_FreeCString(ctx, type_str);
+  JS_FreeValue(ctx, j_type);
+
+  rb_iv_set(r_obj, "@content", r_extract_blob_content(ctx, j_val));
+}
+
+VALUE quickjsrb_try_convert_js_file(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_global = JS_GetGlobalObject(ctx);
+
+  // Check File first (File extends Blob, so instanceof Blob is also true for Files)
+  JSValue j_file_ctor = JS_GetPropertyStr(ctx, j_global, "File");
+  if (!JS_IsUndefined(j_file_ctor) && !JS_IsException(j_file_ctor))
+  {
+    int is_file = JS_IsInstanceOf(ctx, j_val, j_file_ctor);
+    JS_FreeValue(ctx, j_file_ctor);
+    if (is_file > 0)
+    {
+      JS_FreeValue(ctx, j_global);
+
+      VALUE r_quickjs_mod = rb_const_get(rb_cClass, rb_intern("Quickjs"));
+      VALUE r_file = rb_funcall(rb_const_get(r_quickjs_mod, rb_intern("File")), rb_intern("new"), 0);
+      r_populate_blob_attrs(ctx, j_val, r_file);
+
+      JSValue j_name = JS_GetPropertyStr(ctx, j_val, "name");
+      const char *name_str = JS_ToCString(ctx, j_name);
+      rb_iv_set(r_file, "@name", rb_str_new_cstr(name_str ? name_str : ""));
+      JS_FreeCString(ctx, name_str);
+      JS_FreeValue(ctx, j_name);
+
+      JSValue j_last_modified = JS_GetPropertyStr(ctx, j_val, "lastModified");
+      double last_modified_val;
+      JS_ToFloat64(ctx, &last_modified_val, j_last_modified);
+      rb_iv_set(r_file, "@last_modified", DBL2NUM(last_modified_val));
+      JS_FreeValue(ctx, j_last_modified);
+
+      return r_file;
+    }
+  }
+  else
+  {
+    JS_FreeValue(ctx, j_file_ctor);
+  }
+
+  JSValue j_blob_ctor = JS_GetPropertyStr(ctx, j_global, "Blob");
+  JS_FreeValue(ctx, j_global);
+  if (JS_IsUndefined(j_blob_ctor) || JS_IsException(j_blob_ctor))
+  {
+    JS_FreeValue(ctx, j_blob_ctor);
+    return Qnil;
+  }
+
+  int is_blob = JS_IsInstanceOf(ctx, j_val, j_blob_ctor);
+  JS_FreeValue(ctx, j_blob_ctor);
+  if (is_blob <= 0)
+    return Qnil;
+
+  VALUE r_quickjs_mod = rb_const_get(rb_cClass, rb_intern("Quickjs"));
+  VALUE r_blob = rb_funcall(rb_const_get(r_quickjs_mod, rb_intern("Blob")), rb_intern("new"), 0);
+  r_populate_blob_attrs(ctx, j_val, r_blob);
+
+  return r_blob;
+}

data/ext/quickjsrb/quickjsrb_file.h

@@ -0,0 +1,16 @@
+#ifndef QUICKJSRB_FILE_H
+#define QUICKJSRB_FILE_H 1
+
+// This header is included by quickjsrb.c (which already includes quickjsrb.h)
+// and quickjsrb_file.c (which includes quickjsrb.h before this header).
+// So we rely on VMData, JSValue, etc. being already defined.
+
+void quickjsrb_init_file_proxy(VMData *data);
+JSValue quickjsrb_file_to_js(JSContext *ctx, VALUE r_file);
+
+// Check if a JS value is a File instance and convert to Quickjs::File
+// Returns Qnil if not a File
+VALUE quickjsrb_try_convert_js_file(JSContext *ctx, JSValue j_val);
+
+
+#endif /* QUICKJSRB_FILE_H */

data/ext/quickjsrb/vendor/polyfill-encoding.min.js

@@ -0,0 +1 @@
+(function(){var e=class{get encoding(){return`utf-8`}encode(e=``){let t=String(e),n=[];for(let e=0;e<t.length;e++){let r=t.charCodeAt(e);if(r>=55296&&r<=56319&&e+1<t.length){let n=t.charCodeAt(e+1);n>=56320&&n<=57343&&(r=(r-55296)*1024+(n-56320)+65536,e++)}r<=127?n.push(r):r<=2047?n.push(192|r>>6,128|r&63):r<=65535?n.push(224|r>>12,128|r>>6&63,128|r&63):n.push(240|r>>18,128|r>>12&63,128|r>>6&63,128|r&63)}return new Uint8Array(n)}encodeInto(e,t){let n=String(e),r=0,i=0;for(let e=0;e<n.length;e++){let a=n.charCodeAt(e);if(a>=55296&&a<=56319&&e+1<n.length){let o=n.charCodeAt(e+1);if(o>=56320&&o<=57343){if(i+4>t.length)break;a=(a-55296)*1024+(o-56320)+65536,t[i++]=240|a>>18,t[i++]=128|a>>12&63,t[i++]=128|a>>6&63,t[i++]=128|a&63,r+=2,e++;continue}}let o;if(o=a<=127?1:a<=2047?2:3,i+o>t.length)break;o===1?t[i++]=a:o===2?(t[i++]=192|a>>6,t[i++]=128|a&63):(t[i++]=224|a>>12,t[i++]=128|a>>6&63,t[i++]=128|a&63),r++}return{read:r,written:i}}};let t=[`unicode-1-1-utf-8`,`unicode11utf8`,`unicode20utf8`,`utf-8`,`utf8`,`x-unicode20utf8`];function n(e){let n=e.trim().toLowerCase();return t.includes(n)?`utf-8`:null}var r=class{#e;#t;#n;constructor(e=`utf-8`,t={}){let r=n(String(e));if(!r)throw RangeError(`The "${e}" encoding is not supported.`);this.#e=r,this.#t=!!t.fatal,this.#n=!!t.ignoreBOM}get encoding(){return this.#e}get fatal(){return this.#t}get ignoreBOM(){return this.#n}decode(e,t={}){if(e==null)return``;let n;if(e instanceof ArrayBuffer)n=new Uint8Array(e);else if(ArrayBuffer.isView(e))n=new Uint8Array(e.buffer,e.byteOffset,e.byteLength);else throw TypeError(`The provided value is not of type '(ArrayBuffer or ArrayBufferView)'`);let r=0;return!this.#n&&n.length>=3&&n[0]===239&&n[1]===187&&n[2]===191&&(r=3),i(n,r,this.#t)}};function i(e,t,n){let r=``,i=t;for(;i<e.length;){let t=e[i],a,o;if(t<=127)a=t,o=1;else if((t&224)==192){if(i+1>=e.length||(e[i+1]&192)!=128){if(n)throw TypeError(`The encoded data was not valid.`);r+=`�`,i++;continue}a=(t&31)<<6|e[i+1]&63,o=2}else if((t&240)==224){if(i+2>=e.length||(e[i+1]&192)!=128||(e[i+2]&192)!=128){if(n)throw TypeError(`The encoded data was not valid.`);r+=`�`,i++;continue}a=(t&15)<<12|(e[i+1]&63)<<6|e[i+2]&63,o=3}else if((t&248)==240){if(i+3>=e.length||(e[i+1]&192)!=128||(e[i+2]&192)!=128||(e[i+3]&192)!=128){if(n)throw TypeError(`The encoded data was not valid.`);r+=`�`,i++;continue}a=(t&7)<<18|(e[i+1]&63)<<12|(e[i+2]&63)<<6|e[i+3]&63,o=4}else{if(n)throw TypeError(`The encoded data was not valid.`);r+=`�`,i++;continue}a<=65535?r+=String.fromCharCode(a):(a-=65536,r+=String.fromCharCode(55296+(a>>10),56320+(a&1023))),i+=o}return r}globalThis.TextEncoder=e,globalThis.TextDecoder=r})();

data/lib/quickjs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quickjs
-  VERSION = "0.12.0"
+  VERSION = "0.13.0.pre"
 end

data/lib/quickjs.rb

@@ -5,6 +5,14 @@ require_relative "quickjs/version"
 require_relative "quickjs/quickjsrb"
 
 module Quickjs
+  class Blob
+    attr_reader :size, :type, :content
+  end
+
+  class File < Blob
+    attr_reader :name, :last_modified
+  end
+
   def eval_code(code, overwrite_opts = {})
     vm = Quickjs::VM.new(**overwrite_opts)
     res = vm.eval_code(code)

data/polyfills/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.12.0",
+  "version": "0.13.0.pre",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "quickjs-rb-polyfills",
-      "version": "0.12.0",
+      "version": "0.13.0.pre",
       "dependencies": {
         "@formatjs/intl-datetimeformat": "^7.2.1",
         "@formatjs/intl-getcanonicallocales": "^3.2.1",

data/polyfills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.12.0",
+  "version": "0.13.0.pre",
   "private": true,
   "scripts": {
     "build": "rolldown -c rolldown.config.mjs"

data/polyfills/rolldown.config.mjs

@@ -17,4 +17,12 @@ export default [
       minify: true,
     },
   }),
+  defineConfig({
+    input: "src/encoding.js",
+    output: {
+      file: "../ext/quickjsrb/vendor/polyfill-encoding.min.js",
+      format: "iife",
+      minify: true,
+    },
+  }),
 ];

data/polyfills/src/encoding.js

@@ -0,0 +1,231 @@
+// WHATWG TextEncoder/TextDecoder polyfill for QuickJS
+// Spec: https://encoding.spec.whatwg.org/
+
+class TextEncoder {
+  get encoding() {
+    return "utf-8";
+  }
+
+  encode(input = "") {
+    const str = String(input);
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+      let code = str.charCodeAt(i);
+
+      if (code >= 0xd800 && code <= 0xdbff && i + 1 < str.length) {
+        const next = str.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          code = (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
+          i++;
+        }
+      }
+
+      if (code <= 0x7f) {
+        bytes.push(code);
+      } else if (code <= 0x7ff) {
+        bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+      } else if (code <= 0xffff) {
+        bytes.push(
+          0xe0 | (code >> 12),
+          0x80 | ((code >> 6) & 0x3f),
+          0x80 | (code & 0x3f)
+        );
+      } else {
+        bytes.push(
+          0xf0 | (code >> 18),
+          0x80 | ((code >> 12) & 0x3f),
+          0x80 | ((code >> 6) & 0x3f),
+          0x80 | (code & 0x3f)
+        );
+      }
+    }
+    return new Uint8Array(bytes);
+  }
+
+  encodeInto(source, destination) {
+    const str = String(source);
+    let read = 0;
+    let written = 0;
+
+    for (let i = 0; i < str.length; i++) {
+      let code = str.charCodeAt(i);
+
+      if (code >= 0xd800 && code <= 0xdbff && i + 1 < str.length) {
+        const next = str.charCodeAt(i + 1);
+        if (next >= 0xdc00 && next <= 0xdfff) {
+          if (written + 4 > destination.length) break;
+          code = (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
+          destination[written++] = 0xf0 | (code >> 18);
+          destination[written++] = 0x80 | ((code >> 12) & 0x3f);
+          destination[written++] = 0x80 | ((code >> 6) & 0x3f);
+          destination[written++] = 0x80 | (code & 0x3f);
+          read += 2;
+          i++;
+          continue;
+        }
+      }
+
+      let byteCount;
+      if (code <= 0x7f) byteCount = 1;
+      else if (code <= 0x7ff) byteCount = 2;
+      else byteCount = 3;
+
+      if (written + byteCount > destination.length) break;
+
+      if (byteCount === 1) {
+        destination[written++] = code;
+      } else if (byteCount === 2) {
+        destination[written++] = 0xc0 | (code >> 6);
+        destination[written++] = 0x80 | (code & 0x3f);
+      } else {
+        destination[written++] = 0xe0 | (code >> 12);
+        destination[written++] = 0x80 | ((code >> 6) & 0x3f);
+        destination[written++] = 0x80 | (code & 0x3f);
+      }
+      read++;
+    }
+
+    return { read, written };
+  }
+}
+
+const UTF8_LABELS = [
+  "unicode-1-1-utf-8", "unicode11utf8", "unicode20utf8",
+  "utf-8", "utf8", "x-unicode20utf8",
+];
+
+function normalizeEncodingLabel(label) {
+  const normalized = label.trim().toLowerCase();
+  if (UTF8_LABELS.includes(normalized)) return "utf-8";
+  return null;
+}
+
+class TextDecoder {
+  #encoding;
+  #fatal;
+  #ignoreBOM;
+
+  constructor(label = "utf-8", options = {}) {
+    const normalized = normalizeEncodingLabel(String(label));
+    if (!normalized) {
+      throw new RangeError(`The "${label}" encoding is not supported.`);
+    }
+    this.#encoding = normalized;
+    this.#fatal = Boolean(options.fatal);
+    this.#ignoreBOM = Boolean(options.ignoreBOM);
+  }
+
+  get encoding() {
+    return this.#encoding;
+  }
+
+  get fatal() {
+    return this.#fatal;
+  }
+
+  get ignoreBOM() {
+    return this.#ignoreBOM;
+  }
+
+  decode(input, options = {}) {
+    if (input === undefined || input === null) return "";
+
+    let bytes;
+    if (input instanceof ArrayBuffer) {
+      bytes = new Uint8Array(input);
+    } else if (ArrayBuffer.isView(input)) {
+      bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    } else {
+      throw new TypeError(
+        "The provided value is not of type '(ArrayBuffer or ArrayBufferView)'"
+      );
+    }
+
+    let start = 0;
+    if (
+      !this.#ignoreBOM &&
+      bytes.length >= 3 &&
+      bytes[0] === 0xef &&
+      bytes[1] === 0xbb &&
+      bytes[2] === 0xbf
+    ) {
+      start = 3;
+    }
+
+    return decodeUTF8(bytes, start, this.#fatal);
+  }
+}
+
+function decodeUTF8(bytes, start, fatal) {
+  let str = "";
+  let i = start;
+  while (i < bytes.length) {
+    const b = bytes[i];
+    let code, byteLen;
+
+    if (b <= 0x7f) {
+      code = b;
+      byteLen = 1;
+    } else if ((b & 0xe0) === 0xc0) {
+      if (i + 1 >= bytes.length || (bytes[i + 1] & 0xc0) !== 0x80) {
+        if (fatal) throw new TypeError("The encoded data was not valid.");
+        str += "\ufffd";
+        i++;
+        continue;
+      }
+      code = ((b & 0x1f) << 6) | (bytes[i + 1] & 0x3f);
+      byteLen = 2;
+    } else if ((b & 0xf0) === 0xe0) {
+      if (
+        i + 2 >= bytes.length ||
+        (bytes[i + 1] & 0xc0) !== 0x80 ||
+        (bytes[i + 2] & 0xc0) !== 0x80
+      ) {
+        if (fatal) throw new TypeError("The encoded data was not valid.");
+        str += "\ufffd";
+        i++;
+        continue;
+      }
+      code =
+        ((b & 0x0f) << 12) |
+        ((bytes[i + 1] & 0x3f) << 6) |
+        (bytes[i + 2] & 0x3f);
+      byteLen = 3;
+    } else if ((b & 0xf8) === 0xf0) {
+      if (
+        i + 3 >= bytes.length ||
+        (bytes[i + 1] & 0xc0) !== 0x80 ||
+        (bytes[i + 2] & 0xc0) !== 0x80 ||
+        (bytes[i + 3] & 0xc0) !== 0x80
+      ) {
+        if (fatal) throw new TypeError("The encoded data was not valid.");
+        str += "\ufffd";
+        i++;
+        continue;
+      }
+      code =
+        ((b & 0x07) << 18) |
+        ((bytes[i + 1] & 0x3f) << 12) |
+        ((bytes[i + 2] & 0x3f) << 6) |
+        (bytes[i + 3] & 0x3f);
+      byteLen = 4;
+    } else {
+      if (fatal) throw new TypeError("The encoded data was not valid.");
+      str += "\ufffd";
+      i++;
+      continue;
+    }
+
+    if (code <= 0xffff) {
+      str += String.fromCharCode(code);
+    } else {
+      code -= 0x10000;
+      str += String.fromCharCode(0xd800 + (code >> 10), 0xdc00 + (code & 0x3ff));
+    }
+    i += byteLen;
+  }
+  return str;
+}
+
+globalThis.TextEncoder = TextEncoder;
+globalThis.TextDecoder = TextDecoder;

data/sig/quickjs.rbs

@@ -1,4 +1,72 @@
 module Quickjs
   VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+  MODULE_STD: Symbol
+  MODULE_OS: Symbol
+  FEATURE_TIMEOUT: Symbol
+  POLYFILL_INTL: Symbol
+  POLYFILL_FILE: Symbol
+  POLYFILL_HTML_BASE64: Symbol
+
+  def self.eval_code: (String code, ?Hash[Symbol, untyped] overwrite_opts) -> untyped
+
+  class Value
+    UNDEFINED: Symbol
+    NAN: Symbol
+  end
+
+  class VM
+    def initialize: (?features: Array[Symbol], ?memory_limit: Integer, ?max_stack_size: Integer, ?timeout_msec: Integer) -> void
+
+    def eval_code: (String code) -> untyped
+
+    def define_function: (String | Symbol name, *Symbol flags) { (*untyped) -> untyped } -> Symbol
+
+    def import: (String | Array[String] | Hash[Symbol, String] imported, from: String, ?code_to_expose: String?) -> true
+
+    def logs: () -> Array[Log]
+
+    class Log
+      attr_reader severity: Symbol
+
+      def raw: () -> Array[untyped]
+
+      def to_s: () -> String
+
+      def inspect: () -> String
+    end
+  end
+
+  class RuntimeError < ::RuntimeError
+    def initialize: (String message, String? js_name) -> void
+
+    attr_reader js_name: String?
+  end
+
+  class SyntaxError < RuntimeError
+  end
+
+  class TypeError < RuntimeError
+  end
+
+  class ReferenceError < RuntimeError
+  end
+
+  class RangeError < RuntimeError
+  end
+
+  class EvalError < RuntimeError
+  end
+
+  class URIError < RuntimeError
+  end
+
+  class AggregateError < RuntimeError
+  end
+
+  class InterruptedError < RuntimeError
+  end
+
+  class NoAwaitError < RuntimeError
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0.pre
 platform: ruby
 authors:
 - hmsk
@@ -78,6 +78,9 @@ files:
 - ext/quickjsrb/quickjs/unicode_gen_def.h
 - ext/quickjsrb/quickjsrb.c
 - ext/quickjsrb/quickjsrb.h
+- ext/quickjsrb/quickjsrb_file.c
+- ext/quickjsrb/quickjsrb_file.h
+- ext/quickjsrb/vendor/polyfill-encoding.min.js
 - ext/quickjsrb/vendor/polyfill-file.min.js
 - ext/quickjsrb/vendor/polyfill-intl-en.min.js
 - lib/quickjs.rb
@@ -85,6 +88,7 @@ files:
 - polyfills/package-lock.json
 - polyfills/package.json
 - polyfills/rolldown.config.mjs
+- polyfills/src/encoding.js
 - polyfills/src/file.js
 - polyfills/src/intl-en.js
 - sig/quickjs.rbs