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

package/wasm_wasm.js

@@ -1,41 +1,46 @@
 /* @ts-self-types="./wasm_wasm.d.ts" */
-import { visitSdfBatchExport, visitSdfBatchRead, visitSdfDataset } from './snippets/wasm-wasm-30282a0f796f892b/inline1.js';
-import { visitScalarMorganMolecule, visitScalarMorganatom, visitScalarMorganbond, visitScalarMorgancall, visitScalarMorganparams } from './snippets/wasm-wasm-30282a0f796f892b/inline10.js';
-import { visitMorganAtom, visitMorganBond, visitMorganInvariants, visitMorganParams, visitMorganQuery } from './snippets/wasm-wasm-30282a0f796f892b/inline11.js';
-import { visitReactionCxSmilesFields } from './snippets/wasm-wasm-30282a0f796f892b/inline12.js';
-import { visitReactionCoordinateSelection } from './snippets/wasm-wasm-30282a0f796f892b/inline13.js';
-import { visitAtomPairInvariants, visitAtomPairParams } from './snippets/wasm-wasm-30282a0f796f892b/inline14.js';
-import { visit_sanitize_operations } from './snippets/wasm-wasm-30282a0f796f892b/inline15.js';
-import { visitFingerprintAdditionalOutput } from './snippets/wasm-wasm-30282a0f796f892b/inline16.js';
-import { visitLayeredMask } from './snippets/wasm-wasm-30282a0f796f892b/inline17.js';
-import { visitLayeredParams } from './snippets/wasm-wasm-30282a0f796f892b/inline18.js';
-import { visitScalarTopologicalTorsionMolecule, visitScalarTopologicalTorsionatom, visitScalarTopologicalTorsioncall, visitScalarTopologicalTorsionparams } from './snippets/wasm-wasm-30282a0f796f892b/inline19.js';
-import { visitSdfReadParams } from './snippets/wasm-wasm-30282a0f796f892b/inline2.js';
-import { visitTorsionInvariants, visitTorsionParams } from './snippets/wasm-wasm-30282a0f796f892b/inline20.js';
-import { visitInchiRead, visitInchiWrite } from './snippets/wasm-wasm-30282a0f796f892b/inline21.js';
-import { visitRingSearchParams } from './snippets/wasm-wasm-30282a0f796f892b/inline22.js';
-import { visitSearchCompiledQuery } from './snippets/wasm-wasm-30282a0f796f892b/inline23.js';
-import { visitSearchSubstructMatchParams } from './snippets/wasm-wasm-30282a0f796f892b/inline24.js';
-import { visitSearchQueryGraph } from './snippets/wasm-wasm-30282a0f796f892b/inline25.js';
-import { visitSearchSmartsWriteParams } from './snippets/wasm-wasm-30282a0f796f892b/inline26.js';
-import { visitKekulizeParams } from './snippets/wasm-wasm-30282a0f796f892b/inline27.js';
-import { visitDistanceMatrix3dParams } from './snippets/wasm-wasm-30282a0f796f892b/inline28.js';
-import { visitDistanceMatrixParams } from './snippets/wasm-wasm-30282a0f796f892b/inline29.js';
-import { visit_execution } from './snippets/wasm-wasm-30282a0f796f892b/inline3.js';
-import { visitReactionMolecule } from './snippets/wasm-wasm-30282a0f796f892b/inline30.js';
-import { visitReactionQuery } from './snippets/wasm-wasm-30282a0f796f892b/inline31.js';
-import { visitSanitizeParams } from './snippets/wasm-wasm-30282a0f796f892b/inline32.js';
-import { visitMol2Params, visitXyzParams } from './snippets/wasm-wasm-30282a0f796f892b/inline33.js';
-import { visitHydrogenAddParams, visitHydrogenRemoveParams } from './snippets/wasm-wasm-30282a0f796f892b/inline34.js';
-import { visitGroupId, visitGroupKind } from './snippets/wasm-wasm-30282a0f796f892b/inline4.js';
-import { visitSupplierParams } from './snippets/wasm-wasm-30282a0f796f892b/inline5.js';
-import { visitBioAltloc, visitBioElement } from './snippets/wasm-wasm-30282a0f796f892b/inline6.js';
-import { visit_batch_records } from './snippets/wasm-wasm-30282a0f796f892b/inline7.js';
-import { visitBioMoleculeParams } from './snippets/wasm-wasm-30282a0f796f892b/inline8.js';
-import { visitMolProperties, visitMolQuery, visitMolSelection, visitMolWriteParams } 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/inline1.js"
-import * as import3 from "./snippets/wasm-wasm-30282a0f796f892b/inline5.js"
+import { visitSdfBatchExport, visitSdfBatchRead, visitSdfDataset } from './snippets/wasm-wasm-6920c347788a3bef/inline1.js';
+import { visitScalarMorganMolecule, visitScalarMorganatom, visitScalarMorganbond, visitScalarMorgancall, visitScalarMorganparams } from './snippets/wasm-wasm-6920c347788a3bef/inline10.js';
+import { visitMorganAtom, visitMorganBond, visitMorganInvariants, visitMorganParams, visitMorganQuery } from './snippets/wasm-wasm-6920c347788a3bef/inline11.js';
+import { visitReactionCoordinateSelection } from './snippets/wasm-wasm-6920c347788a3bef/inline12.js';
+import { visitReactionCxSmilesFields } from './snippets/wasm-wasm-6920c347788a3bef/inline13.js';
+import { visitAtomPairInvariants, visitAtomPairParams } from './snippets/wasm-wasm-6920c347788a3bef/inline14.js';
+import { visit_sanitize_operations } from './snippets/wasm-wasm-6920c347788a3bef/inline15.js';
+import { visitFingerprintAdditionalOutput } from './snippets/wasm-wasm-6920c347788a3bef/inline16.js';
+import { visitLayeredMask } from './snippets/wasm-wasm-6920c347788a3bef/inline17.js';
+import { visitLayeredParams } from './snippets/wasm-wasm-6920c347788a3bef/inline18.js';
+import { visitScalarTopologicalTorsionMolecule, visitScalarTopologicalTorsionatom, visitScalarTopologicalTorsioncall, visitScalarTopologicalTorsionparams } from './snippets/wasm-wasm-6920c347788a3bef/inline19.js';
+import { visitSdfReadParams } from './snippets/wasm-wasm-6920c347788a3bef/inline2.js';
+import { visitTorsionInvariants, visitTorsionParams } from './snippets/wasm-wasm-6920c347788a3bef/inline20.js';
+import { visitMcsParameters } from './snippets/wasm-wasm-6920c347788a3bef/inline21.js';
+import { visitMcsBondCompareParameters } from './snippets/wasm-wasm-6920c347788a3bef/inline22.js';
+import { visitMcsMolecule } from './snippets/wasm-wasm-6920c347788a3bef/inline23.js';
+import { visitMcsAtomCompareParameters } from './snippets/wasm-wasm-6920c347788a3bef/inline24.js';
+import { visitInchiRead, visitInchiWrite } from './snippets/wasm-wasm-6920c347788a3bef/inline25.js';
+import { visitRingSearchParams } from './snippets/wasm-wasm-6920c347788a3bef/inline26.js';
+import { visitAvalonParams } from './snippets/wasm-wasm-6920c347788a3bef/inline27.js';
+import { visitSearchCompiledQuery } from './snippets/wasm-wasm-6920c347788a3bef/inline28.js';
+import { visitSearchSmartsWriteParams } from './snippets/wasm-wasm-6920c347788a3bef/inline29.js';
+import { visit_execution } from './snippets/wasm-wasm-6920c347788a3bef/inline3.js';
+import { visitSearchQueryGraph } from './snippets/wasm-wasm-6920c347788a3bef/inline30.js';
+import { visitSearchSubstructMatchParams } from './snippets/wasm-wasm-6920c347788a3bef/inline31.js';
+import { visitKekulizeParams } from './snippets/wasm-wasm-6920c347788a3bef/inline32.js';
+import { visitDistanceMatrix3dParams } from './snippets/wasm-wasm-6920c347788a3bef/inline33.js';
+import { visitDistanceMatrixParams } from './snippets/wasm-wasm-6920c347788a3bef/inline34.js';
+import { visitReactionQuery } from './snippets/wasm-wasm-6920c347788a3bef/inline35.js';
+import { visitReactionMolecule } from './snippets/wasm-wasm-6920c347788a3bef/inline36.js';
+import { visitSanitizeParams } from './snippets/wasm-wasm-6920c347788a3bef/inline37.js';
+import { visitMol2Params, visitXyzParams } from './snippets/wasm-wasm-6920c347788a3bef/inline38.js';
+import { visitHydrogenAddParams, visitHydrogenRemoveParams } from './snippets/wasm-wasm-6920c347788a3bef/inline39.js';
+import { visitGroupId, visitGroupKind } from './snippets/wasm-wasm-6920c347788a3bef/inline4.js';
+import { visitSupplierParams } from './snippets/wasm-wasm-6920c347788a3bef/inline5.js';
+import { visitBioAltloc, visitBioElement } from './snippets/wasm-wasm-6920c347788a3bef/inline6.js';
+import { visit_batch_records } from './snippets/wasm-wasm-6920c347788a3bef/inline7.js';
+import { visitBioMoleculeParams } from './snippets/wasm-wasm-6920c347788a3bef/inline8.js';
+import { visitMolProperties, visitMolQuery, visitMolSelection, visitMolWriteParams } 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/inline1.js"
+import * as import3 from "./snippets/wasm-wasm-6920c347788a3bef/inline5.js"
 
 
 export class AddHsParams {
@@ -1608,6 +1613,287 @@ export class AtomSourceIds {
 }
 if (Symbol.dispose) AtomSourceIds.prototype[Symbol.dispose] = AtomSourceIds.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);
