libwz 0.1.0

package/dist/index.js

@@ -0,0 +1,1146 @@
+let currentNative;
+let currentCapabilities;
+let currentType;
+function setWzBinding(native, capabilities, type) {
+    currentNative = native;
+    currentCapabilities = capabilities;
+    currentType = type;
+}
+function getWzBinding() {
+    if (currentNative === undefined) {
+        throw new Error('libwz binding is not initialized');
+    }
+    return currentNative;
+}
+function getWzCapabilities() {
+    if (currentCapabilities === undefined) {
+        throw new Error('libwz binding is not initialized');
+    }
+    return currentCapabilities;
+}
+function getWzBindingType() {
+    if (currentType === undefined) {
+        throw new Error('libwz binding is not initialized');
+    }
+    return currentType;
+}
+
+function installNativeBinding() {
+    try {
+        const native = loadNative();
+        if (native === null)
+            return false;
+        setWzBinding(native, {
+            blobInput: false,
+            pathInput: true,
+            saveToDisk: true
+        }, 'native');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function loadNative() {
+    const moduleBuiltin = getBuiltinModule('module');
+    const path = getBuiltinModule('path');
+    const url = getBuiltinModule('url');
+    if (moduleBuiltin === null || path === null || url === null)
+        return null;
+    const nodeRequire = moduleBuiltin.createRequire(import.meta.url);
+    const moduleDir = import.meta.dirname
+        ?? path.dirname(url.fileURLToPath(import.meta.url));
+    for (const candidate of nativeCandidates(path, moduleDir)) {
+        try {
+            return nodeRequire(candidate);
+        }
+        catch (err) {
+            const { code } = err;
+            if (code !== 'MODULE_NOT_FOUND')
+                throw err;
+        }
+    }
+    throw new Error('libwz native addon is not built. Run `npm run build`.');
+}
+function nativeCandidates(path, moduleDir) {
+    return [
+        path.join(moduleDir, '..', 'build', 'Release', 'wz.node'),
+        path.join(moduleDir, '..', 'build', 'Release', 'libwz.node'),
+        path.join(moduleDir, '..', 'build', 'Debug', 'wz.node'),
+        path.join(moduleDir, '..', 'build', 'Debug', 'libwz.node')
+    ];
+}
+function getBuiltinModule(id) {
+    if (typeof process !== 'object' || process === null)
+        return null;
+    if (typeof process.getBuiltinModule !== 'function')
+        return null;
+    try {
+        return process.getBuiltinModule(id);
+    }
+    catch {
+        return null;
+    }
+}
+
+function configureWasmBinding(loaded, _options) {
+    const isNode = isNodeRuntime();
+    const pathMapper = isNode ? createNodePathMapper(loaded.module) : undefined;
+    const binding = isNode ? normalizeNodePathBinding(loaded.binding, pathMapper) : loaded.binding;
+    setWzBinding(binding, {
+        blobInput: true,
+        pathInput: isNode,
+        saveToDisk: isNode
+    }, 'wasm');
+}
+const nodeMountedRoots = new WeakMap();
+function normalizeNodePathBinding(binding, pathMapper) {
+    return Object.defineProperties(Object.create(binding), {
+        openFile: {
+            value(path, gameVersionOrIv, mapleVersion) {
+                const wasmPath = toWasmNodePath(path, pathMapper);
+                if (gameVersionOrIv instanceof Uint8Array)
+                    return binding.openFile(wasmPath, gameVersionOrIv);
+                if (mapleVersion === undefined)
+                    throw new TypeError('mapleVersion is required');
+                return binding.openFile(wasmPath, gameVersionOrIv, mapleVersion);
+            }
+        },
+        fileSaveToDisk: {
+            value(ptr, path) {
+                binding.fileSaveToDisk(ptr, toWasmNodePath(path, pathMapper));
+            }
+        },
+        canvasSaveToFile: {
+            value(ptr, path) {
+                return binding.canvasSaveToFile(ptr, toWasmNodePath(path, pathMapper));
+            }
+        },
+        pngSaveToFile: {
+            value(ptr, path) {
+                return binding.pngSaveToFile(ptr, toWasmNodePath(path, pathMapper));
+            }
+        },
+        binarySaveToFile: {
+            value(ptr, path) {
+                return binding.binarySaveToFile(ptr, toWasmNodePath(path, pathMapper));
+            }
+        },
+        detectMapleVersion: {
+            value(path) {
+                return binding.detectMapleVersion(toWasmNodePath(path, pathMapper));
+            }
+        }
+    });
+}
+function toWasmNodePath(path, pathMapper) {
+    return pathMapper?.toWasmPath(path) ?? normalizePath(path);
+}
+function normalizePath(path) {
+    const normalizedPath = path.replaceAll('\\', '/');
+    if (normalizedPath.length > 1 && normalizedPath.endsWith('/')) {
+        return normalizedPath.replace(/\/+$/u, '');
+    }
+    return normalizedPath;
+}
+function createNodePathMapper(module) {
+    if (module.FS === undefined || module.NODEFS === undefined) {
+        return undefined;
+    }
+    const nodePath = getNodePathModule();
+    if (nodePath === undefined)
+        return undefined;
+    let mountedRoots = nodeMountedRoots.get(module);
+    if (mountedRoots === undefined) {
+        mountedRoots = new Map();
+        nodeMountedRoots.set(module, mountedRoots);
+    }
+    const mountRoot = '/mnt';
+    return {
+        toWasmPath(path) {
+            const hostPath = normalizePath(nodePath.resolve(path));
+            const hostRoot = normalizePath(nodePath.parse(hostPath).root);
+            let wasmRoot = mountedRoots.get(hostRoot);
+            if (wasmRoot === undefined) {
+                wasmRoot = hostRoot === '/'
+                    ? mountRoot
+                    : `${mountRoot}/${hostRoot.replaceAll(':', '').replace(/^\/+|\/+$/gu, '')}`;
+                module.FS?.mkdirTree(wasmRoot);
+                module.FS?.mount(module.NODEFS, { root: hostRoot }, wasmRoot);
+                mountedRoots.set(hostRoot, wasmRoot);
+            }
+            if (hostPath === hostRoot)
+                return wasmRoot;
+            const suffix = hostPath.slice(hostRoot.length).replace(/^\/+/u, '');
+            return suffix.length === 0 ? wasmRoot : `${wasmRoot}/${suffix}`;
+        }
+    };
+}
+function isNodeRuntime() {
+    const maybeProcess = globalThis.process;
+    return typeof maybeProcess?.versions?.node === 'string';
+}
+function getNodePathModule() {
+    const maybeProcess = globalThis.process;
+    if (typeof maybeProcess?.getBuiltinModule === 'function') {
+        return maybeProcess.getBuiltinModule('path');
+    }
+    return undefined;
+}
+
+const asyncCache = new Map();
+async function initializeWasm(wasmUrl) {
+    const resolvedWasmUrl = wasmUrl.toString();
+    const cached = asyncCache.get(resolvedWasmUrl);
+    if (cached !== undefined)
+        return await cached;
+    const loaded = loadWasmDependencies().then(async ({ createLibwzModule, getDefaultContext }) => {
+        const module = await createLibwzModule({
+            locateFile(path, prefix) {
+                if (path.endsWith('.wasm')) {
+                    return resolvedWasmUrl;
+                }
+                return `${prefix}${path}`;
+            }
+        });
+        return {
+            binding: module.emnapiInit({
+                context: getDefaultContext(),
+                filename: 'libwz.wasm'
+            }),
+            module
+        };
+    });
+    asyncCache.set(resolvedWasmUrl, loaded);
+    return await loaded;
+}
+async function loadWzModule() {
+    return await initializeWasm(defaultWasmUrl());
+}
+function defaultWasmUrl() {
+    return new URL('./libwz.wasm', import.meta.url);
+}
+async function loadWasmDependencies() {
+    const [runtime, generated] = await Promise.all([
+        import('@emnapi/runtime'),
+        importGeneratedLibwzModule()
+    ]);
+    return {
+        createLibwzModule: generated,
+        getDefaultContext: () => runtime.getDefaultContext()
+    };
+}
+async function importGeneratedLibwzModule() {
+    // @ts-expect-error Emscripten generates this module during build:wasm.
+    const generated = await import('./libwz.js');
+    return generated.default;
+}
+
+var MapleVersion;
+(function (MapleVersion) {
+    MapleVersion[MapleVersion["GMS"] = 0] = "GMS";
+    MapleVersion[MapleVersion["EMS"] = 1] = "EMS";
+    MapleVersion[MapleVersion["BMS"] = 2] = "BMS";
+    MapleVersion[MapleVersion["CLASSIC"] = 3] = "CLASSIC";
+    MapleVersion[MapleVersion["GENERATE"] = 4] = "GENERATE";
+    MapleVersion[MapleVersion["GETFROMZLZ"] = 5] = "GETFROMZLZ";
+    MapleVersion[MapleVersion["CUSTOM"] = 6] = "CUSTOM";
+    MapleVersion[MapleVersion["UNKNOWN"] = 99] = "UNKNOWN";
+})(MapleVersion || (MapleVersion = {}));
+var ParseStatus;
+(function (ParseStatus) {
+    ParseStatus[ParseStatus["PATH_IS_NULL"] = -1] = "PATH_IS_NULL";
+    ParseStatus[ParseStatus["ERROR_GAME_VER_HASH"] = -2] = "ERROR_GAME_VER_HASH";
+    ParseStatus[ParseStatus["FAILED_UNKNOWN"] = 0] = "FAILED_UNKNOWN";
+    ParseStatus[ParseStatus["SUCCESS"] = 1] = "SUCCESS";
+})(ParseStatus || (ParseStatus = {}));
+var PropertyType;
+(function (PropertyType) {
+    PropertyType[PropertyType["NULL"] = 0] = "NULL";
+    PropertyType[PropertyType["SHORT"] = 1] = "SHORT";
+    PropertyType[PropertyType["INT"] = 2] = "INT";
+    PropertyType[PropertyType["LONG"] = 3] = "LONG";
+    PropertyType[PropertyType["FLOAT"] = 4] = "FLOAT";
+    PropertyType[PropertyType["DOUBLE"] = 5] = "DOUBLE";
+    PropertyType[PropertyType["STRING"] = 6] = "STRING";
+    PropertyType[PropertyType["SUB"] = 7] = "SUB";
+    PropertyType[PropertyType["CANVAS"] = 8] = "CANVAS";
+    PropertyType[PropertyType["VECTOR"] = 9] = "VECTOR";
+    PropertyType[PropertyType["CONVEX"] = 10] = "CONVEX";
+    PropertyType[PropertyType["SOUND"] = 11] = "SOUND";
+    PropertyType[PropertyType["RAW"] = 12] = "RAW";
+    PropertyType[PropertyType["UOL"] = 13] = "UOL";
+    PropertyType[PropertyType["LUA"] = 14] = "LUA";
+    PropertyType[PropertyType["PNG"] = 15] = "PNG";
+})(PropertyType || (PropertyType = {}));
+var ObjectType;
+(function (ObjectType) {
+    ObjectType[ObjectType["FILE"] = 0] = "FILE";
+    ObjectType[ObjectType["IMAGE"] = 1] = "IMAGE";
+    ObjectType[ObjectType["DIRECTORY"] = 2] = "DIRECTORY";
+    ObjectType[ObjectType["PROPERTY"] = 3] = "PROPERTY";
+    ObjectType[ObjectType["LIST"] = 4] = "LIST";
+})(ObjectType || (ObjectType = {}));
+var BinaryType;
+(function (BinaryType) {
+    BinaryType[BinaryType["RAW"] = 0] = "RAW";
+    BinaryType[BinaryType["MP3"] = 1] = "MP3";
+    BinaryType[BinaryType["WAV"] = 2] = "WAV";
+})(BinaryType || (BinaryType = {}));
+const native = new Proxy({}, {
+    get(_target, property) {
+        const binding = getWzBinding();
+        const value = binding[property];
+        return typeof value === 'function' ? value.bind(binding) : value;
+    }
+});
+const capabilities = new Proxy({}, {
+    get(_target, property) {
+        return getWzCapabilities()[property];
+    }
+});
+function assertHandle(ptr) {
+    if (typeof ptr !== 'bigint' || ptr === 0n) {
+        throw new TypeError('native handle must be a non-zero bigint');
+    }
+}
+function isPresent(value) {
+    return value !== null;
+}
+function createWzFile(ptr, ownsNative = false) {
+    const NativeWzFile = WzFile;
+    return new NativeWzFile(ptr, ownsNative);
+}
+const handleRegistry = new Map();
+function registerHandle(ptr, obj) {
+    let entries = handleRegistry.get(ptr);
+    if (entries === undefined) {
+        entries = new Set();
+        handleRegistry.set(ptr, entries);
+    }
+    entries.add(obj);
+}
+function unregisterHandle(ptr, obj) {
+    const entries = handleRegistry.get(ptr);
+    if (entries === undefined)
+        return;
+    entries.delete(obj);
+    if (entries.size === 0)
+        handleRegistry.delete(ptr);
+}
+function markHandleBorrowed(ptr) {
+    const entries = handleRegistry.get(ptr);
+    if (entries === undefined)
+        return;
+    for (const entry of entries)
+        entry._markBorrowedInstance();
+}
+function markHandleOwned(ptr) {
+    const entries = handleRegistry.get(ptr);
+    if (entries === undefined)
+        return;
+    for (const entry of entries)
+        entry._markOwnedInstance();
+}
+function invalidateHandle(ptr) {
+    const entries = handleRegistry.get(ptr);
+    if (entries === undefined)
+        return;
+    handleRegistry.delete(ptr);
+    for (const entry of entries)
+        entry._markDisposedInstance();
+}
+function invalidateHandles(ptrs) {
+    for (const ptr of ptrs)
+        invalidateHandle(ptr);
+}
+function registeredObjectsSnapshot() {
+    const objects = new Set();
+    for (const entries of handleRegistry.values()) {
+        for (const entry of entries)
+            objects.add(entry);
+    }
+    return Array.from(objects);
+}
+function livePtr(obj) {
+    try {
+        return obj.nativePtr();
+    }
+    catch {
+        return null;
+    }
+}
+function collectKnownFilePtrs(file) {
+    const filePtr = file.nativePtr();
+    const ptrs = new Set([filePtr]);
+    for (const obj of registeredObjectsSnapshot()) {
+        const ptr = livePtr(obj);
+        if (ptr === null || ptr === filePtr)
+            continue;
+        try {
+            if (native.objectWzFileParent(ptr) === filePtr)
+                ptrs.add(ptr);
+        }
+        catch {
+            // Detached properties and already-invalid objects are not file-owned.
+        }
+    }
+    return ptrs;
+}
+function isDescendantPath(path, rootPath) {
+    return path === rootPath
+        || path.startsWith(`${rootPath}/`)
+        || path.startsWith(`${rootPath}\\`);
+}
+function collectKnownSubtreePtrs(root) {
+    const rootPtr = root.nativePtr();
+    const rootPath = native.objectFullPath(rootPtr);
+    const ptrs = new Set([rootPtr]);
+    for (const obj of registeredObjectsSnapshot()) {
+        const ptr = livePtr(obj);
+        if (ptr === null || ptr === rootPtr)
+            continue;
+        try {
+            if (isDescendantPath(native.objectFullPath(ptr), rootPath)) {
+                ptrs.add(ptr);
+            }
+        }
+        catch {
+            // Some detached properties do not have a tree path.
+        }
+    }
+    return ptrs;
+}
+function collectPropertySubtreePtrs(prop, out = new Set()) {
+    const ptr = prop.nativePtr();
+    if (out.has(ptr))
+        return out;
+    out.add(ptr);
+    for (const child of prop.wzProperties())
+        collectPropertySubtreePtrs(child, out);
+    return out;
+}
+function collectImagePropertyPtrs(image) {
+    const ptrs = new Set();
+    for (const prop of image.wzProperties())
+        collectPropertySubtreePtrs(prop, ptrs);
+    return ptrs;
+}
+function collectPropertyChildrenPtrs(prop) {
+    const ptrs = new Set();
+    for (const child of prop.wzProperties())
+        collectPropertySubtreePtrs(child, ptrs);
+    return ptrs;
+}
+class WzObject {
+    _ptr;
+    _ownsNative;
+    constructor(ptr, ownsNative = false) {
+        if (new.target === WzObject) {
+            throw new TypeError('WzObject is abstract');
+        }
+        assertHandle(ptr);
+        this._ptr = ptr;
+        this._ownsNative = ownsNative;
+        registerHandle(ptr, this);
+    }
+    nativePtr() {
+        this._assertAlive();
+        return this._ptr;
+    }
+    _assertAlive() {
+        if (this._ptr === 0n)
+            throw new Error('native object is disposed');
+    }
+    _markBorrowed() {
+        this._assertAlive();
+        markHandleBorrowed(this._ptr);
+    }
+    _markOwned() {
+        this._assertAlive();
+        markHandleOwned(this._ptr);
+    }
+    _markDisposed() {
+        this._assertAlive();
+        invalidateHandle(this._ptr);
+    }
+    _markBorrowedInstance() {
+        this._ownsNative = false;
+    }
+    _markOwnedInstance() {
+        this._ownsNative = true;
+    }
+    _markDisposedInstance() {
+        this._ptr = 0n;
+        this._ownsNative = false;
+    }
+    ownsNative() {
+        return this._ownsNative;
+    }
+    getObjectType() {
+        return native.objectType(this.nativePtr());
+    }
+    getName() {
+        return native.objectName(this.nativePtr());
+    }
+    getParent() {
+        return wrapObjectInfo(native.objectParent(this.nativePtr()));
+    }
+    getFullPath() {
+        return native.objectFullPath(this.nativePtr());
+    }
+    getWzFileParent() {
+        const ptr = native.objectWzFileParent(this.nativePtr());
+        return ptr === null ? null : createWzFile(ptr);
+    }
+    getTopMostWzDirectory() {
+        return wrapObjectInfo(native.objectTopMostDirectory(this.nativePtr()));
+    }
+    getTopMostWzImage() {
+        return wrapObjectInfo(native.objectTopMostImage(this.nativePtr()));
+    }
+    at(name) {
+        return wrapObjectInfo(native.objectAt(this.nativePtr(), name));
+    }
+    setName(name) {
+        native.objectSetName(this.nativePtr(), name);
+    }
+    remove() {
+        const ptr = this.nativePtr();
+        native.objectRemove(this.nativePtr());
+        markHandleOwned(ptr);
+    }
+    close() {
+        if (this._ownsNative && this._ptr !== 0n) {
+            const ptr = this._ptr;
+            const ptrs = collectKnownSubtreePtrs(this);
+            try {
+                native.objectFree(ptr);
+            }
+            finally {
+                invalidateHandles(ptrs);
+            }
+        }
+        else if (this._ptr !== 0n) {
+            unregisterHandle(this._ptr, this);
+            this._ptr = 0n;
+        }
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+}
+class WzFile extends WzObject {
+    disposeCallbacks = [];
+    static create(gameVersion, mapleVersion) {
+        const ptr = native.createFile(gameVersion, mapleVersion);
+        if (ptr === null)
+            throw new Error('failed to create WZ file');
+        return createWzFile(ptr, true);
+    }
+    static fromBytes(name, bytes, gameVersionOrMapleVersionOrIv, mapleVersion) {
+        let ptr;
+        if (gameVersionOrMapleVersionOrIv instanceof Uint8Array) {
+            ptr = native.openMemory(name, bytes, gameVersionOrMapleVersionOrIv);
+        }
+        else {
+            const gameVersion = mapleVersion === undefined ? -1 : gameVersionOrMapleVersionOrIv;
+            const version = mapleVersion === undefined
+                ? gameVersionOrMapleVersionOrIv
+                : mapleVersion;
+            ptr = native.openMemory(name, bytes, gameVersion, version);
+        }
+        if (ptr === null)
+            throw new Error('failed to open WZ file from bytes');
+        return createWzFile(ptr, true);
+    }
+    static fromBlobSource(name, size, gameVersionOrMapleVersionOrIv, mapleVersionOrReadRange, readRange) {
+        if (!capabilities.blobInput) {
+            throw new Error('Blob-backed WZ input is not supported in this runtime');
+        }
+        if (native.openBlobSource === undefined) {
+            throw new Error('Blob-backed WZ input is not supported by this binding');
+        }
+        let ptr;
+        if (gameVersionOrMapleVersionOrIv instanceof Uint8Array) {
+            const callback = mapleVersionOrReadRange;
+            ptr = native.openBlobSource(size, name, gameVersionOrMapleVersionOrIv, callback);
+        }
+        else {
+            const mapleVersion = typeof mapleVersionOrReadRange === 'function'
+                ? undefined
+                : mapleVersionOrReadRange;
+            const callback = (readRange ?? mapleVersionOrReadRange);
+            const gameVersion = mapleVersion === undefined ? -1 : gameVersionOrMapleVersionOrIv;
+            const version = mapleVersion === undefined
+                ? gameVersionOrMapleVersionOrIv
+                : mapleVersion;
+            ptr = native.openBlobSource(size, name, gameVersion, version, callback);
+        }
+        if (ptr === null)
+            throw new Error('failed to open WZ file from Blob');
+        return createWzFile(ptr, true);
+    }
+    constructor(pathOrPtr, gameVersionOrMapleVersion = MapleVersion.GMS, mapleVersion) {
+        if (typeof pathOrPtr === 'bigint') {
+            super(pathOrPtr, gameVersionOrMapleVersion === true);
+            return;
+        }
+        if (!capabilities.pathInput) {
+            throw new Error('WZ file path input is not supported by this binding');
+        }
+        let ptr;
+        if (gameVersionOrMapleVersion instanceof Uint8Array) {
+            ptr = native.openFile(pathOrPtr, gameVersionOrMapleVersion);
+        }
+        else {
+            const gameVersion = mapleVersion === undefined ? -1 : gameVersionOrMapleVersion;
+            const version = mapleVersion === undefined
+                ? gameVersionOrMapleVersion
+                : mapleVersion;
+            ptr = native.openFile(pathOrPtr, gameVersion, version);
+        }
+        if (ptr === null)
+            throw new Error('failed to open WZ file');
+        super(ptr, true);
+    }
+    addDisposeCallback(callback) {
+        this.disposeCallbacks.push(callback);
+    }
+    parseWzFile() {
+        return native.parseFile(this.nativePtr());
+    }
+    saveToDisk(path) {
+        if (!capabilities.saveToDisk) {
+            throw new Error('saving WZ files to disk is not supported by this binding');
+        }
+        native.fileSaveToDisk(this.nativePtr(), path);
+    }
+    getName() {
+        return native.fileName(this.nativePtr());
+    }
+    getFilePath() {
+        return native.filePath(this.nativePtr());
+    }
+    getVersion() {
+        return native.fileVersion(this.nativePtr());
+    }
+    getMapleVersion() {
+        return native.fileMapleVersion(this.nativePtr());
+    }
+    getWzDirectory() {
+        const ptr = native.fileWzDirectory(this.nativePtr());
+        return ptr === null ? null : new WzDirectory(ptr);
+    }
+    is64BitWzFile() {
+        return native.fileIs64Bit(this.nativePtr());
+    }
+    isUnloaded() {
+        return native.fileIsUnloaded(this.nativePtr());
+    }
+    getVersionHash() {
+        return native.fileVersionHash(this.nativePtr());
+    }
+    getObjectFromPath(path, checkFirstDirectoryName = true) {
+        return wrapObjectInfo(native.fileObjectFromPath(this.nativePtr(), path, checkFirstDirectoryName));
+    }
+    close() {
+        if (this._ownsNative && this._ptr !== 0n) {
+            const ptr = this._ptr;
+            const ptrs = collectKnownFilePtrs(this);
+            try {
+                native.closeFile(ptr);
+            }
+            finally {
+                invalidateHandles(ptrs);
+                for (const callback of this.disposeCallbacks.splice(0))
+                    callback();
+            }
+        }
+    }
+}
+class WzDirectory extends WzObject {
+    getName() {
+        return native.dirName(this.nativePtr());
+    }
+    countImages() {
+        return native.dirCountImagesTotal(this.nativePtr());
+    }
+    wzImages() {
+        const count = native.dirCountImages(this.nativePtr());
+        return Array.from({ length: count }, (_, i) => this.getImage(i));
+    }
+    wzDirectories() {
+        const count = native.dirCountDirectories(this.nativePtr());
+        return Array.from({ length: count }, (_, i) => this.getDirectory(i));
+    }
+    getImage(index) {
+        const ptr = native.dirGetImage(this.nativePtr(), index);
+        return ptr === null ? null : new WzImage(ptr);
+    }
+    getImageByName(name) {
+        const ptr = native.dirGetImageByName(this.nativePtr(), name);
+        return ptr === null ? null : new WzImage(ptr);
+    }
+    getDirectory(index) {
+        const ptr = native.dirGetDirectory(this.nativePtr(), index);
+        return ptr === null ? null : new WzDirectory(ptr);
+    }
+    getDirectoryByName(name) {
+        const ptr = native.dirGetDirectoryByName(this.nativePtr(), name);
+        return ptr === null ? null : new WzDirectory(ptr);
+    }
+    createDirectory(name) {
+        const ptr = native.dirCreateDirectory(this.nativePtr(), name);
+        if (ptr === null)
+            throw new Error('failed to create WZ directory');
+        return new WzDirectory(ptr);
+    }
+    createImage(name) {
+        const ptr = native.dirCreateImage(this.nativePtr(), name);
+        if (ptr === null)
+            throw new Error('failed to create WZ image');
+        return new WzImage(ptr);
+    }
+    removeDirectory(child) {
+        native.dirRemoveDirectory(this.nativePtr(), child.nativePtr());
+        child._markOwned();
+    }
+    removeImage(child) {
+        native.dirRemoveImage(this.nativePtr(), child.nativePtr());
+        child._markOwned();
+    }
+    getBlockSize() {
+        return native.dirBlockSize(this.nativePtr());
+    }
+    getChecksum() {
+        return native.dirChecksum(this.nativePtr());
+    }
+    getOffset() {
+        return native.dirOffset(this.nativePtr());
+    }
+}
+class WzImage extends WzObject {
+    static fromFile(path, mapleVersion) {
+        if (!capabilities.pathInput || native.openImage === undefined) {
+            throw new Error('WZ image path input is not supported by this binding');
+        }
+        const ptr = native.openImage(path, mapleVersion);
+        if (ptr === null)
+            throw new Error('failed to open WZ image');
+        return new WzImage(ptr, true);
+    }
+    getName() {
+        return native.imageName(this.nativePtr());
+    }
+    isParsed() {
+        return native.imageParsed(this.nativePtr());
+    }
+    isChanged() {
+        return native.imageChanged(this.nativePtr());
+    }
+    getBlockSize() {
+        return native.imageBlockSize(this.nativePtr());
+    }
+    getChecksum() {
+        return native.imageChecksum(this.nativePtr());
+    }
+    getOffset() {
+        return native.imageOffset(this.nativePtr());
+    }
+    isLuaWzImage() {
+        return native.imageIsLua(this.nativePtr());
+    }
+    parseImage() {
+        native.imageParse(this.nativePtr());
+    }
+    wzProperties() {
+        const count = native.imageCountProperties(this.nativePtr());
+        return new WzPropertyCollection(...Array.from({ length: count }, (_, i) => {
+            const ptr = native.imageGetProperty(this.nativePtr(), i);
+            return ptr === null ? null : wrapProperty(ptr);
+        }).filter(isPresent));
+    }
+    getFromPath(path) {
+        const ptr = native.imageGetFromPath(this.nativePtr(), path);
+        return ptr === null ? null : wrapProperty(ptr);
+    }
+    addProperty(prop) {
+        native.imageAddProperty(this.nativePtr(), prop.nativePtr());
+        prop._markBorrowed();
+    }
+    removeProperty(prop) {
+        native.imageRemoveProperty(this.nativePtr(), prop.nativePtr());
+        prop._markOwned();
+    }
+    clearProperties() {
+        const ptrs = collectImagePropertyPtrs(this);
+        native.imageClearProperties(this.nativePtr());
+        invalidateHandles(ptrs);
+    }
+}
+class WzPropertyCollection extends Array {
+    get(index) {
+        return this[index];
+    }
+}
+class WzImageProperty extends WzObject {
+    getPropertyType() {
+        return native.propType(this.nativePtr());
+    }
+    getName() {
+        return native.propName(this.nativePtr());
+    }
+    wzProperties() {
+        const count = native.propCountChildren(this.nativePtr());
+        return new WzPropertyCollection(...Array.from({ length: count }, (_, i) => this.getChild(i)).filter(isPresent));
+    }
+    getChild(index) {
+        const ptr = native.propGetChild(this.nativePtr(), index);
+        return ptr === null ? null : wrapProperty(ptr);
+    }
+    getChildByName(name) {
+        const ptr = native.propGetChildByName(this.nativePtr(), name);
+        return ptr === null ? null : wrapProperty(ptr);
+    }
+    getFromPath(path) {
+        const ptr = native.propGetFromPath(this.nativePtr(), path);
+        return ptr === null ? null : wrapProperty(ptr);
+    }
+    getLinkedWzImageProperty() {
+        const ptr = native.propLinked(this.nativePtr());
+        return ptr === null ? null : wrapProperty(ptr);
+    }
+    getInt() {
+        return native.propGetInt(this.nativePtr());
+    }
+    getShort() {
+        return native.propGetShort(this.nativePtr());
+    }
+    getLong() {
+        return native.propGetLong(this.nativePtr());
+    }
+    getFloat() {
+        return native.propGetFloat(this.nativePtr());
+    }
+    getDouble() {
+        return native.propGetDouble(this.nativePtr());
+    }
+    getString() {
+        return native.propGetString(this.nativePtr());
+    }
+    getBytes() {
+        return native.propGetBytes(this.nativePtr());
+    }
+    addProperty(child) {
+        native.propertyAddChild(this.nativePtr(), child.nativePtr());
+        child._markBorrowed();
+    }
+    removeProperty(child) {
+        native.propertyRemoveChild(this.nativePtr(), child.nativePtr());
+        child._markOwned();
+    }
+    clearProperties() {
+        const ptrs = collectPropertyChildrenPtrs(this);
+        native.propertyClearChildren(this.nativePtr());
+        invalidateHandles(ptrs);
+    }
+    close() {
+        super.close();
+    }
+}
+class WzNullProperty extends WzImageProperty {
+}
+class WzShortProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+}
+class WzIntProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+}
+class WzLongProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+}
+class WzFloatProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+}
+class WzDoubleProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+}
+class WzStringProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+}
+class WzSubProperty extends WzImageProperty {
+}
+class WzCanvasProperty extends WzImageProperty {
+    getPngProperty() {
+        const ptr = native.canvasPng(this.nativePtr());
+        return ptr === null ? null : new WzPngProperty(ptr);
+    }
+    containsInlinkProperty() {
+        return native.canvasContainsInlink(this.nativePtr());
+    }
+    containsOutlinkProperty() {
+        return native.canvasContainsOutlink(this.nativePtr());
+    }
+    getLinkedWzImageProperty() {
+        const ptr = native.canvasLinked(this.nativePtr());
+        return ptr === null ? null : wrapProperty(ptr);
+    }
+    saveToFile(path) {
+        return native.canvasSaveToFile(this.nativePtr(), path);
+    }
+}
+class WzPngProperty extends WzImageProperty {
+    getWidth() {
+        return native.pngWidth(this.nativePtr());
+    }
+    getHeight() {
+        return native.pngHeight(this.nativePtr());
+    }
+    getFormat() {
+        return native.pngFormat(this.nativePtr());
+    }
+    isListWzUsed() {
+        return native.pngListWzUsed(this.nativePtr());
+    }
+    getImage() {
+        return native.pngImage(this.nativePtr());
+    }
+    getCompressedBytes() {
+        return native.pngCompressedBytes(this.nativePtr());
+    }
+    saveToFile(path) {
+        return native.pngSaveToFile(this.nativePtr(), path);
+    }
+}
+class WzVectorProperty extends WzImageProperty {
+    getX() {
+        return native.vectorX(this.nativePtr());
+    }
+    getY() {
+        return native.vectorY(this.nativePtr());
+    }
+}
+class WzConvexProperty extends WzImageProperty {
+}
+class WzBinaryProperty extends WzImageProperty {
+    getBytes() {
+        return native.binaryData(this.nativePtr());
+    }
+    getWAVPlayback() {
+        return native.binaryWav(this.nativePtr());
+    }
+    getLength() {
+        return native.binaryLength(this.nativePtr());
+    }
+    getFrequency() {
+        return native.binaryFrequency(this.nativePtr());
+    }
+    getType() {
+        return native.binaryType(this.nativePtr());
+    }
+    isHeaderEncrypted() {
+        return native.binaryHeaderEncrypted(this.nativePtr());
+    }
+    saveToFile(path) {
+        return native.binarySaveToFile(this.nativePtr(), path);
+    }
+}
+class WzRawDataProperty extends WzImageProperty {
+    getBytes() {
+        return native.rawData(this.nativePtr());
+    }
+    getRawType() {
+        return native.rawType(this.nativePtr());
+    }
+}
+class WzVideoProperty extends WzImageProperty {
+    getData() {
+        return native.videoData(this.nativePtr());
+    }
+}
+class WzUOLProperty extends WzImageProperty {
+    getValue() {
+        return native.propertyValue(this.nativePtr());
+    }
+    setValue(value) {
+        native.propertySetValue(this.nativePtr(), value);
+    }
+    getLinkValue() {
+        return wrapObjectInfo(native.uolLinkValue(this.nativePtr()));
+    }
+}
+class WzLuaProperty extends WzImageProperty {
+    getData() {
+        return native.luaData(this.nativePtr());
+    }
+    getString() {
+        return native.luaString(this.nativePtr());
+    }
+}
+function wrapObjectInfo(info) {
+    if (info === null)
+        return null;
+    return wrapObject(info.type, info.ptr);
+}
+function wrapObject(type, ptr) {
+    if (type === ObjectType.FILE)
+        return createWzFile(ptr);
+    if (type === ObjectType.IMAGE)
+        return new WzImage(ptr);
+    if (type === ObjectType.DIRECTORY)
+        return new WzDirectory(ptr);
+    if (type === ObjectType.PROPERTY)
+        return wrapProperty(ptr);
+    return null;
+}
+function requireProperty(ptr) {
+    if (ptr === null)
+        throw new Error('failed to create WZ property');
+    return wrapProperty(ptr, true);
+}
+class WzProperty {
+    static createNull(name) {
+        return requireProperty(native.propertyCreateNull(name));
+    }
+    static createShort(name, value) {
+        return requireProperty(native.propertyCreateShort(name, value));
+    }
+    static createInt(name, value) {
+        return requireProperty(native.propertyCreateInt(name, value));
+    }
+    static createLong(name, value) {
+        return requireProperty(native.propertyCreateLong(name, value));
+    }
+    static createFloat(name, value) {
+        return requireProperty(native.propertyCreateFloat(name, value));
+    }
+    static createDouble(name, value) {
+        return requireProperty(native.propertyCreateDouble(name, value));
+    }
+    static createString(name, value) {
+        return requireProperty(native.propertyCreateString(name, value));
+    }
+    static createSub(name) {
+        return requireProperty(native.propertyCreateSub(name));
+    }
+    static createVector(name, x, y) {
+        return requireProperty(native.propertyCreateVector(name, x, y));
+    }
+    static createUol(name, value) {
+        return requireProperty(native.propertyCreateUol(name, value));
+    }
+    static createCanvasFromPng(name, path) {
+        return requireProperty(native.propertyCreateCanvasFromPng(name, path));
+    }
+}
+function wrapProperty(ptr, ownsNative = false) {
+    const type = native.propType(ptr);
+    if (type === PropertyType.NULL)
+        return new WzNullProperty(ptr, ownsNative);
+    if (type === PropertyType.SHORT)
+        return new WzShortProperty(ptr, ownsNative);
+    if (type === PropertyType.INT)
+        return new WzIntProperty(ptr, ownsNative);
+    if (type === PropertyType.LONG)
+        return new WzLongProperty(ptr, ownsNative);
+    if (type === PropertyType.FLOAT)
+        return new WzFloatProperty(ptr, ownsNative);
+    if (type === PropertyType.DOUBLE)
+        return new WzDoubleProperty(ptr, ownsNative);
+    if (type === PropertyType.STRING)
+        return new WzStringProperty(ptr, ownsNative);
+    if (type === PropertyType.SUB)
+        return new WzSubProperty(ptr, ownsNative);
+    if (type === PropertyType.CANVAS)
+        return new WzCanvasProperty(ptr, ownsNative);
+    if (type === PropertyType.VECTOR)
+        return new WzVectorProperty(ptr, ownsNative);
+    if (type === PropertyType.CONVEX)
+        return new WzConvexProperty(ptr, ownsNative);
+    if (type === PropertyType.SOUND)
+        return new WzBinaryProperty(ptr, ownsNative);
+    if (type === PropertyType.RAW) {
+        return native.propIsVideo(ptr)
+            ? new WzVideoProperty(ptr, ownsNative)
+            : new WzRawDataProperty(ptr, ownsNative);
+    }
+    if (type === PropertyType.UOL)
+        return new WzUOLProperty(ptr, ownsNative);
+    if (type === PropertyType.LUA)
+        return new WzLuaProperty(ptr, ownsNative);
+    if (type === PropertyType.PNG)
+        return new WzPngProperty(ptr, ownsNative);
+    return new WzImageProperty(ptr, ownsNative);
+}
+const WzTool = Object.freeze({
+    detectMapleVersion(path) {
+        if (!capabilities.pathInput) {
+            throw new Error('path-based WZ input is not supported in this runtime');
+        }
+        return native.detectMapleVersion(path);
+    },
+    getIvForVersion(version) {
+        return native.ivForVersion(version);
+    }
+});
+
+async function init(wasmUrlOrOptions, options = {}) {
+    const request = parseInitArgs(wasmUrlOrOptions, options);
+    const shouldUseNative = nativeReady && !request.needsWasm;
+    if (shouldUseNative) {
+        await Promise.resolve();
+        return;
+    }
+    nativeReady = false;
+    const loaded = request.wasmUrl === undefined
+        ? await loadWzModule()
+        : await initializeWasm(request.wasmUrl);
+    configureWasmBinding(loaded);
+}
+function parseInitArgs(wasmUrlOrOptions, options) {
+    const hasOptionsOnly = isInitOptions(wasmUrlOrOptions);
+    const initOptions = hasOptionsOnly ? wasmUrlOrOptions : options;
+    const wasmUrl = hasOptionsOnly ? undefined : wasmUrlOrOptions;
+    return {
+        needsWasm: wasmUrl !== undefined || initOptions.forceWasm === true,
+        options: initOptions,
+        wasmUrl
+    };
+}
+function isInitOptions(value) {
+    return typeof value === 'object' && value !== null && !(value instanceof URL);
+}
+let nativeReady = installNativeBinding();
+
+export { BinaryType, MapleVersion, ObjectType, ParseStatus, PropertyType, WzBinaryProperty, WzCanvasProperty, WzConvexProperty, WzDirectory, WzDoubleProperty, WzFile, WzFloatProperty, WzImage, WzImageProperty, WzIntProperty, WzLongProperty, WzLuaProperty, WzNullProperty, WzObject, WzPngProperty, WzProperty, WzPropertyCollection, WzRawDataProperty, WzShortProperty, WzStringProperty, WzSubProperty, WzTool, WzUOLProperty, WzVectorProperty, WzVideoProperty, getWzBindingType, init };