molstar 2.3.9 → 3.0.0-dev.10

package/lib/mol-io/reader/cif/schema/mmcif.js

@@ -1,7 +1,7 @@
 /**
  * Copyright (c) 2017-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
- * Code-generated 'mmCIF' schema file. Dictionary versions: mmCIF 5.350, IHM 1.17, CARB draft.
+ * Code-generated 'mmCIF' schema file. Dictionary versions: mmCIF 5.354, IHM 1.17, MA 1.3.3.
  *
  * @author molstar/ciftools package
  */
@@ -938,6 +938,48 @@ export var mmCIF_Schema = {
          */
         method: Aliased(str),
     },
+    /**
+     * Data items in the SOFTWARE category record details about
+     * the software used in the structure analysis, which implies
+     * any software used in the generation of any data items
+     * associated with the structure determination and
+     * structure representation.
+     *
+     * These data items allow computer programs to be referenced
+     * in more detail than data items in the COMPUTING category do.
+     */
+    software: {
+        /**
+         * The classification of the program according to its
+         * major function.
+         */
+        classification: str,
+        /**
+         * The date the software was released.
+         */
+        date: str,
+        /**
+         * Description of the software.
+         */
+        description: str,
+        /**
+         * The name of the software.
+         */
+        name: str,
+        /**
+         * The classification of the software according to the most
+         * common types.
+         */
+        type: Aliased(str),
+        /**
+         * The version of the software.
+         */
+        version: str,
+        /**
+         * An ordinal index for this category
+         */
+        pdbx_ordinal: int,
+    },
     /**
      * Data items in the STRUCT category record details about the
      * description of the crystallographic structure.
@@ -4713,6 +4755,289 @@ export var mmCIF_Schema = {
          */
         dataset_list_id: int,
     },
