@cosmol-studio/cosmolkit-core-analysis 0.5.0-rc.18 → 0.5.0-rc.21

package/wasm_wasm.js

@@ -1,32 +1,37 @@
 /* @ts-self-types="./wasm_wasm.d.ts" */
-import { visitSdfBatchExport, visitSdfBatchRead, visitSdfDataset } from './snippets/wasm-wasm-30282a0f796f892b/inline0.js';
-import { visitSdfReadParams } from './snippets/wasm-wasm-30282a0f796f892b/inline1.js';
-import { visitFingerprintAdditionalOutput } from './snippets/wasm-wasm-30282a0f796f892b/inline10.js';
-import { visitLayeredMask } from './snippets/wasm-wasm-30282a0f796f892b/inline11.js';
-import { visitLayeredParams } from './snippets/wasm-wasm-30282a0f796f892b/inline12.js';
-import { visitScalarTopologicalTorsionMolecule, visitScalarTopologicalTorsionatom, visitScalarTopologicalTorsioncall, visitScalarTopologicalTorsionparams } from './snippets/wasm-wasm-30282a0f796f892b/inline13.js';
-import { visitTorsionInvariants, visitTorsionParams } from './snippets/wasm-wasm-30282a0f796f892b/inline14.js';
-import { visitRingSearchParams } from './snippets/wasm-wasm-30282a0f796f892b/inline15.js';
-import { visitSearchCompiledQuery } from './snippets/wasm-wasm-30282a0f796f892b/inline16.js';
-import { visitSearchSmartsWriteParams } from './snippets/wasm-wasm-30282a0f796f892b/inline17.js';
-import { visitSearchSubstructMatchParams } from './snippets/wasm-wasm-30282a0f796f892b/inline18.js';
-import { visitSearchQueryGraph } from './snippets/wasm-wasm-30282a0f796f892b/inline19.js';
-import { visitGroupId, visitGroupKind } from './snippets/wasm-wasm-30282a0f796f892b/inline2.js';
-import { visitKekulizeParams } from './snippets/wasm-wasm-30282a0f796f892b/inline20.js';
-import { visitDistanceMatrix3dParams } from './snippets/wasm-wasm-30282a0f796f892b/inline21.js';
-import { visitDistanceMatrixParams } from './snippets/wasm-wasm-30282a0f796f892b/inline22.js';
-import { visitSanitizeParams } from './snippets/wasm-wasm-30282a0f796f892b/inline23.js';
-import { visitMol2Params, visitXyzParams } from './snippets/wasm-wasm-30282a0f796f892b/inline24.js';
-import { visitHydrogenAddParams, visitHydrogenRemoveParams } from './snippets/wasm-wasm-30282a0f796f892b/inline25.js';
-import { visitSupplierParams } from './snippets/wasm-wasm-30282a0f796f892b/inline3.js';
-import { visit_batch_records } from './snippets/wasm-wasm-30282a0f796f892b/inline4.js';
-import { visitMolProperties, visitMolQuery, visitMolSelection, visitMolWriteParams } from './snippets/wasm-wasm-30282a0f796f892b/inline5.js';
-import { visitScalarMorganMolecule, visitScalarMorganatom, visitScalarMorganbond, visitScalarMorgancall, visitScalarMorganparams } from './snippets/wasm-wasm-30282a0f796f892b/inline6.js';
-import { visitMorganAtom, visitMorganBond, visitMorganInvariants, visitMorganParams, visitMorganQuery } from './snippets/wasm-wasm-30282a0f796f892b/inline7.js';
-import { visitAtomPairInvariants, visitAtomPairParams } from './snippets/wasm-wasm-30282a0f796f892b/inline8.js';
-import { visit_sanitize_operations } from './snippets/wasm-wasm-30282a0f796f892b/inline9.js';
-import * as import1 from "./snippets/wasm-wasm-30282a0f796f892b/inline0.js"
-import * as import2 from "./snippets/wasm-wasm-30282a0f796f892b/inline3.js"
+import { visitSdfBatchExport, visitSdfBatchRead, visitSdfDataset } from './snippets/wasm-wasm-6920c347788a3bef/inline0.js';
+import { visitSdfReadParams } from './snippets/wasm-wasm-6920c347788a3bef/inline1.js';
+import { visitFingerprintAdditionalOutput } from './snippets/wasm-wasm-6920c347788a3bef/inline10.js';
+import { visitLayeredMask } from './snippets/wasm-wasm-6920c347788a3bef/inline11.js';
+import { visitLayeredParams } from './snippets/wasm-wasm-6920c347788a3bef/inline12.js';
+import { visitScalarTopologicalTorsionMolecule, visitScalarTopologicalTorsionatom, visitScalarTopologicalTorsioncall, visitScalarTopologicalTorsionparams } from './snippets/wasm-wasm-6920c347788a3bef/inline13.js';
+import { visitTorsionInvariants, visitTorsionParams } from './snippets/wasm-wasm-6920c347788a3bef/inline14.js';
+import { visitMcsParameters } from './snippets/wasm-wasm-6920c347788a3bef/inline15.js';
+import { visitMcsMolecule } from './snippets/wasm-wasm-6920c347788a3bef/inline16.js';
+import { visitMcsBondCompareParameters } from './snippets/wasm-wasm-6920c347788a3bef/inline17.js';
+import { visitMcsAtomCompareParameters } from './snippets/wasm-wasm-6920c347788a3bef/inline18.js';
+import { visitRingSearchParams } from './snippets/wasm-wasm-6920c347788a3bef/inline19.js';
+import { visitGroupId, visitGroupKind } from './snippets/wasm-wasm-6920c347788a3bef/inline2.js';
+import { visitAvalonParams } from './snippets/wasm-wasm-6920c347788a3bef/inline20.js';
+import { visitSearchCompiledQuery } from './snippets/wasm-wasm-6920c347788a3bef/inline21.js';
+import { visitSearchSmartsWriteParams } from './snippets/wasm-wasm-6920c347788a3bef/inline22.js';
+import { visitSearchQueryGraph } from './snippets/wasm-wasm-6920c347788a3bef/inline23.js';
+import { visitSearchSubstructMatchParams } from './snippets/wasm-wasm-6920c347788a3bef/inline24.js';
+import { visitKekulizeParams } from './snippets/wasm-wasm-6920c347788a3bef/inline25.js';
+import { visitDistanceMatrix3dParams } from './snippets/wasm-wasm-6920c347788a3bef/inline26.js';
+import { visitDistanceMatrixParams } from './snippets/wasm-wasm-6920c347788a3bef/inline27.js';
+import { visitSanitizeParams } from './snippets/wasm-wasm-6920c347788a3bef/inline28.js';
+import { visitMol2Params, visitXyzParams } from './snippets/wasm-wasm-6920c347788a3bef/inline29.js';
+import { visitSupplierParams } from './snippets/wasm-wasm-6920c347788a3bef/inline3.js';
+import { visitHydrogenAddParams, visitHydrogenRemoveParams } from './snippets/wasm-wasm-6920c347788a3bef/inline30.js';
+import { visit_batch_records } from './snippets/wasm-wasm-6920c347788a3bef/inline4.js';
+import { visitMolProperties, visitMolQuery, visitMolSelection, visitMolWriteParams } from './snippets/wasm-wasm-6920c347788a3bef/inline5.js';
+import { visitScalarMorganMolecule, visitScalarMorganatom, visitScalarMorganbond, visitScalarMorgancall, visitScalarMorganparams } from './snippets/wasm-wasm-6920c347788a3bef/inline6.js';
+import { visitMorganAtom, visitMorganBond, visitMorganInvariants, visitMorganParams, visitMorganQuery } from './snippets/wasm-wasm-6920c347788a3bef/inline7.js';
+import { visitAtomPairInvariants, visitAtomPairParams } from './snippets/wasm-wasm-6920c347788a3bef/inline8.js';
+import { visit_sanitize_operations } from './snippets/wasm-wasm-6920c347788a3bef/inline9.js';
+import * as import1 from "./snippets/wasm-wasm-6920c347788a3bef/inline0.js"
+import * as import2 from "./snippets/wasm-wasm-6920c347788a3bef/inline3.js"
 
 
 export class AddHsParams {
@@ -862,6 +867,287 @@ export class AtomPairsParameters {
 }
 if (Symbol.dispose) AtomPairsParameters.prototype[Symbol.dispose] = AtomPairsParameters.prototype.free;
 
+export class AvalonEngineError {
+    static __wrap(ptr) {
+        const obj = Object.create(AvalonEngineError.prototype);
+        obj.__wbg_ptr = ptr;
+        AvalonEngineErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AvalonEngineErrorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_avalonengineerror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get domain() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonengineerror_domain(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonengineerror_kind(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get reason() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonengineerror_reason(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) AvalonEngineError.prototype[Symbol.dispose] = AvalonEngineError.prototype.free;
+
+export class AvalonFingerprintError {
+    static __wrap(ptr) {
+        const obj = Object.create(AvalonFingerprintError.prototype);
+        obj.__wbg_ptr = ptr;
+        AvalonFingerprintErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AvalonFingerprintErrorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_avalonfingerprinterror_free(ptr, 0);
+    }
+    /**
+     * @returns {Error | null}
+     */
+    get cause() {
+        const ret = wasm.avalonfingerprinterror_cause(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get domain() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonfingerprinterror_domain(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonfingerprinterror_kind(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonfingerprinterror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) AvalonFingerprintError.prototype[Symbol.dispose] = AvalonFingerprintError.prototype.free;
+
+export class AvalonFingerprintFlags {
+    static __wrap(ptr) {
+        const obj = Object.create(AvalonFingerprintFlags.prototype);
+        obj.__wbg_ptr = ptr;
+        AvalonFingerprintFlagsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AvalonFingerprintFlagsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_avalonfingerprintflags_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    bits() {
+        const ret = wasm.avalonfingerprintflags_bits(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} bits
+     * @returns {AvalonFingerprintFlags}
+     */
+    static fromBitsRetain(bits) {
+        const ret = wasm.avalonfingerprintflags_fromBitsRetain(bits);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AvalonFingerprintFlags.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonfingerprintflags_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) AvalonFingerprintFlags.prototype[Symbol.dispose] = AvalonFingerprintFlags.prototype.free;
+
+export class AvalonFingerprintParams {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AvalonFingerprintParamsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_avalonfingerprintparams_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get bitFlags() {
+        const ret = wasm.avalonfingerprintparams_bitFlags(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get isQuery() {
+        const ret = wasm.avalonfingerprintparams_isQuery(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get nBits() {
+        const ret = wasm.avalonfingerprintparams_nBits(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} [n_bits]
+     * @param {boolean} [is_query]
+     * @param {number} [bit_flags]
+     */
+    constructor(n_bits, is_query, bit_flags) {
+        const ret = wasm.avalonfingerprintparams_new(n_bits, is_query, bit_flags);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        AvalonFingerprintParamsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {number} value
+     */
+    set bitFlags(value) {
+        const ret = wasm.avalonfingerprintparams_set_bitFlags(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {boolean} value
+     */
+    set isQuery(value) {
+        const ret = wasm.avalonfingerprintparams_set_isQuery(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    set nBits(value) {
+        const ret = wasm.avalonfingerprintparams_set_nBits(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.avalonfingerprintparams_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) AvalonFingerprintParams.prototype[Symbol.dispose] = AvalonFingerprintParams.prototype.free;
+
 export class BatchError {
     static __wrap(ptr) {
         const obj = Object.create(BatchError.prototype);
@@ -3866,10 +4152,644 @@ export class MatrixError {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) MatrixError.prototype[Symbol.dispose] = MatrixError.prototype.free;
+
+/**
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const McsAtomComparator = Object.freeze({
+    Any: 0, "0": "Any",
+    Elements: 1, "1": "Elements",
+    Isotopes: 2, "2": "Isotopes",
+    AnyHeavyAtom: 3, "3": "AnyHeavyAtom",
+});
+
+export class McsAtomCompareParameters {
+    static __wrap(ptr) {
+        const obj = Object.create(McsAtomCompareParameters.prototype);
+        obj.__wbg_ptr = ptr;
+        McsAtomCompareParametersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McsAtomCompareParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcsatomcompareparameters_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get completeRingsOnly() {
+        const ret = wasm.mcsatomcompareparameters_completeRingsOnly(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchChiralTag() {
+        const ret = wasm.mcsatomcompareparameters_matchChiralTag(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchFormalCharge() {
+        const ret = wasm.mcsatomcompareparameters_matchFormalCharge(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchIsotope() {
+        const ret = wasm.mcsatomcompareparameters_matchIsotope(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchValences() {
+        const ret = wasm.mcsatomcompareparameters_matchValences(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get maxDistance() {
+        const ret = wasm.mcsatomcompareparameters_maxDistance(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {boolean} [match_valences]
+     * @param {boolean} [match_chiral_tag]
+     * @param {boolean} [match_formal_charge]
+     * @param {boolean} [ring_matches_ring_only]
+     * @param {boolean} [complete_rings_only]
+     * @param {boolean} [match_isotope]
+     * @param {number} [max_distance]
+     */
+    constructor(match_valences, match_chiral_tag, match_formal_charge, ring_matches_ring_only, complete_rings_only, match_isotope, max_distance) {
+        const ret = wasm.mcsatomcompareparameters_new(match_valences, match_chiral_tag, match_formal_charge, ring_matches_ring_only, complete_rings_only, match_isotope, max_distance);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        McsAtomCompareParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get ringMatchesRingOnly() {
+        const ret = wasm.mcsatomcompareparameters_ringMatchesRingOnly(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {any} value
+     */
+    set completeRingsOnly(value) {
+        const ret = wasm.mcsatomcompareparameters_set_completeRingsOnly(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchChiralTag(value) {
+        const ret = wasm.mcsatomcompareparameters_set_matchChiralTag(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchFormalCharge(value) {
+        const ret = wasm.mcsatomcompareparameters_set_matchFormalCharge(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchIsotope(value) {
+        const ret = wasm.mcsatomcompareparameters_set_matchIsotope(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchValences(value) {
+        const ret = wasm.mcsatomcompareparameters_set_matchValences(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set maxDistance(value) {
+        const ret = wasm.mcsatomcompareparameters_set_maxDistance(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set ringMatchesRingOnly(value) {
+        const ret = wasm.mcsatomcompareparameters_set_ringMatchesRingOnly(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) McsAtomCompareParameters.prototype[Symbol.dispose] = McsAtomCompareParameters.prototype.free;
+
+/**
+ * @enum {0 | 1 | 2}
+ */
+export const McsBondComparator = Object.freeze({
+    Any: 0, "0": "Any",
+    Order: 1, "1": "Order",
+    OrderExact: 2, "2": "OrderExact",
+});
+
+export class McsBondCompareParameters {
+    static __wrap(ptr) {
+        const obj = Object.create(McsBondCompareParameters.prototype);
+        obj.__wbg_ptr = ptr;
+        McsBondCompareParametersFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McsBondCompareParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcsbondcompareparameters_free(ptr, 0);
+    }
+    /**
+     * @returns {boolean}
+     */
+    get completeRingsOnly() {
+        const ret = wasm.mcsbondcompareparameters_completeRingsOnly(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchFusedRingsStrict() {
+        const ret = wasm.mcsbondcompareparameters_matchFusedRingsStrict(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchFusedRings() {
+        const ret = wasm.mcsbondcompareparameters_matchFusedRings(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get matchStereo() {
+        const ret = wasm.mcsbondcompareparameters_matchStereo(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} [ring_matches_ring_only]
+     * @param {boolean} [complete_rings_only]
+     * @param {boolean} [match_fused_rings]
+     * @param {boolean} [match_fused_rings_strict]
+     * @param {boolean} [match_stereo]
+     */
+    constructor(ring_matches_ring_only, complete_rings_only, match_fused_rings, match_fused_rings_strict, match_stereo) {
+        const ret = wasm.mcsbondcompareparameters_new(ring_matches_ring_only, complete_rings_only, match_fused_rings, match_fused_rings_strict, match_stereo);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        McsBondCompareParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get ringMatchesRingOnly() {
+        const ret = wasm.mcsbondcompareparameters_ringMatchesRingOnly(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {any} value
+     */
+    set completeRingsOnly(value) {
+        const ret = wasm.mcsbondcompareparameters_set_completeRingsOnly(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchFusedRingsStrict(value) {
+        const ret = wasm.mcsbondcompareparameters_set_matchFusedRingsStrict(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchFusedRings(value) {
+        const ret = wasm.mcsbondcompareparameters_set_matchFusedRings(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set matchStereo(value) {
+        const ret = wasm.mcsbondcompareparameters_set_matchStereo(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set ringMatchesRingOnly(value) {
+        const ret = wasm.mcsbondcompareparameters_set_ringMatchesRingOnly(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) McsBondCompareParameters.prototype[Symbol.dispose] = McsBondCompareParameters.prototype.free;
+
+export class McsError {
+    static __wrap(ptr) {
+        const obj = Object.create(McsError.prototype);
+        obj.__wbg_ptr = ptr;
+        McsErrorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McsErrorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcserror_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get domain() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mcserror_domain(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get kind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mcserror_kind(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    get message() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mcserror_message(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) McsError.prototype[Symbol.dispose] = McsError.prototype.free;
+
+export class McsParameters {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McsParametersFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcsparameters_free(ptr, 0);
+    }
+    /**
+     * @returns {McsAtomComparator}
+     */
+    get atomComparator() {
+        const ret = wasm.mcsparameters_atomComparator(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {McsAtomCompareParameters}
+     */
+    get atomCompareParameters() {
+        const ret = wasm.mcsparameters_atomCompareParameters(this.__wbg_ptr);
+        return McsAtomCompareParameters.__wrap(ret);
+    }
+    /**
+     * @returns {McsBondComparator}
+     */
+    get bondComparator() {
+        const ret = wasm.mcsparameters_bondComparator(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {McsBondCompareParameters}
+     */
+    get bondCompareParameters() {
+        const ret = wasm.mcsparameters_bondCompareParameters(this.__wbg_ptr);
+        return McsBondCompareParameters.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    get initialSeed() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mcsparameters_initialSeed(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get maximizeBonds() {
+        const ret = wasm.mcsparameters_maximizeBonds(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} [store_all]
+     * @param {boolean} [maximize_bonds]
+     * @param {number} [threshold]
+     * @param {number} [timeout]
+     * @param {boolean} [verbose]
+     * @param {McsAtomCompareParameters | McsAtomCompareParametersOptions} [atom_compare_parameters]
+     * @param {McsBondCompareParameters | McsBondCompareParametersOptions} [bond_compare_parameters]
+     * @param {McsAtomComparator} [atom_comparator]
+     * @param {McsBondComparator} [bond_comparator]
+     * @param {string} [initial_seed]
+     */
+    constructor(store_all, maximize_bonds, threshold, timeout, verbose, atom_compare_parameters, bond_compare_parameters, atom_comparator, bond_comparator, initial_seed) {
+        const ret = wasm.mcsparameters_new(store_all, maximize_bonds, threshold, timeout, verbose, atom_compare_parameters, bond_compare_parameters, atom_comparator, bond_comparator, initial_seed);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        McsParametersFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {McsAtomComparator} value
+     */
+    set atomComparator(value) {
+        const ret = wasm.mcsparameters_set_atomComparator(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {McsAtomCompareParameters | McsAtomCompareParametersOptions} value
+     */
+    set atomCompareParameters(value) {
+        const ret = wasm.mcsparameters_set_atomCompareParameters(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {McsBondComparator} value
+     */
+    set bondComparator(value) {
+        const ret = wasm.mcsparameters_set_bondComparator(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {McsBondCompareParameters | McsBondCompareParametersOptions} value
+     */
+    set bondCompareParameters(value) {
+        const ret = wasm.mcsparameters_set_bondCompareParameters(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} value
+     */
+    set initialSeed(value) {
+        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mcsparameters_set_initialSeed(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set maximizeBonds(value) {
+        const ret = wasm.mcsparameters_set_maximizeBonds(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set storeAll(value) {
+        const ret = wasm.mcsparameters_set_storeAll(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set threshold(value) {
+        const ret = wasm.mcsparameters_set_threshold(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set timeout(value) {
+        const ret = wasm.mcsparameters_set_timeout(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} value
+     */
+    set verbose(value) {
+        const ret = wasm.mcsparameters_set_verbose(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get storeAll() {
+        const ret = wasm.mcsparameters_storeAll(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get threshold() {
+        const ret = wasm.mcsparameters_threshold(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get timeout() {
+        const ret = wasm.mcsparameters_timeout(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get verbose() {
+        const ret = wasm.mcsparameters_verbose(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) McsParameters.prototype[Symbol.dispose] = McsParameters.prototype.free;
+
+export class McsResult {
+    static __wrap(ptr) {
+        const obj = Object.create(McsResult.prototype);
+        obj.__wbg_ptr = ptr;
+        McsResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        McsResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mcsresult_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get atomCount() {
+        const ret = wasm.mcsresult_atomCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get bondCount() {
+        const ret = wasm.mcsresult_bondCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get completed() {
+        const ret = wasm.mcsresult_completed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Map<string, QueryGraph>}
+     */
+    get degenerate() {
+        const ret = wasm.mcsresult_degenerate(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {QueryGraph | null}
+     */
+    get query() {
+        const ret = wasm.mcsresult_query(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    get smarts() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.mcsresult_smarts(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
     }
 }
-if (Symbol.dispose) MatrixError.prototype[Symbol.dispose] = MatrixError.prototype.free;
+if (Symbol.dispose) McsResult.prototype[Symbol.dispose] = McsResult.prototype.free;
 
 export class Mol2PostError {
     static __wrap(ptr) {
@@ -4634,6 +5554,21 @@ export class Molecule {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * Read typed user metadata; a missing key returns null.
+     * @param {number} atom
+     * @param {string} key
+     * @returns {boolean | number | string | number[] | string[] | null}
+     */
+    atomProperty(atom, key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.molecule_atomProperty(this.__wbg_ptr, atom, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Returns atomic numbers in molecule atom order.
      * @returns {Uint8Array}
@@ -5164,6 +6099,29 @@ export class Molecule {
         }
         return Fingerprint.__wrap(ret[0]);
     }
+    /**
+     * @param {AvalonFingerprintParams} params
+     * @returns {Fingerprint}
+     */
+    fingerprintAvalonWithParams(params) {
+        _assertClass(params, AvalonFingerprintParams);
+        const ret = wasm.molecule_fingerprintAvalonWithParams(this.__wbg_ptr, params.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Fingerprint.__wrap(ret[0]);
+    }
+    /**
+     * @param {AvalonFingerprintParams | AvalonFingerprintOptions} [params]
+     * @returns {Fingerprint}
+     */
+    fingerprintAvalon(params) {
+        const ret = wasm.molecule_fingerprintAvalon(this.__wbg_ptr, params);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Fingerprint.__wrap(ret[0]);
+    }
     /**
      * @param {LayeredFingerprintParams} params
      * @returns {LayeredFingerprintResult}
@@ -5682,6 +6640,19 @@ export class Molecule {
         }
         return ret[0];
     }
+    /**
+     * Sanitized components in source order, including conformers; self is unchanged.
+     * @returns {Molecule[]}
+     */
+    fragments() {
+        const ret = wasm.molecule_fragments(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @param {string} text
      * @param {Mol2ReadParams} params
@@ -5951,6 +6922,17 @@ export class Molecule {
         }
         return ret[0];
     }
+    /**
+     * Most atoms, last on ties. Empty input throws OperationError.
+     * @returns {Molecule}
+     */
+    largestFragment() {
+        const ret = wasm.molecule_largestFragment(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Molecule.__wrap(ret[0]);
+    }
     /**
      * @returns {number}
      */
@@ -6070,6 +7052,28 @@ export class Molecule {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * ChemTransforms MurckoDecompose; retains ring-exocyclic double bonds.
+     * @returns {Molecule}
+     */
+    murckoDecompose() {
+        const ret = wasm.molecule_murckoDecompose(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Molecule.__wrap(ret[0]);
+    }
+    /**
+     * MolHash MurckoScaffold; returns a new molecule.
+     * @returns {Molecule}
+     */
+    murckoScaffold() {
+        const ret = wasm.molecule_murckoScaffold(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Molecule.__wrap(ret[0]);
+    }
     /**
      * Returns the molecule name, or an empty string when no name is stored.
      * @returns {string}
@@ -6092,6 +7096,17 @@ export class Molecule {
             wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * MolHash ExtendedMurcko; neighboring substituents become dummy atoms.
+     * @returns {Molecule}
+     */
+    netScaffold() {
+        const ret = wasm.molecule_netScaffold(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Molecule.__wrap(ret[0]);
+    }
     /**
      * Creates an empty molecule.
      * @returns {Molecule}
@@ -6587,6 +7602,20 @@ export class Molecule {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Set metadata in place; COW keeps other molecule copies unchanged.
+     * @param {number} atom
+     * @param {string} key
+     * @param {boolean | number | string | number[] | string[]} value
+     */
+    setAtomProperty(atom, key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.molecule_setAtomProperty(this.__wbg_ptr, atom, ptr0, len0, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {number}
      */
@@ -7325,6 +8354,22 @@ export class Molecule {
         }
         return AtomPairAtomCodeResult.__wrap(ret[0]);
     }
+    /**
+     * Return a new molecule; the receiver and its shared copies are unchanged.
+     * @param {number} atom
+     * @param {string} key
+     * @param {boolean | number | string | number[] | string[]} value
+     * @returns {Molecule}
+     */
+    withAtomProperty(atom, key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.molecule_withAtomProperty(this.__wbg_ptr, atom, ptr0, len0, value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Molecule.__wrap(ret[0]);
+    }
     /**
      * @param {AddHsParams} params
      * @returns {Molecule}
@@ -9781,6 +10826,86 @@ export const PropertyValueKind = Object.freeze({
     StringVector: 6, "6": "StringVector",
 });
 
+/**
+ * Read-only query carrier, including wildcard atomic identities.
+ */
+export class QueryAtom {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QueryAtomFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_queryatom_free(ptr, 0);
+    }
+    /**
+     * @returns {number | null}
+     */
+    atomMap() {
+        const ret = wasm.queryatom_atomMap(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    atomicNumber() {
+        const ret = wasm.queryatom_atomicNumber(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    explicitHydrogens() {
+        const ret = wasm.queryatom_explicitHydrogens(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    formalCharge() {
+        const ret = wasm.queryatom_formalCharge(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    id() {
+        const ret = wasm.queryatom_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    isAromatic() {
+        const ret = wasm.queryatom_isAromatic(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number | null}
+     */
+    isotope() {
+        const ret = wasm.queryatom_isotope(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    noImplicit() {
+        const ret = wasm.queryatom_noImplicit(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    radicalElectrons() {
+        const ret = wasm.queryatom_radicalElectrons(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) QueryAtom.prototype[Symbol.dispose] = QueryAtom.prototype.free;
+
 export class QueryCompileError {
     static __wrap(ptr) {
         const obj = Object.create(QueryCompileError.prototype);
@@ -15102,6 +16227,33 @@ export function fingerprintTopologicalQueryWithParams(query, params) {
     return Fingerprint.__wrap(ret[0]);
 }
 
+/**
+ * @param {Molecule[]} molecules
+ * @param {McsParameters | McsParametersOptions} [params]
+ * @returns {McsResult}
+ */
+export function maximumCommonSubstructure(molecules, params) {
+    const ret = wasm.maximumCommonSubstructure(molecules, params);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return McsResult.__wrap(ret[0]);
+}
+
+/**
+ * @param {Molecule[]} molecules
+ * @param {McsParameters} params
+ * @returns {McsResult}
+ */
+export function maximumCommonSubstructureWithParams(molecules, params) {
+    _assertClass(params, McsParameters);
+    const ret = wasm.maximumCommonSubstructureWithParams(molecules, params.__wbg_ptr);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return McsResult.__wrap(ret[0]);
+}
+
 /**
  * @param {string} text
  * @returns {QueryGraph}
@@ -15268,6 +16420,14 @@ function __wbg_get_imports() {
             const ret = AtomPairReadError.__wrap(arg0);
             return ret;
         },
+        __wbg_avalonengineerror_new: function(arg0) {
+            const ret = AvalonEngineError.__wrap(arg0);
+            return ret;
+        },
+        __wbg_avalonfingerprinterror_new: function(arg0) {
+            const ret = AvalonFingerprintError.__wrap(arg0);
+            return ret;
+        },
         __wbg_batcherror_new: function(arg0) {
             const ret = BatchError.__wrap(arg0);
             return ret;
@@ -15426,6 +16586,10 @@ function __wbg_get_imports() {
             const ret = MatrixError.__wrap(arg0);
             return ret;
         },
+        __wbg_mcserror_new: function(arg0) {
+            const ret = McsError.__wrap(arg0);
+            return ret;
+        },
         __wbg_mol2posterror_new: function(arg0) {
             const ret = Mol2PostError.__wrap(arg0);
             return ret;
@@ -15665,14 +16829,14 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_visitAtomPairInvariants_89f4f094cb965e9f: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitAtomPairInvariants_29b5b9745bfbc598: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_817(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_820(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15682,14 +16846,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitAtomPairParams_cbb5590392a2b0e2: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitAtomPairParams_12a3f215f9118576: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10_816(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h28f432a120fa162b_819(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15699,14 +16863,31 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitDistanceMatrix3dParams_810bd31b364f77bd: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitAvalonParams_dd8741b67281463a: function() { return handleError(function (arg0, arg1, arg2) {
+            try {
+                var state0 = {a: arg1, b: arg2};
+                var cb0 = (arg0) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1151(a, state0.b, arg0);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                visitAvalonParams(arg0, cb0);
+            } finally {
+                state0.a = 0;
+            }
+        }, arguments); },
+        __wbg_visitDistanceMatrix3dParams_2de68859baa8be30: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1171(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1268(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15716,14 +16897,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitDistanceMatrixParams_f83c45dd07860ab3: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitDistanceMatrixParams_857a95fbbd0073ba: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1172(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1269(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15733,14 +16914,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitFingerprintAdditionalOutput_0a522ab0fd373df4: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitFingerprintAdditionalOutput_bf433553c65ab462: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h17c4f8efe4311580(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h6d6136530f67bbcd(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15750,14 +16931,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitGroupId_51ca765fb7347b19: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitGroupId_6b490f3af6f041bf: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h74c7817024b189c7(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15767,14 +16948,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitGroupKind_11d721cfd86c9f93: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitGroupKind_706269ce030a2e35: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h535810dba926e5f2(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h1d7fa7045865bb6d(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15784,14 +16965,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitHydrogenAddParams_20398eee4fd0639b: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitHydrogenAddParams_e57313182e1b467a: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h51c73e0b17c4f1aa(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hde0ecdc91425767e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15801,14 +16982,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitHydrogenRemoveParams_bb7d780b7c3159fe: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitHydrogenRemoveParams_2be6b02d98373bd6: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h923e9d799b9b82a6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__ha1c840908ed22dcc(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15818,14 +16999,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitKekulizeParams_5ca9ad2cd6a0105f: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitKekulizeParams_2b3f9fce3385db8d: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h34f0ec1a841a69c4_1163(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hbdf8236d6834fc3c_1260(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15835,14 +17016,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitLayeredMask_85a1f37a73aefbcf: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitLayeredMask_756d583b7a6264f9: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h7ae2bcd4b3e5c9b3(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h429a9f6cd8ec7296(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15852,14 +17033,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitLayeredParams_6e8d1d2c551dfa2c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitLayeredParams_3d843198f45996eb: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hbe14b74b216a6301(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hc704151a3782ede3(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15869,14 +17050,82 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMol2Params_5ba4d3fb63ac0901: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMcsAtomCompareParameters_ff876522be0d0d80: function() { return handleError(function (arg0, arg1, arg2) {
+            try {
+                var state0 = {a: arg1, b: arg2};
+                var cb0 = (arg0) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b_1089(a, state0.b, arg0);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                visitMcsAtomCompareParameters(arg0, cb0);
+            } finally {
+                state0.a = 0;
+            }
+        }, arguments); },
+        __wbg_visitMcsBondCompareParameters_bfe8e78e2271e799: function() { return handleError(function (arg0, arg1, arg2) {
+            try {
+                var state0 = {a: arg1, b: arg2};
+                var cb0 = (arg0) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b_1088(a, state0.b, arg0);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                visitMcsBondCompareParameters(arg0, cb0);
+            } finally {
+                state0.a = 0;
+            }
+        }, arguments); },
+        __wbg_visitMcsMolecule_1411bf5b0e387bb6: function() { return handleError(function (arg0, arg1, arg2) {
+            try {
+                var state0 = {a: arg1, b: arg2};
+                var cb0 = (arg0) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures________invoke__hca9a52768545031e(a, state0.b, arg0);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                visitMcsMolecule(arg0, cb0);
+            } finally {
+                state0.a = 0;
+            }
+        }, arguments); },
+        __wbg_visitMcsParameters_af583ff2efd97717: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h2d8c1f0cec73022a(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b(a, state0.b, arg0);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                visitMcsParameters(arg0, cb0);
+            } finally {
+                state0.a = 0;
+            }
+        }, arguments); },
+        __wbg_visitMol2Params_c0ffc45ded1da8d2: function() { return handleError(function (arg0, arg1, arg2) {
+            try {
+                var state0 = {a: arg1, b: arg2};
+                var cb0 = (arg0) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen__convert__closures________invoke__h0912d6eb5c2e2c48(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15886,14 +17135,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMolProperties_8822d8ebcfcf1d83: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMolProperties_ed2d2b670af6670b: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hc1dada456cd7568d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__he122a50ccdd4ebd3(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15903,14 +17152,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMolQuery_ccbda4eec89daf0d: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMolQuery_0f28122dfe6d073e: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h288193f920e98e98(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h23a5f0dd421e928a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15920,14 +17169,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMolSelection_95dc7eb51b0e6ed3: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMolSelection_080c2ea92590f0c7: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h34f0ec1a841a69c4(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hbdf8236d6834fc3c(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15937,14 +17186,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMolWriteParams_90263e4c9c920224: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMolWriteParams_96462971ac8f293f: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hbb2f6e2396006d37(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hf09ec4fc65c4731e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15954,14 +17203,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMorganAtom_7e713a91ab3cb85c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMorganAtom_bd802ad70670728a: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h590eaab9614c12fe(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2b854c7e119a31dd(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15971,14 +17220,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMorganBond_18d809d96ece31a5: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMorganBond_b60b9e587e1019ee: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -15988,14 +17237,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMorganInvariants_32830355483ef08d: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMorganInvariants_61ffce4642e5bf25: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hd3ea8e022290fe5e(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h1ce5208db5e0b12f(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16005,14 +17254,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMorganParams_6666fc87738988f0: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMorganParams_2dd84fd2d9db1e98: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h28f432a120fa162b(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16022,14 +17271,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitMorganQuery_00b1e1f912323794: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitMorganQuery_5e1f2ac217a5f64d: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h288193f920e98e98(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h23a5f0dd421e928a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16039,14 +17288,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitRingSearchParams_721b5bfb3dde82fa: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitRingSearchParams_b3e5cfbab7029e7d: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1077(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1141(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16056,14 +17305,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSanitizeParams_790fa5c39f17ee59: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSanitizeParams_8084786865375e37: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f_1187(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h74c7817024b189c7_1284(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16073,14 +17322,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarMorganMolecule_ba23b1c703da411c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarMorganMolecule_1411bf5b0e387bb6: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__ha4aa2868be42b268(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hca9a52768545031e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16090,14 +17339,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarMorganatom_c75889d4395a441b: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarMorganatom_9bb32137f8e2e4ac: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h590eaab9614c12fe(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2b854c7e119a31dd(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16107,14 +17356,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarMorganbond_a2963751d930326a: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarMorganbond_03410128aef43415: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16124,14 +17373,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarMorgancall_131b624b306f3fa7: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarMorgancall_a81cf2ac4ae0b55c: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h5623dec9f2615308(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h9572276f526e85ea(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16141,14 +17390,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarMorganparams_8b2909a8113d12bb: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarMorganparams_439fc5eea09517b1: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h28f432a120fa162b(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16158,14 +17407,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarTopologicalTorsionMolecule_ba23b1c703da411c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarTopologicalTorsionMolecule_1411bf5b0e387bb6: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__ha4aa2868be42b268(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hca9a52768545031e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16175,14 +17424,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarTopologicalTorsionatom_6ec53dca76a7849c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarTopologicalTorsionatom_5aff8e87073bdb34: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_971(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_974(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16192,14 +17441,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarTopologicalTorsioncall_96159b5d42c14661: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarTopologicalTorsioncall_76d935f369f1fbd4: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h095e57be8c82b3a5(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__ha60d7d03cff977ad(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16209,14 +17458,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitScalarTopologicalTorsionparams_2d9159a7c5389e40: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitScalarTopologicalTorsionparams_e42618f9374949e4: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h5bf5544d0078289b(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hfc8767d395d96e60(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16226,14 +17475,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSdfBatchExport_683ea67a31d618c6: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSdfBatchExport_66c0fa26562495ce: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16243,14 +17492,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSdfBatchRead_ca73bbd18c270bef: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSdfBatchRead_ce73e389c656d779: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hc73270323d67dc15(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h67327df01e24910e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16260,14 +17509,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSdfDataset_206bb584e1c9ceb8: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSdfDataset_26de56a7a5b0e28f: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3e71b1b11aad9506(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hf9bfb439270c49a5(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16277,14 +17526,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSdfReadParams_0f1e0f06960d63f7: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSdfReadParams_3840e4a751ad8d6c: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hc73270323d67dc15(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h67327df01e24910e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16294,14 +17543,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSearchCompiledQuery_45579fc98810d76c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSearchCompiledQuery_5859ea59ce04f502: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h26d4cacfef65d4f3(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7b139ce493cebee3(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16311,14 +17560,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSearchQueryGraph_bb4df311522d714c: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSearchQueryGraph_325fa1f278841d71: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h288193f920e98e98(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h23a5f0dd421e928a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16328,14 +17577,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSearchSmartsWriteParams_a8694d5a165e23af: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSearchSmartsWriteParams_a28acc344e1b7b82: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1098(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1185(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16345,14 +17594,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSearchSubstructMatchParams_72e0730ab119eea2: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSearchSubstructMatchParams_c0248eb0fe11bf9b: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h451888c1ebe58ad4(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hdcb39c3ae1a56d45(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16362,14 +17611,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitSupplierParams_6fc508a670b35166: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitSupplierParams_7394e1b3e410e7a9: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__hc73270323d67dc15(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h67327df01e24910e(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16379,14 +17628,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitTorsionInvariants_89f4f094cb965e9f: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitTorsionInvariants_29b5b9745bfbc598: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1025(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1028(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16396,14 +17645,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitTorsionParams_c9325d4b1959d038: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitTorsionParams_0e408698b68da71d: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h5bf5544d0078289b(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hfc8767d395d96e60(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16413,14 +17662,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitXyzParams_9b3b8147f824bf39: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitXyzParams_96e131bde1b3f398: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1208(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1305(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16430,14 +17679,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visit_batch_records_78c6faf64c4d7709: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visit_batch_records_d8b988e197ad49cf: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h9b911451f98a0716(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h0ce994ec9516eec8(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16447,14 +17696,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visit_sanitize_operations_be4311637c2a67a4: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visit_sanitize_operations_2a75485596913f85: function() { return handleError(function (arg0, arg1, arg2) {
             try {
                 var state0 = {a: arg1, b: arg2};
                 var cb0 = (arg0) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f_882(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h74c7817024b189c7_885(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -16505,199 +17754,219 @@ function __wbg_get_imports() {
     return {
         __proto__: null,
         "./wasm_wasm_bg.js": import0,
-        "./snippets/wasm-wasm-30282a0f796f892b/inline0.js": import1,
-        "./snippets/wasm-wasm-30282a0f796f892b/inline3.js": import2,
+        "./snippets/wasm-wasm-6920c347788a3bef/inline0.js": import1,
+        "./snippets/wasm-wasm-6920c347788a3bef/inline3.js": import2,
     };
 }
 
-function wasm_bindgen__convert__closures________invoke__hc73270323d67dc15(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h67327df01e24910e(arg0, arg1, arg2) {
     _assertClass(arg2, SdfReadParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hc73270323d67dc15(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h67327df01e24910e(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1(arg0, arg1, arg2) {
     _assertClass(arg2, BatchExportParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3e71b1b11aad9506(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hf9bfb439270c49a5(arg0, arg1, arg2) {
     _assertClass(arg2, SdfDataset);
-    wasm.wasm_bindgen__convert__closures________invoke__h3e71b1b11aad9506(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hf9bfb439270c49a5(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h74c7817024b189c7(arg0, arg1, arg2) {
     _assertClass(arg2, SubstanceGroupId);
-    wasm.wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h74c7817024b189c7(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h535810dba926e5f2(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h1d7fa7045865bb6d(arg0, arg1, arg2) {
     _assertClass(arg2, SubstanceGroupKind);
-    wasm.wasm_bindgen__convert__closures________invoke__h535810dba926e5f2(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h1d7fa7045865bb6d(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h9b911451f98a0716(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h0ce994ec9516eec8(arg0, arg1, arg2) {
     _assertClass(arg2, BatchRecord);
-    wasm.wasm_bindgen__convert__closures________invoke__h9b911451f98a0716(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h0ce994ec9516eec8(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h34f0ec1a841a69c4(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hbdf8236d6834fc3c(arg0, arg1, arg2) {
     _assertClass(arg2, MolCoordinateSelection);
-    wasm.wasm_bindgen__convert__closures________invoke__h34f0ec1a841a69c4(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hbdf8236d6834fc3c(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hbb2f6e2396006d37(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hf09ec4fc65c4731e(arg0, arg1, arg2) {
     _assertClass(arg2, MolBlockWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hbb2f6e2396006d37(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hf09ec4fc65c4731e(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h288193f920e98e98(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h23a5f0dd421e928a(arg0, arg1, arg2) {
     _assertClass(arg2, QueryGraph);
-    wasm.wasm_bindgen__convert__closures________invoke__h288193f920e98e98(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h23a5f0dd421e928a(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hc1dada456cd7568d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__he122a50ccdd4ebd3(arg0, arg1, arg2) {
     _assertClass(arg2, MoleculeProperties);
-    wasm.wasm_bindgen__convert__closures________invoke__hc1dada456cd7568d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__he122a50ccdd4ebd3(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h28f432a120fa162b(arg0, arg1, arg2) {
     _assertClass(arg2, MorganParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h28f432a120fa162b(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h590eaab9614c12fe(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2b854c7e119a31dd(arg0, arg1, arg2) {
     _assertClass(arg2, MorganAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h590eaab9614c12fe(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h2b854c7e119a31dd(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a(arg0, arg1, arg2) {
     _assertClass(arg2, MorganBondInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5623dec9f2615308(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h9572276f526e85ea(arg0, arg1, arg2) {
     _assertClass(arg2, MorganCallParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h5623dec9f2615308(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h9572276f526e85ea(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__ha4aa2868be42b268(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hca9a52768545031e(arg0, arg1, arg2) {
     _assertClass(arg2, Molecule);
-    wasm.wasm_bindgen__convert__closures________invoke__ha4aa2868be42b268(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hca9a52768545031e(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hd3ea8e022290fe5e(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h1ce5208db5e0b12f(arg0, arg1, arg2) {
     _assertClass(arg2, MorganInvariants);
-    wasm.wasm_bindgen__convert__closures________invoke__hd3ea8e022290fe5e(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h1ce5208db5e0b12f(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10_816(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h28f432a120fa162b_819(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h9c55363cf397ad10_816(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h28f432a120fa162b_819(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_817(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_820(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_817(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_820(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f_882(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h74c7817024b189c7_885(arg0, arg1, arg2) {
     _assertClass(arg2, SanitizeOperations);
-    wasm.wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f_882(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h74c7817024b189c7_885(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h17c4f8efe4311580(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h6d6136530f67bbcd(arg0, arg1, arg2) {
     _assertClass(arg2, FingerprintAdditionalOutput);
-    wasm.wasm_bindgen__convert__closures________invoke__h17c4f8efe4311580(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h6d6136530f67bbcd(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h7ae2bcd4b3e5c9b3(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h429a9f6cd8ec7296(arg0, arg1, arg2) {
     _assertClass(arg2, Fingerprint);
-    wasm.wasm_bindgen__convert__closures________invoke__h7ae2bcd4b3e5c9b3(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h429a9f6cd8ec7296(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hbe14b74b216a6301(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hc704151a3782ede3(arg0, arg1, arg2) {
     _assertClass(arg2, LayeredFingerprintParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hbe14b74b216a6301(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hc704151a3782ede3(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bf5544d0078289b(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hfc8767d395d96e60(arg0, arg1, arg2) {
     _assertClass(arg2, TopologicalTorsionParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bf5544d0078289b(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hfc8767d395d96e60(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_971(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_974(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_971(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_974(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h095e57be8c82b3a5(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__ha60d7d03cff977ad(arg0, arg1, arg2) {
     _assertClass(arg2, TopologicalTorsionCallParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h095e57be8c82b3a5(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__ha60d7d03cff977ad(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1025(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1028(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1025(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1028(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b(arg0, arg1, arg2) {
+    _assertClass(arg2, McsParameters);
+    wasm.wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1077(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b_1088(arg0, arg1, arg2) {
+    _assertClass(arg2, McsBondCompareParameters);
+    wasm.wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b_1088(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b_1089(arg0, arg1, arg2) {
+    _assertClass(arg2, McsAtomCompareParameters);
+    wasm.wasm_bindgen__convert__closures________invoke__h04b915a529a37a0b_1089(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1141(arg0, arg1, arg2) {
     _assertClass(arg2, RingSearchParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1077(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1141(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h26d4cacfef65d4f3(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1151(arg0, arg1, arg2) {
+    _assertClass(arg2, AvalonFingerprintParams);
+    wasm.wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1151(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h7b139ce493cebee3(arg0, arg1, arg2) {
     _assertClass(arg2, CompiledQuery);
-    wasm.wasm_bindgen__convert__closures________invoke__h26d4cacfef65d4f3(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7b139ce493cebee3(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1098(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1185(arg0, arg1, arg2) {
     _assertClass(arg2, SmartsWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1098(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1185(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h451888c1ebe58ad4(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hdcb39c3ae1a56d45(arg0, arg1, arg2) {
     _assertClass(arg2, SubstructMatchParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h451888c1ebe58ad4(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hdcb39c3ae1a56d45(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h34f0ec1a841a69c4_1163(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hbdf8236d6834fc3c_1260(arg0, arg1, arg2) {
     _assertClass(arg2, KekulizeParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h34f0ec1a841a69c4_1163(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hbdf8236d6834fc3c_1260(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1171(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1268(arg0, arg1, arg2) {
     _assertClass(arg2, DistanceMatrix3dParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1171(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1268(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1172(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1269(arg0, arg1, arg2) {
     _assertClass(arg2, DistanceMatrixParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h3aec87b01df447b6_1172(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h3d1933dc7abc885a_1269(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f_1187(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h74c7817024b189c7_1284(arg0, arg1, arg2) {
     _assertClass(arg2, SanitizeParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h3efa4bd8d595938f_1187(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h74c7817024b189c7_1284(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h2d8c1f0cec73022a(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h0912d6eb5c2e2c48(arg0, arg1, arg2) {
     _assertClass(arg2, Mol2ReadParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h2d8c1f0cec73022a(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h0912d6eb5c2e2c48(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1208(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1305(arg0, arg1, arg2) {
     _assertClass(arg2, XyzWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h6506b1b4a763013c_1208(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h2afeaa19ee7bdcf1_1305(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h51c73e0b17c4f1aa(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hde0ecdc91425767e(arg0, arg1, arg2) {
     _assertClass(arg2, AddHsParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h51c73e0b17c4f1aa(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hde0ecdc91425767e(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h923e9d799b9b82a6(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__ha1c840908ed22dcc(arg0, arg1, arg2) {
     _assertClass(arg2, RemoveHsParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h923e9d799b9b82a6(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__ha1c840908ed22dcc(arg0, arg1, arg2.__wbg_ptr);
 }
 
 const AddHsParamsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -16733,6 +18002,18 @@ const AtomPairReadErrorFinalization = (typeof FinalizationRegistry === 'undefine
 const AtomPairsParametersFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_atompairsparameters_free(ptr, 1));
+const AvalonEngineErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_avalonengineerror_free(ptr, 1));
+const AvalonFingerprintErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_avalonfingerprinterror_free(ptr, 1));
+const AvalonFingerprintFlagsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_avalonfingerprintflags_free(ptr, 1));
+const AvalonFingerprintParamsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_avalonfingerprintparams_free(ptr, 1));
 const BatchErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_batcherror_free(ptr, 1));
@@ -16859,6 +18140,21 @@ const MatchResultFinalization = (typeof FinalizationRegistry === 'undefined')
 const MatrixErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_matrixerror_free(ptr, 1));
+const McsAtomCompareParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcsatomcompareparameters_free(ptr, 1));
+const McsBondCompareParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcsbondcompareparameters_free(ptr, 1));
+const McsErrorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcserror_free(ptr, 1));
+const McsParametersFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcsparameters_free(ptr, 1));
+const McsResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mcsresult_free(ptr, 1));
 const Mol2PostErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mol2posterror_free(ptr, 1));
@@ -16934,6 +18230,9 @@ const PropertyValueFinalization = (typeof FinalizationRegistry === 'undefined')
 const PropertyValueErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_propertyvalueerror_free(ptr, 1));
+const QueryAtomFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_queryatom_free(ptr, 1));
 const QueryCompileErrorFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_querycompileerror_free(ptr, 1));