impl PartialEq<String> for ModuleSpecifier {     &self.to_string() == other   } }++#[cfg(test)]+mod tests {+  use super::*;++  #[test]+  fn test_absolute() {+    if cfg!(target_os = "windows") {+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd(r"C:/deno/tests/006_url_imports.ts")+          .unwrap()+          .to_string(),+        "file:///C:/deno/tests/006_url_imports.ts",+      );+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd(r"C:\deno\tests\006_url_imports.ts")+          .unwrap()+          .to_string(),+        "file:///C:/deno/tests/006_url_imports.ts",+      );+    } else {+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd("/deno/tests/006_url_imports.ts")+          .unwrap()+          .to_string(),+        "file:///deno/tests/006_url_imports.ts",+      );+    }+  }++  #[test]+  fn test_relative() {+    // Assuming cwd is the deno repo root.+    let cwd = std::env::current_dir().unwrap();+    let cwd_string = String::from(cwd.to_str().unwrap()) + "/";+    let expected_url = format!(+      "file://{}{}",+      cwd_string.as_str(),+      "tests/006_url_imports.ts"+    ).replace("\\", "/");++    if cfg!(target_os = "windows") {+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd(r"/tests/006_url_imports.ts")

 impl PartialEq<String> for ModuleSpecifier {     &self.to_string() == other   } }++#[cfg(test)]+mod tests {+  use super::*;++  #[test]+  fn test_absolute() {+    if cfg!(target_os = "windows") {+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd(r"C:/deno/tests/006_url_imports.ts")+          .unwrap()+          .to_string(),+        "file:///C:/deno/tests/006_url_imports.ts",+      );+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd(r"C:\deno\tests\006_url_imports.ts")+          .unwrap()+          .to_string(),+        "file:///C:/deno/tests/006_url_imports.ts",+      );+    } else {+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd("/deno/tests/006_url_imports.ts")+          .unwrap()+          .to_string(),+        "file:///deno/tests/006_url_imports.ts",+      );+    }+  }++  #[test]+  fn test_relative() {+    // Assuming cwd is the deno repo root.+    let cwd = std::env::current_dir().unwrap();+    let cwd_string = String::from(cwd.to_str().unwrap()) + "/";+    let expected_url = format!(+      "file://{}{}",+      cwd_string.as_str(),+      "tests/006_url_imports.ts"+    ).replace("\\", "/");++    if cfg!(target_os = "windows") {+      assert_eq!(+        ModuleSpecifier::resolve_from_cwd(r"/tests/006_url_imports.ts")

 To change installation directory use -d/--dir flag           // this is a fake subcommand - it's used in conjunction with           // AppSettings:AllowExternalSubcommand to treat it as an           // entry point script-          SubCommand::with_name("<script>").about("Script URL"),+          SubCommand::with_name("[SCRIPT]").about("Script URL"),         ),     ).subcommand(+      SubCommand::with_name("completions")+        .settings(&[+          AppSettings::DisableHelpSubcommand,

 To change installation directory use -d/--dir flag           // this is a fake subcommand - it's used in conjunction with           // AppSettings:AllowExternalSubcommand to treat it as an           // entry point script-          SubCommand::with_name("<script>").about("Script URL"),+          SubCommand::with_name("[SCRIPT]").about("Script URL"),         ),     ).subcommand(+      SubCommand::with_name("completions")+        .settings(&[+          AppSettings::DisableHelpSubcommand,

 pub fn flags_from_vec(       argv.extend(vec![source_file.to_string(), out_file.to_string()]);       DenoSubcommand::Bundle     }+    ("completions", Some(completions_match)) => {+      let shell: &str = completions_match.value_of("shell").unwrap();+      create_cli_app().gen_completions_to(+        "deno",+        Shell::from_str(shell).unwrap(),+        &mut std::io::stdout(),+      );+      std::process::exit(0);

 const { openPlugin, pluginFilename, env } = Deno;  const plugin = openPlugin(-  env().DENO_BUILD_PATH + "/" + pluginFilename("test_plugin")+  env().DENO_BUILD_PATH + "/rust_crates/" + pluginFilename("test_plugin")

 script: - ./tools/lint.py - ./tools/test_format.py - ./tools/build.py -C target/release-- DENO_BUILD_MODE=release ./tools/test.py+- cargo build -p test_plugin --release --locked

 script: - ./tools/lint.py - ./tools/test_format.py - ./tools/build.py -C target/release-- DENO_BUILD_MODE=release ./tools/test.py+- cargo build -p test_plugin --release --locked

 install:   # Clone the third_party submodule.   - ps: |-       try {-        Exec { & git submodule update --init --force --depth 1 }+        Exec { & git submodule update --init --force --recursive --depth 2 }       } catch {         # Git will fail if the `third_party` directory was restored from cache,         # but the `.git/modules` directory wasn't. Rebuild it from scratch.         Delete-Tree $env:DENO_THIRD_PARTY_PATH-        Exec -NoNewLines { & git submodule update --init --force --depth 1 }+        Exec -NoNewLines { & git submodule update --init --force --recursive --depth 2 }

+const { openPlugin, pluginFilename, env } = Deno;++const plugin = openPlugin(+  env().DENO_BUILD_PATH + "/" + pluginFilename("test_plugin")+);+const testOp = plugin.loadOp("test_op");++interface TestOptions {+  // eslint-disable-next-line @typescript-eslint/no-explicit-any+  data: any;+  // eslint-disable-next-line @typescript-eslint/no-explicit-any+  zeroCopyData: any;+}++interface TestResponse {+  data: Uint8Array;+}++const textEncoder = new TextEncoder();++// eslint-disable-next-line @typescript-eslint/no-explicit-any+function encodeTestOp(args: any): Uint8Array {+  return textEncoder.encode(JSON.stringify(args));+}++const textDecoder = new TextDecoder();++// eslint-disable-next-line @typescript-eslint/no-explicit-any+function decodeTestOp(data: Uint8Array): any {

 pub fn flags_from_vec(       argv.extend(vec![source_file.to_string(), out_file.to_string()]);       DenoSubcommand::Bundle     }+    ("completions", Some(_completions_match)) => {+      create_cli_app().gen_completions_to(+        "deno",+        Shell::Bash,+        &mut std::io::stdout(),+      );+      std::process::exit(1);

+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.+// Some of the code here is adapted directly from V8 and licensed under a BSD+// style license available here: https://github.com/v8/v8/blob/24886f2d1c565287d33d71e4109a53bf0b54b75c/LICENSE.v8++import * as msg from "gen/cli/msg_generated";+import * as flatbuffers from "./flatbuffers";+import * as dispatch from "./dispatch";+import { assert } from "./util";++export interface Location {+  /** The full url for the module, e.g. `file://some/file.ts` or+   * `https://some/file.ts`. */+  filename: string;++  /** The line number in the file.  It is assumed to be 1-indexed. */+  line: number;++  /** The column number in the file.  It is assumed to be 1-indexed. */+  column: number;+}++function req(+  filename: string,+  line: number,+  column: number+): [flatbuffers.Builder, msg.Any.ApplySourceMap, flatbuffers.Offset] {+  const builder = flatbuffers.createBuilder();+  const filename_ = builder.createString(filename);+  const inner = msg.ApplySourceMap.createApplySourceMap(+    builder,+    filename_,+    // On this side, line/column are 1 based, but in the source maps, they are+    // 0 based, so we have to convert back and forth+    line - 1,+    column - 1+  );+  return [builder, msg.Any.ApplySourceMap, inner];+}++function res(baseRes: msg.Base | null): Location {+  assert(baseRes != null);+  assert(baseRes!.innerType() === msg.Any.ApplySourceMap);+  const res = new msg.ApplySourceMap();+  assert(baseRes!.inner(res) != null);+  const filename = res.filename()!;+  assert(filename != null);+  return {+    filename,+    // On this side, line/column are 1 based, but in the source maps, they are+    // 0 based, so we have to convert back and forth+    line: res.line() + 1,+    column: res.column() + 1+  };+}++/** Given a current location in a module, lookup the source location and+ * return it.+ *+ * When Deno transpiles code, it keep source maps of the transpiled code.  This+ * function can be used to lookup the original location.  This is automatically+ * done when accessing the `.stack` of an error, or when an uncaught error is+ * logged.  This function can be used to perform the lookup for creating better+ * error handling.+ *+ * **Note:** `line` and `column` are 1 indexed, which matches display+ * expectations, but is not typical of most index numbers in Deno.+ *+ * An example:+ *+ *       const orig = Deno.apply({+ *         location: "file://my/module.ts",+ *         line: 5,+ *         column: 15+ *       });+ *       console.log(`${orig.filename}:${orig.line}:${orig.column}`);+ *+ */+export function applySourceMap(location: Location): Location {+  const { filename, line, column } = location;+  return res(dispatch.sendSync(...req(filename, line, column)));+}++/** Mutate the call site so that it returns the location, instead of its+ * original location.+ */+function patchCallSite(callSite: CallSite, location: Location): CallSite {+  return {+    getThis(): unknown {+      return callSite.getThis();+    },+    getTypeName(): string {+      return callSite.getTypeName();+    },+    getFunction(): Function {+      return callSite.getFunction();+    },+    getFunctionName(): string {+      return callSite.getFunctionName();+    },+    getMethodName(): string {+      return callSite.getMethodName();+    },+    getFileName(): string {+      return location.filename;+    },+    getLineNumber(): number {+      return location.line;+    },+    getColumnNumber(): number {+      return location.column;+    },+    getEvalOrigin(): string | null {+      return callSite.getEvalOrigin();+    },+    isToplevel(): boolean {+      return callSite.isToplevel();+    },+    isEval(): boolean {+      return callSite.isEval();+    },+    isNative(): boolean {+      return callSite.isNative();+    },+    isConstructor(): boolean {+      return callSite.isConstructor();+    },+    isAsync(): boolean {+      return callSite.isAsync();+    },+    isPromiseAll(): boolean {+      return callSite.isPromiseAll();+    },+    getPromiseIndex(): number | null {+      return callSite.getPromiseIndex();+    }+  };+}++/** Return a string representations of a CallSite's method call name+ *+ * This is adapted directly from V8.+ */+function getMethodCall(callSite: CallSite): string {+  let result = "";++  const typeName = callSite.getTypeName();+  const methodName = callSite.getMethodName();+  const functionName = callSite.getFunctionName();++  if (functionName) {+    if (typeName) {+      const startsWithTypeName = functionName.startsWith(typeName);+      if (!startsWithTypeName) {+        result += `${typeName}.`;+      }+    }+    result += functionName;++    if (methodName) {+      if (!functionName.endsWith(methodName)) {+        result += ` [as ${methodName}]`;+      }+    }+  } else {+    if (typeName) {+      result += `${typeName}.`;+    }+    if (methodName) {+      result += methodName;+    } else {+      result += "<anonymous>";+    }+  }++  return result;+}++/** Return a string representations of a CallSite's file location+ *+ * This is adapted directly from V8.+ */+function getFileLocation(callSite: CallSite): string {+  if (callSite.isNative()) {+    return "native";+  }++  let result = "";++  const fileName = callSite.getFileName();+  if (!fileName && callSite.isEval()) {+    const evalOrigin = callSite.getEvalOrigin();+    assert(evalOrigin != null);+    result += `${evalOrigin}, `;+  }++  if (fileName) {+    result += fileName;+  } else {+    result += "<anonymous>";+  }++  const lineNumber = callSite.getLineNumber();+  if (lineNumber != null) {+    result += `:${lineNumber}`;++    const columnNumber = callSite.getColumnNumber();+    if (columnNumber != null) {+      result += `:${columnNumber}`;+    }+  }++  return result;+}++/** Convert a CallSite to a string.+ *+ * This is adapted directly from V8.+ */+function callSiteToString(callSite: CallSite): string {+  let result = "";+  const functionName = callSite.getFunctionName();++  const isTopLevel = callSite.isToplevel();+  const isAsync = callSite.isAsync();+  const isPromiseAll = callSite.isPromiseAll();+  const isConstructor = callSite.isConstructor();+  const isMethodCall = !(isTopLevel || isConstructor);++  if (isAsync) {+    result += "async ";+  }+  if (isPromiseAll) {+    result += `Promise.all (index ${callSite.getPromiseIndex})`;+    return result;+  }+  if (isMethodCall) {+    result += getMethodCall(callSite);+  } else if (isConstructor) {+    result += "new ";+    if (functionName) {+      result += functionName;+    } else {+      result += "<anonymous>";+    }+  } else if (functionName) {+    result += functionName;+  } else {+    result += getFileLocation(callSite);+    return result;+  }++  result += ` (${getFileLocation(callSite)})`;+  return result;+}++/** A replacement for the default stack trace preparer which will op into Rust+ * to apply source maps to individual sites+ */+function prepareStackTrace(+  error: Error,+  structuredStackTrace: CallSite[]+): string {+  return (+    `${error.name}: ${error.message}\n` ++    structuredStackTrace+      .map(+        (callSite): CallSite => {+          const filename = callSite.getFileName();+          const line = callSite.getLineNumber();+          const column = callSite.getColumnNumber();+          if (filename && line != null && column != null) {+            return patchCallSite(+              callSite,+              applySourceMap({+                filename,+                line,+                column+              })+            );+          }+          return callSite;+        }+      )+      .map((callSite): string => `    at ${callSiteToString(callSite)}`)+      .join("\n")+  );+}++/** Sets the `prepareStackTrace` method on the Error constructor which will+ * op into Rust to remap source code for caught errors where the `.stack` is+ * being accessed.+ */+// @internal+export function setPrepareStackTrace(ErrorConstructor: typeof Error): void {

+use crate::isolate::Op;+use crate::libdeno::PinnedBuf;+use std::fmt;+use std::io;++pub type PluginResult<T> = std::result::Result<T, PluginError>;++#[derive(Debug)]+pub struct PluginError {+  repr: Repr,+}++#[derive(Debug)]+enum Repr {+  Simple(String),+  IoErr(io::Error),+}++pub fn new_plugin_error(msg: String) -> PluginError {+  PluginError {+    repr: Repr::Simple(msg),+  }+}++impl fmt::Display for PluginError {+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+    match self.repr {+      Repr::Simple(ref err_str) => f.pad(err_str),+      Repr::IoErr(ref err) => err.fmt(f),+    }+  }+}++impl std::error::Error for PluginError {+  fn description(&self) -> &str {+    match self.repr {+      Repr::Simple(ref msg) => msg.as_str(),+      Repr::IoErr(ref err) => err.description(),+    }+  }++  fn cause(&self) -> Option<&dyn std::error::Error> {+    match self.repr {+      Repr::Simple(ref _msg) => None,+      Repr::IoErr(ref err) => Some(err),+    }+  }+}++impl From<io::Error> for PluginError {+  #[inline]+  fn from(err: io::Error) -> Self {+    Self {+      repr: Repr::IoErr(err),+    }+  }+}++/// Base result type for a plugin op represents either a Sync or Async value+pub type PluginOp = Op<PluginError>;++/// Complete return type for a plugin op including Sync errors+pub type PluginOpResult = PluginResult<PluginOp>;++/// Funciton type for plugin ops+pub type PluginDispatchFn =+  fn(is_sync: bool, data: &[u8], zero_copy: Option<PinnedBuf>)+    -> PluginOpResult;

+use crate::isolate::Op;+use crate::libdeno::PinnedBuf;+use std::fmt;+use std::io;++pub type PluginResult<T> = std::result::Result<T, PluginError>;++#[derive(Debug)]+pub struct PluginError {+  repr: Repr,+}++#[derive(Debug)]+enum Repr {+  Simple(String),+  IoErr(io::Error),+}++pub fn new_plugin_error(msg: String) -> PluginError {+  PluginError {+    repr: Repr::Simple(msg),+  }+}++impl fmt::Display for PluginError {+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+    match self.repr {+      Repr::Simple(ref err_str) => f.pad(err_str),+      Repr::IoErr(ref err) => err.fmt(f),+    }+  }+}++impl std::error::Error for PluginError {+  fn description(&self) -> &str {+    match self.repr {+      Repr::Simple(ref msg) => msg.as_str(),+      Repr::IoErr(ref err) => err.description(),+    }+  }++  fn cause(&self) -> Option<&dyn std::error::Error> {+    match self.repr {+      Repr::Simple(ref _msg) => None,+      Repr::IoErr(ref err) => Some(err),+    }+  }+}++impl From<io::Error> for PluginError {+  #[inline]+  fn from(err: io::Error) -> Self {+    Self {+      repr: Repr::IoErr(err),+    }+  }+}++/// Base result type for a plugin op represents either a Sync or Async value+pub type PluginOp = Op<PluginError>;++/// Complete return type for a plugin op including Sync errors+pub type PluginOpResult = PluginResult<PluginOp>;++/// Funciton type for plugin ops+pub type PluginDispatchFn =+  fn(is_sync: bool, data: &[u8], zero_copy: Option<PinnedBuf>)+    -> PluginOpResult;

+use crate::isolate::Op;+use crate::libdeno::PinnedBuf;+use std::fmt;+use std::io;++pub type PluginResult<T> = std::result::Result<T, PluginError>;++#[derive(Debug)]+pub struct PluginError {+  repr: Repr,+}++#[derive(Debug)]+enum Repr {+  Simple(String),+  IoErr(io::Error),+}++pub fn new_plugin_error(msg: String) -> PluginError {+  PluginError {+    repr: Repr::Simple(msg),+  }+}++impl fmt::Display for PluginError {+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+    match self.repr {+      Repr::Simple(ref err_str) => f.pad(err_str),+      Repr::IoErr(ref err) => err.fmt(f),+    }+  }+}++impl std::error::Error for PluginError {+  fn description(&self) -> &str {+    match self.repr {+      Repr::Simple(ref msg) => msg.as_str(),+      Repr::IoErr(ref err) => err.description(),+    }+  }++  fn cause(&self) -> Option<&dyn std::error::Error> {+    match self.repr {+      Repr::Simple(ref _msg) => None,+      Repr::IoErr(ref err) => Some(err),+    }+  }+}++impl From<io::Error> for PluginError {+  #[inline]+  fn from(err: io::Error) -> Self {+    Self {+      repr: Repr::IoErr(err),+    }+  }+}++/// Base result type for a plugin op represents either a Sync or Async value+pub type PluginOp = Op<PluginError>;++/// Complete return type for a plugin op including Sync errors+pub type PluginOpResult = PluginResult<PluginOp>;++/// Funciton type for plugin ops+pub type PluginDispatchFn =+  fn(is_sync: bool, data: &[u8], zero_copy: Option<PinnedBuf>)+    -> PluginOpResult;

 union Any {   StatRes,   Symlink,   Truncate,+  UserHomeDir,+  UserHomeDirRes,

 export function start(source?: string): msg.StartRes {    return startResMsg; }++/**+ * Returns the current user's home directory.+ */+export function userHomeDir(): string {

+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.+const { dlname, dlopen } = Deno;++let localPath: any = import.meta.url.split("/");+localPath.pop();+localPath = localPath.join("/");++const dLib = dlopen(env().DL_PATH_TEST_BINDING + "/" + dlname("test_plugin"));

+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.+const { dlname, dlopen } = Deno;++let localPath: any = import.meta.url.split("/");+localPath.pop();+localPath = localPath.join("/");++const dLib = dlopen(env().DL_PATH_TEST_BINDING + "/" + dlname("test_plugin"));

+use crate::isolate::Op;+use crate::libdeno::PinnedBuf;+use std::fmt;+use std::io;++pub type PluginResult<T> = std::result::Result<T, PluginError>;++#[derive(Debug)]+pub struct PluginError {+  repr: Repr,+}++#[derive(Debug)]+enum Repr {+  Simple(String),+  IoErr(io::Error),+}++pub fn new_plugin_error(msg: String) -> PluginError {+  PluginError {+    repr: Repr::Simple(msg),+  }+}++impl fmt::Display for PluginError {+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+    match self.repr {+      Repr::Simple(ref err_str) => f.pad(err_str),+      Repr::IoErr(ref err) => err.fmt(f),+    }+  }+}++impl std::error::Error for PluginError {+  fn description(&self) -> &str {+    match self.repr {+      Repr::Simple(ref msg) => msg.as_str(),+      Repr::IoErr(ref err) => err.description(),+    }+  }++  fn cause(&self) -> Option<&dyn std::error::Error> {+    match self.repr {+      Repr::Simple(ref _msg) => None,+      Repr::IoErr(ref err) => Some(err),+    }+  }+}++impl From<io::Error> for PluginError {+  #[inline]+  fn from(err: io::Error) -> Self {+    Self {+      repr: Repr::IoErr(err),+    }+  }+}++/// Base result type for a plugin op represents either a Sync or Async value+pub type PluginOp = Op<PluginError>;++/// Complete return type for a plugin op including Sync errors+pub type PluginOpResult = PluginResult<PluginOp>;++/// Funciton type for plugin ops+pub type PluginDispatchFn =+  fn(is_sync: bool, data: &[u8], zero_copy: Option<PinnedBuf>)+    -> PluginOpResult;

+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.+use deno::{PinnedBuf, Buf};+use deno::plugins::{PluginOpResult, new_plugin_error};+use deno::Op;++#[macro_use]+extern crate deno;++pub fn op_test_op(+  is_sync: bool,+  data: &[u8],+  zero_copy: Option<PinnedBuf>,+) -> PluginOpResult {+    if !is_sync {

+# Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.

 fn add_run_args<'a, 'b>(app: App<'a, 'b>) -> App<'a, 'b> {       Arg::with_name("allow-hrtime")         .long("allow-hrtime")         .help("Allow high resolution time measurement"),+    ).arg(+      Arg::with_name("allow-dlopen")+        .long("allow-dlopen")