+    /**
+     * Data items in the MA_MODEL_LIST category record the
+     * details of the models being deposited.
+     */
+    ma_model_list: {
+        /**
+         * A unique identifier for the model / model group combination.
+         */
+        ordinal_id: int,
+        /**
+         * A unique identifier for the structural model being deposited.
+         */
+        model_id: int,
+        /**
+         * An identifier to group structural models into collections or sets.
+         * A cluster of models and its representative can either be grouped together
+         * or can be separate groups in the ma_model_list table. The choice between
+         * the two options should be decided based on how the modeling was carried out
+         * and how the representative was chosen. If the representative is a member of
+         * the ensemble (i.e., best scoring model), then it is recommended that the
+         * representative and the ensemble belong to the same model group. If the
+         * representative is calculated from the ensemble (i.e., centroid), then it is
+         * recommended that the representative be separated into a different group.
+         * If the models do not need to be grouped into collections, then the
+         * _ma_model_list.model_group_id is the same as _ma_model_list.model_id.
+         */
+        model_group_id: int,
+        /**
+         * A decsriptive name for the model.
+         */
+        model_name: str,
+        /**
+         * A decsriptive name for the model group.
+         */
+        model_group_name: str,
+        /**
+         * The type of model.
+         */
+        model_type: Aliased(str),
+        /**
+         * The data_id identifier. This data item is a pointer to
+         * _ma_data.id in the MA_DATA category.
+         */
+        data_id: int,
+    },
+    /**
+     * Data items in the MA_TARGET_ENTITY category record details about
+     * the target entities. The details are provided for each entity
+     * being modeled.
+     */
+    ma_target_entity: {
+        /**
+         * A unique identifier for the distinct molecular entity of the target.
+         * This data item is a pointer to _entity.id in the ENTITY category.
+         */
+        entity_id: str,
+        /**
+         * The data_id identifier. This data item is a pointer to
+         * _ma_data.id in the MA_DATA category.
+         */
+        data_id: int,
+        /**
+         * The origin of the target entity.
+         */
+        origin: Aliased(str),
+    },
+    /**
+     * Data items in the MA_TARGET_ENTITY_INSTANCE category record details about
+     * the instances of target entities modeled.
+     */
+    ma_target_entity_instance: {
+        /**
+         * A unique identifier for the instance of the entity.
+         */
+        asym_id: str,
+        /**
+         * A unique identifier for the distinct molecular entity of the target.
+         * This data item is a pointer to _ma_target_entity.entity_id in the
+         * MA_TARGET_ENTITY category.
+         */
+        entity_id: str,
+        /**
+         * Additional details about the entity instance.
+         */
+        details: str,
+    },
+    /**
+     * Data items in the MA_TARGET_REF_DB_DETAILS category record details about
+     * the reference databases for the target sequences.
+     */
+    ma_target_ref_db_details: {
+        /**
+         * An identifier for the target entity.
+         */
+        target_entity_id: str,
+        /**
+         * The name of the database containing reference information about
+         * this entity or biological unit.
+         */
+        db_name: Aliased(str),
+        /**
+         * The code for this entity or biological unit or for a closely
+         * related entity or biological unit in the named database.
+         * This can include the version number.
+         */
+        db_code: str,
+        /**
+         * Accession code assigned by the reference database.
+         */
+        db_accession: str,
+        /**
+         * Database code assigned by the reference database for a sequence isoform.   An isoform sequence is an
+         * alternative protein sequence that can be generated from the same gene by a single or by a combination of
+         * biological events such as: alternative promoter usage, alternative splicing, alternative initiation
+         * and ribosomal frameshifting.
+         */
+        seq_db_isoform: str,
+        /**
+         * Beginning index in the chemical sequence from the
+         * reference database.
+         */
+        seq_db_align_begin: str,
+        /**
+         * Ending index in the chemical sequence from the
+         * reference database.
+         */
+        seq_db_align_end: str,
+        /**
+         * Taxonomy identifier provided by NCBI.
+         */
+        ncbi_taxonomy_id: str,
+        /**
+         * Scientific name of the organism.
+         */
+        organism_scientific: str,
+    },
+    /**
+     * Data items in the MA_DATA category capture the different kinds of
+     * data used in the modeling. These can be multiple sequence
+     * alignments, spatial restraints, template structures etc.
+     */
+    ma_data: {
+        /**
+         * A unique identifier for the data.
+         */
+        id: int,
+        /**
+         * The type of data held in the dataset.
+         */
+        content_type: Aliased(str),
+        /**
+         * Details for other content types.
+         */
+        content_type_other_details: str,
+        /**
+         * An author-given name for the content held in the dataset.
+         */
+        name: str,
+    },
+    /**
+     * Data items in the MA_SOFTWARE_GROUP category describes the
+     * collection of software into groups so that they can be used
+     * efficiently in the MA_PROTOCOL_STEP category.
+     */
+    ma_software_group: {
+        /**
+         * A unique identifier for the category.
+         */
+        ordinal_id: int,
+        /**
+         * An identifier for the group entry.
+         * If data does not need to be grouped, then _ma_software_group.group_id
+         * is the same as _ma_software_group.software_id.
+         */
+        group_id: int,
+        /**
+         * The identifier for the software.
+         * This data item is a pointer to _software.pdbx_ordinal
+         * in the SOFTWARE category.
+         */
+        software_id: int,
+    },
+    /**
+     * Data items in the MA_QA_METRIC category record the
+     * details of the metrics use to assess model quality.
+     */
+    ma_qa_metric: {
+        /**
+         * An identifier for the QA metric.
+         */
+        id: int,
+        /**
+         * Name of the QA metric.
+         */
+        name: str,
+        /**
+         * The type of QA metric.
+         */
+        type: Aliased(str),
+        /**
+         * The mode of calculation of the QA metric.
+         */
+        mode: Aliased(str),
+        /**
+         * Identifier to the set of software used to calculate the QA metric.
+         * This data item is a pointer to the _ma_software_group.group_id in the
+         * MA_SOFTWARE_GROUP category.
+         */
+        software_group_id: int,
+    },
+    /**
+     * Data items in the MA_QA_METRIC_GLOBAL category captures the
+     * details of the global QA metrics, calculated at the model-level.
+     */
+    ma_qa_metric_global: {
+        /**
+         * A unique identifier for the category.
+         */
+        ordinal_id: int,
+        /**
+         * The identifier for the structural model, for which global QA metric is provided.
+         * This data item is a pointer to _ma_model_list.model_id
+         * in the MA_MODEL_LIST category.
+         */
+        model_id: int,
+        /**
+         * The identifier for the QA metric.
+         * This data item is a pointer to _ma_qa_metric.id in the
+         * MA_QA_METRIC category.
+         */
+        metric_id: int,
+        /**
+         * The value of the global QA metric.
+         */
+        metric_value: float,
+    },
+    /**
+     * Data items in the MA_QA_METRIC_LOCAL category captures the
+     * details of the local QA metrics, calculated at the residue-level.
+     */
+    ma_qa_metric_local: {
+        /**
+         * A unique identifier for the category.
+         */
+        ordinal_id: int,
+        /**
+         * The identifier for the structural model, for which local QA metric is provided.
+         * This data item is a pointer to _ma_model_list.model_id
+         * in the MA_MODEL_LIST category.
+         */
+        model_id: int,
+        /**
+         * The identifier for the asym id of the residue in the
+         * structural model, for which local QA metric is provided.
+         * This data item is a pointer to _atom_site.label_asym_id
+         * in the ATOM_SITE category.
+         */
+        label_asym_id: str,
+        /**
+         * The identifier for the sequence index of the residue
+         * in the structural model, for which local QA metric is provided.
+         * This data item is a pointer to _atom_site.label_seq_id
+         * in the ATOM_SITE category.
+         */
+        label_seq_id: int,
+        /**
+         * The component identifier for the residue in the
+         * structural model, for which local QA metric is provided.
+         * This data item is a pointer to _atom_site.label_comp_id
+         * in the ATOM_SITE category.
+         */
+        label_comp_id: str,
+        /**
+         * The identifier for the QA metric.
+         * This data item is a pointer to _ma_qa_metric.id in the
+         * MA_QA_METRIC category.
+         */
+        metric_id: int,
+        /**
+         * The value of the local QA metric.
+         */
+        metric_value: float,
+    },
 };
 ;
 //# sourceMappingURL=mmcif.js.map