@@ -13288,6 +13574,640 @@ export class MatrixError {
 }
 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) McsResult.prototype[Symbol.dispose] = McsResult.prototype.free;
+
 export class MmffAtomProperties {
     static __wrap(ptr) {
         const obj = Object.create(MmffAtomProperties.prototype);
@@ -14842,6 +15762,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}
@@ -15558,6 +16493,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}
@@ -16076,6 +17034,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 {InchiReadParams} params
@@ -16374,6 +17345,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}
      */
@@ -16547,6 +17529,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}
@@ -16569,6 +17573,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}
@@ -17114,6 +18129,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}
      */
@@ -18173,6 +19202,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}
@@ -21900,6 +22945,86 @@ export class ProteinSelectionSummary {
 }
 if (Symbol.dispose) ProteinSelectionSummary.prototype[Symbol.dispose] = ProteinSelectionSummary.prototype.free;
 
+/**
+ * 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);
@@ -23431,6 +24556,13 @@ export class ReactionRunParams {
         const ret = wasm.reactionrunparams_coordinateSelections(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {boolean}
+     */
+    get copyAtomProperties() {
+        const ret = wasm.reactionrunparams_copyAtomProperties(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {number}
      */
@@ -23441,9 +24573,10 @@ export class ReactionRunParams {
     /**
      * @param {number} [max_products]
      * @param {ReactionCoordinateSelection[]} [coordinate_selections]
+     * @param {boolean} [copy_atom_properties]
      */
-    constructor(max_products, coordinate_selections) {
-        const ret = wasm.reactionrunparams_new(max_products, coordinate_selections);
+    constructor(max_products, coordinate_selections, copy_atom_properties) {
+        const ret = wasm.reactionrunparams_new(max_products, coordinate_selections, copy_atom_properties);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -23451,6 +24584,33 @@ export class ReactionRunParams {
         ReactionRunParamsFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {ReactionCoordinateSelection[]} value
+     */
+    set coordinateSelections(value) {
+        const ret = wasm.reactionrunparams_set_coordinateSelections(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {boolean} value
+     */
+    set copyAtomProperties(value) {
+        const ret = wasm.reactionrunparams_set_copyAtomProperties(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {number} value
+     */
+    set maxProducts(value) {
+        const ret = wasm.reactionrunparams_set_maxProducts(this.__wbg_ptr, value);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) ReactionRunParams.prototype[Symbol.dispose] = ReactionRunParams.prototype.free;
 
@@ -30948,6 +32108,33 @@ export function inchiToKey(text) {
     }
 }
 
+/**
+ * @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}
@@ -31199,6 +32386,14 @@ function __wbg_get_imports() {
             const ret = AtomSourceIds.__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;
@@ -31585,6 +32780,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_mmffatomproperties_new: function(arg0) {
             const ret = MmffAtomProperties.__wrap(arg0);
             return ret;
@@ -31972,14 +33171,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__h5bc8a5d04dbc67f5_1827(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_1834(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -31989,14 +33188,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__he454338561b431c1_1826(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hcb848668c5a09202_1833(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32006,14 +33205,31 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitBioAltloc_12e57e2945427cd5: 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__h5ab2fa88a0d77621(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2353(a, state0.b, arg0);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                visitAvalonParams(arg0, cb0);
+            } finally {
+                state0.a = 0;
+            }
+        }, arguments); },
+        __wbg_visitBioAltloc_867e7b75f540738a: 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__h51446d6480d774fd(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32023,14 +33239,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitBioElement_6a50a4d8f31f7737: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitBioElement_6e525d6ccea83f65: 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__h5ab2fa88a0d77621_886(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h51446d6480d774fd_886(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32040,14 +33256,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitBioMoleculeParams_4e1164d814f5735d: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitBioMoleculeParams_1a76d13f5b2a8056: 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__h0d1dcec420f59771(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h15445680e15d01b7(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32057,14 +33273,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitDistanceMatrix3dParams_810bd31b364f77bd: function() { return handleError(function (arg0, arg1, arg2) {
+        __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__h0e6bd8b84df1fce1_2369(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2470(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32074,14 +33290,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__h5bc8a5d04dbc67f5_2370(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2471(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32091,14 +33307,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__h99b7ff61ce79e10b(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h4a7bb9932676e4b9(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32108,14 +33324,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__h0064a98766fb0224(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32125,14 +33341,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__h85b777a3b19d8bca(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h01b1e606e450b2ac(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32142,14 +33358,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__hd60bb4dcb664a8e5(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h0a06d3ba8cca1299(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32159,14 +33375,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__h367854f3909c6b72(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h8c6f2c7593f176e2(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32176,14 +33392,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitInchiRead_a38f2d346b5afa20: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitInchiRead_2f28b45bf8b5d65a: 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__h5bc8a5d04dbc67f5_2252(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2320(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32193,14 +33409,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitInchiWrite_da8cb3546dffd7a8: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitInchiWrite_d1ff9ee945d90aaa: 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__h2fa2bd6861932b9d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hc68671597d64b287(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32210,14 +33426,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__h0d1dcec420f59771_2361(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_2462(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32227,14 +33443,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__h590f60ef0b121ea7(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h08d497340505e30a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32244,14 +33460,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__hd76cc1aaf71726d3(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h6b3d527f431eaa7a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32261,14 +33477,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__hd7206a4f1e3cc39d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c_2197(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__h34ed44600ce80f7c_2195(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__h603896e89802abef(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__h34ed44600ce80f7c(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__h07bf0e008bdc76b0(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32278,14 +33562,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__h2218d91e4996a10d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h16fdeae93d3368ad(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32295,14 +33579,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__h1a472963d24d20a6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h6570fdcd861f2f1d(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32312,14 +33596,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__h0d1dcec420f59771_1119(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_1119(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32329,14 +33613,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__h9afea99fa1a7df0d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h2999e6d37eb6d327(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32346,14 +33630,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__he3247ab5a8c3ce7d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7aeedf70ce4571e2(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32363,14 +33647,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__h5bc8a5d04dbc67f5(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32380,14 +33664,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__hb5f0c2af90259ff8(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h5c52935f5062dd76(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32397,14 +33681,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__he454338561b431c1(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hcb848668c5a09202(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32414,14 +33698,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__h1a472963d24d20a6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h6570fdcd861f2f1d(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32431,14 +33715,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitReactionCoordinateSelection_004a30d3cbedb189: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitReactionCoordinateSelection_347cba41f7acaf59: 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__h0d1dcec420f59771_1688(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_1694(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32448,14 +33732,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitReactionCxSmilesFields_310b7809ec8396e8: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitReactionCxSmilesFields_c7553b9eaa7afb71: 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__h0064a98766fb0224_1687(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_1695(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32465,14 +33749,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitReactionMolecule_8ee9ff17ac5fbe58: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitReactionMolecule_ca0a177b0400a777: 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__hbb9bb400d0faf17a(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h603896e89802abef(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32482,14 +33766,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visitReactionQuery_32f15694ad8f002d: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visitReactionQuery_3aa174c98fef3db1: 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__h1a472963d24d20a6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h6570fdcd861f2f1d(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32499,14 +33783,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__h5bc8a5d04dbc67f5_2275(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2343(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32516,14 +33800,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__h0064a98766fb0224_2446(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_2547(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32533,14 +33817,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__hbb9bb400d0faf17a(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h603896e89802abef(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32550,14 +33834,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__he3247ab5a8c3ce7d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7aeedf70ce4571e2(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32567,14 +33851,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__h5bc8a5d04dbc67f5(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32584,14 +33868,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__h896f474846a4b769(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__he4a7ba0d7e23aa39(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32601,14 +33885,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__he454338561b431c1(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hcb848668c5a09202(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32618,14 +33902,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__hbb9bb400d0faf17a(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h603896e89802abef(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32635,14 +33919,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__h5bc8a5d04dbc67f5_2074(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2081(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32652,14 +33936,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__h70ac3ddb712ddf2e(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hf78da8f4f7fd1802(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32669,14 +33953,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__h4e6875dc92366367(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h27810e84141e08c7(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32686,14 +33970,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__h0e6bd8b84df1fce1(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h020f698551eb66cc(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32703,14 +33987,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__hf1f0a4beb5806796(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__he50bd5777becc806(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32720,14 +34004,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__hae82e598cad2b40f(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__hb326c2acdf46da8a(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32737,14 +34021,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__hf1f0a4beb5806796(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__he50bd5777becc806(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32754,14 +34038,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__h730d32035049500d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__heba3efe5d84c454f(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32771,14 +34055,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__h1a472963d24d20a6(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h6570fdcd861f2f1d(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32788,14 +34072,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__h0e6bd8b84df1fce1_2298(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2384(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32805,14 +34089,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__h127729248a6c8009(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h9e6d12766b45a609(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32822,14 +34106,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__hf1f0a4beb5806796(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__he50bd5777becc806(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32839,14 +34123,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__h5bc8a5d04dbc67f5_2128(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2135(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32856,14 +34140,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__h4e6875dc92366367(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h27810e84141e08c7(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32873,14 +34157,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__h0e6bd8b84df1fce1_2467(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2568(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32890,14 +34174,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__hada9f3926956c01d(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h97d112a15c00bcbf(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32907,14 +34191,14 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         }, arguments); },
-        __wbg_visit_execution_4f41e8dfcbd17533: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_visit_execution_bb48bed39e0a8665: 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__h0e6bd8b84df1fce1_490(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_490(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32924,14 +34208,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__h0064a98766fb0224_1959(a, state0.b, arg0);
+                        return wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_1966(a, state0.b, arg0);
                     } finally {
                         state0.a = a;
                     }
@@ -32982,240 +34266,260 @@ function __wbg_get_imports() {
     return {
         __proto__: null,
         "./wasm_wasm_bg.js": import0,
-        "./snippets/wasm-wasm-30282a0f796f892b/inline0.js": import1,
-        "./snippets/wasm-wasm-30282a0f796f892b/inline1.js": import2,
-        "./snippets/wasm-wasm-30282a0f796f892b/inline5.js": import3,
+        "./snippets/wasm-wasm-6920c347788a3bef/inline0.js": import1,
+        "./snippets/wasm-wasm-6920c347788a3bef/inline1.js": import2,
+        "./snippets/wasm-wasm-6920c347788a3bef/inline5.js": import3,
     };
 }
 
-function wasm_bindgen__convert__closures________invoke__hf1f0a4beb5806796(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__he50bd5777becc806(arg0, arg1, arg2) {
     _assertClass(arg2, SdfReadParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hf1f0a4beb5806796(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__he50bd5777becc806(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h020f698551eb66cc(arg0, arg1, arg2) {
     _assertClass(arg2, BatchExportParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h020f698551eb66cc(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hae82e598cad2b40f(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hb326c2acdf46da8a(arg0, arg1, arg2) {
     _assertClass(arg2, SdfDataset);
-    wasm.wasm_bindgen__convert__closures________invoke__hae82e598cad2b40f(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hb326c2acdf46da8a(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_490(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_490(arg0, arg1, arg2) {
     _assertClass(arg2, BatchParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_490(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_490(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0064a98766fb0224(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa(arg0, arg1, arg2) {
     _assertClass(arg2, SubstanceGroupId);
-    wasm.wasm_bindgen__convert__closures________invoke__h0064a98766fb0224(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h85b777a3b19d8bca(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h01b1e606e450b2ac(arg0, arg1, arg2) {
     _assertClass(arg2, SubstanceGroupKind);
-    wasm.wasm_bindgen__convert__closures________invoke__h85b777a3b19d8bca(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h01b1e606e450b2ac(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5ab2fa88a0d77621(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h51446d6480d774fd(arg0, arg1, arg2) {
     _assertClass(arg2, AltLocLabel);
-    wasm.wasm_bindgen__convert__closures________invoke__h5ab2fa88a0d77621(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h51446d6480d774fd(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5ab2fa88a0d77621_886(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h51446d6480d774fd_886(arg0, arg1, arg2) {
     _assertClass(arg2, Element);
-    wasm.wasm_bindgen__convert__closures________invoke__h5ab2fa88a0d77621_886(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h51446d6480d774fd_886(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hada9f3926956c01d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h97d112a15c00bcbf(arg0, arg1, arg2) {
     _assertClass(arg2, BatchRecord);
-    wasm.wasm_bindgen__convert__closures________invoke__hada9f3926956c01d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h97d112a15c00bcbf(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h15445680e15d01b7(arg0, arg1, arg2) {
     _assertClass(arg2, BioMoleculeParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h15445680e15d01b7(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771_1119(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_1119(arg0, arg1, arg2) {
     _assertClass(arg2, MolCoordinateSelection);
-    wasm.wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771_1119(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_1119(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h9afea99fa1a7df0d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h2999e6d37eb6d327(arg0, arg1, arg2) {
     _assertClass(arg2, MolBlockWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h9afea99fa1a7df0d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h2999e6d37eb6d327(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h1a472963d24d20a6(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h6570fdcd861f2f1d(arg0, arg1, arg2) {
     _assertClass(arg2, QueryGraph);
-    wasm.wasm_bindgen__convert__closures________invoke__h1a472963d24d20a6(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h6570fdcd861f2f1d(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h2218d91e4996a10d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h16fdeae93d3368ad(arg0, arg1, arg2) {
     _assertClass(arg2, MoleculeProperties);
-    wasm.wasm_bindgen__convert__closures________invoke__h2218d91e4996a10d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h16fdeae93d3368ad(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__he454338561b431c1(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hcb848668c5a09202(arg0, arg1, arg2) {
     _assertClass(arg2, MorganParams);
-    wasm.wasm_bindgen__convert__closures________invoke__he454338561b431c1(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hcb848668c5a09202(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__he3247ab5a8c3ce7d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7aeedf70ce4571e2(arg0, arg1, arg2) {
     _assertClass(arg2, MorganAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__he3247ab5a8c3ce7d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7aeedf70ce4571e2(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a(arg0, arg1, arg2) {
     _assertClass(arg2, MorganBondInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h896f474846a4b769(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__he4a7ba0d7e23aa39(arg0, arg1, arg2) {
     _assertClass(arg2, MorganCallParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h896f474846a4b769(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__he4a7ba0d7e23aa39(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hbb9bb400d0faf17a(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h603896e89802abef(arg0, arg1, arg2) {
     _assertClass(arg2, Molecule);
-    wasm.wasm_bindgen__convert__closures________invoke__hbb9bb400d0faf17a(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h603896e89802abef(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hb5f0c2af90259ff8(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h5c52935f5062dd76(arg0, arg1, arg2) {
     _assertClass(arg2, MorganInvariants);
-    wasm.wasm_bindgen__convert__closures________invoke__hb5f0c2af90259ff8(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h5c52935f5062dd76(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0064a98766fb0224_1687(arg0, arg1, arg2) {
-    _assertClass(arg2, CxSmilesFields);
-    wasm.wasm_bindgen__convert__closures________invoke__h0064a98766fb0224_1687(arg0, arg1, arg2.__wbg_ptr);
+function wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_1694(arg0, arg1, arg2) {
+    _assertClass(arg2, ReactionCoordinateSelection);
+    wasm.wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_1694(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771_1688(arg0, arg1, arg2) {
-    _assertClass(arg2, ReactionCoordinateSelection);
-    wasm.wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771_1688(arg0, arg1, arg2.__wbg_ptr);
+function wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_1695(arg0, arg1, arg2) {
+    _assertClass(arg2, CxSmilesFields);
+    wasm.wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_1695(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__he454338561b431c1_1826(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hcb848668c5a09202_1833(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairParams);
-    wasm.wasm_bindgen__convert__closures________invoke__he454338561b431c1_1826(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hcb848668c5a09202_1833(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_1827(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_1834(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_1827(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_1834(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0064a98766fb0224_1959(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_1966(arg0, arg1, arg2) {
     _assertClass(arg2, SanitizeOperations);
-    wasm.wasm_bindgen__convert__closures________invoke__h0064a98766fb0224_1959(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_1966(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h99b7ff61ce79e10b(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h4a7bb9932676e4b9(arg0, arg1, arg2) {
     _assertClass(arg2, FingerprintAdditionalOutput);
-    wasm.wasm_bindgen__convert__closures________invoke__h99b7ff61ce79e10b(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h4a7bb9932676e4b9(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h590f60ef0b121ea7(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h08d497340505e30a(arg0, arg1, arg2) {
     _assertClass(arg2, Fingerprint);
-    wasm.wasm_bindgen__convert__closures________invoke__h590f60ef0b121ea7(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h08d497340505e30a(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hd76cc1aaf71726d3(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h6b3d527f431eaa7a(arg0, arg1, arg2) {
     _assertClass(arg2, LayeredFingerprintParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hd76cc1aaf71726d3(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h6b3d527f431eaa7a(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h4e6875dc92366367(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h27810e84141e08c7(arg0, arg1, arg2) {
     _assertClass(arg2, TopologicalTorsionParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h4e6875dc92366367(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h27810e84141e08c7(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2074(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2081(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2074(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2081(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h70ac3ddb712ddf2e(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hf78da8f4f7fd1802(arg0, arg1, arg2) {
     _assertClass(arg2, TopologicalTorsionCallParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h70ac3ddb712ddf2e(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hf78da8f4f7fd1802(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2128(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2135(arg0, arg1, arg2) {
     _assertClass(arg2, AtomPairAtomInvariantsGenerator);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2128(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2135(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c(arg0, arg1, arg2) {
+    _assertClass(arg2, McsParameters);
+    wasm.wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c_2195(arg0, arg1, arg2) {
+    _assertClass(arg2, McsBondCompareParameters);
+    wasm.wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c_2195(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c_2197(arg0, arg1, arg2) {
+    _assertClass(arg2, McsAtomCompareParameters);
+    wasm.wasm_bindgen__convert__closures________invoke__h34ed44600ce80f7c_2197(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2252(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2320(arg0, arg1, arg2) {
     _assertClass(arg2, InchiReadParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2252(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2320(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h2fa2bd6861932b9d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__hc68671597d64b287(arg0, arg1, arg2) {
     _assertClass(arg2, InchiWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h2fa2bd6861932b9d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__hc68671597d64b287(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2275(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2343(arg0, arg1, arg2) {
     _assertClass(arg2, RingSearchParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2275(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2343(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h730d32035049500d(arg0, arg1, arg2) {
-    _assertClass(arg2, CompiledQuery);
-    wasm.wasm_bindgen__convert__closures________invoke__h730d32035049500d(arg0, arg1, arg2.__wbg_ptr);
+function wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2353(arg0, arg1, arg2) {
+    _assertClass(arg2, AvalonFingerprintParams);
+    wasm.wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2353(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h127729248a6c8009(arg0, arg1, arg2) {
-    _assertClass(arg2, SubstructMatchParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h127729248a6c8009(arg0, arg1, arg2.__wbg_ptr);
+function wasm_bindgen__convert__closures________invoke__heba3efe5d84c454f(arg0, arg1, arg2) {
+    _assertClass(arg2, CompiledQuery);
+    wasm.wasm_bindgen__convert__closures________invoke__heba3efe5d84c454f(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_2298(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2384(arg0, arg1, arg2) {
     _assertClass(arg2, SmartsWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_2298(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2384(arg0, arg1, arg2.__wbg_ptr);
+}
+
+function wasm_bindgen__convert__closures________invoke__h9e6d12766b45a609(arg0, arg1, arg2) {
+    _assertClass(arg2, SubstructMatchParams);
+    wasm.wasm_bindgen__convert__closures________invoke__h9e6d12766b45a609(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771_2361(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_2462(arg0, arg1, arg2) {
     _assertClass(arg2, KekulizeParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0d1dcec420f59771_2361(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h15445680e15d01b7_2462(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_2369(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2470(arg0, arg1, arg2) {
     _assertClass(arg2, DistanceMatrix3dParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_2369(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2470(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2370(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2471(arg0, arg1, arg2) {
     _assertClass(arg2, DistanceMatrixParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h5bc8a5d04dbc67f5_2370(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h7cde413cc7e0fe8a_2471(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0064a98766fb0224_2446(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_2547(arg0, arg1, arg2) {
     _assertClass(arg2, SanitizeParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0064a98766fb0224_2446(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h470e7b9ab969d4aa_2547(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hd7206a4f1e3cc39d(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h07bf0e008bdc76b0(arg0, arg1, arg2) {
     _assertClass(arg2, Mol2ReadParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hd7206a4f1e3cc39d(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h07bf0e008bdc76b0(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_2467(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2568(arg0, arg1, arg2) {
     _assertClass(arg2, XyzWriteParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h0e6bd8b84df1fce1_2467(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h020f698551eb66cc_2568(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__hd60bb4dcb664a8e5(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h0a06d3ba8cca1299(arg0, arg1, arg2) {
     _assertClass(arg2, AddHsParams);
-    wasm.wasm_bindgen__convert__closures________invoke__hd60bb4dcb664a8e5(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h0a06d3ba8cca1299(arg0, arg1, arg2.__wbg_ptr);
 }
 
-function wasm_bindgen__convert__closures________invoke__h367854f3909c6b72(arg0, arg1, arg2) {
+function wasm_bindgen__convert__closures________invoke__h8c6f2c7593f176e2(arg0, arg1, arg2) {
     _assertClass(arg2, RemoveHsParams);
-    wasm.wasm_bindgen__convert__closures________invoke__h367854f3909c6b72(arg0, arg1, arg2.__wbg_ptr);
+    wasm.wasm_bindgen__convert__closures________invoke__h8c6f2c7593f176e2(arg0, arg1, arg2.__wbg_ptr);
 }
 
 const AddHsParamsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -33284,6 +34588,18 @@ const AtomPairsParametersFinalization = (typeof FinalizationRegistry === 'undefi
 const AtomSourceIdsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_atomsourceids_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));
@@ -33677,6 +34993,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 MmffAtomPropertiesFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mmffatomproperties_free(ptr, 1));
@@ -33827,6 +35158,9 @@ const ProteinResidueRefFinalization = (typeof FinalizationRegistry === 'undefine
 const ProteinSelectionSummaryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_proteinselectionsummary_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));