impl IsolateHandle {   } } +/// v8::Locker is a scoped lock object. While it's active, i.e. between its+/// construction and destruction, the current thread is allowed to use the locked+/// isolate. V8 guarantees that an isolate can be locked by at most one thread at+/// any time. In other words, the scope of a v8::Locker is a critical section.+///+/// rusty_v8 note: The Locker lifecycle is managed while a LockedIsolate is borrowed from a SharedIsolate.+#[derive(Debug)]+#[repr(C)]+pub struct Locker {+  has_lock: bool,+  top_level: bool,+  isolate: *mut Isolate,+}++impl Locker {+  /// Creates a locker using the provided Isolate pointer.+  /// Once created, the Locker is considered entered until dropped.+  pub(crate) unsafe fn new(isolate: *mut Isolate) -> Self {+    let mut locker = Self {+      has_lock: false,+      top_level: true,+      isolate,+    };+    v8__Locker__CONSTRUCT(&mut locker, isolate);+    locker+  }+}++impl Drop for Locker {+  fn drop(&mut self) {+    unsafe {+      v8__Locker__DESTRUCT(self);+    }+  }+}++/// The Unlocker object is intended for use in a long-running callback from V8, where you want to release the V8 lock for other threads to use.+/// The v8::Locker is a recursive lock, i.e. you can lock more than once in a given thread.+/// This can be useful if you have code that can be called either from code that holds the lock or from code that does not.+/// The Unlocker is not recursive so you can not have several Unlockers on the stack at once, and you can not use an Unlocker in a thread that is not inside a Locker's scope.+/// An unlocker will unlock several lockers if it has to and reinstate the correct depth of locking on its destruction+///+/// rusty_v8 note: By the nature of Rust's rules, the Unlocker is an inherently unsafe feature to use.+#[derive(Debug)]+#[repr(C)]+pub struct Unlocker<'a> {+  cxx_isolate: *mut Isolate,+  _lifetime: PhantomData<&'a ()>,+}++impl<'a> Unlocker<'a> {+  pub(crate) unsafe fn new(cxx_isolate: *mut Isolate) -> Self {+    let mut locker = Self {+      cxx_isolate,+      _lifetime: PhantomData::default(),+    };+    // the unlocker will exit any scopes (including ContextScopes), so we must do the same.+    (*cxx_isolate).exit();+    ScopeData::get_root_mut(&mut *cxx_isolate);+    // construct V8's native Unlocker instance+    v8__Unlocker__CONSTRUCT(&mut locker, cxx_isolate);+    locker+  }+}++impl<'a> Drop for Unlocker<'a> {+  fn drop(&mut self) {+    unsafe {+      v8__Unlocker__DESTRUCT(self);+      // restore the entered isolate+      (*self.cxx_isolate).enter();+    }+  }+}++/// An entered isolate within a Locker's scope. Created when a SharedIsolate is borrowed.+/// When dropped, the isolate is exited and the locker is deconstructed.+/// This is similar to V8's Isolate::Scope, but a Locker is implicitly entered for the life of a LockedIsolate.+pub struct LockedIsolate<'a> {+  cxx_isolate: &'a mut NonNull<Isolate>,+  locker: Locker,+}++impl<'a> LockedIsolate<'a> {+  /// Creates a new Locker scope and enters the isolate within, returning a scoped LockedIsolate.+  pub(crate) fn new(cxx_isolate: &'a mut NonNull<Isolate>) -> Self {+    let locker = unsafe {+      let locker = Locker::new(cxx_isolate.as_ptr());+      cxx_isolate.as_mut().enter();+      locker+    };+    Self {+      cxx_isolate,+      locker,+    }+  }++  /// Borrows a new Unlocker, temporarily releasing V8's lock on the current thread.+  /// The Unlocker exits the LockedIsolate and signals to V8 that the isolates locked to this thread may be used elsewhere.+  /// When the guard is dropped, the underlying Unlocker is destroyed and the isolate is re-entered.+  ///+  /// This function is marked unsafe because Rust's rules allow you to interact with other LockedIsolates while an Unlocker is active, which is not allowed.+  /// To make up for this limitation, the embedder should instead drop all active LockedIsolate references before doing long-lasting blocking work, re-entering afterwards.+  pub unsafe fn unlock(&mut self) -> Unlocker<'_> {+    Unlocker::new(self.cxx_isolate.as_mut())+  }+}++impl<'a> Deref for LockedIsolate<'a> {+  type Target = Isolate;+  fn deref(&self) -> &Self::Target {+    unsafe { self.cxx_isolate.as_ref() }+  }+}++impl<'a> DerefMut for LockedIsolate<'a> {+  fn deref_mut(&mut self) -> &mut Self::Target {+    unsafe { self.cxx_isolate.as_mut() }+  }+}++impl<'a> AsMut<Isolate> for LockedIsolate<'a> {+  fn as_mut(&mut self) -> &mut Isolate {+    self+  }+}++impl<'a> Drop for LockedIsolate<'a> {+  fn drop(&mut self) {+    // When a Locker is dropped, v8 automatically exits any active scopes.+    // Resetting to the root scope exits any zombie scopes so that the next LockedIsolate can cleanly re-enter a context.+    ScopeData::get_root_mut(self);+    unsafe { self.exit() }+  }+}++/// A reference to an Isolate that may be sent between threads and borrowed with a Locker before entering V8.+/// May be created by calling Isolate::new_shared(params), or converted via SharedIsolate::from(OwnedIsolate).+#[derive(Debug)]+pub struct SharedIsolate {+  cxx_isolate: NonNull<Isolate>,+  skip_disposal: bool,+}++// Because we only allow mutability through a borrowed LockedIsolate scope, we can safely send SharedIsolate across threads.+unsafe impl Send for SharedIsolate {}++impl SharedIsolate {+  /// Creates a new shared Isolate from a raw pointer.+  pub(crate) fn new(cxx_isolate: *mut Isolate) -> Self {+    Self {+      cxx_isolate: NonNull::new(cxx_isolate).unwrap(),+      skip_disposal: false,+    }+  }++  /// Borrows a LockedIsolate from the shared isolate reference.+  /// A Locker is created for the lifetime of the LockedIsolate, and the native isolate is entered.+  /// When the LockedIsolate is dropped, the isolate is and any entered scopes are exited, and the Locker is destroyed.+  pub fn lock(&mut self) -> LockedIsolate<'_> {+    LockedIsolate::new(&mut self.cxx_isolate)+  }+}++impl Deref for SharedIsolate {+  type Target = Isolate;++  fn deref(&self) -> &Self::Target {+    unsafe { self.cxx_isolate.as_ref() }+  }+}++impl From<OwnedIsolate> for SharedIsolate {+  /// Performs a conversion from an OwnedIsolate to a SharedIsolate.+  /// As the OwnedIsolate is dropped during conversion, active scopes and the native isolate are exited.+  fn from(mut isolate: OwnedIsolate) -> Self {+    // marking this as true will skip disposal of the native isolate, which is handed off to the SharedIsolate.+    isolate.skip_disposal = true;+    SharedIsolate::new(isolate.cxx_isolate.as_ptr())

 impl<T> Global<T> {   } } +unsafe impl<T> Send for Global<T> {}

 impl IsolateHandle {   } } +/// v8::Locker is a scoped lock object. While it's active, i.e. between its+/// construction and destruction, the current thread is allowed to use the locked+/// isolate. V8 guarantees that an isolate can be locked by at most one thread at+/// any time. In other words, the scope of a v8::Locker is a critical section.+///+/// rusty_v8 note: The Locker lifecycle is managed while a LockedIsolate is borrowed from a SharedIsolate.+#[derive(Debug)]+#[repr(C)]+pub struct Locker {+  has_lock: bool,+  top_level: bool,+  isolate: *mut Isolate,+}++impl Locker {+  /// Creates a locker using the provided Isolate pointer.+  /// Once created, the Locker is considered entered until dropped.+  pub(crate) unsafe fn new(isolate: *mut Isolate) -> Self {+    let mut locker = Self {+      has_lock: false,+      top_level: true,+      isolate,+    };+    v8__Locker__CONSTRUCT(&mut locker, isolate);+    locker+  }+}++impl Drop for Locker {+  fn drop(&mut self) {+    unsafe {+      v8__Locker__DESTRUCT(self);+    }+  }+}++/// The Unlocker object is intended for use in a long-running callback from V8, where you want to release the V8 lock for other threads to use.+/// The v8::Locker is a recursive lock, i.e. you can lock more than once in a given thread.+/// This can be useful if you have code that can be called either from code that holds the lock or from code that does not.+/// The Unlocker is not recursive so you can not have several Unlockers on the stack at once, and you can not use an Unlocker in a thread that is not inside a Locker's scope.+/// An unlocker will unlock several lockers if it has to and reinstate the correct depth of locking on its destruction

 Deno.test("file_server should show .. if it makes sense", async function (): Pro     await killFileServer();   } });++Deno.test(+  "file_server should download first byte of `hello.html` file",+  async () => {+    await startFileServer();+    try {+      const headers = {+        "range": "bytes=0-0",+      };+      const res = await fetch(+        "http://localhost:4507/testdata/test%20file.txt",+        { headers },+      );+      const text = await res.text();+      console.log(text);+      assertEquals(text, "L");+    } finally {+      await killFileServer();+    }+  },+);++Deno.test(+  "file_server sets `content-range` header for range request responses",+  async () => {+    await startFileServer();+    try {+      const headers = {+        "range": "bytes=0-100",+      };+      const res = await fetch(+        "http://localhost:4507/testdata/test%20file.txt",+        { headers },+      );+      const contentLength = await getTestFileSize();+      assertEquals(+        res.headers.get("content-range"),+        `bytes 0-100/${contentLength}`,+      );++      await res.text(); // Consuming the body so that the test doesn't leak resources+    } finally {+      await killFileServer();+    }+  },+);++const getTestFileSize = async () => {+  const fileInfo = await getTestFileStat();+  return fileInfo.size;+};++const getTestFileStat = async (): Promise<Deno.FileInfo> => {+  const fsPath = join(testdataDir, "test file.txt");+  const fileInfo = await Deno.stat(fsPath);++  return fileInfo;+};++const getTestFileEtag = async () => {+  const fileInfo = await getTestFileStat();++  if (fileInfo.mtime instanceof Date) {+    const lastModified = new Date(fileInfo.mtime);+    const simpleEtag = await createEtagHash(+      `${lastModified.toJSON()}${fileInfo.size}`,+    );+    return simpleEtag;+  } else {+    return "";+  }+};++const createEtagHash = async (message: string) => {+  // see: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest+  const hashType = "SHA-1"; // Faster, and this isn't a security senitive cryptographic use case+  const msgUint8 = new TextEncoder().encode(message);+  const hashBuffer = await crypto.subtle.digest(hashType, msgUint8);+  const hashArray = Array.from(new Uint8Array(hashBuffer));+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join(+    "",+  );+  return hashHex;+};

 Deno.test("file_server should show .. if it makes sense", async function (): Pro     await killFileServer();   } });++Deno.test(+  "file_server should download first byte of `hello.html` file",+  async () => {+    await startFileServer();+    try {+      const headers = {+        "range": "bytes=0-0",+      };+      const res = await fetch(+        "http://localhost:4507/testdata/test%20file.txt",+        { headers },+      );+      const text = await res.text();+      console.log(text);+      assertEquals(text, "L");+    } finally {+      await killFileServer();+    }+  },+);++Deno.test(+  "file_server sets `content-range` header for range request responses",+  async () => {+    await startFileServer();+    try {+      const headers = {+        "range": "bytes=0-100",+      };+      const res = await fetch(+        "http://localhost:4507/testdata/test%20file.txt",+        { headers },+      );+      const contentLength = await getTestFileSize();+      assertEquals(+        res.headers.get("content-range"),+        `bytes 0-100/${contentLength}`,+      );++      await res.text(); // Consuming the body so that the test doesn't leak resources+    } finally {+      await killFileServer();+    }+  },+);++const getTestFileSize = async () => {+  const fileInfo = await getTestFileStat();+  return fileInfo.size;+};++const getTestFileStat = async (): Promise<Deno.FileInfo> => {+  const fsPath = join(testdataDir, "test file.txt");+  const fileInfo = await Deno.stat(fsPath);++  return fileInfo;+};++const getTestFileEtag = async () => {+  const fileInfo = await getTestFileStat();++  if (fileInfo.mtime instanceof Date) {+    const lastModified = new Date(fileInfo.mtime);+    const simpleEtag = await createEtagHash(+      `${lastModified.toJSON()}${fileInfo.size}`,+    );+    return simpleEtag;+  } else {+    return "";+  }+};++const createEtagHash = async (message: string) => {+  // see: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest+  const hashType = "SHA-1"; // Faster, and this isn't a security senitive cryptographic use case+  const msgUint8 = new TextEncoder().encode(message);+  const hashBuffer = await crypto.subtle.digest(hashType, msgUint8);+  const hashArray = Array.from(new Uint8Array(hashBuffer));+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join(+    "",+  );+  return hashHex;+};