package/lib/mol-io/reader/mol/parser.d.ts

@@ -1,7 +1,8 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
  */
 import { Column } from '../../../mol-data/db';
 import { Task } from '../../../mol-task';
@@ -18,6 +19,7 @@ export interface MolFile {
         readonly y: Column<number>;
         readonly z: Column<number>;
         readonly type_symbol: Column<string>;
+        readonly formal_charge: Column<number>;
     };
     readonly bonds: {
         readonly count: number;
@@ -25,7 +27,27 @@ export interface MolFile {
         readonly atomIdxB: Column<number>;
         readonly order: Column<number>;
     };
+    readonly formalCharges: {
+        readonly atomIdx: Column<number>;
+        readonly charge: Column<number>;
+    };
 }
+/**
+ * @param key - The value found at the atom block.
+ * @returns The actual formal charge based on the mapping.
+ */
+export declare function formalChargeMapper(key: number): 0 | 1 | 3 | 2 | -3 | -1 | -2;
 export declare function handleAtoms(tokenizer: Tokenizer, count: number): MolFile['atoms'];
 export declare function handleBonds(tokenizer: Tokenizer, count: number): MolFile['bonds'];
+interface FormalChargesRawData {
+    atomIdx: Array<number>;
+    charge: Array<number>;
+}
+export declare function handleFormalCharges(tokenizer: Tokenizer, lineStart: number, formalCharges: FormalChargesRawData): void;
+/** Call an appropriate handler based on the property type.
+ * (For now it only calls the formal charge handler, additional handlers can
+ * be added for other properties.)
+ */
+export declare function handlePropertiesBlock(tokenizer: Tokenizer): MolFile['formalCharges'];
 export declare function parseMol(data: string): Task<Result<MolFile>>;
+export {};

package/lib/mol-io/reader/mol/parser.js

