java-bridge 2.1.4 → 2.1.5

package/dist/index.dev.min.js

@@ -1,1487 +0,0 @@
-(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 = require('java-bridge-android-arm64')
-          }
-        } 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 = require('java-bridge-android-arm-eabi')
-          }
-        } 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 = require('java-bridge-win32-x64-msvc')
-          }
-        } 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 = require('java-bridge-win32-ia32-msvc')
-          }
-        } 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 = require('java-bridge-win32-arm64-msvc')
-          }
-        } 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 = require('java-bridge-darwin-x64')
-          }
-        } 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 = require('java-bridge-darwin-arm64')
-          }
-        } 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 = require('java-bridge-freebsd-x64')
-      }
-    } 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 = require('java-bridge-linux-x64-musl')
-            }
-          } 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 = require('java-bridge-linux-x64-gnu')
-            }
-          } 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 = require('java-bridge-linux-arm64-musl')
-            }
-          } 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 = require('java-bridge-linux-arm64-gnu')
-            }
-          } 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 = require('java-bridge-linux-arm-gnueabihf')
-          }
-        } 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/TypescriptDefinitionGenerator.ts":
-/*!*************************************************!*\
-  !*** ./ts-src/TypescriptDefinitionGenerator.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 }));
-const typescript_1 = __importStar(__webpack_require__(/*! typescript */ "typescript"));
-const _1 = __webpack_require__(/*! ./. */ "./ts-src/index.ts");
-const fs_1 = __importDefault(__webpack_require__(/*! fs */ "fs"));
-const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
-const sourceFile = typescript_1.default.createSourceFile('source.ts', '', typescript_1.default.ScriptTarget.Latest, false, typescript_1.default.ScriptKind.TS);
-/**
- * A class to generate typescript definitions for java classes.
- * Converts the given class and all of its dependencies to typescript.
- *
- * ## Example
- * ```ts
- * import { TypescriptDefinitionGenerator } from 'java-bridge';
- *
- * const generator = new TypescriptDefinitionGenerator('java.lang.String');
- * // Generate the typescript definitions
- * const definitions = await generator.generate();
- *
- * // Save the definitions to a directory
- * await TypescriptDefinitionGenerator.save(definitions, './project');
- * ```
- */
-class TypescriptDefinitionGenerator {
-    /**
-     * Create a new `TypescriptDefinitionGenerator` instance
-     *
-     * @param classname the fully-qualified name of the class to generate a typescript definition for
-     * @param progressCallback a callback method to be called every time a java class is
-     *                         converted to typescript
-     * @param resolvedImports a list of imports that have already been resolved.
-     *                        This is used to prevent converting a class multiple times
-     */
-    constructor(classname, progressCallback = null, resolvedImports = []) {
-        this.classname = classname;
-        this.progressCallback = progressCallback;
-        this.resolvedImports = resolvedImports;
-        this.usesBasicOrJavaType = false;
-        this.additionalImports = [];
-        this.importsToResolve = [];
-    }
-    static async convertMethods(methods) {
-        const Modifier = await (0, _1.importClassAsync)('java.lang.reflect.Modifier');
-        const result = {};
-        for (const method of methods) {
-            const modifiers = await method.getModifiers();
-            if (await Modifier.isPublic(modifiers)) {
-                const name = await method.getName();
-                const returnType = await method.getReturnType();
-                const parameterTypes = await method.getParameterTypes();
-                const data = {
-                    returnType: await returnType.getTypeName(),
-                    parameters: await Promise.all(parameterTypes.map((p) => p.getTypeName())),
-                    isStatic: await Modifier.isStatic(modifiers),
-                };
-                if (Object.hasOwn(result, name)) {
-                    result[name].push(data);
-                }
-                else {
-                    result[name] = [data];
-                }
-            }
-        }
-        return result;
-    }
-    async convertConstructors(constructors) {
-        const Modifier = await (0, _1.importClassAsync)('java.lang.reflect.Modifier');
-        const types = [];
-        for (const constructor of constructors) {
-            const modifiers = await constructor.getModifiers();
-            if (await Modifier.isPublic(modifiers)) {
-                const parameterTypes = await constructor.getParameterTypes();
-                types.push(await Promise.all(parameterTypes.map((p) => p.getTypeName())));
-            }
-        }
-        const tsConstructors = types.map((t, i) => {
-            const params = t.map(this.convertParameter.bind(this));
-            let declaration = typescript_1.default.factory.createConstructorDeclaration([typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.PublicKeyword)], params, undefined);
-            if (i === 0) {
-                declaration = typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` ================== Constructors ==================`, true);
-            }
-            if (t.length > 0) {
-                declaration = typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, '*\n' +
-                    t
-                        .map((p, i) => ` * @param var${i} original type: '${p}'\n`)
-                        .join('') +
-                    ' ', true);
-            }
-            return declaration;
-        });
-        const newInstanceMethods = types.map((t, i) => {
-            return this.createMethod({
-                returnType: this.classname,
-                parameters: t,
-                isStatic: true,
-            }, 'newInstance', i, false);
-        });
-        return [...newInstanceMethods, ...tsConstructors];
-    }
-    javaTypeToTypescriptType(javaType, isParam) {
-        switch (javaType) {
-            case 'byte[]':
-            case 'java.lang.Byte[]':
-                return typescript_1.default.factory.createTypeReferenceNode('Buffer');
-        }
-        if (javaType.endsWith('[]')) {
-            return typescript_1.default.factory.createArrayTypeNode(this.javaTypeToTypescriptType(javaType.substring(0, javaType.length - 2), isParam));
-        }
-        switch (javaType) {
-            case 'int':
-            case 'java.lang.Integer':
-            case 'long':
-            case 'java.lang.Long':
-            case 'float':
-            case 'java.lang.Float':
-            case 'double':
-            case 'java.lang.Double':
-            case 'byte':
-            case 'java.lang.Byte':
-            case 'short':
-            case 'java.lang.Short':
-                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NumberKeyword);
-            case 'char':
-            case 'java.lang.Character':
-            case 'java.lang.String':
-                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.StringKeyword);
-            case 'boolean':
-            case 'java.lang.Boolean':
-                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.BooleanKeyword);
-            case 'void':
-            case 'java.lang.Void':
-                return typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.VoidKeyword);
-            case 'java.lang.Object':
-                this.usesBasicOrJavaType = true;
-                return typescript_1.default.factory.createTypeReferenceNode('BasicOrJavaType');
-            default:
-                if (!this.resolvedImports.includes(javaType)) {
-                    this.additionalImports.push(javaType);
-                }
-                this.importsToResolve.push(javaType);
-                const isSelf = javaType === this.classname && isParam;
-                return typescript_1.default.factory.createTypeReferenceNode(javaType === this.classname
-                    ? javaType.substring(javaType.lastIndexOf('.') + 1) +
-                        (isSelf ? 'Class' : '')
-                    : javaType.replaceAll('.', '_'));
-        }
-    }
-    convertParameter(param, index) {
-        const name = 'var' + index;
-        const type = this.javaTypeToTypescriptType(param, true);
-        return typescript_1.default.factory.createParameterDeclaration(undefined, undefined, name, undefined, type);
-    }
-    convertParameters(params) {
-        return params.parameters.map(this.convertParameter.bind(this));
-    }
-    static createMethodComment(declaration) {
-        return ('*\n' +
-            declaration.parameters
-                .map((p, i) => ` * @param var${i} original type: '${p}'\n`)
-                .join('') +
-            ` * @return original return type: '${declaration.returnType}'\n `);
-    }
-    createMethod(m, name, i, isSync) {
-        const publicMod = typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.PublicKeyword);
-        const staticMod = typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.StaticKeyword);
-        const modifiers = [publicMod];
-        if (m.isStatic) {
-            modifiers.push(staticMod);
-        }
-        let returnType = this.javaTypeToTypescriptType(m.returnType, false);
-        if (!isSync) {
-            returnType = typescript_1.default.factory.createTypeReferenceNode(typescript_1.default.factory.createIdentifier('Promise'), [returnType]);
-        }
-        let declaration = typescript_1.default.factory.createMethodDeclaration(modifiers, undefined, name + (isSync ? 'Sync' : ''), undefined, undefined, this.convertParameters(m), returnType, undefined);
-        if (i === 0) {
-            declaration = typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.SingleLineCommentTrivia, ` ================== Method ${name} ==================`, true);
-        }
-        return typescript_1.default.addSyntheticLeadingComment(declaration, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, TypescriptDefinitionGenerator.createMethodComment(m), true);
-    }
-    convertMethod(method, name) {
-        const res = [];
-        for (let i = 0; i < method.length; i++) {
-            const m = method[i];
-            res.push(this.createMethod(m, name, i, false), this.createMethod(m, name, i, true));
-        }
-        return res;
-    }
-    getAdditionalImports() {
-        const getPath = (i) => {
-            const thisSplit = this.classname.split('.');
-            const importSplit = i.split('.');
-            for (let j = 0; j < thisSplit.length; j++) {
-                if (importSplit[j] === thisSplit[j]) {
-                    thisSplit[j] = null;
-                    importSplit[j] = null;
-                }
-                else {
-                    break;
-                }
-            }
-            return ('./' +
-                thisSplit
-                    .filter((e) => !!e)
-                    .map(() => '')
-                    .join('../') +
-                importSplit.filter((e) => !!e).join('/'));
-        };
-        const unique = (value, index, self) => {
-            return self.indexOf(value) === index;
-        };
-        return this.importsToResolve
-            .filter((i) => i != this.classname)
-            .filter(unique)
-            .map((i) => typescript_1.default.factory.createImportDeclaration(undefined, typescript_1.default.factory.createImportClause(false, undefined, typescript_1.default.factory.createNamedImports([
-            typescript_1.default.factory.createImportSpecifier(false, typescript_1.default.factory.createIdentifier(i.substring(i.lastIndexOf('.') + 1)), typescript_1.default.factory.createIdentifier(i.replaceAll('.', '_'))),
-        ])), typescript_1.default.factory.createStringLiteral(getPath(i))));
-    }
-    getImports() {
-        const importElements = [
-            typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier('importClass')),
-            typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier('JavaClass')),
-        ];
-        if (this.usesBasicOrJavaType) {
-            importElements.push(typescript_1.default.factory.createImportSpecifier(false, undefined, typescript_1.default.factory.createIdentifier('BasicOrJavaType')));
-        }
-        const imports = typescript_1.default.factory.createNamedImports(importElements);
-        return typescript_1.default.factory.createImportDeclaration(undefined, typescript_1.default.factory.createImportClause(false, undefined, imports), typescript_1.default.factory.createStringLiteral('java-bridge'));
-    }
-    getExportStatement(simpleName) {
-        const statement = typescript_1.default.factory.createClassDeclaration([typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], simpleName, undefined, [
-            typescript_1.default.factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [
-                typescript_1.default.factory.createExpressionWithTypeArguments(typescript_1.default.factory.createIdentifier(`importClass<typeof ${simpleName}Class>("${this.classname}")`), undefined),
-            ]),
-        ], []);
-        return [
-            typescript_1.default.addSyntheticLeadingComment(statement, typescript_1.SyntaxKind.MultiLineCommentTrivia, `*\n * Class ${this.classname}.\n *\n` +
-                ' * This actually imports the java class for further use.\n' +
-                ` * The class ${simpleName}Class only defines types, this is the class you should actually import.\n` +
-                ' * Please note that this statement imports the underlying java class at runtime, which may take a while.\n' +
-                ' * This was generated by java-bridge.\n * You should probably not edit this.\n ', true),
-            typescript_1.default.factory.createExportDefault(typescript_1.default.factory.createIdentifier(simpleName)),
-        ];
-    }
-    getText(nodes) {
-        return nodes
-            .map((n) => (n &&
-            typescript_1.default
-                .createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed })
-                .printNode(typescript_1.default.EmitHint.Unspecified, n, sourceFile)) ||
-            '')
-            .join('\n');
-    }
-    /**
-     * Generates the typescript definition for the given class.
-     *
-     * @returns the generated typescript definitions
-     */
-    async generate() {
-        if (this.resolvedImports.includes(this.classname)) {
-            return [];
-        }
-        this.resolvedImports.push(this.classname);
-        if (this.progressCallback) {
-            this.progressCallback(this.classname);
-        }
-        const Class = await (0, _1.importClassAsync)(this.classname);
-        const cls = Class.class;
-        const simpleName = this.classname.substring(this.classname.lastIndexOf('.') + 1);
-        const methods = await cls.getDeclaredMethods();
-        const classMembers = [];
-        const convertedMethods = await TypescriptDefinitionGenerator.convertMethods(methods);
-        for (const key of Object.keys(convertedMethods)) {
-            const m = convertedMethods[key];
-            classMembers.push(...this.convertMethod(m, key));
-        }
-        const constructors = await cls.getDeclaredConstructors();
-        const convertedConstructors = await this.convertConstructors(constructors);
-        classMembers.push(...convertedConstructors);
-        let tsClass = typescript_1.default.factory.createClassDeclaration([
-            typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword),
-            typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.DeclareKeyword),
-        ], simpleName + 'Class', undefined, [
-            typescript_1.default.factory.createHeritageClause(typescript_1.default.SyntaxKind.ExtendsKeyword, [
-                typescript_1.default.factory.createExpressionWithTypeArguments(typescript_1.default.factory.createIdentifier('JavaClass'), undefined),
-            ]),
-        ], classMembers);
-        tsClass = typescript_1.default.addSyntheticLeadingComment(tsClass, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, `*\n * This class just defines types, you should import ${simpleName} instead of this.\n` +
-            ' * This was generated by java-bridge.\n * You should probably not edit this.\n ', true);
-        const sourceText = this.getText([
-            this.getImports(),
-            ...this.getAdditionalImports(),
-            null,
-            tsClass,
-            null,
-            ...this.getExportStatement(simpleName),
-        ]);
-        const res = [];
-        for (const imported of this.additionalImports) {
-            const generator = new TypescriptDefinitionGenerator(imported, this.progressCallback, this.resolvedImports);
-            const generated = await generator.generate();
-            res.push(...generated);
-        }
-        res.push({
-            name: this.classname,
-            contents: sourceText,
-        });
-        return res;
-    }
-    /**
-     * Save the converted classes to the given directory.
-     *
-     * @param declarations the declarations to save
-     * @param sourceDir the directory to save the files to
-     */
-    static async save(declarations, sourceDir) {
-        for (const declaration of declarations) {
-            const p = declaration.name.split('.');
-            p[p.length - 1] = p[p.length - 1] + '.ts';
-            const filePath = path_1.default.join(sourceDir, ...p);
-            await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), {
-                recursive: true,
-            });
-            await fs_1.default.promises.writeFile(filePath, declaration.contents, {
-                encoding: 'utf8',
-            });
-        }
-    }
-}
-exports["default"] = TypescriptDefinitionGenerator;
-
-
-/***/ }),
-
-/***/ "./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;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TypescriptDefinitionGenerator = exports.getJavaLibPath = exports.JavaClassConstructor = exports.JavaClass = 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; } }));
-Object.defineProperty(exports, "JavaClass", ({ enumerable: true, get: function () { return definitions_1.JavaClass; } }));
-Object.defineProperty(exports, "JavaClassConstructor", ({ enumerable: true, get: function () { return definitions_1.JavaClassConstructor; } }));
-__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; } }));
-const TypescriptDefinitionGenerator_1 = __importDefault(__webpack_require__(/*! ./TypescriptDefinitionGenerator */ "./ts-src/TypescriptDefinitionGenerator.ts"));
-exports.TypescriptDefinitionGenerator = TypescriptDefinitionGenerator_1.default;
-
-
-/***/ }),
-
-/***/ "./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 JavaClass.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");
-
-/***/ }),
-
-/***/ "typescript":
-/*!*****************************!*\
-  !*** external "typescript" ***!
-  \*****************************/
-/***/ ((module) => {
-
-"use strict";
-module.exports = require("typescript");
-
-/***/ }),
-
-/***/ "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