java-bridge 2.1.0-beta.1

package/dist/index.dev.min.js

@@ -0,0 +1,1107 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["java"] = factory();
+	else
+		root["java"] = factory();
+})(global, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./java.linux-x64-gnu.node":
+/*!*********************************!*\
+  !*** ./java.linux-x64-gnu.node ***!
+  \*********************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+/* module decorator */ module = __webpack_require__.nmd(module);
+
+try {
+  process.dlopen(module, __dirname + (__webpack_require__(/*! path */ "path").sep) + __webpack_require__.p + "java.linux-x64-gnu.node");
+} catch (error) {
+  throw new Error('node-loader:\n' + error);
+}
+
+
+/***/ }),
+
+/***/ "./native.js":
+/*!*******************!*\
+  !*** ./native.js ***!
+  \*******************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { existsSync, readFileSync } = __webpack_require__(/*! fs */ "fs")
+const { join } = __webpack_require__(/*! path */ "path")
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      return readFileSync('/usr/bin/ldd', 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'java.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.android-arm64.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-android-arm64'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'java.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.android-arm-eabi.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-android-arm-eabi'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'java.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.win32-x64-msvc.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-win32-x64-msvc'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'java.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.win32-ia32-msvc.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-win32-ia32-msvc'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'java.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.win32-arm64-msvc.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-win32-arm64-msvc'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'java.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.darwin-x64.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-darwin-x64'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'java.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.darwin-arm64.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-darwin-arm64'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'java.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.freebsd-x64.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+      } else {
+        nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-freebsd-x64'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'java.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.linux-x64-musl.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            } else {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-linux-x64-musl'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'java.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = __webpack_require__(/*! ./java.linux-x64-gnu.node */ "./java.linux-x64-gnu.node")
+            } else {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-linux-x64-gnu'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'java.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.linux-arm64-musl.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            } else {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-linux-arm64-musl'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'java.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.linux-arm64-gnu.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            } else {
+              nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-linux-arm64-gnu'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, 'java.linux-arm-gnueabihf.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module './java.linux-arm-gnueabihf.node'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          } else {
+            nativeBinding = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'java-bridge-linux-arm-gnueabihf'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()))
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { Java, getClassFields, getField, setField, getStaticField, setStaticField, JavaInterfaceProxy, StdoutRedirect, getJavaLibPath } = nativeBinding
+
+module.exports.Java = Java
+module.exports.getClassFields = getClassFields
+module.exports.getField = getField
+module.exports.setField = setField
+module.exports.getStaticField = getStaticField
+module.exports.setStaticField = setStaticField
+module.exports.JavaInterfaceProxy = JavaInterfaceProxy
+module.exports.StdoutRedirect = StdoutRedirect
+module.exports.getJavaLibPath = getJavaLibPath
+
+
+/***/ }),
+
+/***/ "./ts-src/definitions.ts":
+/*!*******************************!*\
+  !*** ./ts-src/definitions.ts ***!
+  \*******************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.JavaObject = exports.JavaVersion = void 0;
+/**
+ * The supported java versions.
+ * Your list of supported versions
+ * may differ if you use a different
+ * version of the jvm shared library.
+ */
+var JavaVersion;
+(function (JavaVersion) {
+    /** Java version 1.1 */
+    JavaVersion["VER_1_1"] = "1.1";
+    /** Java version 1.2 */
+    JavaVersion["VER_1_2"] = "1.2";
+    /** Java version 1.4 */
+    JavaVersion["VER_1_4"] = "1.4";
+    /** Java version 1.6 */
+    JavaVersion["VER_1_6"] = "1.6";
+    /** Java version 1.8 */
+    JavaVersion["VER_1_8"] = "1.8";
+    /** Java version 9 */
+    JavaVersion["VER_9"] = "9";
+    /** Java version 10 */
+    JavaVersion["VER_10"] = "10";
+})(JavaVersion = exports.JavaVersion || (exports.JavaVersion = {}));
+Object.freeze(JavaVersion);
+/**
+ * A dummy java object class
+ */
+class JavaObject {
+}
+exports.JavaObject = JavaObject;
+
+
+/***/ }),
+
+/***/ "./ts-src/index.ts":
+/*!*************************!*\
+  !*** ./ts-src/index.ts ***!
+  \*************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getJavaLibPath = exports.JavaClassProxy = exports.JavaClassInstance = exports.JavaObject = exports.JavaVersion = void 0;
+var definitions_1 = __webpack_require__(/*! ./definitions */ "./ts-src/definitions.ts");
+Object.defineProperty(exports, "JavaVersion", ({ enumerable: true, get: function () { return definitions_1.JavaVersion; } }));
+Object.defineProperty(exports, "JavaObject", ({ enumerable: true, get: function () { return definitions_1.JavaObject; } }));
+Object.defineProperty(exports, "JavaClassInstance", ({ enumerable: true, get: function () { return definitions_1.JavaClassInstance; } }));
+Object.defineProperty(exports, "JavaClassProxy", ({ enumerable: true, get: function () { return definitions_1.JavaClassProxy; } }));
+__exportStar(__webpack_require__(/*! ./java */ "./ts-src/java.ts"), exports);
+const java = __importStar(__webpack_require__(/*! ./java */ "./ts-src/java.ts"));
+exports["default"] = java;
+var native_1 = __webpack_require__(/*! ../native */ "./native.js");
+Object.defineProperty(exports, "getJavaLibPath", ({ enumerable: true, get: function () { return native_1.getJavaLibPath; } }));
+
+
+/***/ }),
+
+/***/ "./ts-src/java.ts":
+/*!************************!*\
+  !*** ./ts-src/java.ts ***!
+  \************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getJavaInstance = exports.newProxy = exports.stdout = exports.classpath = exports.isInstanceOf = exports.appendClasspath = exports.importClassAsync = exports.importClass = exports.ensureJvm = void 0;
+const native_1 = __webpack_require__(/*! ../native */ "./native.js");
+const nativeLib_1 = __webpack_require__(/*! ./nativeLib */ "./ts-src/nativeLib.ts");
+/**
+ * The static java instance
+ */
+let javaInstance = null;
+/**
+ * Ensure the java vm is created.
+ * If the jvm is already created, this does nothing.
+ * If the vm is not created yet, the jvm will be created upon this call.
+ * This method is also called every time with no arguments when any call
+ * to the jvm is done in another method.
+ *
+ * ## Examples
+ * Specify the path to jvm.(dylib|dll|so) manually,
+ * specify the java version to use and set to use daemon threads.
+ * ```ts
+ * import { ensureJvm, JavaVersion } from 'java-bridge';
+ *
+ * ensureJvm({
+ *     libPath: 'path/to/jvm.dll',
+ *     version: JavaVersion.VER_9,
+ *     useDaemonThreads: true
+ * });
+ * ```
+ *
+ * Let the plugin find the jvm.(dylib|dll|so)
+ * ```ts
+ * ensureJvm({
+ *     JavaVersion.VER_9,
+ *     useDaemonThreads: true
+ * });
+ * ```
+ *
+ * Let the plugin find the jvm.(dylib|dll|so) and use the default options
+ * ```ts
+ * ensureJvm();
+ * ```
+ *
+ * @param options the options to use when creating the jvm
+ */
+function ensureJvm(options) {
+    if (!javaInstance) {
+        javaInstance = new native_1.Java(options?.libPath, options?.version, options?.opts, options, (0, nativeLib_1.getJavaLibPath)(), (0, nativeLib_1.getNativeLibPath)());
+    }
+}
+exports.ensureJvm = ensureJvm;
+function defineFields(object, getStatic) {
+    for (const field of (0, native_1.getClassFields)(object['class.proxy'], getStatic)) {
+        const getter = () => getStatic
+            ? (0, native_1.getStaticField)(object, field.name)
+            : (0, native_1.getField)(object, field.name);
+        if (field.isFinal) {
+            Object.defineProperty(object, field.name, {
+                get: getter,
+                enumerable: true,
+            });
+        }
+        else {
+            Object.defineProperty(object, field.name, {
+                get: getter,
+                set: (value) => getStatic
+                    ? (0, native_1.setStaticField)(object, field.name, value)
+                    : (0, native_1.setField)(object, field.name, value),
+                enumerable: true,
+            });
+        }
+    }
+}
+/**
+ * Import a class.
+ * Returns the constructor of the class to be created.
+ * For example, import "java.util.ArrayList" for a java Array List.
+ *
+ * Define a custom class type for the imported class and pass the
+ * constructor type of the class as the template parameter to get
+ * the proper type returned. You could also just cast the result.
+ *
+ * ## Examples
+ * ### Import ``java.util.ArrayList`` and create a new instance of it
+ * ```ts
+ * import { importClass } from 'java-bridge';
+ *
+ * // Import java.util.ArrayList
+ * const ArrayList = importClass('java.util.ArrayList');
+ *
+ * // Create a new instance of ArrayList
+ * const list = new ArrayList();
+ * ```
+ *
+ * ### Import ``java.util.ArrayList`` with types
+ * ```ts
+ * import { importClass, JavaClassInstance, JavaType } from 'java-bridge';
+ *
+ * /**
+ *  * Definitions for class java.util.List
+ *  *\/
+ * declare class List <T extends JavaType> extends JavaClassInstance {
+ *     size(): Promise<number>;
+ *     sizeSync(): number;
+ *     add(e: T): Promise<void>;
+ *     addSync(e: T): void;
+ *     get(index: number): Promise<T>;
+ *     getSync(index: number): T;
+ *     toArray(): Promise<T[]>;
+ *     toArraySync(): T[];
+ *     isEmpty(): Promise<boolean>;
+ *     isEmptySync(): boolean;
+ * }
+ *
+ * /**
+ *  * Definitions for class java.util.ArrayList
+ *  *\/
+ * declare class ArrayListClass<T extends JavaType> extends List<T> {
+ *     public constructor(other: ArrayListClass<T>);
+ *     public constructor();
+ * }
+ *
+ * // This causes the class to be import when the module is loaded.
+ * class ArrayList<T> extends importClass<typeof ArrayListClass>('java.util.ArrayList')<T> {}
+ *
+ * // Create a new ArrayList instance
+ * const list = new ArrayList<string>();
+ *
+ * // Add some contents to the list
+ * list.add('Hello');
+ * list.add('World');
+ *
+ * // Check the list contents
+ * assert.equals(list.sizeSync(), 2);
+ * assert.equals(list.getSync(0), 'Hello');
+ * assert.equals(list.getSync(1), 'World');
+ * ```
+ *
+ * @template T the type of the java class to import as a js type
+ * @param classname the name of the class to resolve
+ * @return the java class constructor
+ */
+function importClass(classname) {
+    ensureJvm();
+    const constructor = javaInstance.importClass(classname);
+    defineFields(constructor, true);
+    constructor.constructor = function (...args) {
+        const object = new constructor.prototype.constructor(...args);
+        defineFields(object, false);
+        return object;
+    };
+    return constructor;
+}
+exports.importClass = importClass;
+/**
+ * @inheritDoc importClass
+ */
+async function importClassAsync(classname) {
+    ensureJvm();
+    const constructor = (await javaInstance.importClassAsync(classname));
+    defineFields(constructor, true);
+    constructor.constructor = function (...args) {
+        const object = new constructor.prototype.constructor(...args);
+        defineFields(object, false);
+        return object;
+    };
+    return constructor;
+}
+exports.importClassAsync = importClassAsync;
+/**
+ * Append a single or multiple jars to the class path.
+ *
+ * Just replaces the old internal class loader with a new one containing the new jars.
+ * This doesn't check if the jars are valid and/or even exist.
+ * The new classpath will be available to all classes imported after this call.
+ *
+ * ## Example
+ * ```ts
+ * import { appendClasspath } from 'java-bridge';
+ *
+ * // Append a single jar to the class path
+ * appendClasspath('/path/to/jar.jar');
+ *
+ * // Append multiple jars to the class path
+ * appendClasspath(['/path/to/jar1.jar', '/path/to/jar2.jar']);
+ * ```
+ * or
+ * ```ts
+ * import { classpath } from 'java-bridge';
+ *
+ * // Append a single jar to the class path
+ * classpath.append('/path/to/jar.jar');
+ * ```
+ *
+ * @param path the path(s) to add
+ */
+function appendClasspath(path) {
+    ensureJvm();
+    javaInstance.appendClasspath(path);
+}
+exports.appendClasspath = appendClasspath;
+/**
+ * Check if `this_obj` is instance of `other`.
+ * This uses the native java `instanceof` operator.
+ * You may want to use this if {@link JavaClassInstance.instanceOf}
+ * is overridden, as that method itself does not override
+ * any method defined in the specific java class named 'instanceOf'.
+ *
+ * ## Example
+ * ```ts
+ * import { instanceOf, importClass } from 'java-bridge';
+ *
+ * const ArrayList = importClass('java.util.ArrayList');
+ * const list = new ArrayList();
+ *
+ * isInstanceOf(list, ArrayList); // true
+ * isInstanceOf(list, 'java.util.ArrayList'); // true
+ * isInstanceOf(list, 'java.util.List'); // true
+ * isInstanceOf(list, 'java.util.Collection'); // true
+ * isInstanceOf(list, 'java.lang.Object'); // true
+ * isInstanceOf(list, 'java.lang.String'); // false
+ *
+ * // You can also use the instanceOf method (if not overridden)
+ * list.instanceOf(ArrayList); // true
+ * list.instanceOf('java.util.ArrayList'); // true
+ * list.instanceOf('java.util.List'); // true
+ * list.instanceOf('java.util.Collection'); // true
+ * list.instanceOf('java.lang.Object'); // true
+ * list.instanceOf('java.lang.String'); // false
+ * ```
+ *
+ * @param this_obj the object to check
+ * @param other the class or class name to check against
+ * @return true if `this_obj` is an instance of `other`
+ */
+function isInstanceOf(this_obj, other) {
+    ensureJvm();
+    return javaInstance.isInstanceOf(this_obj, other);
+}
+exports.isInstanceOf = isInstanceOf;
+/**
+ * Methods for altering and querying the class path.
+ * @example
+ * import { classpath } from 'java-bridge';
+ *
+ * // Append a jar to the class path
+ * classpath.append('/path/to/jar.jar');
+ *
+ * assert.equal(classpath.get().length, 1);
+ * assert.equal(classpath.get()[0], '/path/to/jar.jar');
+ */
+var classpath;
+(function (classpath) {
+    /**
+     * @inheritDoc appendClasspath
+     */
+    function append(path) {
+        appendClasspath(path);
+    }
+    classpath.append = append;
+    /**
+     * Get the loaded jars in the class path
+     *
+     * @returns a list of the loaded jars
+     */
+    function get() {
+        ensureJvm();
+        return javaInstance.loadedJars;
+    }
+    classpath.get = get;
+})(classpath = exports.classpath || (exports.classpath = {}));
+/**
+ * A namespace containing methods for redirecting the stdout/stderr of the java process.
+ *
+ * ## See also
+ * * {@link StdoutRedirectGuard}
+ * * {@link stdout.enableRedirect}
+ */
+var stdout;
+(function (stdout_1) {
+    /**
+     * Enable stdout/stderr redirection.
+     *
+     * Pass methods for the stdout and stderr output to be redirected to.
+     * These methods must accept an error as the first argument,
+     * although this will probably never be set and can be ignored.
+     * The second argument is the data that was redirected.
+     *
+     * Setting any method to ``null`` or ``undefined`` will disable the redirect for that method.
+     * This also allows you not set any handler which does not make any sense at all.
+     *
+     * ## Examples
+     * ### Redirect all data to the js console
+     * ```ts
+     * import { stdout } from 'java-bridge';
+     *
+     * const guard = stdout.enableRedirect((_, data) => {
+     *     console.log('Stdout:', data);
+     * }, (_, data) => {
+     *     console.error('Stderr:', data);
+     * });
+     * ```
+     *
+     * ### Redirect stdout to the js console
+     * ```ts
+     * const guard = stdout.enableRedirect((_, data) => {
+     *     console.log('Stdout:', data);
+     * });
+     * ```
+     *
+     * ### Redirect stderr to the js console
+     * ```ts
+     * const guard = stdout.enableRedirect(null, (_, data) => {
+     *    console.error('Stderr:', data);
+     * });
+     * ```
+     *
+     * ### Redirect nothing to the js console (y tho)
+     * This enables you to print nothing to nowhere.
+     * ```ts
+     * // Why would you do this?
+     * const guard = stdout.enableRedirect(null, null);
+     *
+     * // Or
+     * const guard = stdout.enableRedirect();
+     * ```
+     *
+     * @see StdoutRedirectGuard
+     * @see StdoutCallback
+     * @param stdout the callback to be called when stdout is received
+     * @param stderr the callback to be called when stderr is received
+     * @returns a <code>StdoutRedirectGuard</code> instance. Keep this instance in scope to not lose the redirect.
+     */
+    function enableRedirect(stdout, stderr) {
+        ensureJvm();
+        return javaInstance.setStdoutCallbacks(stdout, stderr);
+    }
+    stdout_1.enableRedirect = enableRedirect;
+})(stdout = exports.stdout || (exports.stdout = {}));
+/**
+ * Create a new java interface proxy.
+ * This allows you to implement java interfaces in javascript.
+ *
+ * Pass an object as the second argument with the names of the
+ * methods you want to implement as keys and the implementations
+ * as values in order to expose these methods to the java process.
+ * Any arguments will be converted to javascript values and
+ * return values will be converted to java values.
+ *
+ * When the java process tries to call any method which is
+ * not implemented by the proxy, an error will be thrown.
+ *
+ * ## Examples
+ * ### Implement ``java.lang.Runnable``
+ * ```ts
+ * import { newProxy, importClass } from 'java-bridge';
+ *
+ * // Define the interface
+ * const runnable = newProxy('java.lang.Runnable', {
+ *     run: (): void => {
+ *         console.log('Hello World!');
+ *     }
+ * });
+ *
+ * // Note: You can't do something like this:
+ * // runnable.run();
+ *
+ * // Pass the proxy to a java method instead:
+ * const Thread = importClass('java.lang.Thread');
+ * const thread = new Thread(runnable); // <- Pass the proxy here
+ *
+ * // NOTE: You don't have to call this asynchronously
+ * // as this call instantly returns.
+ * thread.startSync();
+ * ```
+ *
+ * ### Implement ``java.util.function.Function`` to transform a string
+ * ```ts
+ * const func = newProxy('java.util.function.Function', {
+ *     // Any parameters and return types will be automatically converted
+ *     apply: (str: string): string => {
+ *         return str.toUpperCase();
+ *     }
+ * });
+ *
+ * // Import the string class
+ * const JString = java.importClass('java.lang.String');
+ * const str = new JString('hello');
+ *
+ * // Pass the proxy.
+ * // NOTE: You must call this method async otherwise your program will hang.
+ * // See notes for more info.
+ * const transformed = await str.transform(func);
+ *
+ * assert.assertEquals(transformed, 'HELLO');
+ * ```
+ *
+ * Which is equivalent to the following java code:
+ * ```java
+ * Function<String, String> func = new Function<>() {
+ *     @Override
+ *     public String apply(String str) {
+ *         return str.toUpperCase();
+ *     }
+ * };
+ *
+ * String str = "hello";
+ * String transformed = str.transform(func);
+ * assert.assertEquals(transformed, "HELLO");
+ * ```
+ *
+ * #### Throwing exceptions
+ * Any exceptions thrown by the proxy will be converted to java exceptions
+ * and then rethrown in the java process. This may cause the exception
+ * to again be rethrown in the javascript process.
+ * ```ts
+ * const func = newProxy('java.util.function.Function', {
+ *     apply: (str: string): string => {
+ *         throw new Error('Something went wrong');
+ *     }
+ * });
+ *
+ * const JString = java.importClass('java.lang.String');
+ * const str = new JString('hello');
+ *
+ * // This will re-throw the above error
+ * const transformed: never = await str.transform(func);
+ * ```
+ *
+ * ## Notes
+ * * Keep this instance in scope to not destroy the interface proxy.
+ * * Call {@link JavaInterfaceProxy.reset} to instantly destroy this instance.
+ * * If any method is queried by the java process and not implemented in here,
+ *   an exception will be thrown in the java process.
+ * * Any errors thrown in the javascript process will be rethrown in the java process.
+ * * **When calling a java method that uses an interface defined by this, you must call
+ *   that method using the interface asynchronously as Node.js is single threaded and can't
+ *   wait for the java method to return while calling the proxy method at the same time.**
+ *
+ * ## See also
+ * * {@link JavaInterfaceProxy}
+ *
+ * @param interfaceName the name of the java interface to implement
+ * @param methods the methods to implement.
+ * @returns a proxy class to pass back to the java process
+ */
+function newProxy(interfaceName, methods) {
+    ensureJvm();
+    const proxyMethods = Object.create(null);
+    for (const [name, method] of Object.entries(methods)) {
+        proxyMethods[name] = (err, callback, ...args) => {
+            if (err) {
+                throw err;
+            }
+            try {
+                const res = method(...args);
+                callback(null, res);
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    callback(e);
+                }
+                else {
+                    callback(new Error(e.toString()));
+                }
+            }
+        };
+    }
+    return javaInstance.createInterfaceProxy(interfaceName, proxyMethods);
+}
+exports.newProxy = newProxy;
+/**
+ * Get the static java instance.
+ * This has no real use, all important methods are exported explicitly.
+ */
+function getJavaInstance() {
+    return javaInstance;
+}
+exports.getJavaInstance = getJavaInstance;
+
+
+/***/ }),
+
+/***/ "./ts-src/nativeLib.ts":
+/*!*****************************!*\
+  !*** ./ts-src/nativeLib.ts ***!
+  \*****************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getJavaLibPath = exports.getNativeLibPath = void 0;
+const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
+const fs_1 = __importStar(__webpack_require__(/*! fs */ "fs"));
+const glob_1 = __importDefault(__webpack_require__(/*! glob */ "glob"));
+const { platform, arch } = process;
+function getModule(base) {
+    const local = path_1.default.join(__dirname, base + '.node');
+    if (fs_1.default.existsSync(local)) {
+        return local;
+    }
+    else {
+        const module = base.replaceAll('.', '-').replace('java', 'java-bridge');
+        // @ts-ignore
+        if (require && require.resolve) {
+            // @ts-ignore
+            return require.resolve(module);
+        }
+        else {
+            return /*require.resolve*/(__webpack_require__("./ts-src sync recursive").resolve(module));
+        }
+    }
+}
+function UnsupportedPlatform() {
+    return new Error(`Unsupported platform: ${platform} ${arch}`);
+}
+function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+        try {
+            return (0, fs_1.readFileSync)('/usr/bin/ldd', 'utf8').includes('musl');
+        }
+        catch (e) {
+            return true;
+        }
+    }
+    else {
+        const { glibcVersionRuntime } = process.report.getReport()
+            .header;
+        return !glibcVersionRuntime;
+    }
+}
+function getNativeLibPath() {
+    switch (platform) {
+        case 'android':
+            switch (arch) {
+                case 'arm64':
+                    return getModule('java.android-arm64');
+                case 'arm':
+                    return getModule('java.android-arm-eabi');
+                default:
+                    throw UnsupportedPlatform();
+            }
+        case 'win32':
+            return getModule(`java.win32-${arch}-msvc`);
+        case 'darwin':
+            return getModule(`java.darwin-${arch}`);
+        case 'freebsd':
+            return getModule(`java.freebsd-${arch}`);
+        case 'linux':
+            switch (arch) {
+                case 'x64':
+                case 'arm64':
+                    return getModule(`java.linux-${arch}-${isMusl() ? 'musl' : 'gnu'}`);
+                case 'arm':
+                    return getModule('java.linux-arm-gnueabihf');
+                default:
+                    throw UnsupportedPlatform();
+            }
+        default:
+            throw UnsupportedPlatform();
+    }
+}
+exports.getNativeLibPath = getNativeLibPath;
+function getJavaLibPath() {
+    const dir = path_1.default.join(__dirname, '..', 'java-src', 'build', 'libs');
+    let files = glob_1.default.sync('*.jar', { cwd: dir });
+    if (files.length === 0) {
+        throw new Error(`No java lib found in ${dir}`);
+    }
+    else {
+        return path_1.default.join(dir, files[0]);
+    }
+}
+exports.getJavaLibPath = getJavaLibPath;
+
+
+/***/ }),
+
+/***/ "./ts-src sync recursive":
+/*!**********************!*\
+  !*** ./ts-src/ sync ***!
+  \**********************/
+/***/ ((module) => {
+
+function webpackEmptyContext(req) {
+	var e = new Error("Cannot find module '" + req + "'");
+	e.code = 'MODULE_NOT_FOUND';
+	throw e;
+}
+webpackEmptyContext.keys = () => ([]);
+webpackEmptyContext.resolve = webpackEmptyContext;
+webpackEmptyContext.id = "./ts-src sync recursive";
+module.exports = webpackEmptyContext;
+
+/***/ }),
+
+/***/ "glob":
+/*!***********************!*\
+  !*** external "glob" ***!
+  \***********************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("glob");
+
+/***/ }),
+
+/***/ "fs":
+/*!*********************!*\
+  !*** external "fs" ***!
+  \*********************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ "path":
+/*!***********************!*\
+  !*** external "path" ***!
+  \***********************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("path");
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			id: moduleId,
+/******/ 			loaded: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/node module decorator */
+/******/ 	(() => {
+/******/ 		__webpack_require__.nmd = (module) => {
+/******/ 			module.paths = [];
+/******/ 			if (!module.children) module.children = [];
+/******/ 			return module;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		__webpack_require__.p = "";
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./ts-src/index.ts");
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=index.dev.min.js.map