@@ -1,7 +1,8 @@
 /**
- * Copyright (c) 2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2020-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
  */
 import { __awaiter, __generator } from "tslib";
 import { Column } from '../../../mol-data/db';
@@ -9,11 +10,57 @@ import { Task } from '../../../mol-task';
 import { TokenColumnProvider as TokenColumn } from '../common/text/column/token';
 import { TokenBuilder, Tokenizer } from '../common/text/tokenizer';
 import { ReaderResult as Result } from '../result';
+/*
+    The atom lines in a .mol file have the following structure:
+
+    xxxxx.xxxxyyyyy.yyyyzzzzz.zzzz aaaddcccssshhhbbbvvvHHHrrriiimmmnnneee
+    ---------------------------------------------------------------------
+
+    Below is a breakdown of each component and its start/end indices:
+
+    xxxxx.xxxx  (X COORDINATE, 1-10)
+    yyyyy.yyyy  (Y COORDINATE, 10-20)
+    zzzzz.zzzz  (Z COORDINATE, 20-30)
+    _           (30 IS EMPTY)
+    aaa         (ATOM SYMBOL, 31-34)
+    dd          (MASS DIFF, 34-36)
+    ccc         (FORMAL CHARGE, 36-39)
+    sss         (ATOM STEREO PARITY, 39-42)
+    hhh         (HYDROGEN COUNT+1, 42-45)
+    bbb         (STEREO CARE BOX, 45-48)
+    vvv         (VALENCE, 48-51)
+    HHH         (H0 DESIGNATOR, 51-54)
+    rrr         (UNUSED, 54-57)
+    iii         (UNUSED, 57-60)
+    mmm         (ATOM-ATOM MAPPING NUMBER, 60-63)
+    nnn         (INVERSION/RETENTION FLAG, 63-66)
+    eee         (EXACT CHANGE FLAG, 66-69)
+*/
+/**
+ * @param key - The value found at the atom block.
+ * @returns The actual formal charge based on the mapping.
+ */
+export function formalChargeMapper(key) {
+    switch (key) {
+        case 7: return -3;
+        case 6: return -2;
+        case 5: return -1;
+        case 0: return 0;
+        case 3: return 1;
+        case 2: return 2;
+        case 1: return 3;
+        case 4: return 0;
+        default:
+            console.error("Value ".concat(key, " is outside the 0-7 range, defaulting to 0."));
+            return 0;
+    }
+}
 export function handleAtoms(tokenizer, count) {
     var x = TokenBuilder.create(tokenizer.data, count * 2);
     var y = TokenBuilder.create(tokenizer.data, count * 2);
     var z = TokenBuilder.create(tokenizer.data, count * 2);
     var type_symbol = TokenBuilder.create(tokenizer.data, count * 2);
+    var formal_charge = TokenBuilder.create(tokenizer.data, count * 2);
     for (var i = 0; i < count; ++i) {
         Tokenizer.markLine(tokenizer);
         var s = tokenizer.tokenStart, position = tokenizer.position;
@@ -25,6 +72,8 @@ export function handleAtoms(tokenizer, count) {
         TokenBuilder.addUnchecked(z, tokenizer.tokenStart, tokenizer.tokenEnd);
         Tokenizer.trim(tokenizer, s + 31, s + 34);
         TokenBuilder.addUnchecked(type_symbol, tokenizer.tokenStart, tokenizer.tokenEnd);
+        Tokenizer.trim(tokenizer, s + 36, s + 39);
+        TokenBuilder.addUnchecked(formal_charge, tokenizer.tokenStart, tokenizer.tokenEnd);
         tokenizer.position = position;
     }
     return {
@@ -32,7 +81,8 @@ export function handleAtoms(tokenizer, count) {
         x: TokenColumn(x)(Column.Schema.float),
         y: TokenColumn(y)(Column.Schema.float),
         z: TokenColumn(z)(Column.Schema.float),
-        type_symbol: TokenColumn(type_symbol)(Column.Schema.str)
+        type_symbol: TokenColumn(type_symbol)(Column.Schema.str),
+        formal_charge: TokenColumn(formal_charge)(Column.Schema.int)
     };
 }
 export function handleBonds(tokenizer, count) {
@@ -57,6 +107,63 @@ export function handleBonds(tokenizer, count) {
         order: TokenColumn(order)(Column.Schema.int)
     };
 }
+export function handleFormalCharges(tokenizer, lineStart, formalCharges) {
+    Tokenizer.trim(tokenizer, lineStart + 6, lineStart + 9);
+    var numOfCharges = parseInt(Tokenizer.getTokenString(tokenizer));
+    for (var i = 0; i < numOfCharges; ++i) {
+        /*
+        M  CHG  3   1  -1   2   0   2  -1
+                |   |   |   |   |
+                |   |   |   |   |__charge2 (etc.)
+                |   |   |   |
+                |   |   |   |__atomIdx2
+                |   |   |
+                |   |   |__charge1
+                |   |
+                |   |__atomIdx1 (cursor at position 12)
+                |
+                |___numOfCharges
+        */
+        var offset = 9 + (i * 8);
+        Tokenizer.trim(tokenizer, lineStart + offset, lineStart + offset + 4);
+        var _atomIdx = Tokenizer.getTokenString(tokenizer);
+        formalCharges.atomIdx.push(+_atomIdx);
+        Tokenizer.trim(tokenizer, lineStart + offset + 4, lineStart + offset + 8);
+        var _charge = Tokenizer.getTokenString(tokenizer);
+        formalCharges.charge.push(+_charge);
+    }
+    /* Once the line is read, move to the next one. */
+    Tokenizer.eatLine(tokenizer);
+}
+/** Call an appropriate handler based on the property type.
+ * (For now it only calls the formal charge handler, additional handlers can
+ * be added for other properties.)
+ */
+export function handlePropertiesBlock(tokenizer) {
+    var _atomIdx = [];
+    var _charge = [];
+    var _formalCharges = { atomIdx: _atomIdx, charge: _charge };
+    while (tokenizer.position < tokenizer.length) {
+        var s = tokenizer.position;
+        Tokenizer.trim(tokenizer, s + 3, s + 6);
+        var propertyType = Tokenizer.getTokenString(tokenizer);
+        if (propertyType === 'END')
+            break;
+        Tokenizer.eatLine(tokenizer);
+        switch (propertyType) {
+            case 'CHG':
+                handleFormalCharges(tokenizer, s, _formalCharges);
+                break;
+            default:
+                break;
+        }
+    }
+    var formalCharges = {
+        atomIdx: Column.ofIntArray(_formalCharges.atomIdx),
+        charge: Column.ofIntArray(_formalCharges.charge)
+    };
+    return formalCharges;
+}
 function parseInternal(data) {
     var tokenizer = Tokenizer(data);
     var title = Tokenizer.readLine(tokenizer).trim();
@@ -66,12 +173,14 @@ function parseInternal(data) {
     var atomCount = +counts.substr(0, 3), bondCount = +counts.substr(3, 3);
     var atoms = handleAtoms(tokenizer, atomCount);
     var bonds = handleBonds(tokenizer, bondCount);
+    var formalCharges = handlePropertiesBlock(tokenizer);
     var result = {
         title: title,
         program: program,
         comment: comment,
         atoms: atoms,
-        bonds: bonds
+        bonds: bonds,
+        formalCharges: formalCharges,
     };
     return Result.success(result);
 }

package/lib/mol-io/reader/mol2/parser.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Zepei Xu <xuzepei19950617@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>

package/lib/mol-io/reader/mol2/parser.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017-2020 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Zepei Xu <xuzepei19950617@gmail.com>
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
@@ -241,9 +241,38 @@ function handleBonds(state) {
         });
     });
 }
+function handleCrysin(state) {
+    var tokenizer = state.tokenizer;
+    while (tokenizer.position < tokenizer.data.length) {
+        var l = getTokenString(tokenizer);
+        if (l === '@<TRIPOS>MOLECULE') {
+            return;
+        }
+        else if (l === '@<TRIPOS>CRYSIN') {
+            break;
+        }
+        else {
+            markLine(tokenizer);
+        }
+    }
+    if (tokenizer.position >= tokenizer.data.length)
+        return;
+    markLine(tokenizer);
+    var values = getTokenString(tokenizer).trim().split(reWhitespace);
+    return {
+        a: parseFloat(values[0]),
+        b: parseFloat(values[1]),
+        c: parseFloat(values[2]),
+        alpha: parseFloat(values[3]),
+        beta: parseFloat(values[4]),
+        gamma: parseFloat(values[5]),
+        spaceGroup: parseInt(values[6], 10),
+        setting: parseInt(values[7], 10),
+    };
+}
 function parseInternal(ctx, data, name) {
     return __awaiter(this, void 0, void 0, function () {
-        var tokenizer, structures, state, atoms, bonds, result;
+        var tokenizer, structures, state, atoms, bonds, crysin, result;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
@@ -261,7 +290,8 @@ function parseInternal(ctx, data, name) {
                     return [4 /*yield*/, handleBonds(state)];
                 case 3:
                     bonds = _a.sent();
-                    structures.push({ molecule: state.molecule, atoms: atoms, bonds: bonds });
+                    crysin = handleCrysin(state);
+                    structures.push({ molecule: state.molecule, atoms: atoms, bonds: bonds, crysin: crysin });
                     skipWhitespace(tokenizer);
                     while (getTokenString(tokenizer) !== '@<TRIPOS>MOLECULE' && tokenizer.position < tokenizer.data.length) {
                         markLine(tokenizer);

package/lib/mol-io/reader/mol2/schema.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */
@@ -37,10 +37,21 @@ export interface Mol2Bonds {
     bond_type: Column<string>;
     status_bits: Column<string>;
 }
+export interface Mol2Crysin {
+    a: number;
+    b: number;
+    c: number;
+    alpha: number;
+    beta: number;
+    gamma: number;
+    spaceGroup: number;
+    setting: number;
+}
 export interface Mol2Structure {
     molecule: Readonly<Mol2Molecule>;
     atoms: Readonly<Mol2Atoms>;
     bonds: Readonly<Mol2Bonds>;
+    crysin?: Readonly<Mol2Crysin>;
 }
 export interface Mol2File {
     name: string;

package/lib/mol-io/reader/mol2/schema.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ * Copyright (c) 2017-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
  *
  * @author Alexander Rose <alexander.rose@weirdbyte.de>
  */

package/lib/mol-io/reader/ply/schema.d.ts

@@ -24,7 +24,7 @@ export declare const PlyTypeByteLength: {
 };
 export declare type PlyType = keyof typeof PlyTypeByteLength;
 export declare const PlyTypes: Set<string>;
-export declare function PlyType(str: string): "float32" | "int32" | "uint16" | "uint32" | "uint8" | "int8" | "int16" | "ushort" | "float" | "int" | "char" | "uchar" | "short" | "uint" | "double" | "float64";
+export declare function PlyType(str: string): "double" | "float" | "char" | "int" | "uint8" | "int8" | "uint16" | "int16" | "uint32" | "int32" | "float32" | "ushort" | "uchar" | "short" | "uint" | "float64";
 export interface PlyFile {
     readonly comments: ReadonlyArray<string>;
     readonly elementNames: ReadonlyArray<string>;

package/lib/mol-io/reader/sdf/parser-v3-util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2021-2022 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Jason Pattle <jpattle@exscientia.co.uk>
+ * @author Panagiotis Tourlas <panagiot_tourlov@hotmail.com>
+ */
+import { MolFile } from '../mol/parser';
+import { Tokenizer } from '../common/text/tokenizer';
+export declare function isV3(versionLine: string): boolean;
+export declare function handleCountsV3(tokenizer: Tokenizer): {
+    atomCount: number;
+    bondCount: number;
+};
+export declare function handleAtomsV3(tokenizer: Tokenizer, atomCount: number): MolFile['atoms'];
+export declare function handleBondsV3(tokenizer: Tokenizer, bondCount: number): MolFile['bonds'];